The saving is CONDITIONAL on repo size × tangle, not a fixed multiplier. Measured on real
repos: ~5.7x fewer tokens/query on a mid-size service, ~73x on a large interconnected one,
~13% on a tiny library. The graph query cost is ~constant; naive full-corpus cost scales with
size — so reduction = corpus ÷ constant. Do the arithmetic on YOUR repo, don't quote a headline.
Hard boundary: the graph helps NAVIGATION, not REASONING. "Design a cache", "why is this slow"
get zero lift. It gathers context efficiently; it does not think for the model.
Uses graphify (open-source, tree-sitter + NetworkX, MIT). Code extraction is local +
deterministic + free (no API key). Install once: uv tool install graphifyy (or pipx/pip).
If graphify is absent, this skill degrades to a no-op — never a hard failure.
1---2name: knowledge-graph3description: Build + keep-fresh + query a deterministic code knowledge graph to cut agent orientation-token cost. Triggers: knowledge graph, graphify, code graph, god nodes, orientation cost, token bill, map the codebase, what connects X to Y, callers of, blast radius.4---56<skill id="knowledge-graph">78<purpose>9An agent's token bill splits into ORIENTATION (finding where the answer lives — reading10files, following imports, grepping) and REASONING (actually solving). On a large, tangled11repo the orientation half dominates, and it is pure overhead: the model is not thinking yet,12it is still navigating. A pre-built code knowledge graph replaces that file-crawl with one13query, so you pay orientation tokens once (at build) instead of every session.1415The saving is CONDITIONAL on repo size × tangle, not a fixed multiplier. Measured on real16repos: ~5.7x fewer tokens/query on a mid-size service, ~73x on a large interconnected one,17~13% on a tiny library. The graph query cost is ~constant; naive full-corpus cost scales with18size — so reduction = corpus ÷ constant. Do the arithmetic on YOUR repo, don't quote a headline.1920Hard boundary: the graph helps NAVIGATION, not REASONING. "Design a cache", "why is this slow"21get zero lift. It gathers context efficiently; it does not think for the model.22</purpose>2324<prerequisite>25Uses `graphify` (open-source, tree-sitter + NetworkX, MIT). Code extraction is local +26deterministic + free (no API key). Install once: `uv tool install graphifyy` (or `pipx`/`pip`).27If graphify is absent, this skill degrades to a no-op — never a hard failure.28</prerequisite>2930<build>31Code-layer graph (free, offline, seconds):32```bash33graphify extract <path> --code-only # local AST only; skips docs; no LLM, no cost34```35Outputs `graphify-out/graph.json` (+ report; +interactive graph.html under ~5000 nodes).36NEVER commit `graphify-out/` — it is DERIVED. Gitignore it and rebuild on demand37(the sqlite-mirror discipline: commit the source, rebuild the artifact).38</build>3940<query>41```bash42graphify query "what connects auth to the database?" # BFS over the graph, token-budgeted43graphify path "UserService" "DatabasePool" # shortest path between two symbols44graphify god-nodes --top 12 # architectural hubs (most-connected)45graphify affected "RateLimiter" # reverse traversal = change blast radius46graphify benchmark # measure YOUR token reduction, per question47```48`god-nodes` doubles as a comprehension + pruning lens: hubs are the real spine; low-degree,49never-linked nodes are dead-code / consolidation candidates. Also available as an MCP server50(`query_graph`, `shortest_path`, `get_neighbors`) for repeated structured access.51</query>5253<automatic>54The graph pays off only if it is CONSULTED. A skill telling the agent to reach for it is opt-in55and unreliable, so the orientation layer is AMBIENT: when the working repo has a graph, the56session-start hook injects its architectural spine (top god-nodes + the query commands) directly57into context — the agent boots already oriented, no tool call, no human ask. Deep on-demand58queries ("what calls this exact function") still go through `graphify query`/`path`/`affected`59or the MCP tools; those are available + steered, but the baseline map arrives for free.60</automatic>6162<continuous>63A stale graph is worse than none. Keep it fresh, cheaply:64- **Code layer (free):** `graphify extract <path> --code-only` is incremental via its AST cache65 ("N cached/unchanged, 0 re-extracted"). Wire it into `post-commit` so the graph is never more66 than one commit stale, at ~zero cost. Opt-in installer: `hooks/scripts/knowledge-graph.sh install`67 (gated on `KERNEL_GRAPH_ON=1`, mirroring autopush — never stamps hooks by surprise).68- **NEVER `graphify update`** for the code graph: it re-scans ALL files and adds docs as bare69 nodes (measured 1506 → 13156 on one tree). Always `extract --code-only`.70- **Doc/semantic layer** (summaries, tags, prose edges) needs a model and is OPTIONAL polish.71 Run it incrementally (changed files only), never full-corpus, never on every commit. Local72 models are "good enough for orientation, not a top-tier artefact"; a frontier model is sharper.73</continuous>7475<boundaries>76- Free + deterministic is the CODE layer only. The doc/paper/image "why" layer sends semantic77 descriptions (never raw source) to a configured backend — that costs a model.78- Small or reasoning-heavy repos: the graph is a solved problem you did not have. Skip it.79- The graph is a comprehension artefact that also saves tokens — value it as a map first.80</boundaries>8182</skill>
hashgraph-online