codmap 0.0.23__tar.gz → 0.0.24__tar.gz

{codmap-0.0.23/codmap.egg-info → codmap-0.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codmap
-Version: 0.0.23
+Version: 0.0.24
 Summary: Static analyzer that turns a package's source into a queryable code graph.
 Author-email: kogriv <kogriv@gmail.com>
 License-Expression: MIT
@@ -44,7 +44,7 @@ and a **SCIP index** for interop with Sourcegraph / Glean and other precise-code
 
 [![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.13, **1115 tests with no failures on
+**Status:** 🟢 M0–M20 implemented + research track (R1/R2) — schema 0.13, **1128 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 &

{codmap-0.0.23 → codmap-0.0.24}/README.md

@@ -8,7 +8,7 @@ and a **SCIP index** for interop with Sourcegraph / Glean and other precise-code
 
 [![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.13, **1115 tests with no failures on
+**Status:** 🟢 M0–M20 implemented + research track (R1/R2) — schema 0.13, **1128 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 &

{codmap-0.0.23 → codmap-0.0.24}/codemap/cli.py

@@ -982,8 +982,41 @@ def _add_source(p) -> None:
                    help="Deep call resolution via jedi (richer, ~1 min; default fast).")
 
 
+def version_line() -> str:
+    """``codemap 0.0.24 @abc1234 · answer format 4 · schema 0.13`` (R1-C73).
+
+    Built from ``provenance.tool_identity()`` — the identity every graph records as
+    ``provenance.tool`` — so the CLI and the artifact cannot disagree. Commit and dirtiness
+    appear only when known, as there; a missing distribution is said, never invented.
+    """
+    from codemap.model import ANSWER_FORMAT, SCHEMA_VERSION
+    from codemap.provenance import tool_identity
+    t = tool_identity()
+    head = f"codemap {t['version']}" if t.get("version") else \
+        "codemap version unknown (not installed as a distribution)"
+    if t.get("commit"):
+        head += f" @{t['commit']}"
+    if t.get("dirty"):
+        head += " (dirty)"
+    return f"{head} · answer format {ANSWER_FORMAT} · schema {SCHEMA_VERSION}"
+
+
+class _VersionAction(argparse.Action):
+    """``--version``, computed only when asked: ``tool_identity()`` calls git (design D1)."""
+
+    def __init__(self, option_strings, dest=argparse.SUPPRESS, default=argparse.SUPPRESS,
+                 help="Print the installed version, the answer format and the graph schema, then exit."):
+        super().__init__(option_strings=option_strings, dest=dest, default=default, nargs=0,
+                         help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        print(version_line())
+        parser.exit(0)
+
+
 def build_parser() -> argparse.ArgumentParser:
     p = argparse.ArgumentParser(prog="codemap", description="Static code-graph builder.")
+    p.add_argument("--version", action=_VersionAction)
     sub = p.add_subparsers(dest="command", required=True)
 
     b = sub.add_parser("build", help="Build the canonical graph from a package path.")

{codmap-0.0.23 → codmap-0.0.24}/codemap/extract/behavior.py

@@ -83,11 +83,18 @@ def add_behavior(graph, griffe_root, target_pkg: str, *, deep: bool = False,
         # R1-C46: the surviving definition says which earlier bodies it replaced. Stamped
         # here because this pass holds the AST; the walkers below skip those bodies.
         _stamp_shadows(graph, tree, modpath)
+        walked_here: set[str] = set()   # R1-C74: nodes that already took a body in this module
+        shadow_skip = _shadow_map(tree)[0]
         for fnode, class_stack, scope in _named_functions_scoped(tree):
             node_id = _node_id(modpath, class_stack, fnode.name)
             local = local_imports.get(id(fnode))
             fn_imports = {**imports, **local} if local else imports
-            if node_id not in graph.nodes:
+            # R1-C74: a def nested in a function is never a definition node, whatever its
+            # name. `_node_id` sees only the class chain, so `def getfixturedefs` inside a method
+            # of `FixtureManager` used to *become* the method `FixtureManager.getfixturedefs` —
+            # its calls and edges attributed to a namesake (found by the conservation check).
+            nested_in_function = len(scope) > len(class_stack)
+            if node_id not in graph.nodes or nested_in_function:
                 # R1-C22 D3: a closure / dynamically-built class body is not a definition
                 # node, but the calls inside it are real. Attribute them to the innermost
                 # definition that *does* exist instead of discarding them.
@@ -103,7 +110,9 @@ def add_behavior(graph, griffe_root, target_pkg: str, *, deep: bool = False,
                 return _resolve(call, modpath, _cp, _im, _mm, _me, reexports, nodes)
             resolve = (_deep_then_fast(graph, script, target_pkg, fast, modpath, known_modules)
                        if script else fast)
-            _process_function(graph, node_id, fnode, resolve)
+            _process_function(graph, node_id, fnode, resolve,
+                              accumulate=node_id in walked_here)
+            walked_here.add(node_id)
             # R1-C22 D1: functions/classes named as *values* here (dispatch tables,
             # `default=` callbacks) — a use the call layer cannot see.
             _emit_name_references(graph, node_id, fnode, modpath, fn_imports, modmembers,
@@ -115,7 +124,11 @@ def add_behavior(graph, griffe_root, target_pkg: str, *, deep: bool = False,
         mod_resolve = (_deep_then_fast(graph, script, target_pkg, mod_fast, modpath, known_modules)
                        if script else mod_fast)
         _process_module_level(graph, modpath, tree, mod_resolve, imports, modmembers,
-                              reexports)
+                              reexports, shadow_skip=shadow_skip)
+        # R1-C74: class bodies run at import time and were walked by nobody.
+        _process_class_bodies(graph, modpath, tree, mod_resolve, imports, modmembers,
+                              script, target_pkg, nested, known_modules, reexports,
+                              skip=shadow_skip)
         _emit_nested_calls(graph, nested)
 
 
@@ -525,30 +538,49 @@ def _deep_then_fast(graph, script, target_pkg, fast, modpath, known_modules):
     return resolve
 
 
-def _process_function(graph, node_id, fnode, resolve) -> None:
-    counts = {"out": 0, "resolved": 0, "external": 0, "unresolved": 0, "dynamic": 0}
+def _new_counts() -> dict:
+    return {"out": 0, "resolved": 0, "external": 0, "unresolved": 0, "dynamic": 0}
+
+
+def _tally(counts: dict, graph, target, resolution) -> bool:
+    """Count one call site by how it resolved; True when it becomes an internal edge.
+
+    One rule for every scope (R1-C74): a function body, a nested function, module-level
+    code and a class body are classified the same way, so their counters can be summed
+    and checked against the source.
+    """
+    counts["out"] += 1
+    if resolution in _EDGE_RESOLUTIONS and target and target in graph.nodes:
+        counts["resolved"] += 1
+        return True
+    if resolution == "external":
+        counts["external"] += 1
+    elif resolution == "dynamic":
+        counts["dynamic"] += 1
+    else:
+        counts["unresolved"] += 1
+    return False
+
+
+def _process_function(graph, node_id, fnode, resolve, accumulate: bool = False) -> None:
+    """``accumulate``: this node already took a body in this pass (R1-C74). A name defined in
+    both branches of an ``if``/``try``, or a legitimate rebinding (a property's setter), keeps
+    *both* bodies walked (R1-C46) — their counts add up instead of the last overwriting."""
+    counts = _new_counts()
     # F7: edges are deduped caller->callee, so aggregate the per-call-site argument
     # contract before emitting — a refactorer needs "how is it called", and the
     # collapse itself (2 sites -> 1 edge) must stay visible via `callsites`.
     by_target: dict[str, dict] = {}
     for call in _own_calls(fnode):
-        counts["out"] += 1
         target, resolution = resolve(call)
         # Soundness (R1-C13-f1/f2): an internal call edge must point at a real
         # graph node. A resolver can name a non-node — a local variable jedi typed
         # to its own scope-path, or a nested/closure function that is not a
         # definition node — so downgrade any such target to unresolved rather than
         # emit an edge to nothing (which would poison callers/callees/impact).
-        if resolution in _EDGE_RESOLUTIONS and target and target in graph.nodes:
-            counts["resolved"] += 1
+        if _tally(counts, graph, target, resolution):
             agg = by_target.setdefault(target, {"resolution": resolution, "shapes": []})
             agg["shapes"].append(_arg_shape(call))
-        elif resolution == "external":
-            counts["external"] += 1
-        elif resolution == "dynamic":
-            counts["dynamic"] += 1
-        else:
-            counts["unresolved"] += 1
 
     for target in sorted(by_target):
         agg = by_target[target]
@@ -556,7 +588,11 @@ def _process_function(graph, node_id, fnode, resolve) -> None:
         graph.add_edge(Edge("calls", node_id, target, extras=extras))
 
     node = graph.nodes[node_id]
-    node.extras["calls"] = counts
+    if accumulate and "calls" in node.extras:
+        for k, v in counts.items():
+            node.extras["calls"][k] = node.extras["calls"].get(k, 0) + v
+    else:
+        node.extras["calls"] = counts
     node.extras["control"] = _control(fnode)
     node.extras["complexity"] = _complexity(fnode)
 
@@ -941,14 +977,30 @@ def _emit_name_references(graph, src_id, scope, modpath, imports, modmembers,
 
 
 def _process_module_level(graph, modpath, tree, resolve, imports, modmembers,
-                          reexports=None) -> None:
-    """Calls and value-references in module-level code, sourced from the module (D1/D2)."""
+                          reexports=None, shadow_skip=None) -> None:
+    """Calls and value-references in module-level code, sourced from the module (D1/D2).
+
+    R1-C74: the module node also carries ``extras.calls`` — its sites used to make edges
+    and appear in no resolution figure.
+    """
     by_target: dict[str, dict] = {}
+    counts = _new_counts()
     for call in (n for n in _module_level_nodes(tree) if isinstance(n, ast.Call)):
         target, resolution = resolve(call)
-        if resolution in _EDGE_RESOLUTIONS and target and target in graph.nodes:
+        if _tally(counts, graph, target, resolution):
             agg = by_target.setdefault(target, {"resolution": resolution, "shapes": []})
             agg["shapes"].append(_arg_shape(call))
+    if modpath in graph.nodes:
+        graph.nodes[modpath].extras["calls"] = counts
+        # R1-C74 D1: a replaced body is not walked (R1-C46) — said, not absorbed.
+        skipped = _shadow_map(tree)[0] if shadow_skip is None else shadow_skip
+        if skipped:
+            seen: set[int] = set()
+            for node in ast.walk(tree):
+                if id(node) in skipped:
+                    seen.update(id(c) for c in ast.walk(node) if isinstance(c, ast.Call))
+            if seen:
+                graph.nodes[modpath].extras["calls_shadowed"] = len(seen)
     for target in sorted(by_target):
         agg = by_target[target]
         graph.add_edge(Edge("calls", modpath, target,
@@ -958,6 +1010,57 @@ def _process_module_level(graph, modpath, tree, resolve, imports, modmembers,
                           reexports=reexports)
 
 
+def _process_class_bodies(graph, modpath, tree, resolve, imports, modmembers, script,
+                          target_pkg, nested, known_modules=frozenset(), reexports=None,
+                          skip=None) -> None:
+    """Calls in class bodies outside their methods — bases, keywords, decorators, statements.
+
+    R1-C74 (design ``call_site_conservation.md`` D1). A class body runs at import time, so a
+    class that is a graph node is the source of its own ``calls`` edges and carries
+    ``extras.calls``, resolved like module-level code. A class nested in a function runs
+    when the function does: its sites go to the owner as nested, like a closure's. Shadowed
+    definitions are skipped, as everywhere (R1-C46).
+    """
+    skip = _shadow_map(tree)[0] if skip is None else skip
+
+    def visit(node, scope, in_function):
+        for child in ast.iter_child_nodes(node):
+            if id(child) in skip:
+                continue
+            if isinstance(child, ast.ClassDef):
+                cscope = scope + [child.name]
+                calls = [n for n in _own_nodes(child) if isinstance(n, ast.Call)]
+                cid = ".".join([modpath, *cscope])
+                if not in_function and cid in graph.nodes:
+                    counts = _new_counts()
+                    by_target: dict[str, dict] = {}
+                    for call in calls:
+                        target, resolution = resolve(call)
+                        if _tally(counts, graph, target, resolution) and target != cid:
+                            agg = by_target.setdefault(target, {"resolution": resolution,
+                                                                "shapes": []})
+                            agg["shapes"].append(_arg_shape(call))
+                    graph.nodes[cid].extras["calls"] = counts
+                    for target in sorted(by_target):
+                        agg = by_target[target]
+                        graph.add_edge(Edge("calls", cid, target,
+                                            extras={"resolution": agg["resolution"],
+                                                    **_arg_contract(agg["shapes"])}))
+                elif calls:
+                    owner = _nearest_owner(graph, modpath, scope)
+                    if owner is not None:
+                        _collect_nested_calls(graph, owner, child, modpath, imports, modmembers,
+                                              script, target_pkg, nested, known_modules,
+                                              reexports, calls=calls)
+                visit(child, cscope, in_function)
+            elif isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                visit(child, scope + [child.name], True)
+            else:
+                visit(child, scope, in_function)
+
+    visit(tree, [], False)
+
+
 def _named_functions_scoped(tree):
     """Like :func:`_named_functions`, plus the **full** enclosing scope names.
 
@@ -1001,17 +1104,22 @@ def _nearest_owner(graph, modpath, scope) -> str | None:
 
 def _collect_nested_calls(graph, owner, fnode, modpath, imports, modmembers,
                           script, target_pkg, out, known_modules=frozenset(),
-                          reexports=None) -> None:
-    """Resolve a non-node function's own calls and stage them under ``owner`` (D3)."""
+                          reexports=None, calls=None) -> None:
+    """Resolve a non-node function's own calls and stage them under ``owner`` (D3).
+
+    ``fnode`` may also be a class nested in a function (R1-C74): its body runs inside the
+    owner, like a closure's. Every site is counted into the owner's ``extras.calls_nested``.
+    """
     def fast(call):
         return _resolve(call, modpath, "", imports, modmembers, {}, reexports, graph.nodes)
     # R1-C26: the same union the named-function path uses — a closure's calls must not be
     # resolved by a weaker rule than its neighbours'.
     resolve = (_deep_then_fast(graph, script, target_pkg, fast, modpath, known_modules)
                if script is not None else fast)
-    for call in _own_calls(fnode):
+    counts = graph.nodes[owner].extras.setdefault("calls_nested", _new_counts())
+    for call in (calls if calls is not None else _own_calls(fnode)):
         target, resolution = resolve(call)
-        if resolution not in _EDGE_RESOLUTIONS or not target or target not in graph.nodes:
+        if not _tally(counts, graph, target, resolution):
             continue
         if target == owner:
             continue  # a closure calling its own enclosing function — recursion, not a dep

{codmap-0.0.23 → codmap-0.0.24}/codemap/model.py

@@ -109,7 +109,11 @@ SCHEMA_VERSION = "0.13"
 #       `check --graph` carries a currency line, and its structured answer a `graph_currency`
 #       block, with a graph behind its source tree failing the gate (R1-C70,
 #       docs/design/check_graph_currency.md).
-ANSWER_FORMAT = 3
+#   4 — `report behavior` states the whole and its parts: call sites in function bodies,
+#       nested functions, module-level code and class bodies, plus sites in shadowed
+#       bodies that are not walked; the structured answer gains `by_scope` and
+#       `shadowed_not_walked` (R1-C74, docs/design/call_site_conservation.md).
+ANSWER_FORMAT = 4
 
 # Closed vocabulary of edge types (R1-C7). Node ``kind`` is deliberately an OPEN set
 # (DESIGN §2 — new entity kinds may appear), but edges are TYPED: every relationship

{codmap-0.0.23 → codmap-0.0.24}/codemap/serve/audit.py

@@ -103,15 +103,37 @@ def build_dead_code(query: Query, *, whitelist: tuple[str, ...] = (),
     }
 
 
+def call_sites_by_scope(graph) -> dict:
+    """Call-site counters summed by the scope that runs them (R1-C74, design D2).
+
+    ``function`` — own bodies of function nodes (attribute nodes are properties: functions too);
+    ``nested`` — closures and classes inside them, carried by their owner; ``module`` —
+    module-level code; ``class_body`` — class bodies outside methods. Plus the sites in
+    shadowed bodies, which are counted but never walked.
+    """
+    keys = ("out", "resolved", "external", "unresolved", "dynamic")
+    by = {s: dict.fromkeys(keys, 0) for s in ("function", "nested", "module", "class_body")}
+    shadowed = 0
+    for n in graph.nodes.values():
+        scope = {"function": "function", "attribute": "function", "module": "module",
+                 "class": "class_body"}.get(n.kind)
+        for key, bucket in (("calls", scope), ("calls_nested", "nested")):
+            c = n.extras.get(key)
+            if c and bucket:
+                for k in keys:
+                    by[bucket][k] += c.get(k, 0)
+        shadowed += n.extras.get("calls_shadowed", 0)
+    every = {k: sum(by[s][k] for s in by) for k in keys}
+    return {"all": every, "by_scope": by, "shadowed_not_walked": shadowed}
+
+
 def build_behavior(query: Query) -> dict:
     """:func:`render_behavior`, structured (R1-C32)."""
     graph = query.graph
     funcs = [n for n in graph.nodes.values() if n.kind == "function"]
     with_cov = [n for n in funcs if "calls" in n.extras]
-    agg = {"out": 0, "resolved": 0, "external": 0, "unresolved": 0, "dynamic": 0}
-    for n in with_cov:
-        for k, v in n.extras["calls"].items():
-            agg[k] = agg.get(k, 0) + v
+    sites = call_sites_by_scope(graph)
+    agg = sites["all"]
     by_res: dict[str, int] = {}
     for e in graph.edges:
         if e.type == "calls":
@@ -122,7 +144,11 @@ def build_behavior(query: Query) -> dict:
     return {
         "kind": "behavior",
         "target": graph.target,
-        "call_sites": {**agg, "functions_with_coverage": len(with_cov)},
+        "call_sites": {**agg, "functions_with_coverage": len(with_cov),
+                       # R1-C74: the whole and its parts; they sum to every call in the source
+                       # that can run (shadowed bodies are named, not walked).
+                       "by_scope": sites["by_scope"],
+                       "shadowed_not_walked": sites["shadowed_not_walked"]},
         "calls_edges": {"total": sum(by_res.values()), "by_resolution": dict(sorted(by_res.items()))},
         "complexity": {
             "functions_scored": len(scored),
@@ -236,10 +262,8 @@ def render_behavior(query: Query) -> str:
     graph = query.graph
     funcs = [n for n in graph.nodes.values() if n.kind == "function"]
     with_cov = [n for n in funcs if "calls" in n.extras]
-    agg = {"out": 0, "resolved": 0, "external": 0, "unresolved": 0, "dynamic": 0}
-    for n in with_cov:
-        for k, v in n.extras["calls"].items():
-            agg[k] += v
+    sites = call_sites_by_scope(graph)
+    agg, by = sites["all"], sites["by_scope"]
     total = agg["out"] or 1
     lines = [f"# Behavioral layer — `{graph.target}`", ""]
     lines.append(
@@ -247,7 +271,17 @@ def render_behavior(query: Query) -> str:
         "type inference and are left unresolved on purpose (gaps/ CM-09/10)._"
     )
     lines.append("")
-    lines.append(f"## Call-site resolution ({agg['out']} sites in {len(with_cov)} functions)")
+    lines.append(f"## Call-site resolution ({agg['out']} call sites)")
+    lines.append("")
+    # R1-C74: name the parts. The heading used to count function bodies only and read as the
+    # whole package; module-level code, nested functions and class bodies were outside it.
+    shadow = sites["shadowed_not_walked"]
+    lines.append(
+        f"_{by['function']['out']} in function bodies, {by['nested']['out']} in nested functions, "
+        f"{by['module']['out']} at module level, {by['class_body']['out']} in class bodies"
+        + (f"; {shadow} more sit in bodies replaced by a later definition and are not walked "
+           "(they cannot run)" if shadow else "")
+        + "._")
     lines.append("")
     lines.append(f"- resolved to internal edges: **{agg['resolved']}** ({100*agg['resolved']/total:.1f}%)")
     lines.append(f"- external / builtin (flagged): {agg['external']} ({100*agg['external']/total:.1f}%)")

{codmap-0.0.23 → codmap-0.0.24/codmap.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codmap
-Version: 0.0.23
+Version: 0.0.24
 Summary: Static analyzer that turns a package's source into a queryable code graph.
 Author-email: kogriv <kogriv@gmail.com>
 License-Expression: MIT
@@ -44,7 +44,7 @@ and a **SCIP index** for interop with Sourcegraph / Glean and other precise-code
 
 [![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.13, **1115 tests with no failures on
+**Status:** 🟢 M0–M20 implemented + research track (R1/R2) — schema 0.13, **1128 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 &

{codmap-0.0.23 → codmap-0.0.24}/codmap.egg-info/SOURCES.txt

@@ -144,6 +144,8 @@ tests/test_r1c6_pack.py
 tests/test_r1c70_check_graph_currency.py
 tests/test_r1c71_attribute_chain_calls.py
 tests/test_r1c72_flat_inference_in_packages.py
+tests/test_r1c73_cli_version.py
+tests/test_r1c74_call_site_conservation.py
 tests/test_r1c7_edge_vocab.py
 tests/test_r1c8_deadcode.py
 tests/test_r1c9_incremental.py

{codmap-0.0.23 → codmap-0.0.24}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 # version. README says this plainly, since `pip install codmap` / `import codemap` is a
 # seam a reader will otherwise hit by surprise.
 name = "codmap"
-version = "0.0.23"
+version = "0.0.24"
 description = "Static analyzer that turns a package's source into a queryable code graph."
 readme = "README.md"
 # M20/D1: measured, not assumed. Each release of the declared range runs the full suite in

{codmap-0.0.23 → codmap-0.0.24}/tests/test_r1c63_answer_format.py

@@ -43,7 +43,8 @@ from codemap.serve.session import Session
 # blind-spot line — wording inside an existing note, not a change of structure.
 # Re-pinned with a bump to 3 (2026-11-03, R1-C69/R1-C70): the refusal of an invalid contract and
 # the three states of the `check --graph` currency line join the pinned surfaces.
-RENDERED_SHA = "395f32ca271c12cc0ad26bee19e66e1eae23ee1826098dd97e0ce8c5437f2d35"
+# Re-pinned with a bump to 4 (2026-11-03, R1-C74): `report behavior` names its scopes.
+RENDERED_SHA = "32a160c89e31af252873c0703d0e903397c6d470013fad5889b9194e2a3a2eb8"
 
 FILES = {
     "__init__.py": "",

codmap-0.0.24/tests/test_r1c73_cli_version.py

@@ -0,0 +1,72 @@
+"""R1-C73 — `codemap --version`, from the identity the graph records.
+
+Design `docs/design/cli_version.md`. Pinned: V1 (agrees with `importlib.metadata` and with
+`provenance.tool`), V3 (the flag wins over a subcommand), V4 (no arguments is still an error), V5 (no other
+command pays for `tool_identity()`), and V6 (a fixed string goes red). V2, the wheel outside the source
+tree, is the CI wheel job's ground and was measured by hand at acceptance.
+"""
+
+from __future__ import annotations
+
+import importlib.metadata
+from unittest import mock
+
+import pytest
+
+from codemap import cli, provenance
+from codemap.model import ANSWER_FORMAT, SCHEMA_VERSION
+
+
+def _version_out(capsys, *argv) -> tuple[int, str]:
+    with pytest.raises(SystemExit) as exc:
+        cli.main(["--version", *argv])
+    return exc.value.code, capsys.readouterr().out.strip()
+
+
+def test_it_agrees_with_the_metadata_and_with_provenance(capsys):
+    rc, out = _version_out(capsys)
+    assert rc == 0
+    ident = provenance.tool_identity()
+    assert out.startswith(f"codemap {importlib.metadata.version('codmap')}")
+    if ident.get("commit"):
+        assert f"@{ident['commit']}" in out
+    assert out.endswith(f"· answer format {ANSWER_FORMAT} · schema {SCHEMA_VERSION}")
+    assert ("(dirty)" in out) == bool(ident.get("dirty"))
+
+
+def test_the_flag_wins_over_a_subcommand(capsys):
+    rc, out = _version_out(capsys, "build", "x")
+    assert rc == 0 and out.startswith("codemap ")
+
+
+def test_no_arguments_is_still_an_error(capsys):
+    with pytest.raises(SystemExit) as exc:
+        cli.main([])
+    assert exc.value.code == 2
+
+
+def test_an_uninstalled_tool_says_so_rather_than_inventing_a_number():
+    with mock.patch.object(provenance, "tool_identity", lambda: {"name": "codemap"}):
+        line = cli.version_line()
+    assert line.startswith("codemap version unknown (not installed as a distribution)")
+
+
+def test_no_other_command_pays_for_the_identity(tmp_path, capsys):
+    """V5: building the parser must not call git; only the flag does."""
+    pkg = tmp_path / "vpkg"
+    pkg.mkdir()
+    (pkg / "__init__.py").write_text("")
+    g = tmp_path / "g.json"
+    assert cli.main(["build", str(pkg), "-o", str(g)]) == 0
+    with mock.patch.object(provenance, "tool_identity", side_effect=AssertionError("called")):
+        assert cli.main(["query", "vpkg", "--graph", str(g)]) in (0, 1)
+        assert cli.main(["report", "dependencies", "--graph", str(g)]) in (0, None)
+
+
+def test_mutation_a_fixed_string_goes_red(capsys):
+    """V6: an action that prints a frozen version disagrees with the metadata."""
+    with mock.patch.object(cli, "version_line", lambda: "codemap 9.9.9 · answer format 1 · schema 0.1"):
+        _, out = _version_out(capsys)
+    assert not out.startswith(f"codemap {importlib.metadata.version('codmap')}")
+    _, out = _version_out(capsys)
+    assert out.startswith(f"codemap {importlib.metadata.version('codmap')}")