feat(review): persist repository graph cache

Author: haasonsaas

TODO.md

@@ -61,7 +61,7 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 
 ## 4. Code Graph and Repository Intelligence
 
-31. [ ] Turn the current symbol graph into a persisted repository graph with durable storage and reload support.
+31. [x] Turn the current symbol graph into a persisted repository graph with durable storage and reload support.
 32. [x] Add caller/callee expansion APIs for multi-hop impact analysis from changed symbols.
 33. [x] Add contract edges between interfaces, implementations, and API endpoints.
 34. [x] Add "similar implementation" lookup so repeated patterns and divergences are explicit.

src/core/mod.rs

@@ -46,4 +46,7 @@ pub use semantic::{
     load_semantic_feedback_store, refresh_semantic_index, save_semantic_feedback_store,
     semantic_context_for_diff, SemanticFeedbackExample, SemanticFeedbackStore,
 };
-pub use symbol_index::{SymbolContextRetriever, SymbolIndex, SymbolRetrievalPolicy};
+pub use symbol_index::{
+    default_symbol_index_path, load_symbol_index, save_symbol_index, SymbolContextRetriever,
+    SymbolIndex, SymbolRetrievalPolicy,
+};

src/core/symbol_graph.rs

@@ -1,11 +1,13 @@
 use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
 
+use serde::{Deserialize, Serialize};
+
 use crate::core::symbol_index::SymbolLocation;
 use crate::core::ContextProvenance;
 
 /// Relationship between two symbols in the codebase.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum SymbolRelation {
     /// This symbol calls the target.
     Calls,
@@ -61,7 +63,7 @@ impl SymbolRelation {
 }
 
 /// A reference to a related symbol with the relationship type.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SymbolEdge {
     pub target: String,
     pub relation: SymbolRelation,
@@ -70,7 +72,7 @@ pub struct SymbolEdge {
 }
 
 /// A node in the symbol graph representing a single symbol definition.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SymbolNode {
     pub name: String,
     pub file_path: PathBuf,
@@ -79,7 +81,7 @@ pub struct SymbolNode {
     pub edges: Vec<SymbolEdge>,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum SymbolKind {
     Function,
     Struct,
@@ -89,7 +91,7 @@ pub enum SymbolKind {
 }
 
 /// Graph-based symbol index that tracks relationships between symbols.
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Serialize, Deserialize)]
 pub struct SymbolGraph {
     /// symbol_name -> list of nodes (same name can appear in multiple files)
     nodes: HashMap<String, Vec<SymbolNode>>,

src/core/symbol_index.rs

@@ -4,6 +4,7 @@ use git2::Repository;
 use ignore::WalkBuilder;
 use once_cell::sync::Lazy;
 use regex::Regex;
+use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use std::collections::{HashMap, HashSet};
 use std::env;
@@ -15,20 +16,23 @@ use std::process::{Child, ChildStdin, ChildStdout, Command, Stdio};
 use crate::core::symbol_graph::SymbolGraph;
 use crate::core::ContextProvenance;
 
+#[path = "symbol_index/persistence.rs"]
+mod persistence;
 #[path = "symbol_index/retrieval.rs"]
 mod retrieval;
 
+pub use persistence::{default_symbol_index_path, load_symbol_index, save_symbol_index};
 pub use retrieval::{SymbolContextRetriever, SymbolRetrievalPolicy};
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SymbolLocation {
     pub file_path: PathBuf,
     pub line_range: (usize, usize),
     pub snippet: String,
     pub provenance: Option<ContextProvenance>,
 }
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
 struct SymbolIndexMetadata {
     provider: String,
     repo_revision: Option<String>,
@@ -160,7 +164,7 @@ impl SymbolIndexFreshnessSnapshot {
     }
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Serialize, Deserialize)]
 pub struct SymbolIndex {
     symbols: HashMap<String, Vec<SymbolLocation>>,
     dependency_graph: HashMap<PathBuf, HashSet<PathBuf>>,
@@ -171,7 +175,7 @@ pub struct SymbolIndex {
     metadata: SymbolIndexMetadata,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 struct FileSummary {
     snippet: String,
     line_count: usize,
@@ -555,6 +559,14 @@ impl SymbolIndex {
         self.freshness_snapshot(repo_root).trace_details()
     }
 
+    pub fn to_json(&self) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(self)
+    }
+
+    pub fn from_json(content: &str) -> Result<Self, serde_json::Error> {
+        serde_json::from_str(content)
+    }
+
     fn register_file_summary(&mut self, relative: &Path, lines: &[&str]) {
         let line_count = lines.len();
         let snippet = lines

src/core/symbol_index/persistence.rs

@@ -0,0 +1,79 @@
+use anyhow::Result;
+use sha2::{Digest, Sha256};
+use std::path::{Path, PathBuf};
+
+use super::SymbolIndex;
+
+pub fn default_symbol_index_path(repo_root: &Path, cache_key: &str) -> PathBuf {
+    let repo_key = hash_text(&repo_root.to_string_lossy());
+    let cache_key = if cache_key.trim().is_empty() {
+        "default".to_string()
+    } else {
+        cache_key.trim().to_string()
+    };
+
+    dirs::data_local_dir()
+        .unwrap_or_else(|| PathBuf::from("."))
+        .join("diffscope")
+        .join("symbol-index")
+        .join(format!(
+            "{}-{}.json",
+            &repo_key[..16],
+            &cache_key[..cache_key.len().min(16)]
+        ))
+}
+
+pub fn load_symbol_index(path: &Path) -> Option<SymbolIndex> {
+    std::fs::read_to_string(path)
+        .ok()
+        .and_then(|content| SymbolIndex::from_json(&content).ok())
+}
+
+pub fn save_symbol_index(path: &Path, index: &SymbolIndex) -> Result<()> {
+    atomic_write_string(path, &index.to_json()?)
+}
+
+fn atomic_write_string(path: &Path, content: &str) -> Result<()> {
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+
+    let file_name = path
+        .file_name()
+        .and_then(|value| value.to_str())
+        .unwrap_or("symbol-index.json");
+    let tmp_path = path.with_file_name(format!("{}.{}.tmp", file_name, std::process::id()));
+    std::fs::write(&tmp_path, content)?;
+    std::fs::rename(&tmp_path, path)?;
+    Ok(())
+}
+
+fn hash_text(content: &str) -> String {
+    format!("{:x}", Sha256::digest(content.as_bytes()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::core::SymbolIndex;
+
+    #[test]
+    fn save_and_load_symbol_index_round_trips() {
+        let dir = tempfile::tempdir().unwrap();
+        let repo_root = dir.path().join("repo");
+        std::fs::create_dir_all(&repo_root).unwrap();
+        let cache_path = dir.path().join("symbol-index.json");
+
+        let source_file = repo_root.join("src/lib.rs");
+        std::fs::create_dir_all(source_file.parent().unwrap()).unwrap();
+        std::fs::write(&source_file, "pub fn helper() {}\n").unwrap();
+
+        let index = SymbolIndex::build(&repo_root, 16, 128 * 1024, 8, |_path| false).unwrap();
+        save_symbol_index(&cache_path, &index).unwrap();
+
+        let loaded = load_symbol_index(&cache_path).unwrap();
+        assert_eq!(loaded.files_indexed(), index.files_indexed());
+        assert_eq!(loaded.symbols_indexed(), index.symbols_indexed());
+        assert!(loaded.lookup("helper").is_some());
+    }
+}