codmap 0.0.3__py3-none-any.whl

codemap/serve/vault.py

@@ -0,0 +1,156 @@
+"""Obsidian-vault export — consumer B (DESIGN §4.1-B, M2.2; repo scope M6).
+
+Renders the graph as a browsable knowledge base: one Markdown note per module and
+per class/function, cross-linked with ``[[wikilinks]]``. Note names are the full
+canonical id (unambiguous), so links resolve without collisions.
+
+With a repo-scoped graph (``extract_repo``) the vault also carries provenance:
+core-symbol notes get a **Used by** section grouped by root (tests/docs/…), each
+consumer note a **Uses (core)** section, and every ``doc`` node its own note — so
+the Obsidian graph shows the blast radius, not just the package interior.
+
+``build_vault`` returns ``{relative_path: content}``; the CLI writes the tree.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+
+from codemap.query import Query
+
+_SYMBOL_KINDS = {"class", "function"}
+_USE_EDGES = {"calls", "references", "imports"}
+
+
+def build_vault(query: Query) -> dict[str, str]:
+    """Return ``{path: markdown}`` for the whole vault (index + module + symbol + doc notes)."""
+    graph = query.graph
+    known = set(graph.nodes)
+    by_module: dict[str, list] = defaultdict(list)
+    for node in graph.nodes.values():
+        if node.kind in _SYMBOL_KINDS:
+            by_module[node.id.rsplit(".", 1)[0]].append(node)
+
+    # outbound uses (source -> [(target, type)]) for consumer "Uses (core)" sections.
+    outbound: dict[str, list[tuple[str, str]]] = defaultdict(list)
+    doc_refs: dict[str, list[str]] = defaultdict(list)
+    for e in graph.edges:
+        if e.type in _USE_EDGES and e.target in known:
+            outbound[e.source].append((e.target, e.type))
+        if e.type == "references" and graph.nodes.get(e.source) \
+                and graph.nodes[e.source].kind == "doc" and e.target in known:
+            doc_refs[e.source].append(e.target)
+
+    modules = sorted(n.id for n in graph.nodes.values() if n.kind == "module")
+    docs = sorted(n.id for n in graph.nodes.values() if n.kind == "doc")
+    out: dict[str, str] = {"index.md": _index_note(graph.target, modules, docs)}
+    for module in modules:
+        node = graph.nodes[module]
+        out[f"{module}.md"] = _module_note(
+            node, sorted(by_module.get(module, []), key=lambda n: n.id),
+            outbound.get(module, []), known,
+        )
+    for node in graph.nodes.values():
+        if node.kind in _SYMBOL_KINDS:
+            out[f"{node.id}.md"] = _symbol_note(query, node, known)
+    for doc in docs:
+        out[f"{doc}.md"] = _doc_note(graph.nodes[doc], sorted(set(doc_refs.get(doc, []))), known)
+    return out
+
+
+def _link(node_id: str) -> str:
+    return f"[[{node_id}|{node_id.rsplit('.', 1)[-1]}]]"
+
+
+def _tags(node) -> str:
+    """Kind + provenance-root tags, so Obsidian graph groups can colour by root."""
+    root = node.extras.get("root", "core")
+    parts = [f"#{node.kind}", f"#{root}"]
+    if node.is_deprecated:
+        parts.append("#deprecated")
+    return " ".join(parts)
+
+
+def _linked(i: str, known: set) -> str:
+    """Wikilink when the target has its own note, else inline code (external base)."""
+    return f"- {_link(i)}" if i in known else f"- `{i}`"
+
+
+def _index_note(target: str, modules: list[str], docs: list[str]) -> str:
+    lines = [f"# {target} — code map", "", f"_{len(modules)} modules, {len(docs)} docs._", ""]
+    lines += [f"- {_link(m)}" for m in modules]
+    if docs:
+        lines += ["", "## Docs", ""] + [f"- [[{d}|{d.rsplit('/', 1)[-1]}]]" for d in docs]
+    return "\n".join(lines) + "\n"
+
+
+def _module_note(node, symbols: list, uses: list[tuple[str, str]], known: set) -> str:
+    module = node.id
+    root = node.extras.get("root", "core")
+    lines = [f"# `{module}`", "", _tags(node), ""]
+    classes = [n for n in symbols if n.kind == "class"]
+    funcs = [n for n in symbols if n.kind == "function" and "." not in n.id[len(module) + 1:]]
+    if classes:
+        lines += ["## Classes", ""] + [f"- {_link(c.id)}" for c in classes] + [""]
+    if funcs:
+        lines += ["## Functions", ""] + [f"- {_link(f.id)}" for f in funcs] + [""]
+    # consumer roots: show what core symbols this file reaches into (the impact link).
+    if root != "core" and uses:
+        core_targets = sorted({t for t, _ in uses})
+        lines += ["## Uses (core)", ""] + [_linked(t, known) for t in core_targets] + [""]
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _symbol_note(query: Query, node, known: set) -> str:
+    module = node.id.rsplit(".", 1)[0]
+    lines = [f"# `{node.id.rsplit('.', 1)[-1]}`", "", _tags(node), "", f"In {_link(module)}."]
+    if node.signature:
+        lines += ["", f"```python\n{node.signature}\n```"]
+    if node.docstring:
+        lines += ["", node.docstring.strip()]
+
+    if node.kind == "class":
+        _section(lines, "Inherits", query.bases(node.id), known)
+        _section(lines, "Subclasses", query.subclasses(node.id), known)
+        reg = node.extras.get("registry")
+        if reg:
+            lines += ["", f"**Registered as** `{reg.get('key')}`."]
+    if node.kind == "function":
+        _section(lines, "Calls", query.callees(node.id), known)
+        _section(lines, "Called by", query.callers(node.id), known)
+    _used_by_section(lines, query, node.id, known)
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _doc_note(node, targets: list[str], known: set) -> str:
+    lines = [f"# `{node.id}`", "", _tags(node), ""]
+    if targets:
+        lines += ["## References", ""] + [_linked(t, known) for t in targets]
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _used_by_section(lines: list, query: Query, node_id: str, known: set) -> None:
+    """Inbound references grouped by root — the blast radius (repo-scoped graphs)."""
+    refs = query.references_to(node_id)
+    if not refs:
+        return
+    by_root: dict[str, set] = defaultdict(set)
+    for r in refs:
+        by_root[r["root"]].add(r["source"])
+    # core self-references are already covered by Calls/Called-by; highlight the rest.
+    external_roots = {r: s for r, s in by_root.items() if r != "core"}
+    if not external_roots:
+        return
+    total = sum(len(s) for s in external_roots.values())
+    lines += ["", f"## Used by ({total} outside core)", ""]
+    for root in sorted(external_roots):
+        for src in sorted(external_roots[root])[:20]:
+            lines.append(f"- {_link(src) if src in known else f'`{src}`'} _({root})_")
+
+
+def _section(lines: list, title: str, ids: list[str], known: set) -> None:
+    if not ids:
+        return
+    lines += ["", f"## {title}", ""]
+    for i in ids:
+        lines.append(_linked(i, known))

codemap/store.py

@@ -0,0 +1,28 @@
+"""Canonical JSON store (DESIGN §2.2, §4).
+
+JSON is the canonical, portable, diffable source of truth. Query backends
+(networkx/SQLite/Neo4j) are derived from it — not the other way round (DESIGN §4).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from codemap.model import Graph
+
+
+def save(graph: Graph, path: str | Path) -> None:
+    Path(path).write_text(
+        json.dumps(graph.to_dict(), ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+
+def dumps(graph: Graph) -> str:
+    return json.dumps(graph.to_dict(), ensure_ascii=False, indent=2)
+
+
+def load(path: str | Path) -> Graph:
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    return Graph.from_dict(data)

codemap/tomlio.py

@@ -0,0 +1,59 @@
+"""One place that reads TOML, and one rule about failing (R1-C27).
+
+Three loaders — the architecture contract (`arch.py`), the integration gate
+(`integrations/gate.py`) and the dead-code whitelist (`serve/audit.py`) — read the same
+``codemap.toml``. Each had grown its own copy of:
+
+    try:
+        import tomllib
+        data = tomllib.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError, ModuleNotFoundError):
+        return <empty>
+
+which collapses three different situations into one silent empty result, and every caller
+then renders that as *the user configured nothing*. It is not the same thing:
+
+- **absent** — the user configured nothing. A legitimate, common answer.
+- **unparseable** — the user configured something and it has a typo. `TOMLDecodeError`
+  subclasses `ValueError`, so one missing ``]`` turned ``codemap check`` from *exit 2, 14
+  imports point up the layer stack* into *"nothing to enforce"*, exit 0. A typo painted a
+  CI gate green.
+- **no parser** — the interpreter cannot do this class of work at all (``tomllib`` is
+  stdlib from 3.11). Not per-file and not per-user: every TOML feature, off, everywhere.
+
+The tolerance is deliberate and stays: reading a broken file must never raise, and must
+never wedge a plain build. What changes is that the tool says which of the three happened,
+so a caller can report *"I could not read your contract"* instead of *"you have no
+contract"* — the same rule as `risk:"unknown"` never being rendered as `risk:"none"`.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+__all__ = ["read_toml"]
+
+
+def read_toml(path: Path) -> tuple[dict, str | None]:
+    """Parse a TOML file → ``(data, error)``. Never raises.
+
+    ``error`` is ``None`` when there is nothing to report — including when the file simply
+    is not there, which is an answer and not a failure. Otherwise ``data`` is ``{}`` and
+    ``error`` is a human-readable reason naming the file and, where the parser gives one,
+    the position of the problem.
+    """
+    if not path.is_file():
+        return {}, None
+    try:
+        import tomllib
+    except ModuleNotFoundError:                      # pragma: no cover - 3.10 and older
+        return {}, (f"cannot read {path.name}: this Python has no `tomllib` "
+                    f"(added to the standard library in 3.11)")
+    try:
+        text = path.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError) as exc:
+        return {}, f"cannot read {path.name}: {exc}"
+    try:
+        return tomllib.loads(text), None
+    except ValueError as exc:                        # TOMLDecodeError subclasses ValueError
+        return {}, f"{path.name} is not valid TOML: {exc}"

codmap-0.0.3.dist-info/METADATA

@@ -0,0 +1,245 @@
+Metadata-Version: 2.4
+Name: codmap
+Version: 0.0.3
+Summary: Static analyzer that turns a package's source into a queryable code graph.
+Author-email: kogriv <kogriv@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/kogriv/codemap
+Project-URL: Source, https://github.com/kogriv/codemap
+Project-URL: Issues, https://github.com/kogriv/codemap/issues
+Project-URL: Changelog, https://github.com/kogriv/codemap/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/kogriv/codemap/tree/main/docs
+Keywords: static-analysis,code-graph,call-graph,dependency-graph,code-intelligence,ast,griffe,mcp,rag,scip
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: griffe>=2.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: jedi>=0.19
+Provides-Extra: mcp
+Requires-Dist: mcp>=2.0; extra == "mcp"
+Provides-Extra: scip
+Requires-Dist: protobuf>=5.26; extra == "scip"
+Dynamic: license-file
+
+# codemap
+
+**A static analyzer that turns a Python package's source into a queryable code graph.**
+It reads source only — no runtime import — so it works on any package and stays decoupled from
+the code it analyzes. One canonical, deterministic graph store → many renders: API surface,
+dependency/architecture audit, RAG chunks, an Obsidian vault, mermaid diagrams, change-set review,
+and a **SCIP index** for interop with Sourcegraph / Glean and other precise-code-intelligence tools.
+
+[![CI](https://github.com/kogriv/codemap/actions/workflows/ci.yml/badge.svg)](https://github.com/kogriv/codemap/actions/workflows/ci.yml)
+
+**Status:** 🟢 M0–M20 implemented + research track (R1/R2) — schema 0.12, **530 tests with no failures on
+Python 3.11–3.14** ([in CI](docs/ci.md): the full suite including the dogfood pass, a determinism check, a
+wheel smoke test, and ctags/SCIP interop against the real CLIs), warm serve surface with 31 ops (28 exposed
+as MCP tools), and SCIP export. See **[DESIGN.md](DESIGN.md)** (product design &
+v1 boundaries), **[BACKLOG.md](BACKLOG.md)** (roadmap), and **[research/](research/)** (tool landscape).
+
+## Why it exists
+
+Docs describe code and CLIs call code; without a parsed map of the code both are done blind. codemap
+builds that map as **facts**: modules, classes, functions, the public API surface, import/inherit/
+export edges, best-effort call edges, registry-family `implements` links, string-key column dataflow,
+and per-call argument contracts — then answers questions over it.
+
+Design principles: **source-only** (static `ast`/`griffe`, never imports the target), **deterministic**
+(canonical sorted JSON, no timestamps — diffable), **CLI-AI-first** (JSON by default, stable exit
+codes), **honest** (approximations are labeled, not hidden).
+
+## Install
+
+**Python 3.11+** — the range is measured on 3.11–3.14 in CI, not assumed ([docs/ci.md](docs/ci.md)).
+
+> **The distribution is `codmap`; everything else is `codemap`.** `codemap` was already taken on
+> PyPI, so you install `codmap` — and then the command, the import and this repository are all
+> spelled `codemap`, as they always were.
+
+```bash
+pip install codmap             # then: codemap build ./yourpkg
+
+# optional: MCP server (`codemap serve --mcp`)
+pip install 'codmap[mcp]'
+
+# optional: SCIP export (`codemap export scip`)
+pip install 'codmap[scip]'
+```
+
+Until the first release lands on PyPI, install straight from the repository instead:
+
+```bash
+pip install git+https://github.com/kogriv/codemap
+```
+
+Working on codemap itself, from a clone:
+
+```bash
+uv venv && uv pip install -e '.[mcp,scip]'    # or: pip install -e '.[mcp,scip]'
+```
+
+Dependencies: `griffe` (structure), `networkx` (query backend), `jedi` (deep call resolution).
+Optional extras: `mcp` (Model Context Protocol server), `scip` (protobuf, for SCIP export).
+
+## Quickstart
+
+```bash
+# build the canonical graph of a package
+codemap build ./yourpkg -o graph.json
+
+# repo-scoped: add consumers (tests/examples) + docs for blast-radius/impact
+codemap build ./yourpkg --deep --mode full --consumer ./tests --docs ./docs -o graph.json
+
+# ask about a symbol (JSON by default; --format text for humans)
+codemap query analyze_zones --graph graph.json
+
+# reports over the graph
+codemap report architecture   --graph graph.json   # layers, coupling, god-objects, cycles
+codemap report dependencies   --graph graph.json
+codemap report dead-code      --graph graph.json
+codemap report impact --symbol MyClass --graph graph.json
+
+# change-set review straight from a diff → risk-sorted dossier
+git diff | codemap review - --graph graph.json
+
+# exports (see docs/export.md)
+codemap export rag     --graph graph.json -o chunks.jsonl
+codemap export mermaid --graph graph.json --mkind class
+codemap export vault   --graph graph.json -o vault/
+codemap export scip    --graph graph.json -o index.scip   # SCIP index (needs [scip] extra)
+codemap export ctags   --graph graph.json -o tags         # universal-ctags tags file
+
+# semantic (concept) search via an opt-in adapter → codemap symbols (needs the tool + opt-in)
+codemap semantic "detect swing pivots" --build ./pkg --root pkg
+
+# token-budgeted context pack — most relevant graph slice under N tokens (ranked; --seed to focus)
+codemap pack --graph graph.json --budget 2000 --seed analyze_zones
+
+# warm resident process — JSON requests over stdin/stdout (29 ops)
+codemap serve --graph graph.json --source-root .
+
+# …or expose the same surface as MCP tools for an AI-agent host (needs [mcp] extra)
+codemap serve --graph graph.json --source-root . --mcp
+```
+
+## What it answers
+
+- **Structure & API** — public surface, signatures, docstrings, deprecation.
+- **Dependencies & architecture** — import cycles, layers + direction/violations, coupling
+  (Ca/Ce/instability), god-objects & call-hubs, per-function complexity (cyclomatic / MI)
+  blended with structural coupling.
+- **Impact / blast radius** — who uses X, across the whole repo (core + tests + docs).
+- **Change review** — a diff → the symbols it touches, their callers, signature-change surface,
+  touched columns, cross-root consumers, risk rank.
+- **Dispatch seams** — registry/factory families and the Protocol each impl satisfies.
+- **Dataflow** — producers/consumers of a string-keyed DataFrame column.
+- **Semantic search** (opt-in) — a concept query routed to an external adapter, with each fuzzy hit
+  resolved to the exact codemap symbol at its location (`codemap semantic`). See [docs/integrations.md](docs/integrations.md).
+- **Context pack** — the most relevant slice of the graph under a token budget, ranked by importance or
+  by relevance to seed symbols (`codemap pack --budget N [--seed X]`). See [docs/pack.md](docs/pack.md).
+- **Interop** — export the graph as a [SCIP](https://scip-code.org/) index (definitions + symbol
+  info + inherits/implements relationships) so Sourcegraph, Glean and other SCIP consumers can drive
+  go-to-definition, symbol search and type hierarchy over it. See [docs/export.md](docs/export.md).
+
+## How it compares
+
+codemap is **the precise structural leg for index-free AI agents** — it complements embeddings-RAG and
+Repomix-style packing rather than competing with them. Its bet is to be the best *deterministic, diffable,
+provenance-aware* graph in that slot, and to interoperate outward (SCIP, ctags) instead of locking the graph
+away.
+
+> **A code graph an agent can trust: source-only, deterministic, diffable — no index to go stale, no LSP to provision.**
+
+The [research track](research/) measures this against the field hands-on, on a shared benchmark scope. The
+[positioning doc](research/positioning.md) is the publication layer — the narrative and the numbers behind the
+claims above; [comparison.md](research/comparison.md) is the coverage matrix that backs them.
+
+Honesty is part of the bet: the call graph is a **measured lower bound**, not a guess. [docs/accuracy.md](docs/accuracy.md)
+reports it — 100% precision / 100% decidable-recall on a hand-labeled suite, an openly-stated ~60% recall
+against *all* true edges (the price of Python's dynamism), and a grep-vs-graph proof that the graph is ~2×
+cheaper than grep for impact on unique names, tens of × on polymorphic ones, and no cheaper for locating a
+symbol.
+
+## Dogfooding
+
+codemap is validated end-to-end against a real external package. Place a target repo as a sibling and
+run the full flow against its package — e.g. `codemap build ../bquant/bquant` (point at the package
+directory that holds `__init__.py`, not the repo root) — treating codemap purely as a third-party tool.
+The `gaps/` directory records those dogfood runs: each is a pre-registered set of hypotheses, a run on
+the live graph, findings, and the milestone that closed them.
+
+## Documentation
+
+- **[DESIGN.md](DESIGN.md)** — product design, the query catalog, v1 boundaries.
+- **[docs/export.md](docs/export.md)** — export recipes: RAG, mermaid, Obsidian vault, SCIP + ctags interop.
+- **[docs/accuracy.md](docs/accuracy.md)** — measured call-graph accuracy, the honest static ceiling, and
+  the grep-vs-graph value proof (both harnesses guarded in CI).
+- **[docs/architecture-contracts.md](docs/architecture-contracts.md)** — declare the intended architecture
+  in `codemap.toml` and enforce it with `codemap check` (CI gate; codemap dogfoods its own).
+- **[docs/api-diff.md](docs/api-diff.md)** — `codemap diff` two snapshots for added/removed/changed symbols
+  and API breaking-change detection (release gate + `review --base`).
+- **[docs/integrations.md](docs/integrations.md)** — the opt-in router/adapter layer over external tools
+  (`codemap route` / `codemap semantic`); license policy; adding an integration.
+- **[docs/dead-code.md](docs/dead-code.md)** — graded dead-code candidates (high/medium/low + provenance
+  reason) with a `[dead_code]` whitelist and `--min-confidence` filter.
+- **[docs/pack.md](docs/pack.md)** — `codemap pack`: PageRank ranking + token-budgeted context slice for
+  AI agents (global importance or seed-focused relevance).
+- **[docs/attribute-edges.md](docs/attribute-edges.md)** — `accesses` edges: who reads/writes a class field,
+  honest field-level `impact` (`accessors`; `unknown` vs `none`).
+- **[docs/incremental.md](docs/incremental.md)** — `codemap build --incremental`: recompute only changed
+  modules (~12× faster on `--deep`), byte-identical on the fast tier.
+- **[docs/test-mapping.md](docs/test-mapping.md)** — `codemap tests <symbol>`: which tests exercise a
+  symbol, as runnable pytest node ids, with the measured distance cutoff and an `unknown` that never
+  pretends to be "untested".
+- **[docs/hard-python.md](docs/hard-python.md)** — what the extractor does with metaclasses, dynamic
+  classes, star imports, quoted annotations, `.pyi` stubs and symlinked trees; and the conditions where it
+  warns instead of answering.
+- **[docs/provenance.md](docs/provenance.md)** — the `provenance` block: which tool, which tier, which
+  input tree built a graph; what stays in the sidecar; the schema-mismatch warning and `diff`'s
+  comparability check.
+- **[docs/flat-layout.md](docs/flat-layout.md)** — flat module directories (sibling imports, no
+  `__init__.py`): labelled `resolution="flat"` edges, and the empty-import-graph warning that stops a
+  vacuous graph from reading as a clean one.
+- **[research/blog/](research/blog/)** — **the build-story series**: field notes on building
+  codemap and measuring it against rival tools (EN + RU). See the section below.
+- **[BACKLOG.md](BACKLOG.md)** — milestones M0–M18, the research track (R1), and deferred work.
+- **[gaps/](gaps/)** — dogfood runs, coverage analysis, the living [axis register](gaps/dogfood_axes.md).
+- **[research/](research/)** — survey of adjacent code-analysis tools and how codemap relates to each
+  (integrate / wrap / learn); source of the R1 capability roadmap. See
+  **[research/positioning.md](research/positioning.md)** for the publication-layer narrative and
+  **[research/comparison.md](research/comparison.md)** for the hands-on coverage matrix.
+
+## Writing — the build-story series
+
+Field notes on building codemap, and on measuring it honestly against the nearest rival
+tools. Published here in the repo; every post exists in English and Russian.
+**Index: [research/blog/](research/blog/README.md).**
+
+| # | Post | |
+|---|------|---|
+| 0 | **A code graph an agent can trust** — what codemap is, the bet it makes, and the honest limits. | [EN](research/blog/00-a-code-graph-an-agent-can-trust.md) · [RU](research/blog/00-a-code-graph-an-agent-can-trust.ru.md) |
+| 1 | **The competitor wasn't broken. We were.** — I nearly published that a rival's impact analysis was broken. The bug was my `PATH`. | [EN](research/blog/01-the-competitor-wasnt-broken.md) · [RU](research/blog/01-the-competitor-wasnt-broken.ru.md) |
+| 2 | **The one that does more — and why that's fine.** — a 1.7 GB hybrid rival that proved the thesis instead of threatening it. | [EN](research/blog/02-the-one-that-does-more.md) · [RU](research/blog/02-the-one-that-does-more.ru.md) |
+| 3 | **The competitor that does *less* — and that's why I take it.** — the emptiest coverage row was the most useful find. For its license, not its features. | [EN](research/blog/03-the-one-that-does-less.md) · [RU](research/blog/03-the-one-that-does-less.ru.md) |
+| 4 | **My determinism test went red. The tool was fine.** — the input was moving under it, and the artifact could not say so. How the graph learned to name what built it. | [EN](research/blog/04-the-determinism-test-that-was-right.md) · [RU](research/blog/04-the-determinism-test-that-was-right.ru.md) |
+
+New here? Read **1 → 0 → 2 → 3 → 4**. Every number in every post reproduces from a
+[tool card](research/tools/) or the [comparison hub](research/comparison.md) — measurements,
+not verdict.
+
+## License
+
+[MIT](LICENSE).

codmap-0.0.3.dist-info/RECORD

@@ -0,0 +1,55 @@
+codemap/__init__.py,sha256=jggl8TP4o82sWxwKfMz6t7IuvhIs8aIKaPrU5FLSgSo,254
+codemap/apidiff.py,sha256=c1FwDsv2PoT36P43gvQuMOgIqRJTMqDh7nYkjC0QNhQ,8851
+codemap/arch.py,sha256=Nvdv2_NskvCi9JzvB3LTH4cwRMsHhG4SnxTrxPxuMCY,7715
+codemap/cli.py,sha256=9DFyAEUnFUpHOeVnavwTZ1FbEpxVohBTYKBLLE_3uJs,35177
+codemap/diagnostics.py,sha256=rrupvLu01gcNEcZq5IPDqGfQz4Z56UcMPOfU0Fvn4YM,12550
+codemap/freshness.py,sha256=x31ABcmxBIId2SK8bEmcnC2tXyAVvXU9uSFXLr2Zoy4,4171
+codemap/incremental.py,sha256=z_3GdTgoKC4HhrnH-VroHI1GxGWprpfi905JKkWbhV4,9401
+codemap/model.py,sha256=BCQkUCrdpEYuUcGDUEcOWyht2J_EoByGeCpkt8u3MIU,9956
+codemap/provenance.py,sha256=evFZ1may3_xko1q5AK4FCbhvRyPPG2hy0PSP4bdlrvI,10017
+codemap/query.py,sha256=o9EHZMWtXAU8KF_1A6TFChtMoCc_0fanFSctNg4MDdU,56669
+codemap/scope.py,sha256=Q19Ff8uI-TJXpPX2PLaMPJcj7O7p6kaTdA2jrqOu4jM,8416
+codemap/store.py,sha256=5Biq0Ymw3p-rkTrXVbHA-Uew6E1gN-DIPk7FZUyLwcY,739
+codemap/tomlio.py,sha256=FdTcUsXNYTdik3xfoyYz89QGs7pkvSXOo483rfZlq9Q,2717
+codemap/extract/__init__.py,sha256=F7p365zBRpdXyPydElj2m0FqiIRu6woPo4cudaut42c,380
+codemap/extract/attrflow.py,sha256=-jL-0oh7cfvxOVuM1yJY-zd87Tu-aLQMSLqaJaVzJTU,10643
+codemap/extract/behavior.py,sha256=3ngdIDZnW-gwoJc3ksuXRAmqMgvLTeOh_ajM7GATR50,35626
+codemap/extract/dataflow.py,sha256=pMnh4ala7mMYMBnk2meo9ylZMbHMxiJe9LgmnKgOo2M,4865
+codemap/extract/dispatch.py,sha256=oAll-vzgkCJ-oZCCbwkMs7y7VYJ4w-gfygLYAA7Tg_8,10563
+codemap/extract/griffe_extractor.py,sha256=ytbEYVrg9vF8YYP0aZbbbgBXKcqrSYaVP96AZMYF-gw,21298
+codemap/extract/gsource.py,sha256=WIGgRtJRZTa_ZsOxG_Xi71K_VSKqRtbD_It05gKPPAs,3570
+codemap/extract/roots.py,sha256=GaTmwx1aoWqAMFATbpFddxFfQb5_hUT-Kw6ORZRFrDY,17839
+codemap/integrations/__init__.py,sha256=lQyfJM8Iu1KJI--hAMRjSj9MayoDXwp58bCELY92QUg,1507
+codemap/integrations/base.py,sha256=BoKb2Z5ak858A7NLHdTzVHgS4Bx_eJKsQ8w890lSIwM,8469
+codemap/integrations/cocoindex.py,sha256=jguBSRQJJsOI9PblxLw7Rla0cY5EPVq9ZRNbf2nBqTo,3353
+codemap/integrations/gate.py,sha256=0c85E3WVQQS0ZK2ehuAhM5KROj25wzMu8jZ-92-z5SQ,2249
+codemap/integrations/gitnexus.py,sha256=rjWlJlr54ZV6RZQLEa0M_4U0T7IfkNyiXMLH20J82cs,4078
+codemap/integrations/registry.py,sha256=wGawI8biedDhyS0bqvXnoYDmwMeubEfmAlgzrvTD7m4,3004
+codemap/integrations/transport.py,sha256=NQWOFcCTvG-7X5KpoeJQYClTJqiC5o_8PuzsIRRpSuQ,1668
+codemap/serve/__init__.py,sha256=wH8fuOAb7nC7zIK-vIO-wKKx3Mvjd8dDS4ak0U8AcAg,862
+codemap/serve/_scip_pb2.py,sha256=Pmq1QXjz5zdIpruFbT1Ja6hjkGxoiFjP97ijEObud5M,17077
+codemap/serve/api_surface.py,sha256=I4b1yI5egp8Hthy3rhdbibhqG3DYPZ1pJ_7fsuk9soQ,2013
+codemap/serve/apidiff.py,sha256=SWNC43QSYTzoxnp-d0QbkWwomYKcZdIZeJKQ5rEkKJA,3324
+codemap/serve/architecture.py,sha256=swnEQEib2BqKER8dIKkjiIK1p0XhFLkNU2dD4_YV1no,4561
+codemap/serve/audit.py,sha256=hrSxX3a2H4zqO7IDHHPGLJK0SUBWp1gH6WKU0waSDIg,8491
+codemap/serve/check.py,sha256=rDY5VVhhMl2a1Sdrcqhbe2kXn1aMqFgcKR8NhJzUY1g,3625
+codemap/serve/ctags.py,sha256=Zw3VIG0rgEwsgDf1SJgwIJHpD4e_GbJGVlSObni9Res,7849
+codemap/serve/impact.py,sha256=sBXppoFF9UVLWQMgrysVObT30hjzdFzCd6ZOcCMcX8I,3859
+codemap/serve/livingdocs.py,sha256=otPvVvYzR-FIcA6orYoIz8PCDNg5djggXJShEIb2S4k,7038
+codemap/serve/mcp_server.py,sha256=W-VJpKFEgUsmXUTy0ZgkIRZenkOBiyQLFMfl_ORN0VI,12882
+codemap/serve/mermaid.py,sha256=7CZF1gyf_lucxOjC1IH6D76wWWl0iCD9ByCRrhELiuA,4558
+codemap/serve/pack.py,sha256=kiZzSkISbXxd3bPjGkRA_U2Rcptryj_IuTWegh1uYX8,3876
+codemap/serve/rag.py,sha256=62cimPFEu4B1uoM1tWf0acbvSdgx-NmXyqLVYjo5wfo,5539
+codemap/serve/review.py,sha256=sSzgmFlXNNjGwB7GPWzSNrAURfqIwWDcohkxp56VCwE,8850
+codemap/serve/scip.py,sha256=7d4hy9AobyMI7DtVvhyHJvkPRlr2K2Z87rKcWg7AOzg,7611
+codemap/serve/semantic.py,sha256=FmHipgggSMHrx1SodvJWK5uE84y6gNFmj2b8mhkjKRw,3376
+codemap/serve/server.py,sha256=JBbLMCdTC2zp1B6oLryShoACDkXwprsM3Phoym_fbts,1589
+codemap/serve/session.py,sha256=aKxKylqrjqL4qIqnv5MAReDaUrkdz6FVSIvdhIm-95M,21794
+codemap/serve/subsystems.py,sha256=BzSo_dacXT5qM1OBxYe6fURriaf9W4Cbo1ndUFiVclA,3609
+codemap/serve/vault.py,sha256=V0DQRxX1VxN3b6_ZjKFY01guh8VPuCSuKBY_1XMuYdU,6568
+codmap-0.0.3.dist-info/licenses/LICENSE,sha256=YmrVnKUwYfMJ7uKkDNJoZ1OxIv69wSo_OV5XxPcBrSU,1063
+codmap-0.0.3.dist-info/METADATA,sha256=vOFiB2NGBAHypzQibXxkB_5KlHpoy2hjzsyx30o6Rl8,14540
+codmap-0.0.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+codmap-0.0.3.dist-info/entry_points.txt,sha256=P73zdmjeFsibIiyUP1n3h2WeNAviIGsEkve74a5NXmU,45
+codmap-0.0.3.dist-info/top_level.txt,sha256=y3cIjxmjvwNiAspXYGejsYO5jxkQ4UXIEgLe3iHpL8g,8
+codmap-0.0.3.dist-info/RECORD,,

codmap-0.0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codmap-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codemap = codemap.cli:main

codmap-0.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kogriv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

codmap-0.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+codemap