feat: add file triage, dynamic context boundaries, and robust LLM parsing

Phase 1 improvements to the review pipeline, informed by competitive analysis
of Greptile, CodeRabbit, and Qodo Merge architectures:

- File triage (#29): Heuristic classifier skips lock files, generated files,
  deletion-only, whitespace-only, and comment-only changes before expensive
  LLM review. 45 unit tests.

- Dynamic context boundaries (#25): Context fetcher now searches upward for
  enclosing function/class definitions instead of using fixed-window context.
  Uses asymmetric padding (more before, less after) matching Qodo's approach.
  6 unit tests.

- Robust LLM output parsing (#28): 5-strategy fallback chain for parsing LLM
  responses — primary format, numbered lists, markdown bullets, file:line
  format, and JSON extraction. Prevents silent comment loss when models deviate
  from the expected format. 11 unit tests.

- Fix rust-embed v8 derive macro (Embed -> RustEmbed)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: haasonsaas

src/core/context.rs

@@ -5,6 +5,7 @@ use std::collections::HashSet;
 use std::path::Path;
 use std::path::PathBuf;
 
+use crate::core::function_chunker::find_enclosing_boundary_line;
 use crate::core::SymbolIndex;
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LLMContextChunk {
@@ -50,8 +51,19 @@ impl ContextFetcher {
                 }
                 let start = start.max(1);
                 let end = end.max(start);
-                let start_idx = start.saturating_sub(1);
-                let end_idx = end.min(file_lines.len());
+
+                // Dynamic context: expand start to enclosing function boundary
+                let expanded_start =
+                    find_enclosing_boundary_line(&content, file_path, start, 10)
+                        .filter(|&boundary| boundary >= start.saturating_sub(10))
+                        .unwrap_or_else(|| start.saturating_sub(5)); // fallback: 5 lines before
+                let expanded_start = expanded_start.max(1);
+
+                // Asymmetric: less context after (1 extra line)
+                let expanded_end = (end + 1).min(file_lines.len());
+
+                let start_idx = expanded_start.saturating_sub(1);
+                let end_idx = expanded_end.min(file_lines.len());
 
                 if start_idx < file_lines.len() {
                     let chunk_content = truncate_with_notice(
@@ -62,7 +74,7 @@ impl ContextFetcher {
                         file_path: file_path.clone(),
                         content: chunk_content,
                         context_type: ContextType::FileContent,
-                        line_range: Some((start, end)),
+                        line_range: Some((expanded_start, expanded_end)),
                     });
                 }
             }
@@ -330,6 +342,28 @@ mod tests {
         let merged = merge_ranges(&ranges);
         assert_eq!(merged, vec![(1, 10)]);
     }
+
+    #[tokio::test]
+    async fn test_fetch_context_expands_to_function_boundary() {
+        // Create a temp file with a function
+        let dir = tempfile::tempdir().unwrap();
+        let file_path = dir.path().join("test.rs");
+        let content = "use std::io;\n\npub fn process(x: i32) -> bool {\n    let y = x + 1;\n    y > 0\n}\n\npub fn other() {\n    println!(\"hi\");\n}\n";
+        std::fs::write(&file_path, content).unwrap();
+
+        let fetcher = ContextFetcher::new(dir.path().to_path_buf());
+        let relative = PathBuf::from("test.rs");
+        // Request context for line 4-5 (inside process function)
+        let chunks = fetcher
+            .fetch_context_for_file(&relative, &[(4, 5)])
+            .await
+            .unwrap();
+
+        assert!(!chunks.is_empty());
+        // Should expand to include the function signature (line 3)
+        let chunk = &chunks[0];
+        assert!(chunk.content.contains("pub fn process"));
+    }
 }
 
 async fn read_file_lossy(path: &Path) -> Result<String> {

src/core/function_chunker.rs

@@ -282,6 +282,21 @@ fn find_function_end(lines: &[&str], start: usize, language: &str) -> usize {
     }
 }
 
+/// Given file content and a line number, find the start line of the enclosing
+/// function/class boundary. Searches upward from `line` up to `max_search_lines`.
+/// Returns the boundary start line, or None if no boundary found.
+pub fn find_enclosing_boundary_line(
+    content: &str,
+    file_path: &Path,
+    line: usize,
+    _max_search_lines: usize,
+) -> Option<usize> {
+    let language = detect_language(file_path);
+    let boundaries = detect_function_boundaries(content, &language);
+    // Find the innermost function containing this line
+    find_enclosing_function(&boundaries, line).map(|b| b.start_line)
+}
+
 fn detect_language(file_path: &Path) -> String {
     file_path
         .extension()
@@ -851,6 +866,51 @@ fn next_func() {
         assert!(result.is_some());
     }
 
+    #[test]
+    fn test_find_enclosing_boundary_line_rust() {
+        let content =
+            "use std::io;\n\npub fn process(x: i32) -> bool {\n    let y = x + 1;\n    y > 0\n}\n";
+        let path = Path::new("test.rs");
+        // Line 4 is inside process() which starts at line 3
+        let result = find_enclosing_boundary_line(content, path, 4, 10);
+        assert_eq!(result, Some(3));
+    }
+
+    #[test]
+    fn test_find_enclosing_boundary_line_no_function() {
+        let content = "let x = 1;\nlet y = 2;\n";
+        let path = Path::new("test.rs");
+        let result = find_enclosing_boundary_line(content, path, 1, 10);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_find_enclosing_boundary_line_python() {
+        let content =
+            "import os\n\ndef handle_request(req):\n    data = req.json()\n    return data\n";
+        let path = Path::new("handler.py");
+        // Line 4 is inside handle_request() which starts at line 3
+        let result = find_enclosing_boundary_line(content, path, 4, 10);
+        assert_eq!(result, Some(3));
+    }
+
+    #[test]
+    fn test_find_enclosing_boundary_line_unsupported_language() {
+        let content = "some text\nmore text\n";
+        let path = Path::new("readme.txt");
+        let result = find_enclosing_boundary_line(content, path, 1, 10);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_find_enclosing_boundary_nested_functions() {
+        let content = "pub fn outer() {\n    fn inner() {\n        let x = 1;\n    }\n}\n";
+        let path = Path::new("test.rs");
+        // Line 3 is inside inner() which starts at line 2
+        let result = find_enclosing_boundary_line(content, path, 3, 10);
+        assert_eq!(result, Some(2));
+    }
+
     #[test]
     fn test_find_function_end_escaped_backslash_in_string() {
         // A string containing "\\" (escaped backslash) on the same line as braces.