tdd-cli 0.2.0__tar.gz → 0.2.1__tar.gz

{tdd_cli-0.2.0 → tdd_cli-0.2.1}/CHANGELOG.md

@@ -6,6 +6,24 @@ and the project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-08-10
+
+### Added
+
+- `tdd doctor` check `default suite cannot reach override files`: when a
+  project declares overrides, doctor probes the default suite's discovery
+  (pytest: the test command with `--collect-only`; vitest: `vitest list`) and
+  fails if it reaches files an override owns — the premise suite overrides
+  require, which nothing previously enforced.
+
+### Fixed
+
+- A test observed by more than one suite invocation of the union (the default
+  suite's discovery sweeping an override's files, e.g. a bare `pytest` default)
+  is now a loud tooling error naming the overlapping tests and the fix, instead
+  of the target being silently judged by whichever suite reported it first —
+  previously an env-less run whose failure said nothing about the overlap.
+
 ## [0.2.0] - 2026-08-10
 
 ### Added

{tdd_cli-0.2.0 → tdd_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tdd-cli
-Version: 0.2.0
+Version: 0.2.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.2.0 → tdd_cli-0.2.1}/src/tddcli/__init__.py

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

{tdd_cli-0.2.0 → tdd_cli-0.2.1}/src/tddcli/adapters/base.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 import subprocess
+from collections import Counter
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -42,6 +43,27 @@ class Collection:
     failed_files: dict[str, str] = field(default_factory=dict)
 
 
+def _suite_overlap(suite_ids: list[set[str]]) -> list[str]:
+    """Test ids observed by more than one suite invocation of the union (R7.13).
+    Overlap means the default command's discovery reaches files an override
+    owns, so those tests also ran without the override's command/env — and
+    target matching would judge the target by whichever run came first."""
+    counts = Counter(i for ids in suite_ids for i in ids)
+    return sorted(i for i, n in counts.items() if n > 1)
+
+
+def _overlap_error(overlap: list[str]) -> str:
+    shown = ", ".join(overlap[:5])
+    more = f" (and {len(overlap) - 5} more)" if len(overlap) > 5 else ""
+    return (
+        f"observed by more than one suite invocation: {shown}{more}."
+        " The default suite's discovery reaches files an override owns, so"
+        " these tests also ran without the override's command/env. Scope the"
+        " default test_command so it cannot reach them (e.g. pass the default"
+        " test directories explicitly)."
+    )
+
+
 def run_command(
     command: str, cwd: Path, timeout: int = 1800,
     extra_env: dict[str, str] | None = None,
@@ -128,6 +150,15 @@ class Adapter:
     def collectable(self) -> GateResult:
         raise NotImplementedError
 
+    def override_isolation(self) -> GateResult:
+        """Whether the default suite's discovery stays out of files an override
+        owns (R7.13's premise). Overlap means runs observe those tests without
+        the override's command/env — and the union then holds the same test
+        twice with conflicting outcomes. Adapters with a way to probe discovery
+        override this; the base answer is ok so third-party adapters without a
+        probe don't fail doctor."""
+        return GateResult(ok=True)
+
     def lint(self) -> GateResult:
         return self._gate(self.project.lint)
 

{tdd_cli-0.2.0 → tdd_cli-0.2.1}/src/tddcli/adapters/pytest_adapter.py

@@ -25,6 +25,8 @@ from .base import (
     Collection,
     GateResult,
     Verdict,
+    _overlap_error,
+    _suite_overlap,
     run_command,
 )
 
@@ -100,6 +102,7 @@ class PytestAdapter(Adapter):
         # agent to rewrite a test that is fine.
         tests: list[dict] = []
         collectors: list[dict] = []
+        suite_ids: list[set[str]] = []
         for base_cmd, extra_env in self._suite_invocations():
             report, error = self._suite_report(base_cmd, extra_env)
             if report is None:
@@ -108,6 +111,12 @@ class PytestAdapter(Adapter):
             verdict.duration_ms += int(report.get("duration", 0) * 1000)
             tests.extend(report.get("tests", []))
             collectors.extend(report.get("collectors", []))
+            suite_ids.append({t["nodeid"] for t in report.get("tests", [])})
+
+        overlap = _suite_overlap(suite_ids)
+        if overlap:
+            verdict.error = _overlap_error(overlap)
+            return verdict
 
         uncollectable: set[str] = set()
         for collector in collectors:
@@ -193,6 +202,34 @@ class PytestAdapter(Adapter):
                 chunks.append(out.strip())
         return GateResult(ok=not chunks, output="\n\n".join(chunks)[:2000])
 
+    def override_isolation(self) -> GateResult:
+        """Probes the *test* command's discovery, not `collect_command`'s: the
+        test command is what runs at suite time, and a scoped `test_command`
+        with a bare per-file `collect_command` is a legitimate registry (the
+        per-file command always gets an explicit path). `{workers}` becomes 0 —
+        xdist's "no workers" — since discovery needs no parallelism. A probe
+        that fails to collect at all is `collectable`'s finding, not this one's."""
+        if not self.project.overrides:
+            return GateResult(ok=True)
+        probe = f"{self._test_cmd().replace('{workers}', '0')} --collect-only -q"
+        code, out, err = run_command(probe, self.root)
+        reached = sorted({
+            f for f in (
+                line.split("::", 1)[0]
+                for line in out.splitlines()
+                if "::" in line
+            )
+            if self.project.override_for(f)
+        })
+        if not reached:
+            return GateResult(ok=True)
+        return GateResult(ok=False, output=(
+            "the default suite's discovery reaches files an override owns, so"
+            " suite runs would observe them without the override's command/env:"
+            f" {', '.join(reached[:5])}. Scope the default test_command so it"
+            " cannot reach them (e.g. `pytest tests/`)."
+        ))
+
     def collect(self) -> Collection:
         """Per file (R10.3) — one uncollectable module must not destroy the whole set."""
         result = Collection()

{tdd_cli-0.2.0 → tdd_cli-0.2.1}/src/tddcli/adapters/vitest_adapter.py

@@ -21,6 +21,8 @@ from .base import (
     Collection,
     GateResult,
     Verdict,
+    _overlap_error,
+    _suite_overlap,
     run_command,
 )
 
@@ -61,6 +63,7 @@ class VitestAdapter(Adapter):
         # producing no JSON is a loud error, not a silent gap: swallowing it would
         # report a target living in that suite as `not_found`.
         suites: list[dict] = []
+        suite_ids: list[set[str]] = []
         for base, extra_env in self._suite_invocations():
             code, out, err = self._run_suite(f"{base} --reporter=json", extra_env)
             report = _extract_json(out)
@@ -70,7 +73,18 @@ class VitestAdapter(Adapter):
                 )
                 return verdict
             verdict.duration_ms += int(report.get("duration") or 0)
