feat: add path-scoped reinforcement buckets

Author: haasonsaas

TODO.md

@@ -28,7 +28,7 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 4. [ ] Separate false-positive rejections from "valid but won't fix" dismissals in stored feedback.
 5. [ ] Weight reinforcement by reviewer role or trust level when GitHub identity is available.
 6. [ ] Add rule-level reinforcement decay so old team preferences do not dominate forever.
-7. [ ] Add path-scoped reinforcement buckets so teams can prefer different standards in `tests/`, `scripts/`, and production code.
+7. [x] Add path-scoped reinforcement buckets so teams can prefer different standards in `tests/`, `scripts/`, and production code.
 8. [ ] Persist explanation text from follow-up feedback replies and mine it into reusable review guidance.
 9. [ ] Learn "preferred phrasing" for accepted comments so comment tone and specificity improve over time.
 10. [ ] Backfill existing stored reviews into the new outcome-aware feedback store for cold-start reduction.
@@ -177,4 +177,5 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 - [x] Add pattern repository resolution coverage for repo-local directories, Git sources, and broken-source skips.
 - [x] Group ReviewView list-mode findings into unresolved, fixed, stale, and informational sections.
 - [x] Add ReviewView keyboard shortcuts for next-finding navigation plus accept/reject/resolve actions.
+- [x] Add path-scoped reinforcement buckets so feedback can distinguish `tests/**`, `scripts/**`, and broader code areas.
 - [ ] Commit and push each validated checkpoint before moving to the next epic.

src/review/feedback.rs

@@ -43,9 +43,18 @@ mod tests {
     }
 
     #[test]
-    fn derive_file_patterns_prefers_specific_suffixes() {
+    fn derive_file_patterns_adds_path_scopes_before_suffixes() {
         let patterns = derive_file_patterns(Path::new("web/src/Settings.test.ts"));
-        assert_eq!(patterns, vec!["*.test.ts", "*.ts"]);
+        assert_eq!(
+            patterns,
+            vec!["web/src/**", "web/**", "src/**", "*.test.ts", "*.ts"]
+        );
+    }
+
+    #[test]
+    fn derive_file_patterns_supports_extensionless_path_scopes() {
+        let patterns = derive_file_patterns(Path::new("scripts/release"));
+        assert_eq!(patterns, vec!["scripts/**"]);
     }
 
     #[test]

src/review/feedback/patterns.rs

@@ -1,6 +1,12 @@
-use std::path::Path;
+use std::path::{Component, Path};
 
 pub fn derive_file_patterns(path: &Path) -> Vec<String> {
+    let mut patterns = derive_directory_scope_patterns(path);
+    patterns.extend(derive_suffix_patterns(path));
+    patterns
+}
+
+fn derive_suffix_patterns(path: &Path) -> Vec<String> {
     let Some(file_name) = path.file_name().and_then(|name| name.to_str()) else {
         return Vec::new();
     };
@@ -20,3 +26,39 @@ pub fn derive_file_patterns(path: &Path) -> Vec<String> {
 
     patterns
 }
+
+fn derive_directory_scope_patterns(path: &Path) -> Vec<String> {
+    let Some(parent) = path.parent() else {
+        return Vec::new();
+    };
+
+    let segments = parent
+        .components()
+        .filter_map(|component| match component {
+            Component::Normal(segment) => Some(segment.to_string_lossy().into_owned()),
+            _ => None,
+        })
+        .collect::<Vec<_>>();
+
+    if segments.is_empty() {
+        return Vec::new();
+    }
+
+    let mut patterns = Vec::new();
+
+    for end in (1..=segments.len()).rev() {
+        push_unique(&mut patterns, format!("{}/**", segments[..end].join("/")));
+    }
+
+    for start in 1..segments.len() {
+        push_unique(&mut patterns, format!("{}/**", segments[start..].join("/")));
+    }
+
+    patterns
+}
+
+fn push_unique(patterns: &mut Vec<String>, pattern: String) {
+    if !patterns.contains(&pattern) {
+        patterns.push(pattern);
+    }
+}

src/review/feedback/record.rs

@@ -80,7 +80,16 @@ mod tests {
 
         assert!(store.accept.contains(&comment.id));
         assert_eq!(store.by_category["Security"].accepted, 1);
+        assert_eq!(store.by_file_pattern["src/**"].accepted, 1);
+        assert_eq!(
+            store.by_category_file_pattern["Security|src/**"].accepted,
+            1
+        );
         assert_eq!(store.by_rule["sec.sql.injection"].accepted, 1);
+        assert_eq!(
+            store.by_rule_file_pattern["sec.sql.injection|src/**"].accepted,
+            1
+        );
         assert_eq!(
             store.by_rule_file_pattern["sec.sql.injection|*.rs"].accepted,
             1

src/review/filters.rs

@@ -462,6 +462,30 @@ mod tests {
         );
     }
 
+    #[test]
+    fn feedback_confidence_prefers_path_scoped_buckets() {
+        let mut feedback = FeedbackStore::default();
+        for _ in 0..10 {
+            feedback.record_feedback("Bug", None, true);
+            feedback.record_feedback_patterns("Bug", &["tests/**"], false);
+        }
+
+        let mut comment = build_comment(
+            "c1",
+            core::comment::Category::Bug,
+            core::comment::Severity::Error,
+            0.8,
+        );
+        comment.file_path = PathBuf::from("tests/unit/parser.rs");
+
+        let result = apply_feedback_confidence_adjustment(vec![comment], &feedback, 5);
+        assert!(
+            (result[0].confidence - 0.6).abs() < 0.01,
+            "Expected path-scoped rejection history to win, got {}",
+            result[0].confidence
+        );
+    }
+
     #[test]
     fn feedback_confidence_clamped_to_one() {
         let mut feedback = FeedbackStore::default();