workspace-graph 0.1.0__py3-none-any.whl

codegraph/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

codegraph/__main__.py

@@ -0,0 +1,3 @@
+from codegraph.cli import app
+
+app()

codegraph/builder.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+import concurrent.futures
+import json
+import subprocess
+import time
+from pathlib import Path
+from typing import Any
+
+from codegraph.config import load_config
+from codegraph.cross_service import detect_cross_service_edges
+from codegraph.discover import BUILT_LANGUAGES, resolve_entries
+from codegraph.graph.serialize import write_graph, write_manifest
+from codegraph.graph.types import UnifiedGraph, WorkspaceEntry, make_unified_graph
+from codegraph.plugin import run_plugins
+
+TOOL_BY_LANGUAGE: dict[str, str] = {
+    "go": "gograph",
+    "python": "pygraph",
+    "typescript": "tsgraph",
+}
+
+GRAPH_FILE_BY_LANGUAGE: dict[str, str] = {
+    "go": ".gograph/graph.json",
+    "python": ".pygraph/graph.json",
+    "typescript": ".tsgraph/graph.json",
+}
+
+
+def _build_cmd(tool: str, entry_path: Path) -> list[str]:
+    if tool in ("gograph", "tsgraph"):
+        return [tool, "build", str(entry_path)]
+    return [tool, "build", "--root", str(entry_path)]
+
+
+def _run_tool_build(entry: WorkspaceEntry, root_path: Path) -> WorkspaceEntry:
+    tool = TOOL_BY_LANGUAGE.get(entry.language)
+    if tool is None:
+        entry.build_status = "unsupported"
+        return entry
+
+    entry_path = root_path / entry.path
+    if not entry_path.is_dir():
+        entry.build_status = "failed"
+        return entry
+
+    start = time.monotonic()
+    try:
+        result = subprocess.run(
+            _build_cmd(tool, entry_path),
+            capture_output=True, text=True, timeout=120,
+            cwd=str(entry_path),
+        )
+        elapsed = int((time.monotonic() - start) * 1000)
+        entry.build_duration_ms = elapsed
+
+        if result.returncode != 0:
+            entry.build_status = "failed"
+            return entry
+
+        entry.build_status = "ok"
+
+        try:
+            version_result = subprocess.run(
+                [tool, "--version"],
+                capture_output=True, text=True, timeout=10,
+            )
+            ver = version_result.stdout.strip() if version_result.returncode == 0 else ""
+            entry.tool_version = ver
+        except (OSError, subprocess.SubprocessError, subprocess.TimeoutExpired):
+            entry.tool_version = ""
+
+    except (OSError, subprocess.TimeoutExpired, subprocess.SubprocessError):
+        entry.build_status = "failed"
+
+    return entry
+
+
+def _prefix_ids(items: list[dict[str, Any]], prefix: str, id_fields: set[str]) -> None:
+    for item in items:
+        for field in id_fields:
+            if field in item and isinstance(item[field], str):
+                item[field] = f"{prefix}::{item[field]}"
+
+
+SYMBOL_ID_FIELDS = {"id"}
+CALL_ID_FIELDS = {"caller_symbol_id"}
+FILE_ID_FIELDS = {"id"}
+PACKAGE_ID_FIELDS = {"id"}
+TEST_EDGE_ID_FIELDS = {"test_func", "target"}
+ERROR_ID_FIELDS = {"function_name"}
+MUTATION_ID_FIELDS = {"function_name"}
+ENV_ID_FIELDS = {"function_name"}
+IMPLEMENTS_ID_FIELDS = {"interface", "concrete"}
+
+
+def _stamp_and_collect(
+    entry: WorkspaceEntry,
+    root_path: Path,
+    unified: UnifiedGraph,
+) -> None:
+    graph_rel = GRAPH_FILE_BY_LANGUAGE.get(entry.language)
+    if graph_rel is None:
+        return
+
+    graph_path = root_path / entry.path / graph_rel
+    if not graph_path.exists():
+        return
+
+    try:
+        raw = graph_path.read_text()
+        data: dict[str, Any] = json.loads(raw)
+    except (OSError, json.JSONDecodeError, ValueError):
+        return
+
+    entry_name = entry.name
+    prefix = entry_name
+
+    packages = data.get("packages", [])
+    _prefix_ids(packages, prefix, PACKAGE_ID_FIELDS)
+    for p in packages:
+        p["entry_name"] = entry_name
+        p["language"] = entry.language
+        p["type"] = entry.type
+    unified.packages.extend(packages)
+
+    files = data.get("files", [])
+    _prefix_ids(files, prefix, FILE_ID_FIELDS)
+    for f in files:
+        f["entry_name"] = entry_name
+        f["language"] = entry.language
+        f["type"] = entry.type
+    unified.files.extend(files)
+
+    symbols = data.get("symbols", [])
+    _prefix_ids(symbols, prefix, SYMBOL_ID_FIELDS)
+    for s in symbols:
+        s["entry_name"] = entry_name
+        s["language"] = entry.language
+        s["type"] = entry.type
+    unified.symbols.extend(symbols)
+    entry.symbol_count = len(symbols)
+
+    calls = data.get("calls", [])
+    _prefix_ids(calls, prefix, CALL_ID_FIELDS)
+    for c in calls:
+        c["entry_name"] = entry_name
+        c["language"] = entry.language
+        c["type"] = entry.type
+    unified.calls.extend(calls)
+    entry.call_count = len(calls)
+
+    imports = data.get("imports", [])
+    for im in imports:
+        im["entry_name"] = entry_name
+        im["language"] = entry.language
+        im["type"] = entry.type
+    unified.imports.extend(imports)
+
+    routes = data.get("routes", [])
+    for r in routes:
+        r["entry_name"] = entry_name
+        r["language"] = entry.language
+        r["type"] = entry.type
+    unified.routes.extend(routes)
+    entry.route_count = len(routes)
+
+    all_lists: list[tuple[list[dict[str, Any]] | None, str, set[str]]] = [
+        (data.get("env_reads"), "env_reads", ENV_ID_FIELDS),
+        (data.get("errors"), "errors", ERROR_ID_FIELDS),
+        (data.get("test_edges"), "test_edges", TEST_EDGE_ID_FIELDS),
+        (data.get("mutations"), "mutations", MUTATION_ID_FIELDS),
+        (data.get("implements"), "implements", IMPLEMENTS_ID_FIELDS),
+        (data.get("blueprints"), "blueprints", set()),
+        (data.get("blueprint_registrations"), "blueprint_registrations", set()),
+        (data.get("template_refs"), "template_refs", set()),
+        (data.get("extensions"), "extensions", set()),
+        (data.get("dependencies"), "dependencies", set()),
+        (data.get("http_calls"), "http_calls", set()),
+    ]
+    for items, field_name, id_fields in all_lists:
+        if items:
+            _prefix_ids(items, prefix, id_fields)
+            for item in items:
+                item["entry_name"] = entry_name
+                item["language"] = entry.language
+                item["type"] = entry.type
+            getattr(unified, field_name).extend(items)
+
+
+def _build_single(entry: WorkspaceEntry, root_path: Path) -> None:
+    if entry.language not in BUILT_LANGUAGES:
+        entry.build_status = "unsupported"
+        return
+
+    _run_tool_build(entry, root_path)
+
+
+def build_entry(entry: WorkspaceEntry, root_path: Path) -> WorkspaceEntry:
+    result = _run_tool_build(entry, root_path)
+    return result
+
+
+def _build_one(entry: WorkspaceEntry, root_path: Path) -> WorkspaceEntry:
+    if entry.language not in BUILT_LANGUAGES:
+        entry.build_status = "unsupported"
+        return entry
+    start = time.monotonic()
+    print(f"  [{entry.name}] building ({entry.language})...", flush=True)
+    entry = _run_tool_build(entry, root_path)
+    elapsed = time.monotonic() - start
+    if entry.build_status == "ok":
+        print(f"  [{entry.name}] done ({elapsed:.1f}s)", flush=True)
+    elif entry.build_status == "failed":
+        print(f"  [{entry.name}] FAILED ({elapsed:.1f}s)", flush=True)
+    else:
+        print(f"  [{entry.name}] {entry.build_status}", flush=True)
+    return entry
+
+
+def build_all(
+    root: str,
+    entries: list[WorkspaceEntry] | None = None,
+    max_workers: int = 4,
+) -> UnifiedGraph:
+    root_path = Path(root).resolve()
+    config = load_config(root)
+
+    if entries is None:
+        entries = resolve_entries(config, root)
+
+    unified = make_unified_graph(workspace_root=str(root_path))
+
+    buildable = [e for e in entries if e.language in BUILT_LANGUAGES]
+    skipped = [e for e in entries if e.language not in BUILT_LANGUAGES]
+
+    for e in skipped:
+        e.build_status = "unsupported"
+        if unified.manifest is not None:
+            unified.manifest.entries.append(e)
+
+    print(f"Building {len(buildable)} entries ({len(skipped)} skipped)...")
+    overall_start = time.monotonic()
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as pool:
+        futures = {
+            pool.submit(_build_one, entry, root_path): entry
+            for entry in buildable
+        }
+        for future in concurrent.futures.as_completed(futures):
+            entry = futures[future]
+            try:
+                result = future.result()
+            except Exception as exc:
+                print(f"  [{entry.name}] ERROR: {exc}", flush=True)
+                result = entry
+                result.build_status = "failed"
+
+            if result.build_status == "ok":
+                _stamp_and_collect(result, root_path, unified)
+
+            if unified.manifest is not None:
+                unified.manifest.entries.append(result)
+
+    total_time = time.monotonic() - overall_start
+    ok_count = sum(1 for e in buildable if e.build_status == "ok")
+    fail_count = sum(1 for e in buildable if e.build_status == "failed")
+    print(
+        f"Built {ok_count}/{len(buildable)} entries "
+        f"({fail_count} failed) in {total_time:.1f}s"
+    )
+
+    return unified
+
+
+def build_and_write(
+    root: str,
+    entry_name: str | None = None,
+) -> Path:
+    root_path = Path(root).resolve()
+    config = load_config(root)
+    entries = resolve_entries(config, root)
+
+    if entry_name is not None:
+        entries = [e for e in entries if e.name == entry_name]
+
+    unified = build_all(root, entries)
+
+    unified.cross_service_edges = detect_cross_service_edges(unified)
+    run_plugins(unified, root)
+
+    out_dir = root_path / ".codegraph"
+    graph_path = out_dir / "workspace.graph.json"
+    write_graph(unified, graph_path)
+
+    if unified.manifest is not None:
+        manifest_path = out_dir / "manifest.json"
+        write_manifest(unified.manifest, manifest_path)
+
+    return graph_path

