tdd-cli 0.4.0__tar.gz → 0.4.1__tar.gz

{tdd_cli-0.4.0 → tdd_cli-0.4.1}/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to this project are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and the project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.4.1] - 2026-08-16
+
+### Changed
+
+- `collect()` runs one invocation per declared suite instead of one per test
+  file, falling back to the per-file loop for anything a batch did not account
+  for. Per-file collection was **77% of a real `run start`** — 313 subprocesses
+  costing 402s, against 117s to actually run every test — because cost scaled
+  with file count at a ~1.08s floor per invocation (the environment manager
+  resolving plus the runner booting). Measured 38.8x faster on a 60-file
+  project, with an identical collected set. R10.3's guarantee is unchanged: a
+  file that fails to collect is still attributed to itself and cannot destroy
+  the set, and a file the batch never reports is still collected individually,
+  so the set can only match or improve on the old one (#27).
+
 ## [0.4.0] - 2026-08-16
 
 ### Added

{tdd_cli-0.4.0 → tdd_cli-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tdd-cli
-Version: 0.4.0
+Version: 0.4.1
 Summary: Ledger-backed TDD process controller for autonomous coding agents
 Project-URL: Homepage, https://github.com/geuben/tdd-cli
 Project-URL: Repository, https://github.com/geuben/tdd-cli

{tdd_cli-0.4.0 → tdd_cli-0.4.1}/src/tddcli/__init__.py

@@ -3,4 +3,4 @@
 State is derived from observed test execution, never asserted by the caller.
 """
 
-__version__ = "0.4.0"
+__version__ = "0.4.1"

{tdd_cli-0.4.0 → tdd_cli-0.4.1}/src/tddcli/adapters/base.py

@@ -189,6 +189,48 @@ class Adapter:
         return "a body that fails loudly, never working logic"
 
     def collect(self) -> Collection:
+        """Enumerate the project's tests: one invocation per declared suite, with
+        the per-file loop kept for what that cannot account for (issue #27).
+
+        Per file, collection cost scaled with *file count* rather than test count —
+        measured at 77% of a whole `run start`, against a floor of ~1.08s per
+        invocation that is the environment manager resolving plus the runner
+        booting, not collection work.
+
+        The batch and the loop do not discover the same way: a batch uses the
+        runner's own config, the loop walks `test_paths`. So the loop still runs for
+        every file the batch did not report — whether the batch failed, returned
+        nothing, or simply never mentioned that file. R10.3's guarantee is
+        unchanged: one uncollectable file is attributed to itself, and cannot
+        destroy the set. What changes is that the healthy case no longer pays for
+        the broken one.
+        """
+        result = Collection()
+        unaccounted = {str(p.relative_to(self.root)) for p in self._test_files()}
+        for command, env in self._collect_invocations():
+            batch = self._collect_batch(command, env)
+            if batch is None:
+                continue
+            tests, files = batch
+            result.tests |= tests
+            unaccounted -= files
+        return self._collect_per_file(unaccounted, result)
+
+    def _collect_invocations(self) -> list[tuple[str, dict[str, str] | None]]:
+        """One collection command per declared suite: the default plus each
+        override's (R7.13), so an override's files are enumerated with its own
+        command and env."""
+        raise NotImplementedError
+
+    def _collect_batch(
+        self, command: str, env: dict[str, str] | None
+    ) -> tuple[set[str], set[str]] | None:
+        """`(test ids, files seen)` for one whole-suite invocation, or None when it
+        produced nothing usable — the signal to leave its files to the loop."""
+        raise NotImplementedError
+
+    def _collect_per_file(self, rels: set[str], result: Collection) -> Collection:
+        """R10.3's loop, now reached only for files no batch accounted for."""
         raise NotImplementedError
 
     def collectable(self) -> GateResult:

{tdd_cli-0.4.0 → tdd_cli-0.4.1}/src/tddcli/adapters/pytest_adapter.py

@@ -235,23 +235,49 @@ class PytestAdapter(Adapter):
             " cannot reach them (e.g. `pytest tests/`)."
         ))
 
-    def collect(self) -> Collection:
+    def _collect_invocations(self) -> list[tuple[str, dict[str, str] | None]]:
+        """An override without a `collect_command` collects with its `test_command`
+        — `--collect-only` composes with any run command."""
+        return [(self._collect_cmd(), self._suite_env(None))] + [
+            (ov.collect_command or ov.test_command, self._suite_env(ov))
+            for ov in self.project.overrides
+        ]
+
+    def _nodeids(self, out: str) -> tuple[set[str], set[str]]:
+        tests: set[str] = set()
+        files: set[str] = set()
+        for line in out.splitlines():
+            line = line.strip()
+            if "::" in line and not line.startswith(("=", "-", "no tests")):
+                tests.add(self.qualify(line))
+                files.add(line.split("::", 1)[0])
+        return tests, files
+
+    def _collect_batch(
+        self, command: str, env: dict[str, str] | None
+    ) -> tuple[set[str], set[str]] | None:
+        code, out, err = run_command(
+            f"{command} --collect-only -q", self.root, extra_env=env, label="collect"
+        )
+        if code != 0:
+            return None
+        # An empty result needs no special case: it accounts for no files, so every
+        # file falls to the loop exactly as a failure would.
+        return self._nodeids(out)
+
+    def _collect_per_file(self, rels: set[str], result: Collection) -> Collection:
         """Per file (R10.3) — one uncollectable module must not destroy the whole set."""
-        result = Collection()
-        for path in self._test_files():
-            rel = path.relative_to(self.root)
-            base, env = self._collect_cmd_for(str(rel))
+        for rel in sorted(rels):
+            base, env = self._collect_cmd_for(rel)
             code, out, err = run_command(
-                f"{base} --collect-only -q {shlex.quote(str(rel))}",
+                f"{base} --collect-only -q {shlex.quote(rel)}",
                 self.root,
                 extra_env=env,
                 label="collect",
             )
             if code != 0:
-                result.failed_files[str(rel)] = (err or out).strip()[:800]
+                result.failed_files[rel] = (err or out).strip()[:800]
                 continue
-            for line in out.splitlines():
-                line = line.strip()
-                if "::" in line and not line.startswith(("=", "-", "no tests")):
-                    result.tests.add(self.qualify(line))
+            tests, _ = self._nodeids(out)
+            result.tests |= tests
         return result

{tdd_cli-0.4.0 → tdd_cli-0.4.1}/src/tddcli/adapters/vitest_adapter.py

@@ -223,10 +223,43 @@ class VitestAdapter(Adapter):
             " config (test.exclude) or scope its include globs."
         ))
 
