@0dai-dev/cli 4.3.6 → 4.3.8

package/lib/python/drift_detector.py

@@ -0,0 +1,388 @@
+#!/usr/bin/env python3
+"""Config drift detection between agent configs.
+
+Detects when native configs (CLAUDE.md, AGENTS.md, etc.) diverge from
+what 0dai generated. Tracks hashes, finds contradictions.
+"""
+from __future__ import annotations
+
+import hashlib
+import pathlib
+import re
+import sys
+import time
+
+from json_utils import load_json, save_json
+
+# Configs that 0dai generates
+TRACKED_CONFIGS = [
+    "CLAUDE.md", "AGENTS.md", "GEMINI.md",
+    "opencode.json", ".cursorrules", ".windsurfrules",
+    ".aider.conf.yml",
+]
+
+HASHES_FILE = "ai/manifest/config_hashes.json"
+
+
+# ---------------------------------------------------------------------------
+# Hash tracking
+# ---------------------------------------------------------------------------
+
+def _hashes_path(target: pathlib.Path) -> pathlib.Path:
+    return target / HASHES_FILE
+
+
+def compute_file_hash(file_path: pathlib.Path) -> str:
+    if not file_path.is_file():
+        return ""
+    return hashlib.sha256(file_path.read_bytes()).hexdigest()[:16]
+
+
+def load_hashes(target: pathlib.Path) -> dict:
+    return load_json(_hashes_path(target))
+
+
+def save_hashes(target: pathlib.Path, hashes: dict) -> None:
+    save_json(_hashes_path(target), hashes)
+
+
+def record_hash(target: pathlib.Path, config_name: str) -> None:
+    """Record hash for a generated config file."""
+    file_path = target / config_name
+    hashes = load_hashes(target)
+    hashes[config_name] = {
+        "hash": compute_file_hash(file_path),
+        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+    }
+    save_hashes(target, hashes)
+
+
+def record_all_hashes(target: pathlib.Path) -> int:
+    """Record hashes for all existing tracked configs. Returns count."""
+    count = 0
+    hashes = load_hashes(target)
+    for name in TRACKED_CONFIGS:
+        fp = target / name
+        if fp.is_file():
+            hashes[name] = {
+                "hash": compute_file_hash(fp),
+                "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            }
+            count += 1
+    save_hashes(target, hashes)
+    return count
+
+
+# ---------------------------------------------------------------------------
+# Drift detection
+# ---------------------------------------------------------------------------
+
+def detect_drift(target: pathlib.Path) -> list[dict]:
+    """Detect drift across all tracked configs."""
+    hashes = load_hashes(target)
+    findings: list[dict] = []
+
+    for name in TRACKED_CONFIGS:
+        fp = target / name
+        recorded = hashes.get(name)
+
+        if recorded and not fp.is_file():
+            # Config was generated but now missing
+            findings.append({
+                "config_file": name,
+                "drift_type": "missing",
+                "severity": "warning",
+                "description": f"{name} was generated but has been deleted",
+                "source_hash": recorded.get("hash", ""),
+                "current_hash": "",
+                "last_synced_at": recorded.get("generated_at", ""),
+            })
+            continue
+
+        if not recorded and fp.is_file():
+            # Config exists but wasn't generated by 0dai
+            findings.append({
+                "config_file": name,
+                "drift_type": "extra",
+                "severity": "info",
+                "description": f"{name} exists but wasn't generated by 0dai",
+                "source_hash": "",
+                "current_hash": compute_file_hash(fp),
+                "last_synced_at": "",
+            })
+            continue
+
+        if recorded and fp.is_file():
+            current = compute_file_hash(fp)
+            if current != recorded.get("hash", ""):
+                findings.append({
+                    "config_file": name,
+                    "drift_type": "modified",
+                    "severity": "warning",
+                    "description": f"{name} was manually edited after last sync",
+                    "source_hash": recorded.get("hash", ""),
+                    "current_hash": current,
+                    "last_synced_at": recorded.get("generated_at", ""),
+                })
+
+    # Check for contradictions between configs
+    findings.extend(detect_contradictions(target))
+
+    return findings
+
+
+# ---------------------------------------------------------------------------
+# Contradiction detection
+# ---------------------------------------------------------------------------
+
+# Keywords to look for in config content — grouped by topic
+_TOPIC_PATTERNS: dict[str, list[tuple[str, re.Pattern]]] = {
+    "testing": [
+        ("jest", re.compile(r"\bjest\b", re.IGNORECASE)),
+        ("vitest", re.compile(r"\bvitest\b", re.IGNORECASE)),
+        ("mocha", re.compile(r"\bmocha\b", re.IGNORECASE)),
+        ("pytest", re.compile(r"\bpytest\b", re.IGNORECASE)),
+        ("unittest", re.compile(r"\bunittest\b", re.IGNORECASE)),
+    ],
+    "package_manager": [
+        ("npm", re.compile(r"\bnpm\s+(install|run|ci|test)\b", re.IGNORECASE)),
+        ("yarn", re.compile(r"\byarn\s+(add|run|install|test)\b", re.IGNORECASE)),
+        ("pnpm", re.compile(r"\bpnpm\s+(add|run|install|test)\b", re.IGNORECASE)),
+        ("bun", re.compile(r"\bbun\s+(add|run|install|test)\b", re.IGNORECASE)),
+    ],
+    "node_version": [
+        ("node18", re.compile(r"node\s*(?:version\s*)?:?\s*['\"]?18\b")),
+        ("node20", re.compile(r"node\s*(?:version\s*)?:?\s*['\"]?20\b")),
+        ("node22", re.compile(r"node\s*(?:version\s*)?:?\s*['\"]?22\b")),
+    ],
+}
+
+
+def detect_contradictions(target: pathlib.Path) -> list[dict]:
+    """Find contradicting values across config files."""
+    # Read all config contents
+    configs: dict[str, str] = {}
+    for name in TRACKED_CONFIGS:
+        fp = target / name
+        if fp.is_file():
+            try:
+                configs[name] = fp.read_text("utf-8", errors="ignore")
+            except OSError:
+                continue
+
+    if len(configs) < 2:
+        return []
+
+    findings: list[dict] = []
+
+    for topic, patterns in _TOPIC_PATTERNS.items():
+        # For each config, find which values are mentioned
+        config_values: dict[str, set[str]] = {}
+        for name, content in configs.items():
+            vals = set()
+            for val_name, regex in patterns:
+                if regex.search(content):
+                    vals.add(val_name)
+            if vals:
+                config_values[name] = vals
+
+        if len(config_values) < 2:
+            continue
+
+        # Check for contradictions: different configs mention different values
+        all_values = set()
+        for vals in config_values.values():
+            all_values.update(vals)
+
+        if len(all_values) <= 1:
+            continue  # all agree
+
+        # Find specific contradictions
+        files_by_value: dict[str, list[str]] = {}
+        for name, vals in config_values.items():
+            for v in vals:
+                files_by_value.setdefault(v, []).append(name)
+
+        # Only flag if different files advocate different values
+        contradicting_pairs: list[tuple[str, str, str, str]] = []
+        seen = set()
+        for v1, files1 in files_by_value.items():
+            for v2, files2 in files_by_value.items():
+                if v1 >= v2:
+                    continue
+                # Check if different files mention different values
+                f1_set = set(files1)
+                f2_set = set(files2)
+                if f1_set != f2_set and not f1_set.issubset(f2_set) and not f2_set.issubset(f1_set):
+                    key = (v1, v2)
+                    if key not in seen:
+                        seen.add(key)
+                        contradicting_pairs.append((v1, ", ".join(sorted(files1)), v2, ", ".join(sorted(files2))))
+
+        for v1, f1, v2, f2 in contradicting_pairs:
+            findings.append({
+                "config_file": f"{f1} vs {f2}",
+                "drift_type": "contradicts",
+                "severity": "critical",
+                "description": f"Contradiction in {topic}: {v1} ({f1}) vs {v2} ({f2})",
+                "source_hash": "",
+                "current_hash": "",
+                "last_synced_at": "",
+                "details": {
+                    "topic": topic,
+                    "value_a": v1,
+                    "files_a": f1,
+                    "value_b": v2,
+                    "files_b": f2,
+                },
+            })
+
+    return findings
+
+
+# ---------------------------------------------------------------------------
+# Drift summary
+# ---------------------------------------------------------------------------
+
+def get_drift_summary(target: pathlib.Path) -> dict:
+    findings = detect_drift(target)
+    by_type = {}
+    for f in findings:
+        by_type[f["drift_type"]] = by_type.get(f["drift_type"], 0) + 1
+    total_tracked = sum(1 for n in TRACKED_CONFIGS if (target / n).is_file())
+    drifted = sum(1 for f in findings if f["drift_type"] in ("modified", "missing"))
+    return {
+        "total_configs": total_tracked,
+        "drifted": drifted,
+        "contradictions": by_type.get("contradicts", 0),
+        "findings": findings,
+        "clean": len(findings) == 0,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Accept drift (update hash to current)
+# ---------------------------------------------------------------------------
+
+def accept_drift(target: pathlib.Path, config_name: str) -> dict:
+    fp = target / config_name
+    if not fp.is_file():
+        return {"ok": False, "error": f"{config_name} does not exist"}
+    hashes = load_hashes(target)
+    hashes[config_name] = {
+        "hash": compute_file_hash(fp),
+        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "accepted": True,
+    }
+    save_hashes(target, hashes)
+    return {"ok": True, "config": config_name}
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def cmd_drift_report(target: pathlib.Path) -> int:
+    summary = get_drift_summary(target)
+    if summary["clean"]:
+        print("Config drift: all configs match generated versions.")
+        return 0
+
+    print("Config Drift Report:\n")
+    for f in summary["findings"]:
+        if f["drift_type"] == "modified":
+            icon = "\U0001f7e1"  # yellow circle
+            print(f"  {icon} MODIFIED: {f['config_file']}")
+            print(f"     Changed after last sync ({f.get('last_synced_at', '?')})")
+            print("     -> Run: 0dai sync --force to regenerate")
+            print(f"     -> Or: 0dai drift accept {f['config_file']}")
+        elif f["drift_type"] == "missing":
+            print(f"  \u274c MISSING: {f['config_file']}")
+            print("     -> Run: 0dai sync --force to regenerate")
+        elif f["drift_type"] == "extra":
+            print(f"  \u2139  EXTRA: {f['config_file']}")
+            print(f"     Not generated by 0dai. Run: 0dai drift accept {f['config_file']}")
+        elif f["drift_type"] == "contradicts":
+            print(f"  \U0001f534 CONTRADICTS: {f['description']}")
+            print("     Agents will receive conflicting instructions")
+            print("     -> Run: 0dai sync --force to resolve")
+        print()
+
+    print(f"Drift score: {summary['drifted']}/{summary['total_configs']} configs drifted")
+    if summary["contradictions"]:
+        print(f"Contradictions: {summary['contradictions']}")
+    return 1 if summary["contradictions"] else 0
+
+
+def cmd_accept(target: pathlib.Path, config_name: str) -> int:
+    result = accept_drift(target, config_name)
+    if result["ok"]:
+        print(f"Accepted {config_name} as new baseline. Drift cleared.")
+        return 0
+    print(result["error"])
+    return 1
+
+
+def cmd_show(target: pathlib.Path, config_name: str) -> int:
+    hashes = load_hashes(target)
+    recorded = hashes.get(config_name)
+    fp = target / config_name
+    if not fp.is_file():
+        print(f"{config_name} does not exist.")
+        return 1
+    if not recorded:
+        print(f"{config_name} has no recorded baseline (not generated by 0dai).")
+        return 0
+    current = compute_file_hash(fp)
+    if current == recorded.get("hash", ""):
+        print(f"{config_name}: no drift (matches generated version).")
+        return 0
+    print(f"{config_name}: DRIFTED")
+    print(f"  Generated: {recorded.get('generated_at', '?')}")
+    print(f"  Hash: {recorded.get('hash', '?')} -> {current}")
+    print("\n  Run: 0dai sync --force to regenerate")
+    print(f"  Or:  0dai drift accept {config_name}")
+    return 1
+
+
+def main() -> None:
+    target = pathlib.Path(".")
+    args = sys.argv[1:]
+    command = "report"
+    config_name = ""
+
+    i = 0
+    while i < len(args):
+        if args[i] == "--target" and i + 1 < len(args):
+            target = pathlib.Path(args[i + 1]).resolve()
+            i += 2
+        elif args[i] == "accept" and i + 1 < len(args):
+            command = "accept"
+            config_name = args[i + 1]
+            i += 2
+        elif args[i] == "show" and i + 1 < len(args):
+            command = "show"
+            config_name = args[i + 1]
+            i += 2
+        elif args[i] == "record":
+            command = "record"
+            i += 1
+        elif args[i] == "report":
+            command = "report"
+            i += 1
+        else:
+            i += 1
+
+    if command == "report":
+        sys.exit(cmd_drift_report(target))
+    elif command == "accept":
+        sys.exit(cmd_accept(target, config_name))
+    elif command == "show":
+        sys.exit(cmd_show(target, config_name))
+    elif command == "record":
+        count = record_all_hashes(target)
+        print(f"Recorded hashes for {count} configs.")
+
+
+if __name__ == "__main__":
+    main()