-            suites.extend(report.get("testResults", []))
+            results = report.get("testResults", [])
+            suites.extend(results)
+            suite_ids.append({
+                self._id_for(s.get("name", ""), t["fullName"])
+                for s in results
+                for t in s.get("assertionResults", [])
+            })
+
+        overlap = _suite_overlap(suite_ids)
+        if overlap:
+            verdict.error = _overlap_error(overlap)
+            return verdict
 
         failed_suites: dict[str, str] = {}
 
@@ -175,6 +189,31 @@ class VitestAdapter(Adapter):
                 chunks.append((err or out).strip())
         return GateResult(ok=not chunks, output="\n\n".join(chunks)[:2000])
 
+    def override_isolation(self) -> GateResult:
+        """Probes with the default `vitest list` — the same stand-in for the
+        default run config that `collectable()` already relies on (`vitest run`
+        has no listing mode, and running the suite just to enumerate it would
+        execute against whatever the tests need live)."""
+        if not self.project.overrides:
+            return GateResult(ok=True)
+        code, out, err = run_command(self._collect_cmd(), self.root)
+        reached = sorted({
+            f for f in (
+                line.strip().partition(" > ")[0]
+                for line in out.splitlines()
+                if " > " in line
+            )
+            if self.project.override_for(f)
+        })
+        if not reached:
+            return GateResult(ok=True)
+        return GateResult(ok=False, output=(
+            "the default config's discovery reaches files an override owns, so"
+            " suite runs would observe them without the override's command/env:"
+            f" {', '.join(reached[:5])}. Exclude them from the default vitest"
+            " config (test.exclude) or scope its include globs."
+        ))
+
     def collect(self) -> Collection:
         result = Collection()
         for path in self._test_files():

{tdd_cli-0.2.0 → tdd_cli-0.2.1}/src/tddcli/cli.py

@@ -275,6 +275,16 @@ def cmd_doctor(args) -> Envelope:
         gate = adapter.collectable()
         check("collectable", gate.ok, gate.output, project=name)
 
+        # R7.13's premise — "files the default runner config cannot reach" — is
+        # a config property nothing else enforces. Probe it at preflight so the
+        # overlap is named here, not discovered as an opaque mid-cycle failure.
+        if project.overrides:
+            gate = adapter.override_isolation()
+            check(
+                "default suite cannot reach override files",
+                gate.ok, gate.output, project=name,
+            )
+
         projects[name] = {"ok": all(c["ok"] for c in checks[before:])}
 
     for art in cfg.artifacts.values():

