codmap 0.0.6__tar.gz → 0.0.7__tar.gz

{codmap-0.0.6 → codmap-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codmap
-Version: 0.0.6
+Version: 0.0.7
 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, **732 tests with no failures on
+**Status:** 🟢 M0–M20 implemented + research track (R1/R2) — schema 0.13, **734 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.6 → codmap-0.0.7}/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, **732 tests with no failures on
+**Status:** 🟢 M0–M20 implemented + research track (R1/R2) — schema 0.13, **734 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.6 → codmap-0.0.7}/codemap/provenance.py

@@ -43,12 +43,17 @@ MATCH, OLDER, NEWER, UNKNOWN = "match", "older", "newer", "unknown"
 
 # -- tool identity (D2) -------------------------------------------------------
 
-@lru_cache(maxsize=1)
-def tool_version() -> str | None:
-    """The installed distribution's version, or None when it is not installed.
+def installed_version() -> str | None:
+    """What the distribution *currently on disk* says, read on every call.
 
-    The single source: `codemap.__version__` reads it too, having drifted a release
-    behind while it was a literal.
+    R1-C38-f1. `tool_version()` below is cached for a whole process, which is right for
+    provenance — every graph a build writes must carry one version — and wrong for the
+    only question that needs the value twice: has the installation changed underneath a
+    long-running server? The cached reader answers with what was true at import, so a
+    comparison between the two is a comparison of one value with itself.
+
+    Measured before trusting it: an upgrade performed while a process runs *is* visible
+    to a fresh `importlib.metadata.version()`, with no `invalidate_caches()` needed.
     """
     from importlib.metadata import PackageNotFoundError, version
     try:
@@ -57,6 +62,19 @@ def tool_version() -> str | None:
         return None
 
 
+@lru_cache(maxsize=1)
+def tool_version() -> str | None:
+    """The installed distribution's version, or None when it is not installed.
+
+    The single source: `codemap.__version__` reads it too, having drifted a release
+    behind while it was a literal.
+
+    Cached on purpose — a build stamps one version into everything it writes. Anything
+    asking *"is this still true?"* rather than *"what was it?"* wants `installed_version()`.
+    """
+    return installed_version()
+
+
 
 @lru_cache(maxsize=8)
 def _commit_of(root: Path) -> str | None:

{codmap-0.0.6 → codmap-0.0.7}/codemap/serve/session.py

@@ -109,7 +109,11 @@ def tool_drift(running: str | None, installed: str | None) -> dict | None:
 
     `stats` already separates the graph's schema from the running tool's. This is the same
     separation one level up, and it is only visible because the version is read from the
-    installed metadata at call time while the code was loaded at import.
+    installed metadata at call time while the code was loaded at import — which is a
+    property of *how the caller reads it*, not of this function. Shipped once without it
+    (0.0.6): `Session._tool_drift` passed the cached `tool_version()` on both sides, so the
+    two arguments were the same value by construction and this returned `None` forever.
+    See `installed_version()` and R1-C38-f1.
     """
     if not running or not installed or running == installed:
         return None
@@ -306,9 +310,13 @@ class Session:
 
     @staticmethod
     def _tool_drift() -> dict | None:
+        # The two sides must be read differently or there is nothing to compare (R1-C38-f1):
+        # `codemap.__version__` is fixed at import — that is the *running* code — while the
+        # installed distribution is re-read here, on every call. Using the cached
+        # `tool_version()` on the right made this compare a value with itself.
         import codemap
-        from codemap.provenance import tool_version
-        return tool_drift(getattr(codemap, "__version__", None), tool_version())
+        from codemap.provenance import installed_version
+        return tool_drift(getattr(codemap, "__version__", None), installed_version())
 
     def _op_reload(self, args) -> dict:
         """Reload the on-disk artifact into the served graph, without a restart (#3).

{codmap-0.0.6 → codmap-0.0.7}/codmap.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codmap
-Version: 0.0.6
+Version: 0.0.7
 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, **732 tests with no failures on
+**Status:** 🟢 M0–M20 implemented + research track (R1/R2) — schema 0.13, **734 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.6 → codmap-0.0.7}/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.6"
+version = "0.0.7"
 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.6 → codmap-0.0.7}/tests/test_r1c38_tool_drift.py

@@ -53,6 +53,55 @@ def test_an_unknown_version_is_not_a_drift():
     assert tool_drift(None, None) is None
 
 
+def _shadow_installed_version(tmp_path, monkeypatch, version: str) -> None:
+    """Make the *installed* distribution look like `version`, the way an upgrade would.
+
+    A `dist-info` directory earlier on `sys.path` wins, so this changes what
+    `importlib.metadata` answers without touching the imported module — exactly the
+    asymmetry a real upgrade under a running server creates.
+    """
+    d = tmp_path / "site"
+    (d / f"codmap-{version}.dist-info").mkdir(parents=True)
+    (d / f"codmap-{version}.dist-info" / "METADATA").write_text(
+        f"Metadata-Version: 2.1\nName: codmap\nVersion: {version}\n")
+    monkeypatch.syspath_prepend(str(d))
+
+
+def test_the_installed_side_is_read_fresh_or_there_is_nothing_to_compare(tmp_path, monkeypatch):
+    """R1-C38-f1 — the defect 0.0.6 shipped, and the reason no test caught it.
+
+    Every other test here hands `tool_drift` two versions, or forces a difference by
+    patching `codemap.__version__`. Both prove the arithmetic. Neither asks the question
+    the feature exists for: *can the condition arise?* It could not — `_tool_drift` read
+    the installed side through `tool_version()`, which is `lru_cache`d and first called at
+    import by `codemap/__init__.py`, so both sides were the same cached value forever.
+
+    Here nothing about the process is patched. Only the installation changes, as an
+    upgrade changes it, and the running server must notice.
+    """
+    from codemap.serve.session import Session
+
+    assert Session._tool_drift() is None            # agreement before the "upgrade"
+    _shadow_installed_version(tmp_path, monkeypatch, "9.9.9")
+
+    d = Session._tool_drift()
+    assert d is not None, "the installed version is being read from a process-lifetime cache"
+    assert d["code"] == "tool_restart_needed" and d["installed"] == "9.9.9"
+
+
+def test_the_build_side_stays_cached(tmp_path, monkeypatch):
+    """The fix must not turn provenance into a per-call filesystem read: a build stamps
+    one version into everything it writes, so `tool_version()` keeps its cache. The two
+    readers exist because they answer different questions — "what was it?" and "is it
+    still?" — and this is the assertion that keeps them apart."""
+    from codemap.provenance import installed_version, tool_version
+
+    before = tool_version()
+    _shadow_installed_version(tmp_path, monkeypatch, "9.9.9")
+    assert tool_version() == before
+    assert installed_version() == "9.9.9"
+
+
 def test_stats_and_reload_carry_it_when_it_applies(tmp_path, monkeypatch):
     import codemap
     from codemap.extract import extract