Merge pull request #13 from Eilodon/claude/ci-mcp-connection-check-1x10o2

Claude/ci mcp connection check 1x10o2

Author: Eilodon

crates/ci-cli/src/main.rs

@@ -157,6 +157,8 @@ async fn main() -> Result<()> {
 
             let thresholds = ci_core::fitness::load_thresholds(config.as_deref())?;
             let boundary_rules = ci_core::fitness::load_boundary_rules(config.as_deref())?;
+            let config_drift_doc_paths =
+                ci_core::fitness::load_config_drift_doc_paths(config.as_deref())?;
 
             let conn = rusqlite::Connection::open(&db_path)
                 .unwrap_or_else(|_| rusqlite::Connection::open_in_memory().expect("in-memory DB"));
@@ -169,6 +171,7 @@ async fn main() -> Result<()> {
                 &root,
                 &coverage,
                 &boundary_rules,
+                &config_drift_doc_paths,
             )?;
 
             // Record today's metrics for later trend comparison (edit_context's
@@ -208,6 +211,13 @@ async fn main() -> Result<()> {
                         );
                     }
                 }
+                if !result.config_drift.is_empty() {
+                    println!();
+                    println!("Config drift (doc references to files that no longer exist):");
+                    for f in &result.config_drift {
+                        println!("  {}: references \"{}\"", f.doc_path, f.reference);
+                    }
+                }
                 println!();
                 if result.passed {
                     println!("All checks passed.");

crates/ci-core/src/analysis/config_drift.rs

@@ -0,0 +1,202 @@
+use std::collections::HashSet;
+use std::path::Path;
+
+use serde::Serialize;
+
+use super::doc_refs::extract_path_refs;
+
+#[derive(Debug, Clone, Serialize, PartialEq)]
+pub struct ConfigDriftFinding {
+    /// Repo-relative path of the doc that made the reference (as declared in
+    /// `[config_drift].doc_paths`).
+    pub doc_path: String,
+    /// The file-path-like token found in that doc that doesn't resolve to
+    /// any real file in the project tree.
+    pub reference: String,
+}
+
+/// Scans each declared doc file for file-path-like references (`server.py`,
+/// `tools/search.py`, `crates/ci-core/src/fitness.rs`) and reports any that
+/// don't resolve to a real file on disk — the same signal that would catch a
+/// `CONTRACTS.md` still describing a pre-rewrite Python layout days after the
+/// codebase moved to Rust.
+///
+/// Existence is checked against the real project tree (gitignore-aware
+/// walk), not the symbol index — a reference to `Cargo.toml` or `README.md`
+/// is legitimate even though neither is a parsed source file the indexer
+/// puts in `file_index`. A reference resolves if it exactly matches a
+/// repo-relative path, or matches the tail of one after a `/` boundary (so a
+/// doc can write the short form `fitness.rs` instead of the full
+/// `crates/ci-core/src/fitness.rs`).
+///
+/// Returns an empty vec (not an error) when `doc_paths` is empty or a
+/// declared doc doesn't exist — this check only judges references *inside*
+/// docs that are present, mirroring `check_boundaries`' "no rules declared"
+/// pass-by-default behavior.
+/// Every repo-relative file path under `project_root`, gitignore-aware —
+/// shared groundwork for both `check_config_drift` (does this reference
+/// resolve at all?) and `crate::memory`'s ref-capture (which real path did a
+/// short-form reference resolve to?), so both pay the walk cost once and
+/// agree on what "real" means.
+pub fn build_real_path_index(project_root: &Path, ignore_patterns: &[String]) -> HashSet<String> {
+    let mut real_paths = HashSet::new();
+    for entry in crate::walk::build_walker(project_root, ignore_patterns) {
+        let Ok(entry) = entry else { continue };
+        if !entry.file_type().is_some_and(|t| t.is_file()) {
+            continue;
+        }
+        let path = entry.into_path();
+        let rel = path
+            .strip_prefix(project_root)
+            .unwrap_or(&path)
+            .to_string_lossy()
+            .replace('\\', "/");
+        real_paths.insert(rel);
+    }
+    real_paths
+}
+
+/// Resolves a file-path-like reference to the repo-relative path it names,
+/// or `None` if it doesn't correspond to any real file. Tries, in order: (1)
+/// a direct filesystem check — covers dot-directories
+/// (`.github/workflows/x.yml`, `.claude/hooks/y.sh`) that `real_paths`
+/// deliberately excludes, same exclusion `search`'s grep walker relies on to
+/// skip `.git`; (2) exact match in `real_paths`; (3) suffix match after a
+/// `/` boundary, so a doc can write the short form `fitness.rs` instead of
+/// the full `crates/ci-core/src/fitness.rs`.
+pub fn resolve_reference(
+    project_root: &Path,
+    real_paths: &HashSet<String>,
+    reference: &str,
+) -> Option<String> {
+    if project_root.join(reference).exists() {
+        return Some(reference.to_string());
+    }
+    if real_paths.contains(reference) {
+        return Some(reference.to_string());
+    }
+    real_paths
+        .iter()
+        .find(|p| p.ends_with(&format!("/{reference}")))
+        .cloned()
+}
+
+pub fn check_config_drift(
+    project_root: &Path,
+    doc_paths: &[String],
+    ignore_patterns: &[String],
+) -> Vec<ConfigDriftFinding> {
+    if doc_paths.is_empty() {
+        return Vec::new();
+    }
+
+    let real_paths = build_real_path_index(project_root, ignore_patterns);
+
+    let mut findings = Vec::new();
+    for doc_path in doc_paths {
+        let full = project_root.join(doc_path);
+        let Ok(text) = std::fs::read_to_string(&full) else {
+            continue;
+        };
+        let mut refs = extract_path_refs(&text);
+        refs.sort();
+        refs.dedup();
+        for r in refs {
+            if resolve_reference(project_root, &real_paths, &r).is_none() {
+                findings.push(ConfigDriftFinding {
+                    doc_path: doc_path.clone(),
+                    reference: r,
+                });
+            }
+        }
+    }
+    findings.sort_by(|a, b| a.doc_path.cmp(&b.doc_path).then(a.reference.cmp(&b.reference)));
+    findings
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn write(dir: &Path, rel: &str, content: &str) {
+        let full = dir.join(rel);
+        if let Some(parent) = full.parent() {
+            std::fs::create_dir_all(parent).unwrap();
+        }
+        std::fs::write(full, content).unwrap();
+    }
+
+    fn temp_project(name: &str) -> std::path::PathBuf {
+        let dir = std::env::temp_dir().join(format!("ci_config_drift_test_{name}_{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    #[test]
+    fn empty_doc_paths_returns_no_findings() {
+        let dir = temp_project("empty");
+        let findings = check_config_drift(&dir, &[], &[]);
+        assert!(findings.is_empty());
+    }
+
+    #[test]
+    fn missing_doc_file_is_skipped_not_errored() {
+        let dir = temp_project("missing_doc");
+        let findings = check_config_drift(&dir, &["NOPE.md".into()], &[]);
+        assert!(findings.is_empty());
+    }
+
+    #[test]
+    fn flags_reference_to_nonexistent_file() {
+        let dir = temp_project("flags_missing");
+        write(&dir, "CONTRACTS.md", "> **Owner:** server.py\n");
+        let findings = check_config_drift(&dir, &["CONTRACTS.md".into()], &[]);
+        assert_eq!(findings.len(), 1);
+        assert_eq!(findings[0].doc_path, "CONTRACTS.md");
+        assert_eq!(findings[0].reference, "server.py");
+    }
+
+    #[test]
+    fn does_not_flag_reference_to_real_file_exact_path() {
+        let dir = temp_project("real_exact");
+        write(&dir, "Cargo.toml", "[package]\n");
+        write(&dir, "README.md", "See `Cargo.toml` for deps.\n");
+        let findings = check_config_drift(&dir, &["README.md".into()], &[]);
+        assert!(findings.is_empty(), "got {findings:?}");
+    }
+
+    #[test]
+    fn does_not_flag_reference_to_real_file_short_suffix_form() {
+        let dir = temp_project("real_suffix");
+        write(&dir, "crates/ci-core/src/fitness.rs", "// stub\n");
+        write(&dir, "AGENTS.md", "See `fitness.rs` for the fitness gate.\n");
+        let findings = check_config_drift(&dir, &["AGENTS.md".into()], &[]);
+        assert!(findings.is_empty(), "got {findings:?}");
+    }
+
+    #[test]
+    fn does_not_flag_reference_to_real_file_in_dot_directory() {
+        let dir = temp_project("dotdir");
+        write(&dir, ".github/workflows/release.yml", "name: Release\n");
+        write(
+            &dir,
+            "README.md",
+            "see `.github/workflows/release.yml` for the release matrix\n",
+        );
+        let findings = check_config_drift(&dir, &["README.md".into()], &[]);
+        assert!(findings.is_empty(), "got {findings:?}");
+    }
+
+    #[test]
+    fn dedups_repeated_reference_within_one_doc() {
+        let dir = temp_project("dedup");
+        write(
+            &dir,
+            "CONTRACTS.md",
+            "server.py owns this.\nAlso see server.py again.\n",
+        );
+        let findings = check_config_drift(&dir, &["CONTRACTS.md".into()], &[]);
+        assert_eq!(findings.len(), 1);
+    }
+}

crates/ci-core/src/analysis/doc_refs.rs

@@ -0,0 +1,146 @@
+use std::sync::OnceLock;
+
+use regex::Regex;
+
+/// File extensions considered a "real reference" worth checking — kept to
+/// source/config/doc extensions actually used in this repo (and most repos)
+/// so the regex doesn't fire on version strings (`v2.7.2`), abbreviations
+/// (`e.g.`), or plain decimals.
+fn path_ref_regex() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| {
+        Regex::new(
+            r"\.?[A-Za-z0-9_][A-Za-z0-9_/.-]*\.(?:rs|py|ts|tsx|js|jsx|go|rb|java|kt|swift|toml|json|ya?ml|sh|md)\b",
+        )
+        .unwrap()
+    })
+}
+
+/// Strips fenced (```) code blocks — illustrative tool-call examples like
+/// `file_overview("src/auth/login.ts")` inside a how-to guide aren't claims
+/// that a file exists, and are the single biggest source of false-positive
+/// references in docs that teach by example.
+fn strip_fenced_code_blocks(text: &str) -> String {
+    let mut out = String::with_capacity(text.len());
+    let mut in_fence = false;
+    for line in text.lines() {
+        if line.trim_start().starts_with("```") {
+            in_fence = !in_fence;
+        } else if !in_fence {
+            out.push_str(line);
+        }
+        out.push('\n');
+    }
+    out
+}
+
+/// Extracts file-path-like tokens from free-form doc text — e.g. `server.py`,
+/// `tools/search.py`, `crates/ci-core/src/fitness.rs`, `.github/workflows/x.yml`
+/// — whether or not they're backtick-wrapped, since real-world drift (a
+/// stale `CONTRACTS.md` section) shows up as plain prose ("Owner:
+/// server.py"), not just inline code spans. Skips matches immediately
+/// preceded by `://` so URLs (`example.com/foo.py`) aren't treated as repo
+/// file references, and skips fenced code blocks (see
+/// `strip_fenced_code_blocks`). Does not dedup — callers that need unique
+/// tokens should sort+dedup the result.
+pub fn extract_path_refs(text: &str) -> Vec<String> {
+    let text = strip_fenced_code_blocks(text);
+    let re = path_ref_regex();
+    let mut out = Vec::new();
+    for m in re.find_iter(&text) {
+        let start = m.start();
+        // `start - 8` can land inside a multi-byte UTF-8 char (e.g. Vietnamese
+        // prose) — walk back to the nearest real char boundary before slicing.
+        let mut lookback = start.saturating_sub(8);
+        while lookback > 0 && !text.is_char_boundary(lookback) {
+            lookback -= 1;
+        }
+        let preceding = &text[lookback..start];
+        if preceding.contains("://") {
+            continue;
+        }
+        out.push(m.as_str().trim_start_matches("./").to_string());
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn extracts_bare_filename() {
+        let refs = extract_path_refs("> **Owner:** server.py");
+        assert_eq!(refs, vec!["server.py"]);
+    }
+
+    #[test]
+    fn extracts_nested_path() {
+        let refs = extract_path_refs("Owner: tools/search.py (_resolve_symbol)");
+        assert_eq!(refs, vec!["tools/search.py"]);
+    }
+
+    #[test]
+    fn extracts_deep_relative_path() {
+        let refs = extract_path_refs("see `crates/ci-core/src/fitness.rs` for details");
+        assert_eq!(refs, vec!["crates/ci-core/src/fitness.rs"]);
+    }
+
+    #[test]
+    fn ignores_version_strings_and_decimals() {
+        let refs = extract_path_refs("v2.7.2 compatible, e.g. 3.14 is not a path");
+        assert!(refs.is_empty(), "got {refs:?}");
+    }
+
+    #[test]
+    fn skips_urls() {
+        let refs = extract_path_refs("see https://example.com/foo.py for reference");
+        assert!(refs.is_empty(), "got {refs:?}");
+    }
+
+    #[test]
+    fn extracts_multiple_and_preserves_order() {
+        let refs = extract_path_refs(
+            "db/schema.py (CREATE), indexer/indexer.py (WRITE), tools/* (READ)",
+        );
+        assert_eq!(refs, vec!["db/schema.py", "indexer/indexer.py"]);
+    }
+
+    #[test]
+    fn strips_leading_dot_slash() {
+        let refs = extract_path_refs("run `./scripts/build.sh` first");
+        assert_eq!(refs, vec!["scripts/build.sh"]);
+    }
+
+    /// Regression: a multi-byte UTF-8 char (e.g. Vietnamese "Nguyên") landing
+    /// within 8 bytes before a match used to panic by slicing mid-character —
+    /// `start.saturating_sub(8)` must walk back to a real char boundary.
+    #[test]
+    fn does_not_panic_on_multibyte_utf8_before_match() {
+        let refs = extract_path_refs("Nguyên tắc: xem server.py để biết chi tiết");
+        assert_eq!(refs, vec!["server.py"]);
+    }
+
+    #[test]
+    fn captures_leading_dot_for_dotfiles_and_dotdirs() {
+        let refs = extract_path_refs(
+            "Claude Code (`.mcp.json`), Cursor (`.cursor/mcp.json`), see `.github/workflows/release.yml`",
+        );
+        assert_eq!(
+            refs,
+            vec![".mcp.json", ".cursor/mcp.json", ".github/workflows/release.yml"]
+        );
+    }
+
+    #[test]
+    fn skips_references_inside_fenced_code_blocks() {
+        let refs = extract_path_refs(
+            "prose mentions server.py\n\
+             ```\n\
+             file_overview(\"src/auth/login.ts\")\n\
+             ```\n\
+             more prose mentions client.py",
+        );
+        assert_eq!(refs, vec!["server.py", "client.py"]);
+    }
+}

crates/ci-core/src/analysis/mod.rs

@@ -1,8 +1,10 @@
 pub mod boundaries;
 pub mod cochange;
 pub mod codeowners;
+pub mod config_drift;
 pub mod coverage;
 pub mod dead_code;
 pub mod diff_impact;
+pub mod doc_refs;
 pub mod git_log;
 pub mod hotspot;