{tdd_cli-0.2.0 → tdd_cli-0.2.1}/tests/test_doctor_attribution.py

@@ -73,3 +73,46 @@ def test_doctor_does_not_check_node_modules_for_a_pytest_project(repo_multi):
     backend_checks = [c for c in checks if c.get("project") == "backend"]
     assert backend_checks, checks
     assert not any(c["check"] == "node_modules present" for c in backend_checks), backend_checks
+
+
+def test_doctor_flags_a_default_suite_that_reaches_override_files(repo):
+    """R7.13's premise — "files the default runner config cannot reach" — is a
+    config property nothing else enforces. With a bare `pytest` default, its own
+    discovery sweeps the override directory, and every run would observe those
+    tests without the override's command/env. Doctor must name the overlap at
+    preflight instead of leaving it to fail opaquely mid-cycle."""
+    (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'
+        "[[project.backend.override]]\n"
+        'pattern      = "contract/"\n'
+        'test_command = "pytest contract"\n'
+    )
+    out = run_cli(repo, "doctor")
+    isolation = [
+        c for c in out["result"]["checks"]
+        if c["check"] == "default suite cannot reach override files"
+    ]
+    assert len(isolation) == 1
+    assert isolation[0]["ok"] is False
+    assert isolation[0]["project"] == "backend"
+    assert "contract/test_api.py" in isolation[0]["detail"]
+
+    scoped = (repo / "tdd.toml").read_text().replace(
+        'test_paths = ["tests/"]\n',
+        'test_paths = ["tests/"]\ntest_command = "pytest tests"\n',
+    )
+    (repo / "tdd.toml").write_text(scoped)
+    out = run_cli(repo, "doctor")
+    isolation = [
+        c for c in out["result"]["checks"]
+        if c["check"] == "default suite cannot reach override files"
+    ]
+    assert len(isolation) == 1
+    assert isolation[0]["ok"] is True

{tdd_cli-0.2.0 → tdd_cli-0.2.1}/tests/test_suite_overrides.py

@@ -404,3 +404,182 @@ def test_a_cycle_can_target_a_test_only_an_override_suite_reaches(repo):
     )
     green = run_cli(repo, "advance")
     assert green["next_action"]["verb"] == "refactor_or_advance", green
