feat: cross-repo dependency graph builder (#93)

scripts/dependency_graph.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""
+Cross-Repo Dependency Graph Builder
+
+Scans repos for import/require/reference patterns and builds a directed
+dependency graph. Detects circular dependencies. Outputs DOT and Mermaid.
+
+Usage:
+  python3 scripts/dependency_graph.py /path/to/repos/
+  python3 scripts/dependency_graph.py --repos repo1,repo2,repo3 --format mermaid
+  python3 scripts/dependency_graph.py --repos-dir /path/to/ --format dot --output deps.dot
+
+Patterns detected:
+  - Python: import X, from X import Y
+  - JavaScript: require("X"), import ... from "X"
+  - Go: import "X"
+  - Ansible: include_role, import_role
+  - Docker/Compose: image: X, depends_on
+  - Config references: repo-name in YAML/TOML/JSON
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+
+# Known repo names for matching
+KNOWN_REPOS = [
+    "hermes-agent", "timmy-config", "timmy-home", "the-nexus", "the-door",
+    "the-beacon", "fleet-ops", "burn-fleet", "timmy-dispatch", "turboquant",
+    "compounding-intelligence", "the-playground", "second-son-of-timmy",
+    "ai-safety-review", "the-echo-pattern", "timmy-academy", "wolf",
+    "the-testament",
+]
+
+
+def normalize_repo_name(name: str) -> str:
+    """Normalize a repo name for comparison."""
+    return name.lower().replace("_", "-").replace(".git", "").strip()
+
+
+def scan_file_for_deps(filepath: str, content: str, own_repo: str) -> set:
+    """Scan a file's content for references to other repos."""
+    deps = set()
+    own_norm = normalize_repo_name(own_repo)
+
+    for repo in KNOWN_REPOS:
+        repo_norm = normalize_repo_name(repo)
+        if repo_norm == own_norm:
+            continue
+
+        # Direct name references
+        patterns = [
+            repo,  # exact name
+            repo.replace("-", "_"),  # underscore variant
+            repo.replace("-", ""),  # no separator
+            f"/{repo}/",  # path reference
+            f'"{repo}"',  # quoted
+            f"'{repo}'",  # single quoted
+            f"Timmy_Foundation/{repo}",  # full Gitea path
+            f"Timmy_Foundation.{repo}",  # Python module path
+        ]
+
+        for pattern in patterns:
+            if pattern in content:
+                deps.add(repo)
+                break
+
+    return deps
+
+
+def scan_repo(repo_path: str, repo_name: str = None) -> dict:
+    """Scan a repo directory for dependencies."""
+    path = Path(repo_path)
+    if not path.is_dir():
+        return {"error": f"Not a directory: {repo_path}"}
+
+    if not repo_name:
+        repo_name = path.name
+
+    deps = set()
+    files_scanned = 0
+    exts = {".py", ".js", ".ts", ".go", ".yaml", ".yml", ".toml", ".json",
+            ".md", ".sh", ".bash", ".Dockerfile", ".tf", ".hcl"}
+
+    for fpath in path.rglob("*"):
+        if not fpath.is_file():
+            continue
+        if fpath.suffix not in exts:
+            continue
+        # Skip common non-source dirs
+        parts = fpath.parts
+        if any(p in (".git", "node_modules", "__pycache__", ".venv", "venv",
+                      "vendor", "dist", "build", ".tox") for p in parts):
+            continue
+
+        try:
+            content = fpath.read_text(errors="ignore")
+        except:
+            continue
+
+        file_deps = scan_file_for_deps(str(fpath), content, repo_name)
+        deps.update(file_deps)
+        files_scanned += 1
+
+    return {
+        "repo": repo_name,
+        "dependencies": sorted(deps),
+        "files_scanned": files_scanned,
+    }
+
+
+def detect_cycles(graph: dict) -> list:
+    """Detect circular dependencies using DFS."""
+    cycles = []
+    visited = set()
+    rec_stack = set()
+
+    def dfs(node, path):
+        visited.add(node)
+        rec_stack.add(node)
+
+        for neighbor in graph.get(node, {}).get("dependencies", []):
+            if neighbor not in visited:
+                result = dfs(neighbor, path + [neighbor])
+                if result:
+                    return result
+            elif neighbor in rec_stack:
+                cycle_start = path.index(neighbor)
+                return path[cycle_start:] + [neighbor]
+
+        rec_stack.remove(node)
+        return None
+
+    for node in graph:
+        if node not in visited:
+            cycle = dfs(node, [node])
+            if cycle:
+                cycles.append(cycle)
+
+    return cycles
+
+
+def to_dot(graph: dict) -> str:
+    """Generate DOT format output."""
+    lines = ["digraph dependencies {"]
+    lines.append("  rankdir=LR;")
+    lines.append("  node [shape=box, style=filled, fillcolor="#1a1a2e", fontcolor="#e6edf3"];")
+    lines.append("  edge [color="#4a4a6a"];")
+    lines.append("")
+
+    for repo, data in sorted(graph.items()):
+        dep_count = len(data.get("dependencies", []))
+        fill = "#2d1b69" if dep_count > 2 else "#16213e"
+        lines.append(f'  "{repo}" [fillcolor="{fill}"];')
+        for dep in data.get("dependencies", []):
+            lines.append(f'  "{repo}" -> "{dep}";')
+
+    lines.append("}")
+    return "\n".join(lines)
+
+
+def to_mermaid(graph: dict) -> str:
+    """Generate Mermaid format output."""
+    lines = ["graph LR"]
+
+    for repo, data in sorted(graph.items()):
+        for dep in data.get("dependencies", []):
+            lines.append(f"    {repo.replace('-','_')} --> {dep.replace('-','_')}")
+
+    # Add node labels
+    lines.append("")
+    for repo in sorted(graph.keys()):
+        lines.append(f"    {repo.replace('-','_')}[{repo}]")
+
+    return "\n".join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Build cross-repo dependency graph")
+    parser.add_argument("repos_dir", nargs="?", help="Directory containing repos")
+    parser.add_argument("--repos", help="Comma-separated list of repo paths")
+    parser.add_argument("--format", choices=["dot", "mermaid", "json"], default="json")
+    parser.add_argument("--output", "-o", help="Output file (default: stdout)")
+    parser.add_argument("--cycles-only", action="store_true", help="Only report cycles")
+    args = parser.parse_args()
+
+    results = {}
+    repo_paths = []
+
+    if args.repos:
+        repo_paths = [p.strip() for p in args.repos.split(",")]
+    elif args.repos_dir:
+        base = Path(args.repos_dir)
+        repo_paths = [str(p) for p in base.iterdir() if p.is_dir() and not p.name.startswith(".")]
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+    for rpath in repo_paths:
+        name = Path(rpath).name
+        print(f"Scanning {name}...", file=sys.stderr)
+        result = scan_repo(rpath, name)
+        if "error" not in result:
+            results[name] = result
+
+    # Detect cycles
+    cycles = detect_cycles(results)
+
+    if args.cycles_only:
+        if cycles:
+            print("CIRCULAR DEPENDENCIES DETECTED:")
+            for cycle in cycles:
+                print(f"  {' -> '.join(cycle)}")
+            sys.exit(1)
+        else:
+            print("No circular dependencies found.")
+            sys.exit(0)
+
+    # Output
+    output = {}
+    if args.format == "dot":
+        output = to_dot(results)
+    elif args.format == "mermaid":
+        output = to_mermaid(results)
+    else:
+        output = json.dumps({
+            "repos": results,
+            "cycles": cycles,
+            "summary": {
+                "total_repos": len(results),
+                "total_deps": sum(len(r["dependencies"]) for r in results.values()),
+                "cycles_found": len(cycles),
+            }
+        }, indent=2)
+
+    if args.output:
+        Path(args.output).write_text(output)
+        print(f"Written to {args.output}", file=sys.stderr)
+    else:
+        print(output)
+
+
+if __name__ == "__main__":
+    main()

scripts/gitea_issue_parser.py

@@ -1,131 +0,0 @@
-#!/usr/bin/env python3
-"""
-Gitea Issue Body Parser — Extract structured data from markdown issue bodies.
-
-Usage:
-    cat issue_body.txt | python3 scripts/gitea_issue_parser.py --stdin --pretty
-    python3 scripts/gitea_issue_parser.py --url https://forge.../api/v1/repos/.../issues/123 --pretty
-    python3 scripts/gitea_issue_parser.py body.txt --title "Fix thing (#42)" --labels pipeline extraction
-"""
-
-import argparse
-import json
-import re
-import sys
-from typing import Dict, List, Any, Optional
-
-
-def parse_issue_body(body: str, title: str = "", labels: List[str] = None) -> Dict[str, Any]:
-    """Parse a Gitea issue markdown body into structured JSON.
-    
-    Extracted fields:
-    - title: Issue title
-    - context: Background/description section
-    - criteria[]: Acceptance criteria (checkboxes or numbered lists)
-    - labels[]: Issue labels
-    - epic_ref: Parent/epic issue reference (from "Closes #N" or title)
-    - sections{}: All ## sections as key-value pairs
-    """
-    result = {
-        "title": title,
-        "context": "",
-        "criteria": [],
-        "labels": labels or [],
-        "epic_ref": None,
-        "sections": {},
-    }
-    
-    if not body:
-        return result
-    
-    # Extract epic reference from title or body
-    epic_patterns = [
-        r"(?:closes|fixes|addresses|refs?)\s+#(\d+)",
-        r"#(\d+)",
-    ]
-    for pattern in epic_patterns:
-        match = re.search(pattern, (title + " " + body).lower())
-        if match:
-            result["epic_ref"] = int(match.group(1))
-            break
-    
-    # Parse ## sections
-    section_pattern = r"^##\s+(.+?)$\n((?:^(?!##\s).*$\n?)*)"
-    for match in re.finditer(section_pattern, body, re.MULTILINE):
-        section_name = match.group(1).strip().lower().replace(" ", "_")
-        section_content = match.group(2).strip()
-        result["sections"][section_name] = section_content
-    
-    # Extract acceptance criteria (checkboxes)
-    checkbox_pattern = r"^\s*-\s*\[([ xX])\]\s*(.+)$"
-    for match in re.finditer(checkbox_pattern, body, re.MULTILINE):
-        checked = match.group(1).lower() == "x"
-        text = match.group(2).strip()
-        result["criteria"].append({"text": text, "checked": checked})
-    
-    # If no checkboxes, try numbered lists in "Acceptance Criteria" or "Criteria" section
-    if not result["criteria"]:
-        for section_name in ["acceptance_criteria", "criteria", "acceptance criteria"]:
-            if section_name in result["sections"]:
-                numbered = r"^\s*\d+\.\s*(.+)$"
-                for match in re.finditer(numbered, result["sections"][section_name], re.MULTILINE):
-                    result["criteria"].append({"text": match.group(1).strip(), "checked": False})
-                break
-    
-    # Extract context (first section or first paragraph before any ## heading)
-    first_heading = body.find("## ")
-    if first_heading > 0:
-        context_text = body[:first_heading].strip()
-    else:
-        context_text = body.split("\n\n")[0].strip()
-    # Clean up: remove "## Context" or "## Problem" header if present
-    context_text = re.sub(r"^#+\s*\w+\s*\n?", "", context_text).strip()
-    result["context"] = context_text[:500]  # Cap at 500 chars
-    
-    return result
-
-
-def fetch_issue_from_url(url: str) -> Dict[str, Any]:
-    """Fetch an issue from a Gitea API URL and parse it."""
-    import urllib.request
-    req = urllib.request.Request(url, headers={"Accept": "application/json"})
-    with urllib.request.urlopen(req) as resp:
-        data = json.loads(resp.read())
-    
-    return parse_issue_body(
-        body=data.get("body", ""),
-        title=data.get("title", ""),
-        labels=[l["name"] for l in data.get("labels", [])]
-    )
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Parse Gitea issue markdown into structured JSON")
-    parser.add_argument("file", nargs="?", help="Issue body file (or use --stdin)")
-    parser.add_argument("--stdin", action="store_true", help="Read from stdin")
-    parser.add_argument("--url", help="Gitea API URL to fetch issue from")
-    parser.add_argument("--title", default="", help="Issue title")
-    parser.add_argument("--labels", nargs="*", default=[], help="Issue labels")
-    parser.add_argument("--pretty", action="store_true", help="Pretty-print JSON output")
-    
-    args = parser.parse_args()
-    
-    if args.url:
-        result = fetch_issue_from_url(args.url)
-    elif args.stdin:
-        body = sys.stdin.read()
-        result = parse_issue_body(body, args.title, args.labels)
-    elif args.file:
-        with open(args.file) as f:
-            body = f.read()
-        result = parse_issue_body(body, args.title, args.labels)
-    else:
-        parser.print_help()
-        sys.exit(1)
-    
-    indent = 2 if args.pretty else None
-    print(json.dumps(result, indent=indent))
-
-
-if __name__ == "__main__":
-    main()

scripts/test_gitea_issue_parser.py

@@ -1,109 +0,0 @@
-#!/usr/bin/env python3
-"""Tests for scripts/gitea_issue_parser.py"""
-
-import sys
-import os
-sys.path.insert(0, os.path.dirname(__file__) or ".")
-
-# Import from sibling
-import importlib.util
-spec = importlib.util.spec_from_file_location("parser", os.path.join(os.path.dirname(__file__) or ".", "gitea_issue_parser.py"))
-mod = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(mod)
-parse_issue_body = mod.parse_issue_body
-
-
-def test_basic_parsing():
-    body = """## Context
-
-This is the background info.
-
-## Acceptance Criteria
-
-- [ ] First criterion
-- [x] Second criterion (done)
-
-## What to build
-
-Some description.
-"""
-    result = parse_issue_body(body, title="Test (#42)", labels=["bug"])
-    assert result["title"] == "Test (#42)"
-    assert result["labels"] == ["bug"]
-    assert result["epic_ref"] == 42
-    assert len(result["criteria"]) == 2
-    assert result["criteria"][0]["text"] == "First criterion"
-    assert result["criteria"][0]["checked"] == False
-    assert result["criteria"][1]["checked"] == True
-    assert "context" in result["sections"]
-    print("PASS: test_basic_parsing")
-
-
-def test_numbered_criteria():
-    body = """## Acceptance Criteria
-
-1. First item
-2. Second item
-3. Third item
-"""
-    result = parse_issue_body(body)
-    assert len(result["criteria"]) == 3
-    assert result["criteria"][0]["text"] == "First item"
-    print("PASS: test_numbered_criteria")
-
-
-def test_epic_ref_from_body():
-    body = "Closes #123\n\nSome description."
-    result = parse_issue_body(body)
-    assert result["epic_ref"] == 123
-    print("PASS: test_epic_ref_from_body")
-
-
-def test_empty_body():
-    result = parse_issue_body("")
-    assert result["criteria"] == []
-    assert result["context"] == ""
-    assert result["sections"] == {}
-    print("PASS: test_empty_body")
-
-
-def test_no_sections():
-    body = "Just a plain issue body with no headings."
-    result = parse_issue_body(body)
-    assert result["context"] == "Just a plain issue body with no headings."
-    print("PASS: test_no_sections")
-
-
-def test_multiple_sections():
-    body = """## Problem
-
-Something is broken.
-
-## Fix
-
-Do this instead.
-
-## Notes
-
-Additional info.
-"""
-    result = parse_issue_body(body)
-    assert "problem" in result["sections"]
-    assert "fix" in result["sections"]
-    assert "notes" in result["sections"]
-    assert "Something is broken" in result["sections"]["problem"]
-    print("PASS: test_multiple_sections")
-
-
-def run_all():
-    test_basic_parsing()
-    test_numbered_criteria()
-    test_epic_ref_from_body()
-    test_empty_body()
-    test_no_sections()
-    test_multiple_sections()
-    print("\nAll 6 tests passed!")
-
-
-if __name__ == "__main__":
-    run_all()