Alexander Whitestone
f7c479c4eb
Some checks failed
Test / pytest (pull_request) Failing after 13s
Lines 152-153 used unescaped double quotes inside Python double-quoted string literals. Switched to single-quoted strings.
250 lines
7.4 KiB
Python
250 lines
7.4 KiB
Python
#!/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()
|