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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.90.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.90.0 → codd_dev-2.92.0}/codd/__init__.py

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

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

@@ -7600,7 +7600,7 @@ def _load_optional_project_config(project_root: Path) -> dict[str, Any]:
         return {}
 
 
-def _intake_stack_contract_for_verify(project_root: Path) -> None:
+def _intake_stack_contract_for_verify(project_root: Path, *, stack_command_executor=None) -> None:
     """Resolve the project's declared stack contract into the verify run trace.
 
     Contract Kernel v2.77a (intake only) — the verify-path mirror of the greenfield
@@ -7609,6 +7609,11 @@ def _intake_stack_contract_for_verify(project_root: Path) -> None:
     the run trace), WITHOUT enforcing any obligation or changing the verify verdict
     (obligation enforcement is v2.77b-e).
 
+    ``stack_command_executor`` is the v2.77c materialization seam (default: the real
+    subprocess executor): an injectable executor that invokes each composed stack
+    command slot (exit-code only). Tests pass a recording/sentinel executor so the
+    declared slots are provably invoked without real Next.js/Playwright.
+
     * No ``stack:`` block → no-op (the opt-in framework layer is unused; the vast
       majority of projects — emits a single trace line, no behaviour change).
     * A declared stack → its ``stack_contract_hash`` is echoed to the run trace.
@@ -7658,6 +7663,40 @@ def _intake_stack_contract_for_verify(project_root: Path) -> None:
     if gate.red:
         raise SystemExit(1)
 
+    # 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
+    # already refuses a silent last-wins merge by recording a Conflict; this makes it
+    # 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). (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,
+        materialize_stack_command_plan,
+    )
+
+    try:
+        plan, _result = materialize_stack_command_plan(
+            contract, project_root, executor=stack_command_executor
+        )
+    except (
+        StackContractConflictError,
+        StackCommandMaterializationError,
+        StackCommandAuthenticityError,
+    ) as exc:
+        click.echo(f"[verify] stack command materialization: {exc}", err=True)
+        raise SystemExit(1) from exc
+    click.echo(
+        f"[verify] stack command materialization: {len(plan.slots)} slot(s) invoked "
+        f"({', '.join(plan.command_ids)})"
+    )
+
 
 def _run_verify_once(
     path: str,

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

@@ -313,6 +313,11 @@ CiScaffoldRunner = Callable[..., str]
 PropagateRunner = Callable[..., str]
 CheckRunner = Callable[[Path], str]
 Notifier = Callable[[str, str], bool]
+#: Injectable seam for the v2.77c stack-command materialization executor (a slot →
+#: exit-code outcome). Default (None) uses the real subprocess executor in
+#: ``codd.stack.command_plan``; tests inject a recording/sentinel executor so the
+#: declared stack command slots are provably invoked without real Next.js/Playwright.
+StackCommandExecutor = Callable[..., Any]
 
 
 class GreenfieldPipeline:
@@ -351,6 +356,7 @@ class GreenfieldPipeline:
         propagate_runner: PropagateRunner | None = None,
         check_runner: CheckRunner | None = None,
         notifier: Notifier | None = None,
+        stack_command_executor: StackCommandExecutor | None = None,
         echo: Callable[[str], None] = print,
     ) -> None:
         self.project_name = project_name
@@ -380,6 +386,7 @@ class GreenfieldPipeline:
         self.propagate_runner = propagate_runner
         self.check_runner = check_runner
         self.notifier = notifier
+        self.stack_command_executor = stack_command_executor
         self.echo = echo
 
     def _restore_session_options(self, session: dict[str, Any]) -> None:
@@ -500,6 +507,32 @@ class GreenfieldPipeline:
                 {"status": STATUS_PENDING, "detail": ""}, str(exc),
             )
 
+        # Stack command MATERIALIZATION (Contract Kernel v2.77c) — connect the
+        # composed stack commands (and thus the stack obligations) to the run's
+        # ACTUAL verify/build/test command plan. Two parts (both RED-routed through
+        # _fail, like intake/lock):
+        #   1. CONFLICT GATE — a composition conflict (command collision / unproved
+        #      replace / weakened obligation / exclusive / deny) is RED. The composer
+        #      already records these (it refuses last-wins); this makes that a gate.
+        #   2. PLAN + EXECUTE — build a deterministic, contract-driven command plan
+        #      from contract.commands (NO framework literal) and INVOKE each slot by
+        #      exit code, so a declared framework_build/e2e_test is genuinely run (not
+        #      silently skipped while the language verify greens alone — the false
+        #      green this step closes). Exit-code ONLY here; command AUTHENTICITY
+        #      (no-op/"build":"true"/observed-no-tests) is v2.77d and the obligation-
+        #      checker gate is v2.77e — both deliberately out of lane.
+        # Only for stack-declared projects (contract is not None) — a non-stack run
+        # never reaches here, so it is byte-identical (no plan, no execution, no new
+        # trace keys).
+        try:
+            if contract is not None:
+                self._materialize_stack_commands(project_root, session, contract)
+        except StageError as exc:
+            return self._fail(
+                project_root, session, options, "stack_commands",
+                {"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,
@@ -667,6 +700,62 @@ class GreenfieldPipeline:
         if gate.red:
             raise StageError(gate.message)
 
+    # ── stack command materialization (Contract Kernel v2.77c) ──
+
+    def _materialize_stack_commands(self, project_root: Path, session: dict[str, Any], contract) -> None:
+        """Conflict-gate + materialize the composed stack commands into the run plan (v2.77c).
+
+        See the call site in :meth:`run`. Only invoked for stack-declared projects.
+
+        1. CONFLICT GATE — :func:`assert_stack_contract_clean` (inside
+           :func:`stack_command_plan`) raises :class:`StackContractConflictError` on
+           ANY composition conflict (command collision / unproved replace / weakened
+           obligation / exclusive / deny). That is RED — the composer already refuses
+           a silent last-wins merge by recording a ``Conflict``; this makes it a gate.
+        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`.
+        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/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 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,
+            materialize_stack_command_plan,
+        )
+
+        try:
+            plan, result = materialize_stack_command_plan(
+                contract, project_root, executor=self.stack_command_executor
+            )
+        except (
+            StackContractConflictError,
+            StackCommandMaterializationError,
+            StackCommandAuthenticityError,
+        ) as exc:
+            self.echo(f"[greenfield] stack command materialization: {exc}")
+            raise StageError(str(exc)) from exc
+
+        record = session.get("stack_contract")
+        if isinstance(record, dict):
+            record["stack_command_plan"] = plan.to_record()
+            record["stack_commands_executed"] = list(result.executed_slot_ids)
+        self.echo(
+            "[greenfield] stack command materialization: "
+            f"{len(plan.slots)} slot(s) invoked ({', '.join(plan.command_ids)})"
+        )
+
     # ── option resolution ───────────────────────────────────
 
     def _resolve_options(self, project_root: Path) -> dict[str, Any]:

{codd_dev-2.90.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.90.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)