codegraph/cli.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from codegraph.commands.build import run as run_build
+from codegraph.commands.callees import run as run_callees
+from codegraph.commands.callers import run as run_callers
+from codegraph.commands.clean import run as run_clean
+from codegraph.commands.context import run as run_context
+from codegraph.commands.cross_service import run as run_cross_service
+from codegraph.commands.impact import run as run_impact
+from codegraph.commands.opencode_plugin import run as run_opencode_plugin
+from codegraph.commands.orphans import run as run_orphans
+from codegraph.commands.query_cmd import run as run_query
+from codegraph.commands.routes import run as run_routes
+from codegraph.commands.status import run as run_status
+from codegraph.commands.trace import run as run_trace
+from codegraph.graph.serialize import read_graph
+from codegraph.query import WorkspaceQuery
+from codegraph.server import run_server
+
+app = typer.Typer()
+
+
+def _find_nearest_graph(root: str) -> Path | None:
+    path = Path(root).resolve()
+    for parent in [path] + list(path.parents):
+        candidate = parent / ".codegraph" / "workspace.graph.json"
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def _load_query(root: str) -> WorkspaceQuery:
+    graph_path = Path(root) / ".codegraph" / "workspace.graph.json"
+    if not graph_path.exists():
+        nearest = _find_nearest_graph(root)
+        if nearest:
+            typer.echo(
+                f"Error: no graph found at {graph_path}.\n"
+                f"Found one at {nearest} — did you mean "
+                f"'--root {nearest.parent.parent}'?"
+            )
+        else:
+            typer.echo(
+                f"Error: no graph found at {graph_path}.\n"
+                f"Run 'codegraph build' in your workspace root first."
+            )
+        raise typer.Exit(1)
+    graph = read_graph(graph_path)
+    return WorkspaceQuery(graph, root=root)
+
+
+@app.command()
+def status(
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """Detect and display workspace entries"""
+    run_status(root)
+
+
+@app.command()
+def build(
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+    entry: str | None = typer.Option(
+        None, "--entry", help="Build only a specific entry by name"
+    ),
+) -> None:
+    """Build graph for all (or one) workspace entries"""
+    run_build(root, entry)
+
+
+@app.command()
+def clean(
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """Remove .codegraph/ output directory"""
+    run_clean(root)
+
+
+@app.command()
+def query(
+    pattern: str,
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """Search symbols by pattern (regex or substring)"""
+    q = _load_query(root)
+    run_query(q, pattern)
+
+
+@app.command()
+def callers(
+    name: str,
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """Show who calls the given symbol"""
+    q = _load_query(root)
+    run_callers(q, name)
+
+
+@app.command()
+def callees(
+    name: str,
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """Show what the given symbol calls"""
+    q = _load_query(root)
+    run_callees(q, name)
+
+
+@app.command()
+def routes(
+    entry: str | None = typer.Option(
+        None, "--entry", help="Filter by entry name"
+    ),
+    type: str | None = typer.Option(
+        None, "--type", help="Filter by entry type (service, frontend, etc.)"
+    ),
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """List all HTTP routes across the workspace"""
+    q = _load_query(root)
+    run_routes(q, entry_filter=entry, type_filter=type)
+
+
+@app.command()
+def impact(
+    name: str,
+    max_depth: int | None = typer.Option(
+        None, "--max-depth", "-d", help="Maximum depth for BFS traversal"
+    ),
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """Show downstream impact (BFS from symbol)"""
+    q = _load_query(root)
+    run_impact(q, name, max_depth=max_depth)
+
+
+@app.command()
+def orphans(
+    all: bool = typer.Option(
+        False, "--all", help="Include public uncalled symbols"
+    ),
+    exclude_type: str | None = typer.Option(
+        None, "--exclude-type", help="Exclude entries of a given type"
+    ),
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """List unreachable symbols (dead code)"""
+    q = _load_query(root)
+    run_orphans(q, include_public=all, exclude_type=exclude_type)
+
+
+@app.command()
+def context(
+    name: str,
+    source: bool = typer.Option(
+        False, "--source", help="Include full source code"
+    ),
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """Show symbol with callers, callees, tests"""
+    q = _load_query(root)
+    run_context(q, name, show_source=source)
+
+
+@app.command()
+def trace(
+    message: str,
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """Find error messages and trace their call paths"""
+    q = _load_query(root)
+    run_trace(q, message)
+
+
+@app.command(name="add-opencode-plugin")
+def add_opencode_plugin(
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """Create .opencode.json with codegraph MCP config + architect agent"""
+    q = _load_query(root)
+    run_opencode_plugin(q, root)
+
+
+@app.command(name="cross-service")
+def cross_service(
+    source_entry: str | None = typer.Option(
+        None, "--source-entry", "-s", help="Filter by source entry name"
+    ),
+    target_entry: str | None = typer.Option(
+        None, "--target-entry", "-t", help="Filter by target entry name"
+    ),
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """Show cross-service HTTP call edges"""
+    q = _load_query(root)
+    run_cross_service(q, source_entry=source_entry, target_entry=target_entry)
+
+
+@app.command()
+def mcp(
+    root: str = typer.Option(".", "--root", help="Workspace root directory"),
+) -> None:
+    """Start MCP stdio server for AI agent integration"""
+    run_server(root)

codegraph/commands/build.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from codegraph.builder import build_and_write
+
+
+def run(root: str, entry_name: str | None = None) -> None:
+    try:
+        out_path = build_and_write(root, entry_name=entry_name)
+        print(f"Built {out_path}")
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+    except Exception as e:
+        print(f"Build failed: {e}")

codegraph/commands/callees.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from codegraph.query import WorkspaceQuery
+
+
+def run(query: WorkspaceQuery, name: str) -> None:
+    results = query.get_callees(name)
+    if not results:
+        print(f"No callees found for '{name}'")
+        return
+
+    print(f"Callees of '{name}':")
+    print()
+    header = f"{'Callee':<30} {'Entry':<16} {'File':<40} {'Line'}"
+    print(header)
+    print("-" * len(header))
+    for callee_sym, edge in results:
+        callee_name = callee_sym.get("name", "") if callee_sym else edge.get("callee_raw", "")
+        entry = edge.get("entry_name", "")
+        file_path = edge.get("file", "")
+        line = edge.get("line", 0)
+        print(f"{callee_name:<30} {entry:<16} {file_path:<40} {line}")

codegraph/commands/callers.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from codegraph.query import WorkspaceQuery
+
+
+def run(query: WorkspaceQuery, name: str) -> None:
+    results = query.get_callers(name)
+    if not results:
+        print(f"No callers found for '{name}'")
+        return
+
+    print(f"Callers of '{name}':")
+    print()
+    header = f"{'Caller':<30} {'Entry':<16} {'File':<40} {'Line'}"
+    print(header)
+    print("-" * len(header))
+    for caller_sym, edge in results:
+        caller_name = caller_sym.get("name", "")
+        entry = caller_sym.get("entry_name", "")
+        file_path = caller_sym.get("file", "")
+        line = edge.get("line", 0)
+        print(f"{caller_name:<30} {entry:<16} {file_path:<40} {line}")

codegraph/commands/clean.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+
+def run(root: str) -> None:
+    root_path = Path(root).resolve()
+    out_dir = root_path / ".codegraph"
+
+    if not out_dir.exists():
+        print("Nothing to clean — .codegraph/ does not exist.")
+        return
+
+    shutil.rmtree(out_dir)
+    print(f"Removed {out_dir}")

codegraph/commands/context.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from codegraph.query import WorkspaceQuery
+
+
+def run(query: WorkspaceQuery, name: str, show_source: bool = False) -> None:
+    ctx = query.get_context(name, include_source=show_source)
+    symbol = ctx.get("symbol")
+
+    if not symbol:
+        print(f"Symbol '{name}' not found")
+        return
+
+    print(f"Symbol: {symbol.get('name', '')}")
+    print(f"  Kind:      {symbol.get('kind', '')}")
+    print(f"  Entry:     {symbol.get('entry_name', '')}")
+    print(f"  Language:  {symbol.get('language', '')}")
+    print(f"  Type:      {symbol.get('type', '')}")
+    print(f"  File:      {symbol.get('file', '')}")
+    print(f"  Line:      {symbol.get('line', 0)}")
+    print(f"  Exported:  {symbol.get('is_exported', False)}")
+    print()
+
+    callers = ctx.get("callers", [])
+    print(f"Callers ({len(callers)}):")
+    if callers:
+        for c in callers[:10]:
+            entry = c.get("entry_name", "")
+            print(f"  {c.get('caller', '')} — {c.get('file', '')}:{c.get('line', '')} [{entry}]")
+    print()
+
+    callees = ctx.get("callees", [])
+    print(f"Callees ({len(callees)}):")
+    if callees:
+        for c in callees[:10]:
+            entry = c.get("entry_name", "")
+            print(f"  {c.get('callee', '')} — {c.get('file', '')}:{c.get('line', '')} [{entry}]")
+    print()
+
+    tests = ctx.get("tests", [])
+    print(f"Tests ({len(tests)}):")
+    if tests:
+        for t in tests[:10]:
+            entry = t.get("entry_name", "")
+            print(f"  {t.get('test_func', '')} — {t.get('file', '')}:{t.get('line', '')} [{entry}]")
+
+    source = ctx.get("source")
+    if source:
+        print()
+        print("Source:")
+        print(source)

codegraph/commands/cross_service.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from codegraph.query import WorkspaceQuery
+
+
+def run(
+    query: WorkspaceQuery,
+    source_entry: str | None = None,
+    target_entry: str | None = None,
+) -> None:
+    edges = query.get_cross_service_edges(
+        source_entry=source_entry, target_entry=target_entry,
+    )
+
+    if not edges:
+        msg = "No cross-service edges found"
+        if source_entry:
+            msg += f" from '{source_entry}'"
+        if target_entry:
+            msg += f" to '{target_entry}'"
+        print(msg)
+        return
+
+    print(f"Cross-service edges ({len(edges)} total):")
+    print()
+    hdr = (
+        f"{'Source Entry':<16} {'Source Symbol':<24} "
+        f"{'Method':<8} {'Target Entry':<16} {'Target Route':<40} "
+        f"{'Confidence':<10}"
+    )
+    print(hdr)
+    print("-" * len(hdr))
+    for e in edges:
+        print(
+            f"{e.get('source_entry', ''):<16} "
+            f"{e.get('source_symbol', ''):<24} "
+            f"{e.get('method', ''):<8} "
+            f"{e.get('target_entry', ''):<16} "
+            f"{e.get('target_route_path', ''):<40} "
+            f"{e.get('confidence', ''):<10}"
+        )