fix: 7 TDD-discovered bugs — path stripping, hunk parsing, storage, endpoint detection

- extract_path_from_header: use strip_prefix instead of trim_start_matches
  to avoid stripping nested a/ and b/ directory prefixes
- extract_file_path fallback: same strip_prefix fix for the regex fallback
- parse_hunk: only treat "--- " as file boundary when followed by "+++ ",
  fixing premature hunk termination on removed lines starting with "-- "
- list_events: add missing github_repo filter (JSON backend was ignoring it)
- prune: flush to disk after removing reviews (was only removing in memory)
- get_event_stats: strip limit/offset before computing stats to avoid
  computing aggregates on a paginated subset
- Config::is_local_endpoint: delegate to common::is_local_endpoint instead
  of naive string matching that treated all non-OpenAI/Anthropic URLs as local
- is_known_public_api: add OpenRouter, Together, Groq, Fireworks, DeepInfra,
  Perplexity to the known cloud provider list
- has_excessive_repetition: fix empty loop range at boundary text lengths

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

Author: haasonsaas

src/adapters/common.rs

@@ -151,6 +151,12 @@ fn is_known_public_api(host: &str) -> bool {
         || host.contains("mistral.ai")
         || host.contains("cohere.ai")
         || host.contains("cohere.com")
+        || host.contains("openrouter.ai")
+        || host.contains("together.ai")
+        || host.contains("groq.com")
+        || host.contains("fireworks.ai")
+        || host.contains("deepinfra.com")
+        || host.contains("perplexity.ai")
 }
 
 #[cfg(test)]

src/config.rs

@@ -1034,13 +1034,7 @@ impl Config {
     /// Returns true if the configured base_url points to a local/self-hosted server.
     pub fn is_local_endpoint(&self) -> bool {
         match self.base_url.as_deref() {
-            Some(url) => {
-                url.contains("localhost")
-                    || url.contains("127.0.0.1")
-                    || url.contains("0.0.0.0")
-                    || url.contains("[::1]")
-                    || (!url.contains("openai.com") && !url.contains("anthropic.com"))
-            }
+            Some(url) => crate::adapters::common::is_local_endpoint(url),
             None => false,
         }
     }
@@ -1776,4 +1770,30 @@ temperature: 0.3
             model
         );
     }
+
+    #[test]
+    fn test_is_local_endpoint_openrouter_not_local() {
+        // BUG: Config::is_local_endpoint returns true for any URL that doesn't
+        // contain "openai.com" or "anthropic.com", including cloud providers
+        let config = Config {
+            base_url: Some("https://openrouter.ai/api/v1".to_string()),
+            ..Default::default()
+        };
+        assert!(
+            !config.is_local_endpoint(),
+            "OpenRouter is a cloud provider, not a local endpoint"
+        );
+    }
+
+    #[test]
+    fn test_is_local_endpoint_azure_not_local() {
+        let config = Config {
+            base_url: Some("https://myinstance.openai.azure.com/v1".to_string()),
+            ..Default::default()
+        };
+        assert!(
+            !config.is_local_endpoint(),
+            "Azure OpenAI is a cloud provider, not a local endpoint"
+        );
+    }
 }

src/core/diff_parser.rs

