Graph

Query forge's live, always-fresh code map — a dependency graph of the repo with god-nodes, modules, and neighbors/impact (blast-radius) queries. Use before editing to know what depends on a file, to find the most-depended-on hotspots, to map an unfamiliar codebase's architecture, or whenever you need current structural context instead of guessing.From its SKILL.md

Install

npx -y skills add vasu-devs/Forge --skill graph

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
runs commandsInstructs the agent to run 5 commands, including `node "$G" map` and 4 more.

SKILL.md

4.5 KB, ~1.0k tokens by cl100k_base, as published. Nobody here has run it

 ██████╗ ██████╗  █████╗ ██████╗ ██╗  ██╗
██╔════╝ ██╔══██╗██╔══██╗██╔══██╗██║  ██║
██║  ███╗██████╔╝███████║██████╔╝███████║
██║   ██║██╔══██╗██╔══██║██╔═══╝ ██╔══██║
╚██████╔╝██║  ██║██║  ██║██║     ██║  ██║
 ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝     ╚═╝  ╚═╝

The live code map

forge keeps a dependency graph of the whole repo — built once, then patched automatically as files change, so your structural context never goes stale. It's a zero-dependency, fully-local synthesis of the three things a code graph is good for:

god-nodes — the most-depended-on files (highest fan-in); the architectural hotspots to touch with care.
modules / clusters — the architecture at a glance (which directories form cohesive units, how many communities exist).
neighbors / impact — who imports a file, and the transitive blast radius of changing it.
cycles · dead files · orchestrators — dependency cycles (refactor hazards), orphaned files (0 in / 0 out, non-entry), and high-fan-out composition roots.

It updates itself: a SessionStart hook injects a fresh map and triggers a background refresh; the Stop hook patches changed files after every turn (mtime-diff — only changed files are reparsed). You usually read the injected map for free; reach for the CLI when you need a specific answer.

When to use it

Before editing a shared file — run impact to see everything that could break.
Entering an unfamiliar repo — run map to learn the hotspots and module layout in one call (cheaper and more accurate than grepping around).
"Where is X / what uses X" — neighbors gives importers and imports directly.
It's the structural layer forge:understand leans on — use the graph first, then read only the files on the path.

Commands

G=~/.claude/skills/forge/scripts/graph.js
node "$G" map                 # god-nodes + module map for this repo
node "$G" neighbors <file>    # direct imports ↑ and importers ↓ of a repo-relative file
node "$G" impact <file>       # transitive blast radius — who breaks if this changes
node "$G" stats               # files / deps / clusters / last-built
node "$G" refresh             # build if missing, else mtime-patch (the hooks do this for you)

Paths are repo-relative with / separators (e.g. src/api/client.ts), exactly as the map prints them.

What it does and doesn't see

Edges = static imports/requires/includes, resolved to real repo files: JS/TS (import/require/dynamic-import, relative + index resolution + tsconfig/jsconfig baseUrl/paths aliases like @/…), Python (absolute + relative, incl. nested-package suffix match), C/C++ (#include "…"), Ruby (require_relative), Rust (mod). It respects the repo's .gitignore (single-name dir/file entries) so generated/ignored code isn't counted.
It does not follow dynamic dispatch / runtime reflection, monorepo workspace-package imports (bare @scope/pkg → another package), or Go module-path imports. Languages without an extractor yet — Go, Java, Kotlin, PHP, C#, Swift — are counted as files but appear as edgeless nodes. Treat the map as a high-accuracy skeleton, not a completeness proof; confirm a critical call path by reading the code (forge:verify).
If a deeper symbol-level call graph is available (e.g. CodeGraph MCP via /codegraph-here), prefer it for precise caller/callee analysis; forge:graph is the always-on, zero-setup baseline.

Freshness

The map is patched after each turn, so during a session it tracks your edits. If you've just made sweeping changes and want certainty before a big query, run node "$G" refresh first. Disable the whole subsystem with FORGE_GRAPH=off.

What ships with it

Read from the repository

Just SKILL.md. No reference files, no scripts.

Gives 0 of the 12 instructions most architecture codebase skills give in ~1.0k tokens

Counted across 858 of the 1,304 authors here whose files we hold, read 2026-09-06

Apply the deletion test to identify shallow modulesin 32 of 858, across 31 files
Read domain glossary and ADRs before exploringin 22 of 858, across 19 files
Use Tailwind and Mermaid via CDN for reportsin 21 of 858, across 18 files
Document architecture decision recordsin 20 of 858, across 12 files
Offer to record ADRs for rejected candidatesin 17 of 858, across 14 files
Limit primary navigation to four to seven itemsin 17 of 858, across 7 files
Write HTML report to the system temp directoryin 17 of 858, across 14 files
Read product marketing context before asking questionsin 16 of 858, across 6 files
Use Mermaid graph TD for visual sitemapsin 15 of 858, across 5 files
Ensure every page has at least one internal linkin 15 of 858, across 5 files
Use ASCII tree format for page hierarchy draftsin 15 of 858, across 5 files
Enforce lowercase URLs with hyphensin 15 of 858, across 5 files

Said here and by no other author read

Run impact before editing shared files
Run map to learn hotspots and module layout
Use neighbors to find importers and imports
Read the injected map for structural context
Run refresh if the map is stale
Use graph before reading files

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once. Length counted with cl100k_base; the agent that loads this file may tokenize it differently.