codecortex 0.9.0__tar.gz → 0.11.0__tar.gz

{codecortex-0.9.0/src/codecortex.egg-info → codecortex-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.9.0
+Version: 0.11.0
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT
@@ -60,10 +60,13 @@ It's one call: `code.query(op, target, engine="auto")`. In `auto` mode (the defa
 | Who calls this? | `callers` | graph | caller symbols + files |
 | What does this call? | `callees` | graph | callee symbols + files |
 | Blast radius of a change | `impact` | graph | callers **and** callees together |
-| Trace a call chain up/downstream | `chain` | graph | ordered hops |
+| Trace a call chain up/downstream | `chain` | graph | ordered, risk-labeled hops |
 | Find symbols by pattern | `pattern` | graph | matching nodes + locations |
 | Project shape at a glance | `overview` | graph → lsp | modules, node/edge counts, languages |
 | Everything about one symbol | `context` | graph + lsp | both views merged |
+| **Impact of your uncommitted edits** | `changed` | graph | changed files → impacted symbols |
+| Refactor-risk hotspots | `hotspots` | graph | highest complexity / fan-in symbols |
+| Unreferenced (dead) code | `deadcode` | graph | non-test symbols with no callers |
 
 Pin one engine with `--engine graph│lsp│semantic`, or fan out with `--engine both` / `all` to merge results.
 
@@ -99,11 +102,21 @@ The agent hands `result` straight to the model. If the graph backend isn't insta
 pip install codecortex
 ```
 
-This installs the `codeintel` CLI; the **semantic** engine works out of the box. The **graph**
-and **LSP** engines use external backends (`codebase-memory-mcp`, and serena via `uvx`) —
-run `codeintel doctor` to see what's available and how to enable the rest. (On PyPI the
+This installs the `codeintel` CLI; the **semantic** engine works out of the box. (On PyPI the
 distribution is `codecortex` because `codeintel` was taken; the CLI and import stay `codeintel`.)
 
+**One command prepares the rest and indexes your repo:**
+
+```bash
+codeintel setup --all /path/to/your/project
+```
+
+This installs `uv` (for the LSP engine), warms serena, downloads the embedding model, indexes the
+repo, and prints a health report ending in a **Next:** list — exactly what's ready and the one
+remaining step. It's idempotent, so re-running is safe. The **graph** engine (`codebase-memory-mcp`)
+is an *optional* external binary that adds who-calls / impact / hotspots / `changed`; codeintel is
+fully usable without it.
+
 Or from source:
 
 ```bash
@@ -112,17 +125,10 @@ cd codeintel
 pip install -e .
 ```
 
-Register with your AI agent(s):
+Register with your AI agent(s), then query:
 
 ```bash
 codeintel install            # registers with Claude, Codex, Gemini, Zed
-```
-
-Index a project, check what's ready, and run your first query:
-
-```bash
-codeintel index /path/to/your/project
-codeintel doctor /path/to/your/project    # which engines are ready + how to fix the rest
 codeintel query --op search --target "authentication middleware"
 ```
 
@@ -174,6 +180,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 - **[Architecture](docs/architecture.md)** — layers, the `CodeProvider` protocol, the safe-null contract, caching, freshness (ASCII + Mermaid).
 - **[Query flow](docs/query-flow.md)** — request lifecycle, engine selection, fan-out & merge, and why it never throws.
 - **[Map file](docs/map-file.md)** — the static `CODE_INTEL.md` orientation layer for hosts with no MCP support.
+- **[Benchmarks](docs/benchmarks.md)** — real numbers at scale: 25 k chunks indexed in ~8 min, ~235 ms warm queries, 60 MB index.
 - Engine references: **[graph](docs/graph.md)** · **[lsp](docs/lsp.md)** · **[semantic](docs/semantic.md)**.
 
 ## CLI reference
@@ -181,7 +188,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | Command | Purpose |
 |---|---|
 | `codeintel install [--agent claude\|codex\|gemini\|zed\|all]` | Register codeintel with AI agent(s) |
-| `codeintel setup [project_root] [--index] [--warm] [--install-uv]` | Check backends + optionally index this repo; ends with a health report |
+| `codeintel setup [project_root] [--all] [--index] [--warm] [--install-uv] [--install-deps] [--json]` | Prepare backends + index this repo (`--all` = one command: do everything automatable, idempotent); ends with a health report + **Next:** steps |
 | `codeintel index [project_root]` | Index a project for semantic search |
 | `codeintel serve` | Start the MCP server (stdio transport) |
 | `codeintel serve-http [--host HOST] [--port 8766] [--allow-remote] [--token TOKEN]` | Start the HTTP transport (loopback-only unless `--allow-remote`; `--token` requires a bearer token on every request) |
@@ -189,6 +196,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | `codeintel status [project_root]` | Show engine availability and index age |
 | `codeintel doctor [project_root] [--deep] [--json]` | Diagnose per-engine health + repo index status, with a fix for each gap |
 | `codeintel map [project_root]` | Generate the `CODE_INTEL.md` orientation file |
+| `codeintel graph [project_root] [--html] [--out FILE] [--limit N]` | Emit the call graph as `{nodes,edges}` JSON, or `--html` a self-contained interactive viewer — see [docs/graph-viewer.md](docs/graph-viewer.md) |
 | `codeintel reset [project_root] [--all] [--yes]` | Clear the semantic index (this repo, or `--all`) to recover from a corrupt/stale DB |
 | `codeintel gen-token` | Print a secure random bearer token (for `serve-http` / RBAC `auth.toml`) |
 

{codecortex-0.9.0 → codecortex-0.11.0}/README.md

@@ -26,10 +26,13 @@ It's one call: `code.query(op, target, engine="auto")`. In `auto` mode (the defa
 | Who calls this? | `callers` | graph | caller symbols + files |
 | What does this call? | `callees` | graph | callee symbols + files |
 | Blast radius of a change | `impact` | graph | callers **and** callees together |
-| Trace a call chain up/downstream | `chain` | graph | ordered hops |
+| Trace a call chain up/downstream | `chain` | graph | ordered, risk-labeled hops |
 | Find symbols by pattern | `pattern` | graph | matching nodes + locations |
 | Project shape at a glance | `overview` | graph → lsp | modules, node/edge counts, languages |
 | Everything about one symbol | `context` | graph + lsp | both views merged |
+| **Impact of your uncommitted edits** | `changed` | graph | changed files → impacted symbols |
+| Refactor-risk hotspots | `hotspots` | graph | highest complexity / fan-in symbols |
+| Unreferenced (dead) code | `deadcode` | graph | non-test symbols with no callers |
 
 Pin one engine with `--engine graph│lsp│semantic`, or fan out with `--engine both` / `all` to merge results.
 
@@ -65,11 +68,21 @@ The agent hands `result` straight to the model. If the graph backend isn't insta
 pip install codecortex
 ```
 
-This installs the `codeintel` CLI; the **semantic** engine works out of the box. The **graph**
-and **LSP** engines use external backends (`codebase-memory-mcp`, and serena via `uvx`) —
-run `codeintel doctor` to see what's available and how to enable the rest. (On PyPI the
+This installs the `codeintel` CLI; the **semantic** engine works out of the box. (On PyPI the
 distribution is `codecortex` because `codeintel` was taken; the CLI and import stay `codeintel`.)
 
+**One command prepares the rest and indexes your repo:**
+
+```bash
+codeintel setup --all /path/to/your/project
+```
+
+This installs `uv` (for the LSP engine), warms serena, downloads the embedding model, indexes the
+repo, and prints a health report ending in a **Next:** list — exactly what's ready and the one
+remaining step. It's idempotent, so re-running is safe. The **graph** engine (`codebase-memory-mcp`)
+is an *optional* external binary that adds who-calls / impact / hotspots / `changed`; codeintel is
+fully usable without it.
+
 Or from source:
 
 ```bash
@@ -78,17 +91,10 @@ cd codeintel
 pip install -e .
 ```
 
-Register with your AI agent(s):
+Register with your AI agent(s), then query:
 
 ```bash
 codeintel install            # registers with Claude, Codex, Gemini, Zed
-```
-
-Index a project, check what's ready, and run your first query:
-
-```bash
-codeintel index /path/to/your/project
-codeintel doctor /path/to/your/project    # which engines are ready + how to fix the rest
 codeintel query --op search --target "authentication middleware"
 ```
 
@@ -140,6 +146,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 - **[Architecture](docs/architecture.md)** — layers, the `CodeProvider` protocol, the safe-null contract, caching, freshness (ASCII + Mermaid).
 - **[Query flow](docs/query-flow.md)** — request lifecycle, engine selection, fan-out & merge, and why it never throws.
 - **[Map file](docs/map-file.md)** — the static `CODE_INTEL.md` orientation layer for hosts with no MCP support.
+- **[Benchmarks](docs/benchmarks.md)** — real numbers at scale: 25 k chunks indexed in ~8 min, ~235 ms warm queries, 60 MB index.
 - Engine references: **[graph](docs/graph.md)** · **[lsp](docs/lsp.md)** · **[semantic](docs/semantic.md)**.
 
 ## CLI reference
@@ -147,7 +154,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | Command | Purpose |
 |---|---|
 | `codeintel install [--agent claude\|codex\|gemini\|zed\|all]` | Register codeintel with AI agent(s) |
-| `codeintel setup [project_root] [--index] [--warm] [--install-uv]` | Check backends + optionally index this repo; ends with a health report |
+| `codeintel setup [project_root] [--all] [--index] [--warm] [--install-uv] [--install-deps] [--json]` | Prepare backends + index this repo (`--all` = one command: do everything automatable, idempotent); ends with a health report + **Next:** steps |
 | `codeintel index [project_root]` | Index a project for semantic search |
 | `codeintel serve` | Start the MCP server (stdio transport) |
 | `codeintel serve-http [--host HOST] [--port 8766] [--allow-remote] [--token TOKEN]` | Start the HTTP transport (loopback-only unless `--allow-remote`; `--token` requires a bearer token on every request) |
@@ -155,6 +162,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | `codeintel status [project_root]` | Show engine availability and index age |
 | `codeintel doctor [project_root] [--deep] [--json]` | Diagnose per-engine health + repo index status, with a fix for each gap |
 | `codeintel map [project_root]` | Generate the `CODE_INTEL.md` orientation file |
+| `codeintel graph [project_root] [--html] [--out FILE] [--limit N]` | Emit the call graph as `{nodes,edges}` JSON, or `--html` a self-contained interactive viewer — see [docs/graph-viewer.md](docs/graph-viewer.md) |
 | `codeintel reset [project_root] [--all] [--yes]` | Clear the semantic index (this repo, or `--all`) to recover from a corrupt/stale DB |
 | `codeintel gen-token` | Print a secure random bearer token (for `serve-http` / RBAC `auth.toml`) |
 

{codecortex-0.9.0 → codecortex-0.11.0}/pyproject.toml

@@ -56,3 +56,7 @@ version = { attr = "codeintel.__version__" }
 
 [tool.setuptools.packages.find]
 where = ["src"]
+
+# Ship the self-contained interactive graph viewer template with the wheel.
+[tool.setuptools.package-data]
+"codeintel.viewer" = ["*.html"]

{codecortex-0.9.0 → codecortex-0.11.0/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.9.0
+Version: 0.11.0
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT
@@ -60,10 +60,13 @@ It's one call: `code.query(op, target, engine="auto")`. In `auto` mode (the defa
 | Who calls this? | `callers` | graph | caller symbols + files |
 | What does this call? | `callees` | graph | callee symbols + files |
 | Blast radius of a change | `impact` | graph | callers **and** callees together |
-| Trace a call chain up/downstream | `chain` | graph | ordered hops |
+| Trace a call chain up/downstream | `chain` | graph | ordered, risk-labeled hops |
 | Find symbols by pattern | `pattern` | graph | matching nodes + locations |
 | Project shape at a glance | `overview` | graph → lsp | modules, node/edge counts, languages |
 | Everything about one symbol | `context` | graph + lsp | both views merged |
+| **Impact of your uncommitted edits** | `changed` | graph | changed files → impacted symbols |
+| Refactor-risk hotspots | `hotspots` | graph | highest complexity / fan-in symbols |
+| Unreferenced (dead) code | `deadcode` | graph | non-test symbols with no callers |
 
 Pin one engine with `--engine graph│lsp│semantic`, or fan out with `--engine both` / `all` to merge results.
 
@@ -99,11 +102,21 @@ The agent hands `result` straight to the model. If the graph backend isn't insta
 pip install codecortex
 ```
 
-This installs the `codeintel` CLI; the **semantic** engine works out of the box. The **graph**
-and **LSP** engines use external backends (`codebase-memory-mcp`, and serena via `uvx`) —
-run `codeintel doctor` to see what's available and how to enable the rest. (On PyPI the
+This installs the `codeintel` CLI; the **semantic** engine works out of the box. (On PyPI the
 distribution is `codecortex` because `codeintel` was taken; the CLI and import stay `codeintel`.)
 
+**One command prepares the rest and indexes your repo:**
+
+```bash
+codeintel setup --all /path/to/your/project
+```
+
+This installs `uv` (for the LSP engine), warms serena, downloads the embedding model, indexes the
+repo, and prints a health report ending in a **Next:** list — exactly what's ready and the one
+remaining step. It's idempotent, so re-running is safe. The **graph** engine (`codebase-memory-mcp`)
+is an *optional* external binary that adds who-calls / impact / hotspots / `changed`; codeintel is
+fully usable without it.
+
 Or from source:
 
 ```bash
@@ -112,17 +125,10 @@ cd codeintel
 pip install -e .
 ```
 
-Register with your AI agent(s):
+Register with your AI agent(s), then query:
 
 ```bash
 codeintel install            # registers with Claude, Codex, Gemini, Zed
-```
-
-Index a project, check what's ready, and run your first query:
-
-```bash
-codeintel index /path/to/your/project
-codeintel doctor /path/to/your/project    # which engines are ready + how to fix the rest
 codeintel query --op search --target "authentication middleware"
 ```
 
@@ -174,6 +180,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 - **[Architecture](docs/architecture.md)** — layers, the `CodeProvider` protocol, the safe-null contract, caching, freshness (ASCII + Mermaid).
 - **[Query flow](docs/query-flow.md)** — request lifecycle, engine selection, fan-out & merge, and why it never throws.
 - **[Map file](docs/map-file.md)** — the static `CODE_INTEL.md` orientation layer for hosts with no MCP support.
+- **[Benchmarks](docs/benchmarks.md)** — real numbers at scale: 25 k chunks indexed in ~8 min, ~235 ms warm queries, 60 MB index.
 - Engine references: **[graph](docs/graph.md)** · **[lsp](docs/lsp.md)** · **[semantic](docs/semantic.md)**.
 
 ## CLI reference
@@ -181,7 +188,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | Command | Purpose |
 |---|---|
 | `codeintel install [--agent claude\|codex\|gemini\|zed\|all]` | Register codeintel with AI agent(s) |
-| `codeintel setup [project_root] [--index] [--warm] [--install-uv]` | Check backends + optionally index this repo; ends with a health report |
+| `codeintel setup [project_root] [--all] [--index] [--warm] [--install-uv] [--install-deps] [--json]` | Prepare backends + index this repo (`--all` = one command: do everything automatable, idempotent); ends with a health report + **Next:** steps |
 | `codeintel index [project_root]` | Index a project for semantic search |
 | `codeintel serve` | Start the MCP server (stdio transport) |
 | `codeintel serve-http [--host HOST] [--port 8766] [--allow-remote] [--token TOKEN]` | Start the HTTP transport (loopback-only unless `--allow-remote`; `--token` requires a bearer token on every request) |
@@ -189,6 +196,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | `codeintel status [project_root]` | Show engine availability and index age |
 | `codeintel doctor [project_root] [--deep] [--json]` | Diagnose per-engine health + repo index status, with a fix for each gap |
 | `codeintel map [project_root]` | Generate the `CODE_INTEL.md` orientation file |
+| `codeintel graph [project_root] [--html] [--out FILE] [--limit N]` | Emit the call graph as `{nodes,edges}` JSON, or `--html` a self-contained interactive viewer — see [docs/graph-viewer.md](docs/graph-viewer.md) |
 | `codeintel reset [project_root] [--all] [--yes]` | Clear the semantic index (this repo, or `--all`) to recover from a corrupt/stale DB |
 | `codeintel gen-token` | Print a secure random bearer token (for `serve-http` / RBAC `auth.toml`) |
 

{codecortex-0.9.0 → codecortex-0.11.0}/src/codecortex.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ src/codeintel/cache.py
 src/codeintel/config.py
 src/codeintel/doctor.py
 src/codeintel/gateway.py
+src/codeintel/grapher.py
 src/codeintel/http_server.py
 src/codeintel/indexer.py
 src/codeintel/injector.py
@@ -35,6 +36,8 @@ src/codeintel/providers/graph.py
 src/codeintel/providers/lsp.py
 src/codeintel/providers/none.py
 src/codeintel/providers/semantic.py
+src/codeintel/viewer/__init__.py
+src/codeintel/viewer/graph_template.html
 tests/test_cache.py
 tests/test_chunking.py
 tests/test_config.py
@@ -45,6 +48,7 @@ tests/test_gateway.py
 tests/test_graph_provider.py
 tests/test_graph_real.py
 tests/test_graph_stdin.py
+tests/test_grapher.py
 tests/test_hardening.py
 tests/test_http_auth.py
 tests/test_http_server.py

codecortex-0.11.0/src/codeintel/__init__.py

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

{codecortex-0.9.0 → codecortex-0.11.0}/src/codeintel/__main__.py

@@ -68,6 +68,13 @@ def main() -> None:
     map_parser.add_argument("--inject", action="store_true", help="Inject reference block into CLAUDE.md/AGENTS.md")
     map_parser.add_argument("--budget", type=int, default=32768, help="Byte budget for CODE_INTEL.md (default: 32768)")
 
+    # graph subcommand — interactive call-graph view (HTML) or the raw {nodes,edges} JSON
+    graph_parser = subparsers.add_parser("graph", help="Build an interactive call-graph view (--html) or emit the graph as JSON — works on any indexed repo")
+    graph_parser.add_argument("project_root", nargs="?", default=None, help="Project root (default: cwd)")
+    graph_parser.add_argument("--html", action="store_true", help="Write a self-contained interactive HTML viewer (default: print JSON)")
+    graph_parser.add_argument("--out", default=None, help="Output path for --html (default: codeintel-graph.html)")
+    graph_parser.add_argument("--limit", type=int, default=220, help="Max call edges to include (default: 220)")
+
     # doctor subcommand
     doctor_parser = subparsers.add_parser("doctor", parents=[color_parent], help="Diagnose engine health + index status for a repo")
     doctor_parser.add_argument("project_root", nargs="?", default=None, help="Project root (default: cwd)")
@@ -77,6 +84,9 @@ def main() -> None:
     # setup subcommand
     setup_parser = subparsers.add_parser("setup", parents=[color_parent], help="Prepare backends and optionally index this repo")
     setup_parser.add_argument("project_root", nargs="?", default=None, help="Project root (default: cwd)")
+    setup_parser.add_argument("--all", action="store_true", dest="all_steps",
+                              help="One-command setup: do everything automatable (uv + deps + index + "
+                                   "warm serena). Idempotent — skips what's already installed.")
     setup_parser.add_argument("--install-uv", action="store_true", help="Run `pip install uv` (provides uvx for the LSP engine)")
     setup_parser.add_argument("--install-deps", action="store_true", help="Run `pip install -e .` (semantic engine deps)")
     setup_parser.add_argument("--index", action="store_true", help="Index this repo now (first run downloads the ~50MB model)")
@@ -187,6 +197,31 @@ def main() -> None:
             print(f"map failed: {exc}")
         sys.exit(0)
 
+    elif args.command == "graph":
+        from codeintel import grapher
+        project_root = args.project_root or os.getcwd()
+        try:
+            payload = grapher.build_graph_payload(project_root, limit=args.limit)
+            n, e = len(payload.get("nodes", [])), len(payload.get("edges", []))
+            if args.html:
+                out = args.out or "codeintel-graph.html"
+                with open(out, "w", encoding="utf-8") as f:
+                    f.write(grapher.render_html(payload))
+                print(f"Wrote {out}  ({n} nodes, {e} edges) — open it in any browser")
+                if not n:
+                    reason = payload.get("reason")
+                    if reason:
+                        print(f"  (graph empty: {reason} — run `codeintel doctor` to check the "
+                              f"graph backend + index)")
+                    else:
+                        print("  (no internal call edges found for this repo)")
+            else:
+                import json as _json
+                print(_json.dumps(payload, indent=2))
+        except Exception as exc:
+            print(f"graph failed: {exc}")
+        sys.exit(0)
+
     elif args.command == "query":
         try:
             import time
@@ -284,12 +319,13 @@ def main() -> None:
             from codeintel import onboarding
 
             project_root = args.project_root or os.getcwd()
+            all_steps = getattr(args, "all_steps", False)  # --all implies every automatable step
             report = onboarding.run_setup(
                 project_root,
-                install_uv=args.install_uv,
-                install_deps=args.install_deps,
-                do_index=args.index,
-                warm_lsp=args.warm,
+                install_uv=args.install_uv or all_steps,
+                install_deps=args.install_deps or all_steps,
+                do_index=args.index or all_steps,
+                warm_lsp=args.warm or all_steps,
             )
             if args.json:
                 import json as _json

{codecortex-0.9.0 → codecortex-0.11.0}/src/codeintel/doctor.py

@@ -11,6 +11,9 @@ import os
 from typing import Any, Callable, Optional
 
 _ENGINES = ("graph", "lsp", "semantic")
+# Graph needs an external native binary (codebase-memory-mcp) codeintel can't auto-install, so a
+# missing graph engine does NOT make a repo "unhealthy" — the tool is fully usable on semantic + lsp.
+_OPTIONAL_ENGINES = frozenset({"graph"})
 
 
 def _status_for(report: dict) -> str:
@@ -112,13 +115,17 @@ def run_doctor(
         treesitter = False
 
     ready = sum(1 for e in engines.values() if e.get("status") != "fail")
+    # "healthy" ignores OPTIONAL engines (graph): a repo with semantic + lsp ready is healthy even
+    # without the external graph binary. `ready`/`total` stay literal (all three) for transparency.
+    healthy = all(
+        e.get("status") != "fail" for n, e in engines.items() if n not in _OPTIONAL_ENGINES
+    )
     return {
         "ok": True,
         "project_root": root,
         "deep": bool(deep),
         "treesitter": treesitter,
-        "summary": {"ready": ready, "total": len(engines),
-                    "healthy": all(e.get("status") != "fail" for e in engines.values())},
+        "summary": {"ready": ready, "total": len(engines), "healthy": healthy},
         "engines": engines,
     }
 
@@ -168,10 +175,16 @@ def render_doctor_text(report: dict) -> str:
     tail = "" if report.get("deep") else c.dim("  (run with --deep to boot-check serena)")
     out.append("")
     out.append(f"  {count} engines ready for this repo.{tail}")
+    opt_down = [n for n in _ENGINES
+                if n in _OPTIONAL_ENGINES and (engines.get(n) or {}).get("status") == "fail"]
+    if opt_down:
+        out.append("  " + c.dim(
+            f"({', '.join(opt_down)} optional — an external backend; codeintel works without it)"
+        ))
     if healthy is False:
         out.append("  " + c.dim(
-            "tip: `codeintel setup --install-uv --install-deps --index` bootstraps the "
-            "pip-installable backends; each fix: line above has the per-engine command."
+            "tip: `codeintel setup --all` installs + indexes everything automatable in one command; "
+            "each fix: line above has the per-engine command."
         ))
     if report.get("treesitter") is False:
         out.append("  " + c.dim(

codecortex-0.11.0/src/codeintel/grapher.py

@@ -0,0 +1,115 @@
+"""Build an interactive view of a project's call graph from the graph engine.
+
+Headless-first, in board-differ's data→renderer spirit: `build_graph_payload` returns a plain
+``{project, nodes, edges}`` dict (the machine-readable `--format json` shape); `render_html` wraps
+that payload in the self-contained interactive viewer (``viewer/graph_template.html``). The engine
+produces the *data*; the template is the *renderer*. Both never raise.
+"""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+from codeintel.provider import log_swallowed
+
+_EMPTY = {"project": "", "engine": "graph", "op": "callgraph", "nodes": [], "edges": []}
+
+
+def build_graph_payload(project_root: Any, *, limit: int = 220, timeout_ms: int = 8000) -> dict:
+    """Query the graph engine for a project's internal call graph → ``{project, nodes, edges}``.
+
+    Nodes are the symbols that participate in an internal call edge, enriched with the same
+    complexity metrics the ``hotspots`` op surfaces; edges are ``CALLS``/``USAGE`` relations.
+    Builtins/synthetic nodes are excluded. Returns an empty payload with a ``reason`` on any
+    failure — never raises (mirrors the safe-null contract)."""
+    try:
+        try:
+            limit = max(1, min(2000, int(limit)))
+        except Exception:
+            limit = 220
+        try:
+            timeout_ms = int(timeout_ms)
+        except Exception:
+            timeout_ms = 8000
+        from codeintel.providers.graph import GraphProvider
+        p = GraphProvider()
+        if not getattr(p, "available", False):
+            return {**_EMPTY, "reason": "engine-unavailable"}
+        project = p._resolve_project(str(project_root or ""))
+        if not project:
+            return {**_EMPTY, "reason": "project-not-indexed"}
+
+        # per-symbol metrics (same search_graph the `hotspots` op uses)
+        metrics: dict[str, dict] = {}
+        for r in (p._search_symbols({"label": "Function", "min_degree": 1, "limit": 600}, project, timeout_ms) or []):
+            qn = str(r.get("qualified_name") or "")
+            if qn:
+                metrics[qn] = r
+
+        # internal call edges — fetch generously and filter builtins/synthetic ('<...>') nodes
+        # CLIENT-SIDE (robust across Cypher dialects; mirrors how the hotspots op drops them).
+        cypher = (
+            "MATCH (a)-[c:CALLS|USAGE]->(b) "
+            "RETURN a.qualified_name, a.name, a.file_path, b.qualified_name, b.name, b.file_path, type(c) "
+            "LIMIT " + str(min(max(limit * 3, 400), 1500))
+        )
+
+        def _synth(fp: str) -> bool:
+            return (not fp) or fp.startswith("<")
+
+        nodes_by_id: dict[str, dict] = {}
+        edges: list[dict] = []
+        seen: set = set()
+
+        def _add(qn: str, name: str, fp: str) -> None:
+            if qn and qn not in nodes_by_id:
+                m = metrics.get(qn, {})
+                nodes_by_id[qn] = {
+                    "id": qn, "label": name or qn.rsplit(".", 1)[-1], "file": str(fp or ""),
+                    "complexity": m.get("complexity") or 0, "cognitive": m.get("cognitive") or 0,
+                    "in_degree": m.get("in_degree") or 0, "out_degree": m.get("out_degree") or 0,
+                    "lines": m.get("lines") or 0,
+                }
+
+        for e in (p._query_rows(cypher, project, timeout_ms) or []):
+            if len(edges) >= limit:
+                break
+            aq, bq = str(e.get("a.qualified_name") or ""), str(e.get("b.qualified_name") or "")
+            af, bf = str(e.get("a.file_path") or ""), str(e.get("b.file_path") or "")
+            if not aq or not bq or aq == bq or _synth(af) or _synth(bf):
+                continue
+            _add(aq, str(e.get("a.name") or ""), af)
+            _add(bq, str(e.get("b.name") or ""), bf)
+            if (aq, bq) not in seen:
+                seen.add((aq, bq))
+                edges.append({"from": aq, "to": bq, "type": str(e.get("type(c)") or "")})
+
+        nodes = list(nodes_by_id.values())
+        return {"project": project, "engine": "graph", "op": "callgraph", "nodes": nodes, "edges": edges}
+    except Exception as exc:
+        log_swallowed("grapher.build_graph_payload", exc)
+        return {**_EMPTY, "reason": "error"}
+
+
+def _template_path() -> str:
+    return os.path.join(os.path.dirname(__file__), "viewer", "graph_template.html")
+
+
+def render_html(payload: dict) -> str:
+    """Wrap a graph payload in the self-contained interactive viewer template. Never raises."""
+    try:
+        # default=str → serialization can't raise on an unexpected value; "</" escape keeps the
+        # JSON inside the <script> element (the template's viewer JS re-emits every string via
+        # textContent, so there is no innerHTML/XSS sink downstream).
+        data = json.dumps(payload, default=str).replace("</", "<\\/")
+        with open(_template_path(), encoding="utf-8") as f:
+            return f.read().replace("__DATA__", data)
+    except Exception as exc:
+        log_swallowed("grapher.render_html", exc)
+        try:
+            body = json.dumps(payload, indent=2, default=str).replace("&", "&amp;").replace("<", "&lt;")
+        except Exception:
+            body = "(graph payload unavailable)"
+        return ("<!doctype html><meta charset=utf-8><title>codeintel graph</title>"
+                "<pre style='font:13px ui-monospace,monospace;padding:16px'>" + body + "</pre>")