@@ -315,8 +315,8 @@ impl DiffParser {
 
         let parts: Vec<&str> = line.split_whitespace().collect();
         if parts.len() >= 4 {
-            let a_path = parts[2].trim_start_matches("a/");
-            let b_path = parts[3].trim_start_matches("b/");
+            let a_path = parts[2].strip_prefix("a/").unwrap_or(parts[2]);
+            let b_path = parts[3].strip_prefix("b/").unwrap_or(parts[3]);
             let chosen = if b_path != "/dev/null" {
                 b_path
             } else {
@@ -342,10 +342,11 @@ impl DiffParser {
         } else {
             raw.split_whitespace().next().unwrap_or(raw)
         };
-        Ok(path
-            .trim_start_matches("a/")
-            .trim_start_matches("b/")
-            .to_string())
+        let path = path
+            .strip_prefix("a/")
+            .or_else(|| path.strip_prefix("b/"))
+            .unwrap_or(path);
+        Ok(path.to_string())
     }
 
     fn parse_hunk(lines: &[&str], i: &mut usize) -> Result<DiffHunk> {
@@ -357,11 +358,17 @@ impl DiffParser {
         let mut old_line = old_start;
         let mut new_line = new_start;
 
+        let is_file_header = |lines: &[&str], idx: usize| -> bool {
+            lines[idx].starts_with("--- ")
+                && lines
+                    .get(idx + 1)
+                    .is_some_and(|next| next.starts_with("+++ "))
+        };
+
         while *i < lines.len()
             && !lines[*i].starts_with("@@")
             && !lines[*i].starts_with("diff --git")
-            && !lines[*i].starts_with("--- ")
-            && !lines[*i].starts_with("+++ ")
+            && !is_file_header(lines, *i)
         {
             let line = lines[*i];
             if line.starts_with("\\ No newline at end of file") {
@@ -599,4 +606,67 @@ index abc..def 100644\n\
             "parse_text_diff with empty new content should set is_deleted=true"
         );
     }
+
+    #[test]
+    fn test_extract_path_from_header_file_in_b_directory() {
+        // BUG: trim_start_matches("a/").trim_start_matches("b/") strips both prefixes
+        // from files inside a directory named "b", e.g. "a/b/config.yaml" -> "config.yaml"
+        let path = DiffParser::extract_path_from_header("--- a/b/config.yaml", "--- ").unwrap();
+        assert_eq!(
+            path, "b/config.yaml",
+            "File in b/ directory should keep the b/ prefix"
+        );
+    }
+
+    #[test]
+    fn test_extract_path_from_header_file_in_a_directory() {
+        // Same bug: "b/a/test.txt" -> "test.txt" via double strip
+        let path = DiffParser::extract_path_from_header("+++ b/a/test.txt", "+++ ").unwrap();
+        assert_eq!(
+            path, "a/test.txt",
+            "File in a/ directory should keep the a/ prefix"
+        );
+    }
+
+    #[test]
+    fn test_parse_hunk_removed_line_starting_with_double_dash() {
+        // BUG: a removed line whose content starts with "-- " produces a diff line
+        // starting with "--- ", which the parser treats as a file header and stops.
+        let diff_text = "\
+diff --git a/test.txt b/test.txt
+--- a/test.txt
++++ b/test.txt
+@@ -1,3 +1,2 @@
+ first line
+--- this is a separator
+ third line
+";
+        let diffs = DiffParser::parse_unified_diff(diff_text).unwrap();
+        assert_eq!(diffs.len(), 1);
+        let hunk = &diffs[0].hunks[0];
+        // Should have 3 changes: context, removed, context
+        assert_eq!(
+            hunk.changes.len(),
+            3,
+            "Hunk should contain all 3 lines, not stop at the '--- ' line. Got {} changes.",
+            hunk.changes.len()
+        );
+        let removed = hunk
+            .changes
+            .iter()
+            .find(|c| c.change_type == ChangeType::Removed);
+        assert!(
+            removed.is_some(),
+            "Should have a removed line with content '-- this is a separator'"
+        );
+    }
+
+    #[test]
+    fn test_extract_file_path_file_in_a_subdirectory() {
+        // Verify the regex path correctly preserves a/ subdirectory
+        let path =
+            DiffParser::extract_file_path("diff --git a/a/nested/file.rs b/a/nested/file.rs")
+                .unwrap();
+        assert_eq!(path, "a/nested/file.rs");
+    }
 }

src/review/pipeline.rs

@@ -1148,7 +1148,8 @@ fn has_excessive_repetition(text: &str) -> bool {
         return false;
     }
     let window = 20.min(text.len() / 5);
-    for start in 0..text.len().saturating_sub(window * 5) {
+    let search_end = text.len().saturating_sub(window);
+    for start in 0..search_end.max(1) {
         if !text.is_char_boundary(start) || !text.is_char_boundary(start + window) {
             continue;
         }
@@ -1910,4 +1911,24 @@ mod tests {
         let config = config::Config::default();
         assert!(!config.multi_pass_specialized);
     }
+
+    #[test]
+    fn test_has_excessive_repetition_boundary_120_chars() {
+        // BUG: when text.len() == 100, window=20, the old loop range was 0..0 (empty).
+        // Even after fixing the range, the check is count > 5, so we need 6 repetitions.
+        let pattern = "abcdefghij1234567890"; // 20 chars
+        let text = pattern.repeat(6); // 120 chars, 6 repetitions
+        assert_eq!(text.len(), 120);
+        assert!(
+            has_excessive_repetition(&text),
+            "120-char string with 6x repeated 20-char pattern should be detected"
+        );
+    }
+
+    #[test]
+    fn test_has_excessive_repetition_short_not_detected() {
+        // Strings under 100 chars should always return false
+        let text = "abc".repeat(30); // 90 chars
+        assert!(!has_excessive_repetition(&text));
+    }
 }