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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.91.0
+Version: 2.93.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.93.0}/codd/__init__.py

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

{codd_dev-2.91.0 → codd_dev-2.93.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(
@@ -7691,6 +7697,28 @@ def _intake_stack_contract_for_verify(project_root: Path, *, stack_command_execu
         f"({', '.join(plan.command_ids)})"
     )
 
+    # Stack obligation CHECKER gate (Contract Kernel v2.77e) — the verify-path mirror of
+    # the greenfield pipeline's :meth:`GreenfieldPipeline._enforce_stack_obligations`.
+    # AFTER materialization (v2.77c) + authenticity (v2.77d), CHECK the composed
+    # framework/addon OBLIGATIONS as a red/green gate: the Next.js ignoreBuildErrors guard
+    # reds a build that would pass with type errors; the Playwright e2e_actually_executed
+    # obligation reds a 0-test run. Anti-false-green: a missing/disabled/faulting checker
+    # or an unenforceable ERROR obligation is RED (honest non-zero exit), never a silent
+    # pass. Uses the ALREADY-RESOLVED ``contract`` from intake (no re-resolution from disk
+    # — avoids a TOCTOU skip) and the SAME current-run evidence the authenticity layer
+    # blessed. A non-stack project never reaches here (byte-identical).
+    from codd.stack.project import StackObligationGateError, enforce_stack_obligation_gate
+
+    try:
+        enforce_stack_obligation_gate(contract, project_root)
+    except StackObligationGateError as exc:
+        click.echo(f"[verify] stack obligation gate: {exc}", err=True)
+        raise SystemExit(1) from exc
+    click.echo(
+        f"[verify] stack obligation gate: {len(contract.obligations)} obligation(s) checked "
+        "— all enforced obligations satisfied"
+    )
+
 
 def _run_verify_once(
     path: str,

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

@@ -533,6 +533,26 @@ class GreenfieldPipeline:
                 {"status": STATUS_PENDING, "detail": ""}, str(exc),
             )
 
+        # Stack obligation CHECKER gate (Contract Kernel v2.77e) — turn the framework/
+        # addon OBLIGATIONS into a red/green gate, AFTER materialization+authenticity. The
+        # composed commands now run (v2.77c) and are authentic (v2.77d); this CHECKS the
+        # declared obligations (the Next.js ignoreBuildErrors guard reds a build that would
+        # pass with type errors; the Playwright e2e_actually_executed obligation reds a
+        # 0-test run). Anti-false-green: a missing/disabled/faulting checker or an
+        # unenforceable ERROR obligation is RED, never a silent pass. Uses the ALREADY-
+        # RESOLVED contract (no re-resolution from disk — avoids a TOCTOU skip) and the
+        # SAME current-run evidence the authenticity layer blessed. Only for stack-declared
+        # projects (contract is not None) — a non-stack run is byte-identical (no gate).
+        # Routed through _fail like intake/lock/materialization.
+        try:
+            if contract is not None:
+                self._enforce_stack_obligations(project_root, session, contract)
+        except StageError as exc:
+            return self._fail(
+                project_root, session, options, "stack_obligations",
+                {"status": STATUS_PENDING, "detail": ""}, str(exc),
+            )
+
         runners: dict[str, Callable[[Path, dict[str, Any], dict[str, Any]], None]] = {
             "init": self._stage_init,
             "elicit": self._stage_elicit,
@@ -715,15 +735,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 +759,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
 
@@ -747,6 +776,45 @@ class GreenfieldPipeline:
             f"{len(plan.slots)} slot(s) invoked ({', '.join(plan.command_ids)})"
         )
 
+    # ── stack obligation checker gate (Contract Kernel v2.77e) ──
+
+    def _enforce_stack_obligations(self, project_root: Path, session: dict[str, Any], contract) -> None:
+        """Run the composed stack obligation checkers as a red/green gate (v2.77e).
+
+        See the call site in :meth:`run`. Only invoked for stack-declared projects
+        (``contract is not None``); non-stack projects never reach here, so they are
+        byte-identical (no obligation gate at all).
+
+        Uses the ALREADY-RESOLVED ``contract`` (passed in from intake/lock/
+        materialization) — NOT a re-resolution from disk — so a stack file that changes
+        or is deleted after materialization cannot make this gate silently skip (a
+        TOCTOU false-green). :func:`enforce_stack_obligation_gate` invokes every
+        obligation's registered checker with ``project_root`` plus the current-run
+        evidence (the SAME e2e report the authenticity layer blessed), and raises
+        :class:`StackObligationGateError` unless every ERROR obligation was genuinely
+        enforced AND satisfied: a blocking violation, an unenforced ERROR obligation
+        (no registered checker — unverifiable), or a checker fault (raised / None /
+        malformed return) is RED. Translated to :class:`StageError` so the autopilot
+        reports it honestly via ``_fail``. The per-obligation verdict counts are
+        recorded in the run trace (observable, like the lock verdict + command plan).
+        """
+        from codd.stack.project import StackObligationGateError, enforce_stack_obligation_gate
+
+        try:
+            result = enforce_stack_obligation_gate(contract, project_root)
+        except StackObligationGateError as exc:
+            self.echo(f"[greenfield] stack obligation gate: {exc}")
+            raise StageError(str(exc)) from exc
+
+        record = session.get("stack_contract")
+        if isinstance(record, dict) and result is not None:
+            record["stack_obligations_checked"] = len(contract.obligations)
+            record["stack_obligations_unenforced"] = [o.id for o in result.unenforced]
+        self.echo(
+            "[greenfield] stack obligation gate: "
+            f"{len(contract.obligations)} obligation(s) checked — all enforced obligations satisfied"
+        )
+
     # ── option resolution ───────────────────────────────────
 
     def _resolve_options(self, project_root: Path) -> dict[str, Any]:

{codd_dev-2.91.0 → codd_dev-2.93.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.93.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)