Open source · MIT

See what a change breaks before your agent makes it.

Wingbox builds the code graph of your repository on your machine and tells an AI coding agent, in a few hundred tokens, what a change will break before it edits.

Latest release 0.2.2 · MIT license · runs on your machine

A terminal runs wingbox impact on one file of the immich server. On a 3D stack of architecture layers the file lights up in the domain layer, then the ten files that import it in the API, service, domain and test layers, then twenty more at two hops.
Real output of Wingbox on the server of immich, an open-source photo platform with 707 modules. Checked against the code: an import resolver written separately from Wingbox finds the same 3,795 dependencies, none extra and none missing.
The command

One command, one exact answer

The agent asks which files depend on the one it is about to edit. Wingbox answers from the code graph instead of reading the repository.

  • What could break if I change this file?
  • Which modules depend on this service, class or type?
  • Does this dependency cross an architecture boundary?
  • Which two or three files should I read before fixing this bug?
The map

Your architecture, in 3D layers

The build also writes an interactive map: one HTML file that opens in a browser without a network connection. The layers view stacks API, services, domain and infrastructure; click a file and its blast radius lights up across the layers.

One DTO changes: 10 files import it, 30 are within two hops.
Layers view of the Wingbox map with the base service selected: 65 direct dependents, 281 modules within two hops, spread over every layer
The base service changes: 65 direct dependents, 281 of 707 modules within two hops.
Open the sample report and the live map
Benchmarks

Measured, and checked against the code

One hundred questions drawn at random in five public repositories, an agent with and without Wingbox, every edge compared with the code. Scripts, reference lists and result files are public, and a container reproduces the run.

100 of 100

questions where the impact command names the complete list of dependent files

-35 %

tokens an agent reads per answer, against its own search alone

55 of 55

complete answers from the agent with Wingbox; 48 without it

3.2 s

to build the graph of FastAPI, 1,227 files, from a fresh checkout

See the benchmarks
Install

Run it on your repository

  1. 1
    $ pipx install wingbox

    Install the command. Claude Code and Codex can also load it as an agent skill: npx skills add aileron-tech/wingbox.

  2. 2
    $ wingbox build .

    Build the graph. The report and the map land in wingbox-out/.

  3. 3
    $ wingbox impact path/to/file 2

    Ask what a change to one file reaches within two hops.

Design

How it works

Local
Everything runs on your machine: no LLM call, no embeddings, no network access to build or query the graph.
Deterministic
Static parsing: the same code gives the same graph, and every edge can be traced to a line of source.
Ten languages
Python, TypeScript, Rust, C#, Java, Go, Ruby, Rails, Free Pascal and Lazarus.
For agents and people
An agent skill for Claude Code and Codex, a plain command, a report and an interactive map.
Limits

Where it will not help

  • Dependencies created at run time: dependency injection, reflection, generated code. The graph holds what the source states.
  • Vendored and minified bundles are left out of the graph, so an import of one has no target.
  • Architecture layers come from folder names; on a library with no such folders they are guesses, and the report says which.
Questions

Before you install

My agent already has grep. Why does it need a graph?
Text search finds lines that match a pattern; the agent then reads files to work out what depends on what. A code graph answers the structural question directly: which files depend on this one, what a change can break, which few files to read first. On 55 questions the agent with Wingbox read -35 % tokens and gave the complete list on all 55; with search alone it was complete on 48.
Does Wingbox send my code anywhere?
No. The graph is built and queried on your machine by deterministic static parsing: no LLM call, no embeddings, no vector database, no network access. The container image runs with the network switched off.
How do I know the graph is right?
Every answer can be traced to an import statement. In the benchmark the graph of seven corpora was compared with resolvers that share no code with Wingbox, and the impact command named the complete list of dependent files on 100 of 100 questions drawn at random. The scripts are public and a container reproduces the run.
Which agents and languages does it work with?
Claude Code, Codex and other clients that support agent skills; the command also runs on its own. Languages: Python, TypeScript and JavaScript, Rust, C#, Java, Go, Ruby and Rails, Free Pascal and Lazarus.
Does it replace a compiler or a language server?
No. It is an architecture and impact-analysis tool. Dependencies that are not explicit in the source, such as generated imports, runtime dependency injection or reflection, are not in the graph and have to be checked against the running application.
How long does it take on a real repository?
Seconds. Building the graph, the report and the map of FastAPI, 1,227 files, takes 3.2 s from a fresh checkout on a hosted runner. An impact answer comes back in about half a second.

Wingbox is the engine behind Agent Control, the fixed-price audit of agent-written code by Aileron Technologies.