feat(analytics): track pattern repository impact

Author: haasonsaas

TODO.md

@@ -106,7 +106,7 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 64. [x] Add unresolved blocker counts per repository and per PR.
 65. [x] Add review completeness and mean-time-to-resolution charts.
 66. [x] Add feedback-learning effectiveness metrics: did reranked findings get higher acceptance after rollout?
-67. [ ] Add pattern-repository utilization analytics showing when extra context actually affected findings.
+67. [x] Add pattern-repository utilization analytics showing when extra context actually affected findings.
 68. [x] Add eval-vs-production dashboards comparing benchmark strength against real-world acceptance.
 69. [x] Add drill-downs from trend charts directly into the affected reviews, findings, and rules.
 70. [x] Add exportable JSON/CSV reports for review quality, lifecycle, and reinforcement metrics.

src/review/rule_helpers/runtime.rs

@@ -90,4 +90,58 @@ mod tests {
         let result = apply_rule_overrides(vec![comment], &rules);
         assert_eq!(result[0].severity, core::comment::Severity::Info);
     }
+
+    #[test]
+    fn apply_rule_overrides_tags_pattern_repository_sources() {
+        let mut comment = build_comment(
+            "c1",
+            core::comment::Category::Bug,
+            core::comment::Severity::Info,
+            0.5,
+        );
+        comment.rule_id = Some("sec.sql.injection".to_string());
+
+        let rules = vec![core::ReviewRule {
+            source: "https://github.com/acme/security-rules.git".to_string(),
+            id: "sec.sql.injection".to_string(),
+            description: "Parameterized queries required".to_string(),
+            severity: None,
+            category: None,
+            scope: None,
+            tags: vec![],
+        }];
+
+        let result = apply_rule_overrides(vec![comment], &rules);
+        assert!(result[0].tags.contains(&"pattern-repository".to_string()));
+        assert!(result[0]
+            .tags
+            .contains(&"pattern-repository:acme/security-rules".to_string()));
+    }
+
+    #[test]
+    fn apply_rule_overrides_skips_repository_source_tag_for_local_rules() {
+        let mut comment = build_comment(
+            "c1",
+            core::comment::Category::Bug,
+            core::comment::Severity::Info,
+            0.5,
+        );
+        comment.rule_id = Some("local.rule".to_string());
+
+        let rules = vec![core::ReviewRule {
+            source: "repository".to_string(),
+            id: "local.rule".to_string(),
+            description: "Repo-local rule".to_string(),
+            severity: None,
+            category: None,
+            scope: None,
+            tags: vec![],
+        }];
+
+        let result = apply_rule_overrides(vec![comment], &rules);
+        assert!(!result[0]
+            .tags
+            .iter()
+            .any(|tag| tag.starts_with("pattern-repository")));
+    }
 }

src/review/rule_helpers/runtime/overrides.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::path::Path;
 
 use crate::core;
 
@@ -67,9 +68,77 @@ fn apply_rule_tags(comment: &mut core::Comment, rule: &core::ReviewRule) {
     if !comment.tags.iter().any(|tag| tag == &marker) {
         comment.tags.push(marker);
     }
+
+    if let Some(pattern_repository_tag) = pattern_repository_source_tag(&rule.source) {
+        if !comment
+            .tags
+            .iter()
+            .any(|existing| existing == "pattern-repository")
+        {
+            comment.tags.push("pattern-repository".to_string());
+        }
+        if !comment
+            .tags
+            .iter()
+            .any(|existing| existing == &pattern_repository_tag)
+        {
+            comment.tags.push(pattern_repository_tag);
+        }
+    }
+
     for tag in &rule.tags {
         if !comment.tags.iter().any(|existing| existing == tag) {
             comment.tags.push(tag.clone());
         }
     }
 }
+
+fn pattern_repository_source_tag(source: &str) -> Option<String> {
+    let trimmed = source.trim();
+    if trimmed.is_empty() || trimmed.eq_ignore_ascii_case("repository") {
+        return None;
+    }
+
+    Some(format!(
+        "pattern-repository:{}",
+        pattern_repository_source_label(trimmed)
+    ))
+}
+
+fn pattern_repository_source_label(source: &str) -> String {
+    let trimmed = source.trim().trim_end_matches('/').trim_end_matches(".git");
+
+    if !trimmed.contains("://") && !trimmed.contains('@') {
+        let parts = trimmed
+            .split('/')
+            .filter(|part| !part.is_empty())
+            .collect::<Vec<_>>();
+
+        if parts.len() == 2 {
+            return format!("{}/{}", parts[0], parts[1]);
+        }
+    }
+
+    if !trimmed.contains("://") && !trimmed.contains('@') {
+        if let Some(name) = Path::new(trimmed)
+            .file_name()
+            .and_then(|value| value.to_str())
+        {
+            if !name.is_empty() {
+                return name.to_string();
+            }
+        }
+    }
+
+    let normalized = trimmed.replace(':', "/");
+    let parts = normalized
+        .split('/')
+        .filter(|part| !part.is_empty() && !part.ends_with(':'))
+        .collect::<Vec<_>>();
+
+    match parts.as_slice() {
+        [.., owner, repo] => format!("{owner}/{repo}"),
+        [single] => (*single).to_string(),
+        [] => "external".to_string(),
+    }
+}