bantamkit 0.27.0__tar.gz → 0.28.0__tar.gz

{bantamkit-0.27.0 → bantamkit-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bantamkit
-Version: 0.27.0
+Version: 0.28.0
 Summary: bantamweight tooling — harness primitives that lift small-model agents
 License-Expression: MIT
 Requires-Python: >=3.11

{bantamkit-0.27.0 → bantamkit-0.28.0}/src/bantamkit/__init__.py

@@ -29,4 +29,4 @@ from bantamkit.structured import StructuredOutputError, extract_json, structured
 # file as its dynamic version source, so the wheel's metadata and the string the MCP
 # server advertises are the same committed bytes, and neither is a function of when
 # someone last ran `pip`.
-__version__ = "0.27.0"
+__version__ = "0.28.0"

{bantamkit-0.27.0 → bantamkit-0.28.0}/src/bantamkit/mcpserver.py

@@ -145,6 +145,29 @@ def _code_fingerprint() -> tuple[str, int, Path]:
         raise _Undetermined(f"unreadable source under {root}: {exc}") from None
 
 
+def _pack_files(root: Path) -> list[Path]:
+    """The pack as SHIPPED: every file except the bytecode caches an interpreter left in it.
+
+    ONE spelling of the rule, because there are TWO walks over this directory — the digest
+    behind `build_identity` and the count `--assets-root` prints — and a rule spelled twice
+    is a rule that gets fixed once. That is not hypothetical: the first version of this fix
+    excluded `__pycache__` from the digest alone, and a `pip install` then had one process
+    contradicting itself, `build_identity` answering 87 files while `--assets-root` printed
+    98 for the pack it had just loaded.
+
+    Bytecode is derived. `_code_fingerprint` has said so since it was written; this is the
+    same sentence applied to the pack, which carries eleven `.py` fixture files of its own.
+
+    The membership test is over the path RELATIVE to `root`, so a pack that happens to live
+    somewhere under a directory named `__pycache__` is walked rather than emptied.
+    """
+    return sorted(
+        p
+        for p in root.rglob("*")
+        if p.is_file() and "__pycache__" not in p.relative_to(root).parts
+    )
+
+
 def _assets_fingerprint() -> tuple[str, int, Path]:
     """Fingerprint the asset pack this build would load.
 
@@ -153,12 +176,26 @@ def _assets_fingerprint() -> tuple[str, int, Path]:
     different pack whether or not today's code opens it. `contracts/default.yaml` is the
     reason — `RB-P84` measured it as the one asset that differed between two live builds
     while no resource template exposed it, so it was invisible on every probed surface.
+
+    EXCEPT bytecode caches, and that exception is the whole point of this field. The pack
+    ships `.py` fixture files, so `pip install` byte-compiles them into `__pycache__` on the
+    way in and the digest of an INSTALLED pack stopped matching the digest of the identical
+    npm pack — measured on the published 0.27.0 artifacts, `sha256:fa8372f6…` over 98 files
+    against `sha256:d47dcf4b…` over 87, and deleting `__pycache__` from the wheel's pack
+    reproduced the npm digest byte for byte. `cross_runtime` tells the caller to compare
+    `assets_digest` across runtimes; without this rule that instruction returned a false
+    "different" on every real install. It was worse than cross-runtime: the digest was not
+    stable for ONE install either, because it changed the first time anything imported a
+    fixture. The pack is what was SHIPPED, never what an interpreter later wrote beside it.
+
+    The rule lives in `_pack_files`, which `--assets-root` shares, and is spelled the same
+    way in `runtime-ts`.
     """
     try:
         root = assets_root()
     except AssetNotFound as exc:
         raise _Undetermined(f"assets_root() could not resolve a pack: {exc}") from None
-    files = sorted(p for p in root.rglob("*") if p.is_file())
+    files = _pack_files(root)
     if not files:
         raise _Undetermined(f"asset pack at {root} contains no files")
     try:
@@ -1301,7 +1338,7 @@ def _print_assets_root() -> None:
     matches too.
     """
     root = assets_root()
-    files = sum(1 for path in root.rglob("*") if path.is_file())
+    files = len(_pack_files(root))
     sys.stdout.buffer.write(f"{root}\n{files} files\n".encode())
     sys.stdout.buffer.flush()
 

{bantamkit-0.27.0 → bantamkit-0.28.0}/tests/test_build_identity.py

@@ -458,3 +458,43 @@ def test_one_build_in_two_install_shapes_is_one_build(pristine, tmp_path):
     assert wheel["code_digest"] == pristine["code_digest"]
     assert wheel["assets_digest"] == pristine["assets_digest"]
     assert wheel["build_id"] == pristine["build_id"]
+
+
+def test_pip_byte_compiling_the_packs_fixtures_is_not_a_different_pack(pristine, tmp_path):
+    """The same defect as the test above, one field over, found on the PUBLISHED artifacts.
+
+    `_code_fingerprint` has excluded `__pycache__` since it was written, for the reason
+    stated there: bytecode is derived, and a build must not fingerprint differently before
+    and after its first import. `_assets_fingerprint` did not, and the asset pack carries
+    eleven `.py` fixture files — so `pip install` byte-compiles them on the way in and the
+    installed pack gained eleven files the npm pack never has.
+
+    Measured on the published 0.27.0 artifacts, before this exclusion existed: the wheel
+    answered `sha256:fa8372f6…` over 98 files where the npm tarball answered
+    `sha256:d47dcf4b…` over 87, and deleting `__pycache__` from the wheel's pack reproduced
+    the npm digest byte for byte. `cross_runtime` was at that moment telling every caller
+    that `assets_digest` is the field to compare across runtimes, so the one instruction the
+    tool gives about itself returned a false "different" on every real install.
+
+    It was not only a cross-runtime defect. The digest was unstable for ONE install: it
+    changed the first time anything imported a fixture. This test pins that half, which is
+    the half a differential gate cannot see — pointed at one polluted pack, both runtimes
+    move together and agree with each other while both are wrong.
+
+    Note `_wheel_shaped` already copies with `ignore_patterns("__pycache__")`. The fixture
+    knew; the shipped walk did not.
+    """
+    pkgroot = _wheel_shaped(tmp_path, "compiled")
+    clean = _identity_of(pkgroot, tmp_path)
+
+    cache = pkgroot / "bantamkit" / "assets" / "evals" / "devteam" / "repo" / "src" / "ledger"
+    cache = cache / "__pycache__"
+    cache.mkdir(parents=True)
+    for stem in ("config", "errors", "posting"):
+        (cache / f"{stem}.cpython-312.pyc").write_bytes(b"not real bytecode\n")
+
+    compiled = _identity_of(pkgroot, tmp_path)
+
+    assert compiled["assets_files"] == clean["assets_files"] == pristine["assets_files"]
+    assert compiled["assets_digest"] == clean["assets_digest"] == pristine["assets_digest"]
+    assert compiled["build_id"] == clean["build_id"] == pristine["build_id"]

{bantamkit-0.27.0 → bantamkit-0.28.0}/tests/test_mcpserver.py

@@ -3,6 +3,7 @@
 import asyncio
 import json
 import os
+import shutil
 import tomllib
 from pathlib import Path
 
@@ -18,6 +19,7 @@ from bantamkit.assets import load_skill, load_tool  # noqa: E402
 # The checkout under test, so a subprocess can be pointed at IT rather than at whatever
 # `bantamkit` is installed in the interpreter that spawns it.
 SRC = Path(__file__).resolve().parents[1] / "src"
+REPO_ASSETS = Path(__file__).resolve().parents[2] / "assets"
 from bantamkit.mcpserver import (  # noqa: E402
     _build_memory,
     _parse_args,
@@ -636,7 +638,15 @@ def test_assets_root_flag_prints_the_root_and_a_file_count_on_stdout(tmp_path):
     from bantamkit.assets import assets_root
 
     root = assets_root()
-    expected = sum(len(names) for _dirpath, _dirnames, names in os.walk(root))
+    # `os.walk` and not the implementation's `rglob`, so a fix that counted directories as
+    # well as files stays red — but with the SAME `__pycache__` rule the implementation
+    # applies, or this expectation becomes a landmine that fires the first time anything
+    # imports the eleven `.py` fixtures the pack ships.
+    expected = sum(
+        len(names)
+        for dirpath, _dirnames, names in os.walk(root)
+        if "__pycache__" not in Path(dirpath).relative_to(root).parts
+    )
     done = _run_cli(["--assets-root"], tmp_path)
 
     assert done.returncode == 0
@@ -645,6 +655,45 @@ def test_assets_root_flag_prints_the_root_and_a_file_count_on_stdout(tmp_path):
     assert done.stdout.count(b"\n") == 2
 
 
+def test_assets_root_and_build_identity_count_the_same_pack_the_same_way(tmp_path):
+    """One process must not contradict itself about the pack it just loaded.
+
+    There are two walks over the asset pack — the digest behind `build_identity` and this
+    count — and the first version of the `__pycache__` exclusion filtered only the digest.
+    On a real `pip install` that left `build_identity` answering 87 files while
+    `--assets-root` printed 98 for the same directory, which is a worse failure than either
+    number being wrong: a caller comparing them has no way to decide which surface lied.
+
+    The pack here carries a `__pycache__` because that is what `pip` leaves behind — the
+    pack ships eleven `.py` fixtures and installing the wheel byte-compiles them.
+    """
+    import subprocess
+    import sys
+
+    pack = tmp_path / "pack"
+    shutil.copytree(REPO_ASSETS, pack, ignore=shutil.ignore_patterns("__pycache__"))
+    shipped = sum(1 for p in pack.rglob("*") if p.is_file())
+
+    cache = pack / "evals" / "devteam" / "repo" / "src" / "ledger" / "__pycache__"
+    cache.mkdir(parents=True)
+    for stem in ("config", "errors", "posting"):
+        (cache / f"{stem}.cpython-312.pyc").write_bytes(b"not real bytecode\n")
+    assert sum(1 for p in pack.rglob("*") if p.is_file()) == shipped + 3
+
+    env = dict(os.environ)
+    env["PYTHONPATH"] = str(SRC)
+    env["BANTAMKIT_ASSETS"] = str(pack)
+    done = subprocess.run(
+        [sys.executable, "-m", "bantamkit.mcpserver", "--assets-root"],
+        capture_output=True,
+        cwd=str(tmp_path),
+        env=env,
+    )
+
+    assert done.returncode == 0
+    assert done.stdout == f"{pack}\n{shipped} files\n".encode()
+
+
 def test_assets_root_flag_returns_before_a_store_or_a_transport_exists(monkeypatch, capsysbinary):
     """The Node arm returns ahead of `new RawStdioTransport()`; so does this one.