TDD: fix path prefix matching boundary and feedback stats double-counting

- config.rs, rules.rs: path_matches now checks path component boundaries
  so pattern "src" won't incorrectly match "srcfoo/file.rs"
- misc.rs: extract feedback accept/reject into testable functions and
  only increment stats when comment ID is newly inserted (fixes
  double-counting when same comment is accepted/rejected multiple times)

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

Author: haasonsaas

src/commands/misc.rs

@@ -193,29 +193,12 @@ pub async fn feedback_command(
     }
 
     let mut store = review::load_feedback_store_from_path(&feedback_path);
-    let mut updated = 0usize;
 
-    if action == "accept" {
-        for comment in &comments {
-            if store.accept.insert(comment.id.clone()) {
-                updated += 1;
-            }
-            store.suppress.remove(&comment.id);
-            let key = review::classify_comment_type(comment).as_str().to_string();
-            let stats = store.by_comment_type.entry(key).or_default();
-            stats.accepted = stats.accepted.saturating_add(1);
-        }
+    let updated = if action == "accept" {
+        apply_feedback_accept(&mut store, &comments)
     } else {
-        for comment in &comments {
-            if store.suppress.insert(comment.id.clone()) {
-                updated += 1;
-            }
-            store.accept.remove(&comment.id);
-            let key = review::classify_comment_type(comment).as_str().to_string();
-            let stats = store.by_comment_type.entry(key).or_default();
-            stats.rejected = stats.rejected.saturating_add(1);
-        }
-    }
+        apply_feedback_reject(&mut store, &comments)
+    };
 
     review::save_feedback_store(&feedback_path, &store)?;
     println!(
@@ -228,6 +211,42 @@ pub async fn feedback_command(
     Ok(())
 }
 
+fn apply_feedback_accept(
+    store: &mut review::FeedbackStore,
+    comments: &[core::Comment],
+) -> usize {
+    let mut updated = 0;
+    for comment in comments {
+        let is_new = store.accept.insert(comment.id.clone());
+        if is_new {
+            updated += 1;
+            let key = review::classify_comment_type(comment).as_str().to_string();
+            let stats = store.by_comment_type.entry(key).or_default();
+            stats.accepted = stats.accepted.saturating_add(1);
+        }
+        store.suppress.remove(&comment.id);
+    }
+    updated
+}
+
+fn apply_feedback_reject(
+    store: &mut review::FeedbackStore,
+    comments: &[core::Comment],
+) -> usize {
+    let mut updated = 0;
+    for comment in comments {
+        let is_new = store.suppress.insert(comment.id.clone());
+        if is_new {
+            updated += 1;
+            let key = review::classify_comment_type(comment).as_str().to_string();
+            let stats = store.by_comment_type.entry(key).or_default();
+            stats.rejected = stats.rejected.saturating_add(1);
+        }
+        store.accept.remove(&comment.id);
+    }
+    updated
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 struct DiscussionTurn {
     role: String,
@@ -387,6 +406,40 @@ mod tests {
         let result = select_discussion_comment(&[comment.clone()], None, None).unwrap();
         assert_eq!(result.id, "cmt_1");
     }
+
+    #[test]
+    fn test_feedback_stats_not_double_counted() {
+        // Simulate accepting the same comment twice — stats should only increment once
+        let mut store = review::FeedbackStore::default();
+        let comment = core::Comment {
+            id: "cmt_dup".to_string(),
+            file_path: PathBuf::from("test.rs"),
+            line_number: 1,
+            content: "test".to_string(),
+            rule_id: None,
+            severity: core::comment::Severity::Warning,
+            category: core::comment::Category::Bug,
+            suggestion: None,
+            confidence: 0.8,
+            code_suggestion: None,
+            tags: vec![],
+            fix_effort: core::comment::FixEffort::Low,
+        };
+
+        let comments = vec![comment];
+
+        // Accept the same batch of comments twice
+        for _ in 0..2 {
+            apply_feedback_accept(&mut store, &comments);
+        }
+
+        let key = review::classify_comment_type(&comments[0]).as_str().to_string();
+        let stats = &store.by_comment_type[&key];
+        assert_eq!(
+            stats.accepted, 1,
+            "Stats should only count 1 acceptance, not 2 (double-counting bug)"
+        );
+    }
 }
 
 fn load_discussion_thread(path: Option<&std::path::Path>, comment_id: &str) -> DiscussionThread {

src/config.rs

@@ -517,8 +517,9 @@ impl Config {
                 false
             }
         } else {
-            // Direct path prefix matching
-            path.starts_with(pattern)
+            // Path prefix matching with component boundary check
+            path == pattern
+                || path.starts_with(&format!("{}/", pattern.trim_end_matches('/')))
         }
     }
 }
@@ -690,4 +691,30 @@ mod tests {
 
         assert_eq!(config.comment_types, vec!["logic", "style"]);
     }
+
+    #[test]
+    fn path_matches_respects_component_boundary() {
+        let config = Config::default();
+
+        // Exact prefix with separator should match
+        assert!(config.path_matches("src/file.rs", "src/"));
+        assert!(config.path_matches("src/sub/file.rs", "src"));
+
+        // Glob patterns should still work
+        assert!(config.path_matches("src/file.rs", "src/*.rs"));
+
+        // Non-glob pattern must NOT match a different path component
+        // "src" should not match "srcfoo/file.rs" or "src-backup/file.rs"
+        assert!(
+            !config.path_matches("srcfoo/file.rs", "src"),
+            "pattern 'src' should not match 'srcfoo/file.rs' (different path component)"
+        );
+        assert!(
+            !config.path_matches("src-backup/file.rs", "src"),
+            "pattern 'src' should not match 'src-backup/file.rs'"
+        );
+
+        // Exact match should work
+        assert!(config.path_matches("src/file.rs", "src/file.rs"));
+    }
 }

src/core/rules.rs

@@ -186,6 +186,25 @@ fn path_matches(path: &str, pattern: &str) -> bool {
             .map(|pattern| pattern.matches(path))
             .unwrap_or(false)
     } else {
-        path.starts_with(pattern)
+        path == pattern
+            || path.starts_with(&format!("{}/", pattern.trim_end_matches('/')))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rules_path_matches_respects_component_boundary() {
+        // "src" should match "src/file.rs" (path starts with component "src")
+        assert!(path_matches("src/file.rs", "src"));
+        assert!(path_matches("src/file.rs", "src/"));
+
+        // "src" should NOT match "srcfoo/file.rs" (different component)
+        assert!(
+            !path_matches("srcfoo/file.rs", "src"),
+            "pattern 'src' should not match 'srcfoo/file.rs'"
+        );
     }
 }