-    def collect(self) -> Collection:
-        result = Collection()
-        for path in self._test_files():
-            rel = path.relative_to(self.root)
+    def _collect_invocations(self) -> list[tuple[str, dict[str, str] | None]]:
+        """An override with no `collect_command` gets no batch — `vitest list` knows
+        nothing of its config, and its files fall to the loop, which records the
+        missing `collect_command` against each of them as before."""
+        return [(self._collect_cmd(), self._suite_env(None))] + [
+            (ov.collect_command, self._suite_env(ov))
+            for ov in self.project.overrides if ov.collect_command
+        ]
+
+    def _collect_batch(
+        self, command: str, env: dict[str, str] | None
+    ) -> tuple[set[str], set[str]] | None:
+        """Unlike `_parse_list_output`, which pins every id to the one file it was
+        given, a whole-suite listing must read the file from each line — the same
+        `file > describe > name` shape, one file per line rather than one per run."""
+        code, out, err = run_command(command, self.root, extra_env=env, label="collect")
+        if code != 0:
+            return None
+        tests: set[str] = set()
+        files: set[str] = set()
+        for line in out.splitlines():
+            line = line.strip()
+            if " > " not in line:
+                continue
+            rel, _, remainder = line.partition(" > ")
+            full_name = " ".join(part.strip() for part in remainder.split(" > "))
+            if rel and full_name:
+                tests.add(self.qualify(f"{rel.strip()} > {full_name}"))
+                files.add(rel.strip())
+        # An empty result needs no special case: it accounts for no files, so every
+        # file falls to the loop exactly as a failure would.
+        return tests, files
+
+    def _collect_per_file(self, rels: set[str], result: Collection) -> Collection:
+        for rel_str in sorted(rels):
+            path = self.root / rel_str
+            rel = Path(rel_str)
             ov = self.project.override_for(str(rel))
             if ov is not None and not ov.collect_command:
                 result.failed_files[str(rel)] = (

tdd_cli-0.4.1/tests/test_batch_collection.py

@@ -0,0 +1,233 @@
+"""Collection asks the runner once, not once per file (issue #27).
+
+Measured on a real repo: 313 per-file subprocesses cost 402s, 77% of a whole
+`run start`, while *running* all the tests cost 117s. The floor per invocation
+was 1.08s — the environment manager resolving plus the runner booting, paid
+again per file. A single file's tests enumerate in milliseconds.
+
+Both adapters already had a whole-suite probe (`collectable()`); collection now
+uses that shape and keeps the per-file loop for the case it exists to serve.
+
+The rule that makes this safe: **a file the batch does not account for gets
+exactly the old per-file treatment.** Batch fails, batch is empty, batch skips a
+file the registry declares — each falls through to the loop, so the collected set
+can only match or improve on the old one, never silently shrink (R10.3/R10.4).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from conftest import run_cli, write_plan
+from tddcli import adapters
+from tddcli import config as config_mod
+
+
+def _adapter(repo: Path, project: str = "backend"):
+    return adapters.build(config_mod.load(repo).project(project), repo)
+
+
+def _counting(monkeypatch, module=None):
+    """Wrap the real `run_command`, recording every command it is asked to run."""
+    seen: list[str] = []
+    real = adapters.base.run_command
+
+    def wrapper(command, cwd, timeout=1800, extra_env=None, label=None):
+        seen.append(command)
+        return real(command, cwd, timeout=timeout, extra_env=extra_env, label=label)
+
+    monkeypatch.setattr(module or adapters.base, "run_command", wrapper)
+    return seen
+
+
+def _write_tests(repo: Path, n: int) -> None:
+    for i in range(n):
+        (repo / "backend" / "tests" / f"test_gen{i}.py").write_text(
+            f"def test_gen{i}():\n    assert True\n"
+        )
+
+
+def test_a_healthy_project_is_collected_in_one_invocation(repo, monkeypatch):
+    """The whole point: cost stops scaling with file count."""
+    _write_tests(repo, 6)
+    seen = _counting(monkeypatch, adapters.pytest_adapter)
+
+    collected = _adapter(repo).collect()
+
+    assert len(seen) == 1, seen
+    assert len(collected.tests) == 7, collected.tests   # 6 generated + test_smoke
+    assert collected.failed_files == {}
+
+
+def test_the_batch_finds_the_same_tests_the_per_file_loop_would(repo, monkeypatch):
+    """Equivalence is the whole risk of this change: batch enumeration uses the
+    runner's own discovery, the per-file loop uses `test_paths` globs."""
+    _write_tests(repo, 4)
+    adapter = _adapter(repo)
+
+    batched = adapter.collect().tests
+    per_file = adapter._collect_per_file(
+        {str(p.relative_to(adapter.root)) for p in adapter._test_files()},
+        adapters.base.Collection(),
+    ).tests
+
+    assert batched == per_file, batched ^ per_file
+
+
+def test_a_file_the_batch_never_reported_is_collected_individually(repo, monkeypatch):
+    """A file matching `test_paths` that the runner's config excludes must not
+    vanish from the set — a quietly smaller baseline is worse than a slow one."""
+    _write_tests(repo, 3)
+    adapter = _adapter(repo)
+    real = adapters.base.run_command
+    seen: list[str] = []
+
+    def hide_one(command, cwd, timeout=1800, extra_env=None, label=None):
+        seen.append(command)
+        code, out, err = real(command, cwd, timeout=timeout, extra_env=extra_env, label=label)
+        if "test_gen1.py" not in command:      # the batch "forgets" this file
+            out = "\n".join(
+                line for line in out.splitlines() if "test_gen1.py" not in line
+            )
+        return code, out, err
+
+    monkeypatch.setattr(adapters.pytest_adapter, "run_command", hide_one)
+    collected = adapter.collect()
+
+    assert any("test_gen1.py" in t for t in collected.tests), collected.tests
+    # Exactly one rescue invocation, naming that file — not a whole re-sweep.
+    per_file = [c for c in seen if "test_gen1.py" in c]
+    assert len(per_file) == 1, seen
+
+
+def test_a_failing_batch_falls_back_to_per_file_attribution(repo_broken):
+    """R10.3's purpose, preserved: one uncollectable module must not destroy the
+    set, and the failure must name the file it came from."""
+    adapter = _adapter(repo_broken, "verify")
+    collected = adapter.collect()
+
+    assert collected.failed_files, "a broken module must be attributed"
+    assert any("test_v.py" in name for name in collected.failed_files), collected.failed_files
+
+
+def test_one_broken_file_does_not_lose_its_healthy_neighbours(repo_broken):
+    """The batch fails wholesale, so the fallback has to recover everything else."""
+    (repo_broken / "verify" / "tests" / "test_ok.py").write_text(
+        "def test_ok():\n    assert True\n"
+    )
+    collected = _adapter(repo_broken, "verify").collect()
+
+    assert any("test_ok.py" in t for t in collected.tests), collected.tests
+    assert any("test_v.py" in f for f in collected.failed_files), collected.failed_files
+
+
+def test_override_files_are_collected_by_their_own_suite(repo, monkeypatch):
+    """R7.13: an override's files are enumerated with the override's command and
+    env, so batching must stay one invocation *per declared suite*."""
+    (repo / "backend" / "contract").mkdir()
+    (repo / "backend" / "contract" / "test_api.py").write_text(
+        "def test_ping():\n    assert True\n"
+    )
+    (repo / "tdd.toml").write_text(
+        "[project.backend]\n"
+        'root       = "backend"\n'
+        'adapter    = "pytest"\n'
+        'test_paths = ["tests/"]\n'
+        'test_command = "pytest tests"\n'
+        "[[project.backend.override]]\n"
+        'pattern      = "contract/"\n'
+        'test_command = "pytest contract"\n'
+    )
+    seen = _counting(monkeypatch, adapters.pytest_adapter)
+
+    collected = _adapter(repo).collect()
+
+    assert len(seen) == 2, seen          # default suite + override suite, no per-file
+    assert any("contract/test_api.py" in t for t in collected.tests), collected.tests
+
+
+def test_partial_output_from_a_failed_batch_is_not_trusted(repo, monkeypatch):
+    """A runner that aborts mid-collection still prints what it reached. Accepting
+    that would take a file's *incomplete* test list as final — and reconciliation
+    could not save it, because the file was mentioned. Every file is re-collected
+    instead, which is the old cost only in the case that was already broken."""
+    _write_tests(repo, 3)
+    adapter = _adapter(repo)
+    real = adapters.base.run_command
+    seen: list[str] = []
+
+    def failing_batch(command, cwd, timeout=1800, extra_env=None, label=None):
+        seen.append(command)
+        if "test_gen" not in command and "test_smoke" not in command:
+            # whole-suite invocation: aborts, having reached one file
+            return 1, "tests/test_gen0.py::test_gen0\n", "INTERNALERROR"
+        return real(command, cwd, timeout=timeout, extra_env=extra_env, label=label)
+
+    monkeypatch.setattr(adapters.pytest_adapter, "run_command", failing_batch)
+    collected = adapter.collect()
+
+    assert any("test_gen0.py" in c for c in seen[1:]), seen
+    assert len(collected.tests) == 4, collected.tests   # 3 generated + test_smoke
+
+
+def test_vitest_partial_output_from_a_failed_batch_is_not_trusted(repo_multi, monkeypatch):
+    """Same rule for the vitest adapter, whose listing has no exit-code-free way to
+    tell a complete run from an aborted one."""
+    (repo_multi / "frontend" / "a.test.ts").write_text("")
+    (repo_multi / "frontend" / "b.test.ts").write_text("")
+    adapter = _adapter(repo_multi, "frontend")
+    seen: list[str] = []
+
+    def failing_batch(command, cwd, timeout=1800, extra_env=None, label=None):
+        seen.append(command)
+        if command.endswith("list"):                       # whole-suite invocation
+            return 1, "a.test.ts > alpha\n", "crashed"
+        return 0, f"{command.rsplit(' ', 1)[1]} > rescued", ""
+
+    monkeypatch.setattr(adapters.vitest_adapter, "run_command", failing_batch)
+    collected = adapter.collect()
+
+    assert collected.tests == {
+        "frontend::a.test.ts > rescued", "frontend::b.test.ts > rescued",
+    }, collected.tests
+
+
+def test_vitest_batch_attributes_each_id_to_its_own_file(repo_multi, monkeypatch):
+    """`_parse_list_output` pinned every id to one path, which is right per-file
+    and wrong for a whole-suite listing."""
+    (repo_multi / "frontend" / "a.test.ts").write_text(
+        "import {test, expect} from 'vitest'\ntest('alpha', () => expect(1).toBe(1))\n"
+    )
+    (repo_multi / "frontend" / "b.test.ts").write_text(
+        "import {test, expect} from 'vitest'\ntest('beta', () => expect(1).toBe(1))\n"
+    )
+    adapter = _adapter(repo_multi, "frontend")
+    monkeypatch.setattr(
+        adapters.vitest_adapter, "run_command",
+        lambda command, cwd, timeout=1800, extra_env=None, label=None: (
+            0, "a.test.ts > alpha\nb.test.ts > beta\n", ""
+        ),
+    )
+    collected = adapter.collect()
+
+    assert collected.tests == {"frontend::a.test.ts > alpha", "frontend::b.test.ts > beta"}
+
+
+def test_run_start_still_reports_the_same_baseline(repo, monkeypatch):
+    """End to end, through the command that pays for this."""
+    _write_tests(repo, 3)
+    plan = write_plan(repo, """---
+cycles:
+  - n: 1
+    project: backend
+    title: "adding two numbers"
+    test: "tests/test_add.py::test_add_two_numbers"
+    commit_red: "test: adding"
+    commit_green: "feat: add"
+---
+# Plan
+""")
+    assert run_cli(repo, "plan", "register", plan)["ok"]
+    out = run_cli(repo, "run", "start", "--plan", plan)
+    assert out["ok"], out
+    assert out["result"]["baselines"] == {"backend": 0}, out["result"]

{tdd_cli-0.4.0 → tdd_cli-0.4.1}/tests/test_suite_overrides.py

@@ -340,7 +340,13 @@ def test_vitest_collection_routes_override_files_to_the_override_command(
     assert collection.tests == {
         "backend::contract/api.contract.test.ts > pings the api"
     }
-    assert seen[0].startswith("npx vitest list --config vitest.contract.config.ts ")
+    # R7.13's requirement is that the override's own command enumerates its files —
+    # not that it does so one file at a time. Collection batches per declared suite
+    # (issue #27), so the override's command is one of the invocations rather than
+    # the first, and carries no file argument.
+    assert any(
+        c.startswith("npx vitest list --config vitest.contract.config.ts") for c in seen
+    ), seen
 
     # With every suite listable the gate passes: the probe must not manufacture a
     # failure out of a healthy override.

{tdd_cli-0.4.0 → tdd_cli-0.4.1}/tests/test_timing_visibility.py

@@ -23,6 +23,8 @@ from __future__ import annotations
 import json
 
 from conftest import run_cli, write_plan
+from tddcli import adapters
+from tddcli import config as config_mod
 from tddcli.adapters import base
 
 PLAN = """---
@@ -114,18 +116,25 @@ def test_a_timed_command_is_attributed_to_its_caller(repo, capsys, monkeypatch):
     assert "collect" in labels, labels
 
 
-def test_the_per_file_collect_loop_is_attributed_per_file(repo, capsys, monkeypatch):
-    """The loop's cost is per file, so its timing has to be too — a single total
-    cannot say which file is slow."""
+def test_the_per_file_collect_fallback_is_attributed_per_file(repo_broken, capsys, monkeypatch):
+    """The fallback loop's cost is per file, so its timing has to be too — a single
+    total cannot say which file is slow.
+
+    Collection batches per suite now (issue #27), so the loop runs only where a
+    batch could not account for a file — which is exactly where per-file
+    attribution earns its keep. `repo_broken`'s uncollectable module fails the
+    batch and drops every file in that project to the loop."""
     monkeypatch.setenv(base.TIMING_ENV, "1")
-    assert _start(repo)["ok"]
+    adapters.build(
+        config_mod.load(repo_broken).project("verify"), repo_broken
+    ).collect()
 
     collects = [
         entry for entry in _lines(capsys.readouterr().err, "command_timing")
         if entry.get("label") == "collect"
     ]
     assert collects, "no collect timings"
-    assert any("test_smoke.py" in entry["command"] for entry in collects), collects
+    assert any("test_v.py" in entry["command"] for entry in collects), collects
 
 
 def test_doctor_probes_are_labelled_as_doctor(repo, capsys, monkeypatch):