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

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

@@ -4,6 +4,60 @@ 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.5.1] - 2026-08-17
+
+### Added
+
+- **exec adapter** — exit-code oracles as first-class test suites. Any executable
+  file (or any file paired with a `test_command`) becomes a test: exit 0 → passed,
+  non-zero → failed, stdout+stderr captured as failure output. Non-executable files
+  without a `test_command` map to `not_collected` rather than `failed`, so a missing
+  executable bit is a configuration error rather than a test failure. Supports a
+  `{file}` placeholder in `test_command` for per-file invocation, with shell-quoting
+  so paths with spaces are handled correctly (#33).
+
+- **xctest adapter** — XCTest/xcodebuild driver for Swift and Objective-C projects.
+  Test ids use xcodebuild's own `-only-testing:` format (`Bundle/Class/method`) so
+  targeted runs compose without translation. A build failure maps to `not_collected`
+  rather than `failed` — Swift has no separate collection phase, so a missing-symbol
+  build error is not the RED state; the discipline is to write a compiling stub first,
+  then observe an assertion failure. Collection tries `xcodebuild test
+  -enumerate-tests` (Xcode 16+) and falls back to grepping Swift source files for
+  `class Foo: XCTestCase` and `func testBar()` patterns. Requires `test_command` in
+  `tdd.toml` so the adapter can append `-only-testing:` and `-enumerate-tests` flags
+  without guessing the scheme or destination (#34).
+
+- **Named exclusive leases** (`lease = "<name>"` on a project or override) — before
+  running a suite the tool acquires an exclusive machine-wide named lease using the
+  same lease-directory machinery as the worker budget. Only one holder machine-wide
+  can hold a given name at a time; a waiting invocation blocks with a `lease_waiting`
+  heartbeat every 5 s rather than silently hanging. Stale locks (pid dead or older
+  than 1 h) are swept immediately so a crash can never permanently block a name.
+  The name is free-form and machine-scoped; two repos naming the same lease
+  intentionally contend, which is the intended semantics for shared physical hardware
+  or a port-bound service (#35).
+
+- **Per-project suite timeouts** (`timeout = <seconds>` on a project or override) —
+  overrides the 1800 s default for suite invocations. `tdd doctor` warns when a
+  configured timeout is shorter than the longest recorded full-suite invocation for
+  that project, so a mis-configuration is caught at preflight rather than at the
+  timeout boundary (#35).
+
+## [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.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tdd-cli
-Version: 0.4.0
+Version: 0.5.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.5.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.5.1"

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

@@ -4,12 +4,16 @@ import importlib.metadata
 from pathlib import Path
 
 from .base import Adapter, Collection, GateResult, Verdict
+from .exec_adapter import ExecAdapter
 from .pytest_adapter import PytestAdapter
 from .vitest_adapter import VitestAdapter
+from .xctest_adapter import XCTestAdapter
 
 REGISTRY: dict[str, type[Adapter]] = {
+    "exec": ExecAdapter,
     "pytest": PytestAdapter,
     "vitest": VitestAdapter,
+    "xctest": XCTestAdapter,
 }
 
 
@@ -39,9 +43,7 @@ def build(project, worktree: Path) -> Adapter:
                 cls = ep.load()
                 break
     if cls is None:
-        raise RuntimeError(
-            f"unknown adapter {project.adapter!r}; available: {sorted(available())}"
-        )
+        raise RuntimeError(f"unknown adapter {project.adapter!r}; available: {sorted(available())}")
     return cls(project, worktree)
 
 

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

@@ -87,7 +87,9 @@ TIMING_ENV = "TDD_TIMING"
 
 
 def run_command(
-    command: str, cwd: Path, timeout: int = 1800,
+    command: str,
+    cwd: Path,
+    timeout: int = 1800,
     extra_env: dict[str, str] | None = None,
     label: str | None = None,
 ) -> tuple[int, str, str]:
@@ -135,13 +137,16 @@ class Adapter:
 
     def strip(self, qualified: str) -> str:
         prefix = f"{self.project.name}::"
-        return qualified[len(prefix):] if qualified.startswith(prefix) else qualified
+        return qualified[len(prefix) :] if qualified.startswith(prefix) else qualified
 
     def run(self, target: str | None = None) -> Verdict:
         raise NotImplementedError
 
     def _run_suite(
-        self, command: str, extra_env: dict[str, str] | None = None
+        self,
+        command: str,
+        extra_env: dict[str, str] | None = None,
+        timeout: int | None = None,
     ) -> tuple[int, str, str]:
         """Run the suite under a machine-wide worker lease.
 
@@ -151,15 +156,32 @@ class Adapter:
         prefer to read the budget themselves. The lease is held for the whole
         invocation so concurrent agents in other worktrees see this one and
         take a smaller share.
+
+        When the project declares `lease`, an exclusive named lease is acquired
+        first (outer context), so only one instance of that suite runs machine-
+        wide at a time. When `timeout` is given it overrides the project-level
+        and default values.
         """
-        with leases.worker_lease() as workers:
+        effective_timeout = timeout or self.project.timeout or 1800
+
+        def _run(workers: int) -> tuple[int, str, str]:
             return run_command(
                 command.replace("{workers}", str(workers)),
                 self.root,
+                timeout=effective_timeout,
                 extra_env={"TDD_WORKERS": str(workers), **(extra_env or {})},
                 label="suite",
             )
 
+        lease_name = getattr(self.project, "lease", None)
+        if lease_name:
+            with leases.named_lease(lease_name):
+                with leases.worker_lease() as workers:
+                    return _run(workers)
+        else:
+            with leases.worker_lease() as workers:
+                return _run(workers)
+
     def _test_cmd(self) -> str:
         raise NotImplementedError
 
@@ -189,6 +211,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.5.1/src/tddcli/adapters/exec_adapter.py

@@ -0,0 +1,173 @@
+"""exec adapter — exit-code oracles as first-class tests (§10).
+
+Each file matching `test_paths` is one test; the verdict is the exit code.
+No output parsing, no runner protocol. Any toolchain can be bootstrapped by
+wrapping its runner in a script before (or instead of) a native adapter
+existing; shell-gate TDD cycles (write a failing check, migrate code until it
+exits 0) use this adapter natively.
+
+Collection is a filesystem walk — no subprocess needed.  A file that is
+matched by `test_paths` but cannot be run (not executable, no `test_command`)
+maps to `not_collected` rather than `failed`, preserving the "a broken oracle
+is not RED" semantics the other adapters uphold via import errors.
+"""
+
+from __future__ import annotations
+
+import os
+import shlex
+import time
+from pathlib import Path
+
+from .base import (
+    FAILED,
+    NOT_COLLECTED,
+    PASSED,
+    Adapter,
+    Collection,
+    GateResult,
+    Verdict,
+    clip_failure,
+    run_command,
+)
+
+
+class ExecAdapter(Adapter):
+    name = "exec"
+
+    def stub_hint(self) -> str:
+        return "a script body that exits non-zero (e.g. `exit 1` with a message explaining what is missing)"
+
+    # ------------------------------------------------------------------
+    # Command resolution
+    # ------------------------------------------------------------------
+
+    def _cmd_for(self, rel: str) -> str:
+        """The shell command that runs one script.
+
+        When `test_command` is set it acts as a template: `{file}` is replaced
+        by the shell-quoted relative path.  Without it the file is invoked
+        directly (requires executable bit and a shebang line).
+        """
+        if self.project.test_command:
+            return self.project.test_command.replace("{file}", shlex.quote(rel))
+        return f"./{rel}"
+
+    def _is_runnable(self, path: Path) -> bool:
+        """True when the file can be executed: either a test_command handles it,
+        or the file itself has the executable bit set."""
+        if self.project.test_command:
+            return True
+        return os.access(path, os.X_OK)
+
+    # ------------------------------------------------------------------
+    # Discovery
+    # ------------------------------------------------------------------
+
+    def _test_files(self) -> list[Path]:
+        found: set[Path] = set()
+        for pattern in self.project.test_patterns or []:
+            if pattern.endswith("/"):
+                base = self.root / pattern
+                if base.is_dir():
+                    for p in base.rglob("*"):
+                        if p.is_file():
+                            found.add(p)
+            else:
+                for p in self.root.glob(pattern):
+                    if p.is_file():
+                        found.add(p)
+        return sorted(found)
+
+    # ------------------------------------------------------------------
+    # Collection — filesystem walk, no subprocess
+    # ------------------------------------------------------------------
+
+    def collect(self) -> Collection:
+        result = Collection()
+        for path in self._test_files():
+            rel = str(path.relative_to(self.root))
+            if self._is_runnable(path):
+                result.tests.add(self.qualify(rel))
+            else:
+                result.failed_files[rel] = (
+                    f"{rel}: not executable and no test_command configured"
+                    ' (chmod +x, or add test_command = "bash {file}" to tdd.toml)'
+                )
+        return result
+
+    # The base collect() calls these three; exec overrides collect() entirely
+    # so they are never reached.  Providing trivial bodies avoids surprises if
+    # a subclass or test calls them directly.
+    def _collect_invocations(self):
+        return []
+
+    def _collect_batch(self, command, env):
+        return None
+
+    def _collect_per_file(self, rels, result):
+        return result
+
+    # ------------------------------------------------------------------
+    # Doctor gate
+    # ------------------------------------------------------------------
+
+    def collectable(self) -> GateResult:
+        """Warn about files that matched test_paths but cannot be run."""
+        if self.project.test_command:
+            return GateResult(ok=True)
+        non_exec = [
+            str(p.relative_to(self.root)) for p in self._test_files() if not os.access(p, os.X_OK)
+        ]
+        if not non_exec:
+            return GateResult(ok=True)
+        listed = "\n".join(non_exec[:10])
+        more = f"\n… and {len(non_exec) - 10} more" if len(non_exec) > 10 else ""
+        return GateResult(
+            ok=False,
+            output=(
+                "these files matched test_paths but are not executable"
+                ' (chmod +x, or set test_command = "bash {file}" in tdd.toml):\n' + listed + more
+            ),
+        )
+
+    # ------------------------------------------------------------------
+    # Suite run
+    # ------------------------------------------------------------------
+
+    def run(self, target: str | None = None) -> Verdict:
+        verdict = Verdict(project=self.project.name, adapter=self.name, target=target)
+        env = self._suite_env(None)
+        started = time.monotonic()
+
+        for path in self._test_files():
+            rel = str(path.relative_to(self.root))
+            qualified = self.qualify(rel)
+
+            # When targeting, skip every other test for speed.
+            if target is not None and qualified != target:
+                continue
+
+            if not self._is_runnable(path):
+                if target == qualified:
+                    verdict.target_outcome = NOT_COLLECTED
+                    verdict.target_failure = f"{rel}: not executable and no test_command configured"
+                continue
+
+            code, out, err = run_command(
+                self._cmd_for(rel), self.root, extra_env=env, label="suite"
+            )
+            combined = (out + "\n" + err).strip()
+
+            if code == 0:
+                verdict.passed.append(qualified)
+                if target == qualified:
+                    verdict.target_outcome = PASSED
+            else:
+                verdict.failed.append(qualified)
+                if target == qualified:
+                    verdict.target_outcome = FAILED
+                    verdict.target_failure = clip_failure(combined)
+
+        verdict.duration_ms = int((time.monotonic() - started) * 1000)
+        return verdict

{tdd_cli-0.4.0 → tdd_cli-0.5.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.5.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)] = (