codd-dev 2.91.0__tar.gz → 2.92.0__tar.gz

{codd_dev-2.91.0 → codd_dev-2.92.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.91.0
+Version: 2.92.0
 Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
 Project-URL: Homepage, https://github.com/yohey-w/codd-dev
 Project-URL: Repository, https://github.com/yohey-w/codd-dev

{codd_dev-2.91.0 → codd_dev-2.92.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.91.0"
+__version__ = "2.92.0"

{codd_dev-2.91.0 → codd_dev-2.92.0}/codd/cli.py

@@ -7663,7 +7663,7 @@ def _intake_stack_contract_for_verify(project_root: Path, *, stack_command_execu
     if gate.red:
         raise SystemExit(1)
 
-    # Stack command MATERIALIZATION (Contract Kernel v2.77c) — the verify-path mirror
+    # Stack command MATERIALIZATION (Contract Kernel v2.77c/d) — the verify-path mirror
     # of the greenfield pipeline's :meth:`_materialize_stack_commands`. (1) CONFLICT
     # GATE: a composition conflict (command collision / unproved replace / weakened
     # obligation / exclusive / deny) is RED (honest non-zero exit) — the composer
@@ -7671,8 +7671,10 @@ def _intake_stack_contract_for_verify(project_root: Path, *, stack_command_execu
     # a gate. (2) PLAN + EXECUTE: build a deterministic, contract-driven command plan
     # (NO framework literal) and INVOKE each composed slot by exit code, so a declared
     # framework_build/e2e_test is genuinely run on verify (not silently skipped while
-    # the language verify greens alone). Exit-code ONLY here; command AUTHENTICITY is
-    # v2.77d and the obligation-checker gate is v2.77e (out of lane).
+    # the language verify greens alone). (3) AUTHENTICITY (v2.77d): exit 0 is necessary
+    # but NOT sufficient — a no-op / observed-no-tests / missing-or-unreadable-report
+    # slot is RED even on exit 0. The obligation-checker gate is v2.77e (out of lane).
+    from codd.stack.command_authenticity import StackCommandAuthenticityError
     from codd.stack.command_plan import (
         StackCommandMaterializationError,
         StackContractConflictError,
@@ -7683,7 +7685,11 @@ def _intake_stack_contract_for_verify(project_root: Path, *, stack_command_execu
         plan, _result = materialize_stack_command_plan(
             contract, project_root, executor=stack_command_executor
         )
-    except (StackContractConflictError, StackCommandMaterializationError) as exc:
+    except (
+        StackContractConflictError,
+        StackCommandMaterializationError,
+        StackCommandAuthenticityError,
+    ) as exc:
         click.echo(f"[verify] stack command materialization: {exc}", err=True)
         raise SystemExit(1) from exc
     click.echo(

{codd_dev-2.91.0 → codd_dev-2.92.0}/codd/greenfield/pipeline.py

@@ -715,15 +715,20 @@ class GreenfieldPipeline:
         2. MATERIALIZE — build a deterministic, contract-driven command plan and
            INVOKE each composed slot by exit code (via the injectable
            ``stack_command_executor`` seam). A failing slot raises
-           :class:`StackCommandMaterializationError`. Both domain errors become a
+           :class:`StackCommandMaterializationError`.
+        3. AUTHENTICITY (v2.77d) — exit 0 is necessary but NOT sufficient: each slot
+           must prove it did its job for its kind (a no-op / observed-no-tests /
+           missing-or-unreadable-report command is RED even on exit 0), raising
+           :class:`StackCommandAuthenticityError`. All three domain errors become a
            :class:`StageError` so the autopilot reports them honestly (the run does
-           NOT advance to the stage loop with a conflicted/failing stack plan).
+           NOT advance to the stage loop with a conflicted/failing/inauthentic plan).
 
         The materialized plan + executed slot ids are recorded in the run trace
         (observable, like the intake hash + lock verdict) so "the declared stack
-        command slots were invoked" is provable. Exit-code only — authenticity is
-        v2.77d, the obligation-checker gate is v2.77e.
+        command slots were invoked AND authentic" is provable. The obligation-checker
+        gate (``verify_project_stack``) is v2.77e (out of lane here).
         """
+        from codd.stack.command_authenticity import StackCommandAuthenticityError
         from codd.stack.command_plan import (
             StackCommandMaterializationError,
             StackContractConflictError,
@@ -734,7 +739,11 @@ class GreenfieldPipeline:
             plan, result = materialize_stack_command_plan(
                 contract, project_root, executor=self.stack_command_executor
             )
-        except (StackContractConflictError, StackCommandMaterializationError) as exc:
+        except (
+            StackContractConflictError,
+            StackCommandMaterializationError,
+            StackCommandAuthenticityError,
+        ) as exc:
             self.echo(f"[greenfield] stack command materialization: {exc}")
             raise StageError(str(exc)) from exc
 

{codd_dev-2.91.0 → codd_dev-2.92.0}/codd/languages/adapters/runner_report.py

@@ -194,6 +194,151 @@ class VitestJsonReportAdapter:
         )
 
 
+@dataclass(frozen=True)
+class PlaywrightJsonReportAdapter:
+    """Playwright ``--reporter=json`` adapter (the stack ``playwright_json`` report).
+
+    ``npx playwright test --reporter=json`` emits a single top-level object whose
+    ``suites`` array is a TREE: each suite has nested ``suites`` and ``specs``; each
+    *spec* carries a ``title``, a ``file`` (project-relative test file), and a
+    ``tests`` array; each *test* carries ``results`` (one per retry/attempt) and an
+    overall ``status`` (Playwright's roll-up: ``expected`` / ``unexpected`` /
+    ``flaky`` / ``skipped``). A test is a clean PASS only when its overall status is
+    ``expected``; ``unexpected`` (a failure), ``flaky`` (passed only on retry — not a
+    clean first-run pass) and ``skipped`` (a skip proves nothing — the SAME rule the
+    vitest/go adapters and the static authenticity gate apply) are NOT clean. A spec's
+    FILE is in ``executed_passed_files`` only when it ran ≥1 test and EVERY test in it
+    was clean; any non-clean test taints the whole file into ``executed_failed_files``.
+
+    Mirrors :class:`VitestJsonReportAdapter`'s contract exactly: it raises
+    :class:`RunnerReportUnsupported` on a structurally-unreadable report (missing /
+    garbled / not an object / no ``suites`` array) so the authenticity gate degrades
+    EXPLICITLY (REPORT_UNREADABLE), never silently treating "nothing parseable" as
+    "nothing ran" (a false-green). ``test_level_available`` is True whenever any test
+    case was observed, so a TEST-kind stack command can require test-level evidence.
+    """
+
+    def parse(self, report_path: Path, *, project_root: Path) -> RunnerExecution:
+        try:
+            payload = json.loads(report_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as exc:
+            raise RunnerReportUnsupported(
+                f"playwright JSON report unreadable at {report_path}: {exc}"
+            ) from exc
+        if not isinstance(payload, dict):
+            raise RunnerReportUnsupported(
+                f"playwright JSON report at {report_path} is not an object"
+            )
+        suites = payload.get("suites")
+        if not isinstance(suites, list):
+            raise RunnerReportUnsupported(
+                f"playwright JSON report at {report_path} has no suites array"
+            )
+
+        passed_files: set[str] = set()
+        failed_files: set[str] = set()
+        passed_cases: set[str] = set()
+        # Per-file rollup: did the file collect any case, and is every case clean?
+        file_any_case: dict[str, bool] = {}
+        file_clean: dict[str, bool] = {}
+        total_cases = 0
+        passed_count = 0
+
+        for spec in _iter_playwright_specs(suites):
+            rel = _relativize(str(spec.get("file") or ""), project_root)
+            if rel is None:
+                continue
+            spec_title = str(spec.get("title") or "").strip()
+            tests = spec.get("tests")
+            tests = tests if isinstance(tests, list) else []
+            file_any_case.setdefault(rel, False)
+            file_clean.setdefault(rel, True)
+            for test in tests:
+                if not isinstance(test, dict):
+                    continue
+                status = str(test.get("status") or "").strip().lower()
+                if not status:
+                    # No roll-up status: fall back to the worst per-result status so a
+                    # malformed test never sneaks in as a clean pass.
+                    status = _playwright_results_status(test.get("results"))
+                if not status:
+                    continue
+                file_any_case[rel] = True
+                total_cases += 1
+                if status == "expected":
+                    passed_count += 1
+                    name = (test.get("title") or spec_title or "").strip()
+                    key = f"{rel}::{name}" if name else rel
+                    passed_cases.add(key)
+                else:
+                    # unexpected / flaky / skipped / timedOut / interrupted — none is a
+                    # clean pass; the whole file is tainted (a skip proves nothing).
+                    file_clean[rel] = False
+
+        for rel, any_case in file_any_case.items():
+            if not any_case:
+                # A spec file that collected zero cases is not a pass (collected nothing).
+                continue
+            if file_clean.get(rel, False):
+                passed_files.add(rel)
+            else:
+                failed_files.add(rel)
+
+        return RunnerExecution(
+            executed_passed_files=frozenset(passed_files),
+            executed_failed_files=frozenset(failed_files),
+            executed_passed_cases=frozenset(passed_cases),
+            test_level_available=total_cases > 0,
+            total_cases=total_cases,
+            passed_cases=passed_count,
+        )
+
+
+def _iter_playwright_specs(suites: list):
+    """Yield every ``spec`` mapping in a Playwright suite TREE (recursive).
+
+    Playwright nests ``suites`` arbitrarily (file suite → describe blocks → …); each
+    level may carry ``specs`` and further ``suites``. We walk the whole tree so a test
+    nested under any number of ``describe`` blocks is still observed.
+    """
+    stack = list(suites)
+    while stack:
+        node = stack.pop()
+        if not isinstance(node, dict):
+            continue
+        specs = node.get("specs")
+        if isinstance(specs, list):
+            for spec in specs:
+                if isinstance(spec, dict):
+                    yield spec
+        child_suites = node.get("suites")
+        if isinstance(child_suites, list):
+            stack.extend(child_suites)
+
+
+def _playwright_results_status(results: Any) -> str:
+    """Worst-case status across a test's ``results`` (retries), Playwright vocabulary.
+
+    Used only as a fallback when a test omits its roll-up ``status``. Any non-passed
+    result (``failed`` / ``timedOut`` / ``interrupted``) makes the test non-clean; a
+    ``skipped`` result is non-clean too; all ``passed`` ⇒ ``expected``. Returns ``""``
+    when there is nothing to judge.
+    """
+    if not isinstance(results, list):
+        return ""
+    seen = False
+    for res in results:
+        if not isinstance(res, dict):
+            continue
+        status = str(res.get("status") or "").strip().lower()
+        if not status:
+            continue
+        seen = True
+        if status != "passed":
+            return "unexpected"
+    return "expected" if seen else ""
+
+
 @dataclass(frozen=True)
 class GoTestJsonReportAdapter:
     """``go test -json`` (line-delimited JSON) reporter adapter.

{codd_dev-2.91.0 → codd_dev-2.92.0}/codd/languages/builtin_adapters.py

@@ -77,11 +77,17 @@ def ensure_builtin_adapters_registered(registry: AdapterRegistry | None = None)
     # import time, so codd.languages stays free of an adapter/coverage import cycle.
     from codd.languages.adapters.runner_report import (
         GoTestJsonReportAdapter,
+        PlaywrightJsonReportAdapter,
         VitestJsonReportAdapter,
     )
 
     _register_once(target, "runner_report", "vitest-json", VitestJsonReportAdapter())
     _register_once(target, "runner_report", "go-test-json", GoTestJsonReportAdapter())
+    # Stack e2e: the Playwright addon declares ``report.adapter: playwright_json`` —
+    # register under that EXACT id so a TEST-kind stack command's required report has a
+    # resolvable adapter (an unregistered adapter for a required report is RED, never a
+    # silent skip; v2.77d authenticity). Underscore spelling matches the profile.
+    _register_once(target, "runner_report", "playwright_json", PlaywrightJsonReportAdapter())
 
     # Implement-oracle tool-semantics adapters (Contract Kernel oracle dispatch §3).
     # All three concrete adapters (go-toolchain / python-composite / typescript-tsc)