Graphify Code Graph

---
name: graphify-code-graph
description: "Deterministic, queryable knowledge graph over a codebase with graphify (tree-sitter, 25+ languages, no LLM cost). Use it for code-level impact analysis inside a client repo, where grep answers poorly."
metadata:
  type: tool-skill
  source: "https://github.com/Graphify-Labs/graphify. This skill DECLARES no license and its manifest carries the repo default over ORIGINAL text: measured at the entry ref b1936079 against all 361 markdown files upstream, tree not truncated: max similarity 0.0519 (0.2091 with difflib autojunk off) and longest shared run 43 characters. An earlier note here said 40 files, 0.0502 and 21 characters; that was a truncated 11% sample published as a census, and the conclusion survived the correction while the receipt did not, so nothing here is copied and this repo's own terms are the right ones. The TOOL was MIT when this was written and upstream relicensed to Apache-2.0 on 2026-07-22 (ba7f9ea9), six days after this entered on 2026-07-16 (a14b67c). That is recorded so nobody 'corrects' the manifest against the current listing: the tool's license was never what this field carried."
  deep-learn: knowledge/repo-deep-learn/graphify/2026-07-16.md
---

# Graphify: deterministic code knowledge graph

## When to use

- A code question spans many files ("what breaks if I change X?", "how does A reach B?") and grep gives partial, noisy answers.
- Onboarding into a large or unfamiliar codebase (client repo, OSS dependency).
- Repeated architecture questions in one repo: build the graph once, query it every session at near-zero token cost.

Not for concept/governance recall. Which skill knows this, where does a rule live, what derives from a doc: that is the brain's connectome (`query_connectome.py`) and lineage (`impact-radius.py`). Graphify maps code symbols; those map concepts. Two layers, keep both.

## Install (one time per machine)

```bash
uv tool install graphifyy      # or: pipx install graphifyy
graphify install               # registers the /graphify skill with the AI assistant
```

The PyPI package is `graphifyy` (double y); the CLI is `graphify`.

## Build the graph (inside the target repo)

```bash
graphify .          # writes graphify-out/graph.json + GRAPH_REPORT.md + graph.html
graphify update .   # incremental re-extract of changed paths only, AST-only, no API cost
graphify watch      # keep it fresh on file changes
```

The code pass is fully deterministic: tree-sitter AST, no LLM, no API key, $0. Only the optional semantic pass (docs, PDFs, images, video, community labels) calls an LLM; without a key it is skipped entirely. Add `graphify-out/` to the repo's `.gitignore` unless the team wants the artifact versioned.

## Query it

```bash
graphify query "how does auth reach the billing module"
graphify affected src/auth/session.py    # code-level impact radius
graphify path NodeA NodeB                # shortest path between symbols
graphify explain "PaymentProcessor"      # natural-language node explanation
graphify diagnose                        # graph health
```

Matching is case-folded substring + IDF over the flat `graph.json` (NetworkX node-link format). No server, no embeddings. For assistant integration without shell calls there is an MCP server: `graphify-mcp` (stdio/HTTP).

## Arm usage pattern

Run it inside ONE arm's repo; the graph lives in that repo's `graphify-out/` and never leaves the arm (arm isolation applies to the artifact like to any other client data). Start every code-impact question with `graphify affected <file>` and fall back to grep only for symbols the graph does not know, same seek-before-scan discipline as the brain's graphs.

## Gotchas

- Edges carry `confidence` (EXTRACTED / INFERRED / AMBIGUOUS, 0.55-0.95 rubric): trust EXTRACTED, verify INFERRED before acting on it.
- The exporter refuses to silently shrink an existing graph (their issue #479). The brain adopted the same invariant in `scripts/generate_neural_map.py` (SHRINK-GUARD).
- Exports available when a human wants to browse: Obsidian vault, GraphML (Gephi/yEd), SVG, Cypher (Neo4j/FalkorDB).

## See also

- [[repomix]]: flat single-file codebase packing, the non-graph alternative for one-shot context stuffing.
- [[4d-paradigm-protocol]]: `graphify affected` is the code-level twin of the concept-level Impact Radius scan.