feat(review): surface similar implementation lookup

haasonsaas · haasonsaas · commit 294ad93e857b · 2026-03-14T15:58:25.000-07:00
diff --git a/TODO.md b/TODO.md
@@ -64,7 +64,7 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 31. [ ] 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. [ ] Add "similar implementation" lookup so repeated patterns and divergences are explicit.
+34. [x] Add "similar implementation" lookup so repeated patterns and divergences are explicit.
 35. [x] Add cross-file blast-radius summaries to findings when a change affects many callers.
 36. [x] Add graph freshness/version metadata so reviews know whether they are using stale repository intelligence.
 37. [x] Add graph-backed ranking of related files before semantic RAG retrieval.
diff --git a/src/core/context_provenance.rs b/src/core/context_provenance.rs
@@ -21,6 +21,10 @@ pub enum ContextProvenance {
     },
     RelatedTestFile,
     ReverseDependencySummary,
+    SimilarImplementation {
+        similarity: f32,
+        symbol_name: String,
+    },
     SemanticRetrieval {
         similarity: f32,
         symbol_name: String,
@@ -56,6 +60,13 @@ impl ContextProvenance {
         }
     }
 
+    pub fn similar_implementation(similarity: f32, symbol_name: impl Into<String>) -> Self {
+        Self::SimilarImplementation {
+            similarity,
+            symbol_name: symbol_name.into(),
+        }
+    }
+
     pub fn symbol_graph_path(relation_path: Vec<String>, hops: usize, relevance: f32) -> Self {
         Self::SymbolGraphPath {
             relation_path,
@@ -69,6 +80,7 @@ impl ContextProvenance {
             Self::ActiveReviewRules => 120,
             Self::PatternRepositorySource { .. } => 40,
             Self::PatternRepositoryContext { .. } => 35,
+            Self::SimilarImplementation { .. } => 30,
             Self::SemanticRetrieval { .. } => 25,
             Self::SymbolGraphPath {
                 relation_path,
@@ -99,6 +111,7 @@ impl ContextProvenance {
     pub fn verification_bonus(&self) -> i32 {
         match self {
             Self::SymbolGraphPath { .. } => 80,
+            Self::SimilarImplementation { .. } => 35,
             Self::SemanticRetrieval { .. } => 30,
             _ => 0,
         }
@@ -120,6 +133,12 @@ impl ContextProvenance {
             }
             Self::RelatedTestFile => "related test file".to_string(),
             Self::ReverseDependencySummary => "reverse dependency summary".to_string(),
+            Self::SimilarImplementation {
+                similarity,
+                symbol_name,
+            } => {
+                format!("similar implementation (similarity={similarity:.2}, symbol={symbol_name})")
+            }
             Self::SemanticRetrieval {
                 similarity,
                 symbol_name,
@@ -166,6 +185,14 @@ mod tests {
         );
         assert_eq!(provenance.ranking_bonus(), 75);
         assert_eq!(provenance.verification_bonus(), 80);
+
+        let similar = ContextProvenance::similar_implementation(0.91, "validate_user");
+        assert_eq!(
+            similar.to_string(),
+            "similar implementation (similarity=0.91, symbol=validate_user)"
+        );
+        assert_eq!(similar.ranking_bonus(), 30);
+        assert_eq!(similar.verification_bonus(), 35);
     }
 
     #[test]
diff --git a/src/core/semantic.rs b/src/core/semantic.rs
@@ -265,32 +265,38 @@ pub async fn semantic_context_for_diff(
     );
     let preferred_file_ranks = build_preferred_file_ranks(preferred_files);
 
-    let mut seen = HashSet::new();
-    let mut chunks = Vec::new();
+    build_semantic_context_chunks(matches, limit, &preferred_file_ranks)
+}
+
+fn build_semantic_context_chunks(
+    matches: Vec<SemanticMatch>,
+    limit: usize,
+    preferred_file_ranks: &HashMap<PathBuf, usize>,
+) -> Vec<LLMContextChunk> {
+    if limit == 0 {
+        return Vec::new();
+    }
+
+    let similar_implementations = select_similar_implementation_matches(&matches, limit.min(2));
+    let mut seen = similar_implementations
+        .iter()
+        .map(|semantic_match| semantic_match.chunk.key.clone())
+        .collect::<HashSet<_>>();
+    let mut chunks = similar_implementations
+        .into_iter()
+        .map(|semantic_match| {
+            build_similar_implementation_chunk(semantic_match, preferred_file_ranks)
+        })
+        .collect::<Vec<_>>();
+
     for semantic_match in matches {
         if !seen.insert(semantic_match.chunk.key.clone()) {
             continue;
         }
-        let ranking_note = preferred_file_ranks
-            .get(&semantic_match.chunk.file_path)
-            .map(|rank| format!(", graph-ranked file #{}", rank + 1))
-            .unwrap_or_default();
-        let content = format!(
-            "Semantic match (similarity {:.2}{})\nSymbol: {}\nSummary: {}\nCode:\n{}",
-            semantic_match.similarity,
-            ranking_note,
-            semantic_match.chunk.symbol_name,
-            semantic_match.chunk.summary,
-            semantic_match.chunk.code_excerpt,
-        );
-        chunks.push(
-            LLMContextChunk::reference(semantic_match.chunk.file_path.clone(), content)
-                .with_line_range(semantic_match.chunk.line_range)
-                .with_provenance(ContextProvenance::semantic_retrieval(
-                    semantic_match.similarity,
-                    semantic_match.chunk.symbol_name.clone(),
-                )),
-        );
+        chunks.push(build_semantic_match_chunk(
+            &semantic_match,
+            preferred_file_ranks,
+        ));
         if chunks.len() >= limit {
             break;
         }
@@ -299,6 +305,87 @@ pub async fn semantic_context_for_diff(
     chunks
 }
 
+fn select_similar_implementation_matches(
+    matches: &[SemanticMatch],
+    limit: usize,
+) -> Vec<&SemanticMatch> {
+    if limit == 0 {
+        return Vec::new();
+    }
+
+    let mut seen_files = HashSet::new();
+    let mut selected = Vec::new();
+
+    for semantic_match in matches {
+        if !seen_files.insert(semantic_match.chunk.file_path.clone()) {
+            continue;
+        }
+
+        selected.push(semantic_match);
+        if selected.len() >= limit {
+            break;
+        }
+    }
+
+    selected
+}
+
+fn build_semantic_match_chunk(
+    semantic_match: &SemanticMatch,
+    preferred_file_ranks: &HashMap<PathBuf, usize>,
+) -> LLMContextChunk {
+    let ranking_note =
+        graph_ranked_file_note(preferred_file_ranks, &semantic_match.chunk.file_path);
+    let content = format!(
+        "Semantic match (similarity {:.2}{})\nSymbol: {}\nSummary: {}\nCode:\n{}",
+        semantic_match.similarity,
+        ranking_note,
+        semantic_match.chunk.symbol_name,
+        semantic_match.chunk.summary,
+        semantic_match.chunk.code_excerpt,
+    );
+
+    LLMContextChunk::reference(semantic_match.chunk.file_path.clone(), content)
+        .with_line_range(semantic_match.chunk.line_range)
+        .with_provenance(ContextProvenance::semantic_retrieval(
+            semantic_match.similarity,
+            semantic_match.chunk.symbol_name.clone(),
+        ))
+}
+
+fn build_similar_implementation_chunk(
+    semantic_match: &SemanticMatch,
+    preferred_file_ranks: &HashMap<PathBuf, usize>,
+) -> LLMContextChunk {
+    let ranking_note =
+        graph_ranked_file_note(preferred_file_ranks, &semantic_match.chunk.file_path);
+    let content = format!(
+        "Similar implementation (similarity {:.2}{})\nCompare this implementation for repeated patterns or divergences.\nSymbol: {}\nSummary: {}\nCode:\n{}",
+        semantic_match.similarity,
+        ranking_note,
+        semantic_match.chunk.symbol_name,
+        semantic_match.chunk.summary,
+        semantic_match.chunk.code_excerpt,
+    );
+
+    LLMContextChunk::reference(semantic_match.chunk.file_path.clone(), content)
+        .with_line_range(semantic_match.chunk.line_range)
+        .with_provenance(ContextProvenance::similar_implementation(
+            semantic_match.similarity,
+            semantic_match.chunk.symbol_name.clone(),
+        ))
+}
+
+fn graph_ranked_file_note(
+    preferred_file_ranks: &HashMap<PathBuf, usize>,
+    file_path: &Path,
+) -> String {
+    preferred_file_ranks
+        .get(file_path)
+        .map(|rank| format!(", graph-ranked file #{}", rank + 1))
+        .unwrap_or_default()
+}
+
 #[allow(dead_code)]
 pub fn find_related_chunks(
     index: &SemanticIndex,
@@ -662,7 +749,11 @@ mod tests {
 
         let chunks = semantic_context_for_diff(&index, &diff, None, None, 3, 0.1, &[]).await;
         assert_eq!(chunks.len(), 1);
-        assert!(chunks[0].content.contains("Semantic match"));
+        assert!(chunks[0].content.contains("Similar implementation"));
+        assert!(matches!(
+            chunks[0].provenance,
+            Some(ContextProvenance::SimilarImplementation { .. })
+        ));
     }
 
     #[test]
@@ -732,4 +823,72 @@ mod tests {
         assert_eq!(matches[0].chunk.file_path, PathBuf::from("src/graph.rs"));
         assert_eq!(matches[1].chunk.file_path, PathBuf::from("src/other.rs"));
     }
+
+    #[test]
+    fn build_semantic_context_chunks_highlights_similar_implementations_first() {
+        let matches = vec![
+            SemanticMatch {
+                chunk: SemanticChunk {
+                    key: "src/auth_guard.rs:validate:1:5".to_string(),
+                    file_path: PathBuf::from("src/auth_guard.rs"),
+                    symbol_name: "validate_admin".to_string(),
+                    line_range: (1, 5),
+                    summary: "Auth guard before a query".to_string(),
+                    embedding_text: "auth guard before a query".to_string(),
+                    code_excerpt: "fn validate_admin() {}".to_string(),
+                    embedding: local_hash_embedding("auth guard before a query"),
+                    content_hash: "guard".to_string(),
+                },
+                similarity: 0.93,
+            },
+            SemanticMatch {
+                chunk: SemanticChunk {
+                    key: "src/member_guard.rs:validate:1:5".to_string(),
+                    file_path: PathBuf::from("src/member_guard.rs"),
+                    symbol_name: "validate_member".to_string(),
+                    line_range: (1, 5),
+                    summary: "Member auth guard before a query".to_string(),
+                    embedding_text: "member auth guard before a query".to_string(),
+                    code_excerpt: "fn validate_member() {}".to_string(),
+                    embedding: local_hash_embedding("member auth guard before a query"),
+                    content_hash: "member".to_string(),
+                },
+                similarity: 0.89,
+            },
+            SemanticMatch {
+                chunk: SemanticChunk {
+                    key: "src/sanitize.rs:sanitize:1:5".to_string(),
+                    file_path: PathBuf::from("src/sanitize.rs"),
+                    symbol_name: "sanitize_name".to_string(),
+                    line_range: (1, 5),
+                    summary: "Sanitize a username before building a query".to_string(),
+                    embedding_text: "sanitize a username before building a query".to_string(),
+                    code_excerpt: "fn sanitize_name() {}".to_string(),
+                    embedding: local_hash_embedding("sanitize a username before building a query"),
+                    content_hash: "sanitize".to_string(),
+                },
+                similarity: 0.82,
+            },
+        ];
+
+        let chunks = build_semantic_context_chunks(
+            matches,
+            3,
+            &build_preferred_file_ranks(&[PathBuf::from("src/auth_guard.rs")]),
+        );
+
+        assert_eq!(chunks.len(), 3);
+        assert!(chunks[0].content.contains("Similar implementation"));
+        assert!(chunks[1].content.contains("Similar implementation"));
+        assert!(chunks[2].content.contains("Semantic match"));
+        assert!(matches!(
+            chunks[0].provenance,
+            Some(ContextProvenance::SimilarImplementation { .. })
+        ));
+        assert!(matches!(
+            chunks[2].provenance,
+            Some(ContextProvenance::SemanticRetrieval { .. })
+        ));
+        assert!(chunks[0].content.contains("graph-ranked file #1"));
+    }
 }
diff --git a/src/review/pipeline/file_context/sources/supplemental.rs b/src/review/pipeline/file_context/sources/supplemental.rs
