A repository map
An example of what index draws · repos as nodes, dependencies as edges, every edge carrying its proof.
index runs offline over real repos / this page shows an example of its output / read about index / github.com/HarperZ9/index
What this shows
index scans a workspace of many repositories and builds a dependency graph from real evidence: imports, package manifests, and references it actually finds in the code. Each repository becomes a node. Each edge is a real dependency, and it carries the file and line that drew it, so you can see why any two repos are connected. index makes no model call and no network call. It runs on your machine, over your repos.
Below is a small, real example: a cluster of eight repositories from the author's own workspace, drawn the way index draws it. Select any edge or node to see the exact evidence index recorded, including a confidence label. The same edges are listed in a plain text table further down, so nothing here depends on seeing the picture.
Example output · 8 repos, 8 edges · from a real index run
The map
Boxes are repositories. Arrows point from a repo to something it depends on. Color shows how strong the evidence is, and a dashed red arrow marks a dependency cycle (two repos that import each other). Click a node or an arrow, or move focus to it with the keyboard and press Enter, to read the evidence index recorded for it.
- Relation
- Click an arrow to see the dependency it stands for.
- Evidence
- The file and line that drew the edge appear here.
- Note
- A confidence label, and whether the edge sits in a cycle.
The same edges, as text
This table is the graph in words. It lists every edge in the example with the evidence index recorded and the confidence it assigned. If the picture above does not render, or you are reading with a screen reader, this is the whole map. It is built from the exact same data, so the two can never disagree.
| Depends on | Evidence (file : line, kind) | Confidence |
|---|---|---|
| proof-surface-report → proof-surface | pyproject.toml:13 manifest, plus src/proof_surface_report/core.py:17 import (4 signals) | high |
| public-surface-sweeper → proof-surface | pyproject.toml:22 manifest, plus src/public_surface_sweeper/cli.py:9 import (3 signals) | high |
| repo-proof-index → proof-surface | pyproject.toml:22 manifest, plus scripts/check_proof_surface_conformance.py:14 import (5 signals) | high |
| model-provenance-validator → proof-surface | pyproject.toml:22 manifest, plus src/model_provenance_validator/packet.py:15 import (2 signals) | high |
| coherence-membrane → proof-surface | src/coherence_membrane/membrane.py:81 import (1 signal) | moderate |
| accountable-surface → coherence-membrane | src/accountable_surface/certify.py:17 import, and 26 more (27 signals) | moderate |
| coherence-membrane → studio-engine | src/coherence_membrane/center/atelier.py:20 import, and 4 more (5 signals) | moderate, in cycle |
| studio-engine → coherence-membrane | studio_engine/certify.py:12 import, and 2 more (3 signals) | moderate, in cycle |
How to read it
- A node is a repository. Its role comes from its place in the graph, not from a label someone wrote. Here
proof-surfaceis the hub: four repositories depend on it, nothing in this slice depends the other way, so index marks it the structural center. - An edge is a real dependency, and it carries the evidence that drew it. A manifest signal (a line in
pyproject.toml) plus matching import lines is stronger than a single import, so those edges are labeled high confidence and the rest moderate. - A cycle is flagged, not hidden.
coherence-membraneandstudio-engineimport each other, so index draws both arrows in dashed red and records that each sits in a cycle. That is a signal worth seeing, not an error to bury. - Confidence is a claim about evidence, not about correctness. A high-confidence edge means index found strong, multiple signals for the dependency. It does not mean the dependency is a good idea. index reports what is there and leaves the judgment to you.
From a map to a checked map
Drawing the graph is the first half. The second half is checking it. You write the rules a healthy codebase keeps into a small .index.toml (which layers may depend on which, edges that must never exist, a ceiling on cycles), and index check measures the real graph against them. It returns one of three words and never a fourth: MATCH when the real shape matches the rules, DRIFT when it has moved away from them, or UNVERIFIABLE when it could not parse enough to decide. There is no TRUSTED.
In this example, a rule that said no dependency cycles would come back as DRIFT, and it would point straight at the coherence-membrane and studio-engine pair as the reason. You believe that verdict by re-running its own recheck command and recomputing its hashes, not because it asked to be trusted.
Honest limits
- This is example output, not a live scan. The eight repos, eight edges, and every file and line shown here come from one real index run over the author's workspace, captured and displayed as a fixed picture. The page does not read your filesystem and does not run index in your browser. To map your own repos you run the tool yourself.
- The full workspace is larger. The real run found roughly 80 repositories and many more edges, most of them dependencies on third-party libraries. This page shows a small, internal-only slice on purpose, so the picture stays readable.
- Confidence labels describe the strength of the evidence index found, nothing more. A high edge is well-witnessed; it is not a verdict that the dependency is correct or wise. index reports structure and leaves judgment to a person.
- Coverage is stated, not assumed. A real index certificate names the files it could not parse and the dynamic imports it could not follow, so a result never claims more than it proved. Anything it cannot establish it labels UNVERIFIABLE rather than guessing.
- The tool is public. index ships on PyPI as index-graph (the name
indexwas taken) with the source at github.com/HarperZ9/index. If you find repos it missed, edges it drew wrong, or roles it assigned incorrectly, those reports are what sharpen it.
This page is an example of index output, captured from one real offline run. No data leaves your machine and nothing is scanned here. The graph and the text table are built from the same data, so they cannot disagree. Updated 2026-06-30.