+
+
+# -- overlap between the default suite and an override suite -------------
+#
+# The feature's premise is "files the default runner config cannot reach". A
+# bare default command (plain `pytest`) quietly breaks that premise: its own
+# discovery sweeps the override directories, the union then holds the same test
+# twice — once observed without the override's command/env — and target
+# matching judged the target by whichever suite reported it first. That failure
+# is opaque (the test fails on some downstream assertion, nothing names the
+# overlap), so it must be a loud typed error instead.
+
+
+def test_pytest_duplicate_nodeid_across_suites_is_a_loud_error(
+    tmp_path, monkeypatch
+):
+    project = project_with(
+        tmp_path, 'test_command = "pytest"\n' + OVERRIDE_BLOCK
+    )
+    adapter = adapters.build(project, tmp_path)
+    duplicated = {
+        "nodeid": "contract/test_api.py::test_ping",
+        "outcome": "failed",
+        "call": {"longrepr": "assert None == '1'"},
+    }
+    monkeypatch.setattr(
+        adapters.base,
+        "run_command",
+        _fake_pytest_run(
+            {
+                # Bare default discovery sweeps contract/ too.
+                "pytest --json-report": {"duration": 1.0, "tests": [duplicated]},
+                "pytest contract": {
+                    "duration": 2.0,
+                    "tests": [dict(duplicated, outcome="passed")],
+                },
+            },
+            [],
+        ),
+    )
+    verdict = adapter.run("backend::contract/test_api.py::test_ping")
+    assert verdict.error is not None
+    assert "contract/test_api.py::test_ping" in verdict.error
+    assert "more than one suite" in verdict.error
+    assert "test_command" in verdict.error
+
+
+def test_vitest_duplicate_test_id_across_suites_is_a_loud_error(
+    tmp_path, monkeypatch
+):
+    project = project_with(
+        tmp_path,
+        'test_command = "npx vitest run"\n'
+        "[[project.backend.override]]\n"
+        'pattern         = "contract/"\n'
+        'test_command    = "npx vitest run --config vitest.contract.config.ts"\n'
+        'collect_command = "npx vitest list --config vitest.contract.config.ts"\n',
+        adapter="vitest",
+    )
+    adapter = adapters.build(project, tmp_path)
+    suite_path = str(tmp_path / "backend" / "contract" / "api.test.ts")
+
+    def result(status):
+        return {
+            "testResults": [
+                {
+                    "name": suite_path,
+                    "status": status,
+                    "assertionResults": [
+                        {"fullName": "pings", "status": status}
+                    ],
+                }
+            ]
+        }
+
+    def fake(command, cwd, timeout=1800, extra_env=None):
+        if "--config" in command:
+            return 0, json.dumps(result("passed")), ""
+        return 1, json.dumps(result("failed")), ""
+
+    monkeypatch.setattr(adapters.base, "run_command", fake)
+    verdict = adapter.run("backend::backend/contract/api.test.ts > pings")
+    assert verdict.error is not None
+    assert "backend/contract/api.test.ts > pings" in verdict.error
+    assert "more than one suite" in verdict.error
+
+
+def test_pytest_isolation_probe_flags_default_reach_into_override_files(
+    tmp_path, monkeypatch
+):
+    project = project_with(
+        tmp_path, 'test_command = "pytest -n {workers}"\n' + OVERRIDE_BLOCK
+    )
+    adapter = adapters.build(project, tmp_path)
+    seen: list = []
+
+    def fake(command, cwd, timeout=1800, extra_env=None):
+        seen.append(command)
+        return 0, (
+            "tests/test_a.py::test_a\n"
+            "contract/test_api.py::test_ping\n"
+            "2 tests collected in 0.01s\n"
+        ), ""
+
+    monkeypatch.setattr(adapters.pytest_adapter, "run_command", fake)
+    gate = adapter.override_isolation()
+    assert gate.ok is False
+    assert "contract/test_api.py" in gate.output
+    assert "test_command" in gate.output
+    # The probe asks the *test* command what it would discover — that is the
+    # command whose reach matters at run time — with parallelism disabled.
+    assert seen == ["pytest -n 0 --collect-only -q"]
+
+
+def test_pytest_isolation_probe_passes_when_the_default_suite_is_scoped(
+    tmp_path, monkeypatch
+):
+    project = project_with(
+        tmp_path, 'test_command = "pytest tests"\n' + OVERRIDE_BLOCK
+    )
+    adapter = adapters.build(project, tmp_path)
+    monkeypatch.setattr(
+        adapters.pytest_adapter,
+        "run_command",
+        lambda command, cwd, timeout=1800, extra_env=None: (
+            0, "tests/test_a.py::test_a\n", ""
+        ),
+    )
+    gate = adapter.override_isolation()
+    assert gate.ok is True
+
+
+def test_vitest_isolation_probe_flags_default_reach_into_override_files(
+    tmp_path, monkeypatch
+):
+    project = project_with(
+        tmp_path,
+        "[[project.backend.override]]\n"
+        'pattern         = "contract/"\n'
+        'test_command    = "npx vitest run --config vitest.contract.config.ts"\n'
+        'collect_command = "npx vitest list --config vitest.contract.config.ts"\n',
+        adapter="vitest",
+    )
+    adapter = adapters.build(project, tmp_path)
+    seen: list = []
+
+    def fake(command, cwd, timeout=1800, extra_env=None):
+        seen.append(command)
+        return 0, (
+            "src/__tests__/a.test.ts > adds\n"
+            "contract/api.test.ts > pings\n"
+        ), ""
+
+    monkeypatch.setattr(adapters.vitest_adapter, "run_command", fake)
+    gate = adapter.override_isolation()
+    assert gate.ok is False
+    assert "contract/api.test.ts" in gate.output
+    assert seen == ["npx vitest list"]
+
+
+def test_isolation_probe_is_free_when_a_project_declares_no_overrides(
+    tmp_path, monkeypatch
+):
+    project = project_with(tmp_path, 'test_command = "pytest tests"\n')
+    adapter = adapters.build(project, tmp_path)
+
+    def explode(command, cwd, timeout=1800, extra_env=None):
+        raise AssertionError("no probe should run without overrides")
+
+    monkeypatch.setattr(adapters.pytest_adapter, "run_command", explode)
+    assert adapter.override_isolation().ok is True
+
+
+def test_overlap_error_truncates_past_five_ids():
+    ids = [f"contract/test_api.py::test_{i}" for i in range(7)]
+    message = adapters.base._overlap_error(ids)
+    assert "test_4" in message and "test_5" not in message
+    assert "and 2 more" in message
+    assert "test_command" in message