Graphify
Build a structural AST index of a repo so your agent maps classes, imports, and call graphs before grepping or editing unfamiliar code.
Overview
Graphify is an agent skill most often used in Build (also Ship, Operate) that builds and queries a tree-sitter AST index so you navigate unfamiliar code before searching or editing.
Install
npx skills add https://github.com/howell5/willhong-skills --skill graphifyWhat is this skill?
- Indexes 12 languages with tree-sitter into graphify-out/graph.json (classes, functions, imports, call graph)
- Commands: graphify build, query, and incremental update after file edits
- Requires global install: npm i -g graphify-ts (Bun runtime)
- Manual refresh only—avoids auto-writes that break git worktrees and parallel sessions
- Trigger: /graphify when exploring unfamiliar code before search
- 12 languages via tree-sitter
- Outputs graphify-out/graph.json
Adoption & trust: 900 installs on skills.sh; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
You are about to change or debug a codebase you do not know, and plain grep misses structure, imports, and call relationships.
Who is it for?
Solo builders using Claude Code or Cursor on polyglot repos who want a repeatable /graphify ritual before deep edits.
Skip if: Projects where you cannot install a global CLI or allow shell access to run graphify build.
When should I use this skill?
Exploring unfamiliar codebases, before searching for code, or after editing files; user triggers /graphify.
What do I get? / Deliverables
You get a queryable graph.json index and symbol locations, then refresh incrementally after edits instead of guessing file layout.
- graphify-out/graph.json index
- Symbol query results with file locations
- Index stats report (files, nodes, edges)
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Agent-facing code navigation is shelved under Build/agent-tooling because it augments how you explore and change code during implementation. Agent-tooling fits CLI-backed skills that agents invoke via slash commands to shorten discovery loops in real codebases.
Where it fits
Run graphify build then query a service name to find callers before adding an API field.
Query changed modules to trace import fan-out before approving a large PR.
graphify update on hotfixed files then query regressions paths in production bug work.
How it compares
Structural index and query layer—not a substitute for running tests, linters, or full static-analysis security suites.
Common Questions / FAQ
Who is graphify for?
Developers and coding agents that need a fast structural map—symbols, imports, and call edges—across multi-language repos.
When should I use graphify?
Use it when exploring an unfamiliar codebase in Build, before refactors in Ship review prep, or after edits in Operate maintenance—always before heavy grep-only search if structure matters.
Is graphify safe to install?
It runs a third-party global CLI via Bash; check the Security Audits panel on this Prism page and review graphify-ts before granting shell permissions.
SKILL.md
READMESKILL.md - Graphify
# graphify — Code Navigation Layer Structural index of the codebase. Know what exists, where, and how it connects — before you grep. **Requires CLI:** `npm i -g graphify-ts` (uses Bun runtime). **Manual updates only.** The graph does not refresh on its own — you (or the user) run `graphify update` or `graphify build` when you want a fresh index. This avoids write conflicts in git worktrees and other multi-session setups. ## First-time setup (one-time per machine) ```bash npm i -g graphify-ts # install CLI ``` Then, once per project: ```bash graphify build . ``` After that, refresh manually whenever the index drifts from the code (see `graphify update` below). ## Commands ### `/graphify build` — Build index (first time, or full rebuild) ```bash graphify build . ``` Scans all source files, extracts AST structure, saves to `graphify-out/graph.json`. Report: "Indexed {files} files, {nodes} symbols, {edges} relationships" ### `/graphify query <name>` — Search for symbols ```bash graphify query graphify-out/graph.json <name> ``` Case-insensitive search. Returns matching symbols with file locations. ### `/graphify update <files...>` — Incremental update after edits ```bash graphify update graphify-out/graph.json <file1> [file2...] ``` Re-extract only the specified files. Run this after editing code if you plan to query the graph again in the same session. ### `/graphify auto-update` — Bulk update from git diff ```bash graphify auto-update [dir] ``` Computes changed code files via `git diff` + untracked files, then calls `updateIndex`. Silent when there's nothing to do. Convenient for refreshing after a batch of edits without naming each file. ## When to Use **Before searching code:** If `graphify-out/graph.json` exists, query it before Glob or Grep. The graph tells you which files contain which symbols. This is the main value — replace blind keyword search with structured lookup. **After editing:** If you'll query the graph again in the same session, run `graphify update <edited-files>` (or `graphify auto-update` for a bulk refresh). Otherwise leave it — the next `graphify build` or update will catch up. **Exploring unfamiliar code:** Run `/graphify query <concept>` to find entry points without guessing filenames. ## Supported Languages Python, JavaScript, TypeScript (JSX/TSX), Go, Rust, Java, C, C++, Ruby, C#, Kotlin, Scala, PHP ## Graph Output Saved as `graphify-out/graph.json`: ```json { "nodes": [{ "id": "main::app", "label": "App", "sourceFile": "main.py", "sourceLocation": "main.py:5" }], "edges": [{ "source": "file::main", "target": "main::app", "relation": "contains", "confidence": "EXTRACTED" }], "metadata": { "files": 10, "nodes": 45, "edges": 62 } } ``` Edge relations: `contains`, `method`, `imports`, `imports_from`, `calls` (INFERRED), `inherits`