One Code Map, Twenty Languages

Real repositories are rarely one language. A TypeScript front end calls a Go service that shares a Python data pipeline and a sprinkling of shell in the build. Most tools that promise to "understand your codebase" handle one of those and stop at the boundary — and the boundary is exactly where the risky change lives, because that is where a rename or a signature change quietly breaks something two languages away.

vg build produces one map of the whole repository — across 20 languages — with the cross-module edges that make the boundary visible.

Twenty languages, one command

Build the map at the root of your project. It is written to .vibgrate/graph.json, and a bare vg builds it as the final step of a scan, so you often have it already:

$ vg build
✔ code map · 1,204 nodes · 3,881 edges · 20 languages

The 20 supported languages are TypeScript and TSX, JavaScript, Python, Go, Java, Rust, C#, Ruby, PHP, Kotlin, Swift, Scala, Dart, Lua, Elixir, Shell, Zig, C, and C++. One graph spans all of them, so a polyglot repository is described in a single, consistent structure rather than a pile of per-language reports.

Cross-module call edges — the part that matters

A list of files and symbols is a table of contents. What makes a map useful is the edges — which function calls which, across module boundaries. Vibgrate resolves those relations so the graph carries real call edges, not just a directory tree. That is what lets a question like "what depends on this?" have an answer.

vg impact: what does this change touch?

Because the edges are there, you can trace the blast radius of a change before you make it. vg impact walks the call graph from a file or symbol and reports everything it reaches:

$ vg impact src/auth/session.ts
reaches 37 nodes across 9 modules · 2 public entrypoints

That is the difference between "I think this is safe" and "I can see the 37 places this touches, and two of them are public." For companion views over the same map, vg map gives an architecture overview, and vg hubs, vg areas, and vg oddities surface the concentrations of risk.

Deterministic and committable

The map is deterministic — the same code produces the same graph — which means you can commit it and diff it. A pull request that changes the structure of your system shows that change in the graph, reviewable like any other file. It is not a snapshot that rots in a wiki; it lives next to the code and moves with it.

Feed it to your assistant

The same map is what your AI assistant should be reading instead of re-deriving your structure file by file. Over the Model Context Protocol, an assistant can fetch a node, find a path between two symbols, or compute impact — the mechanism behind our measured ~24% reduction in AI coding tokens with the same results. The code map is a free developer tool; you can build and query it with no account.

Try it

$ vg build
$ vg impact <file-or-symbol>

The vg build reference and vg impact reference cover the flags, and the Vibgrate Graph page shows the free code-graph tool in full.