codd-dev 2.42.0__tar.gz → 2.44.0__tar.gz

{codd_dev-2.42.0 → codd_dev-2.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.42.0
+Version: 2.44.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.42.0 → codd_dev-2.44.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.42.0"
+__version__ = "2.44.0"

{codd_dev-2.42.0 → codd_dev-2.44.0}/codd/repair/verify_runner.py

@@ -265,6 +265,11 @@ class VerifyRunner:
                 results.append(_runtime_result(node.id, template_ref, False, "verification template is not registered"))
                 continue
 
+            toolchain_error = _runtime_toolchain_failure(template_ref, self.project_root)
+            if toolchain_error:
+                results.append(_runtime_result(node.id, template_ref, False, toolchain_error))
+                continue
+
             template_config = template_settings.get(template_ref, {})
             try:
                 template = _new_template(template_cls, template_config, per_node_seconds=per_node_seconds)
@@ -969,6 +974,40 @@ def _runtime_result(node_id: str, template_ref: str, passed: bool, output: str)
     }
 
 
+#: Verification templates whose runner needs a node/npm toolchain (a
+#: ``package.json`` + installed ``node_modules``). The toolchain-coherence
+#: preflight uses this to turn a cryptic runtime ``Cannot find module`` into an
+#: explicit, attributable CoDD contract failure.
+_NODE_VERIFICATION_TEMPLATES = frozenset({"playwright", "vitest"})
+
+
+def _runtime_toolchain_failure(template_ref: str, project_root: Path) -> str | None:
+    """Preflight: a node test harness needs a node manifest to be runnable.
+
+    When a generated verification node names a node/Playwright harness but the
+    project has no ``package.json``, the runner would execute ``npx playwright``
+    (or ``vitest``) and fail with a cryptic ``Cannot find module
+    '@playwright/test'`` at runtime — a failure that looks like, but is not, a
+    source-code defect. Convert it into an explicit CoDD contract failure BEFORE
+    running, so it is attributable.
+
+    This is anti-cryptic-failure, NOT anti-false-green: the run was already
+    honest-failing. The gate only ever rewrites the *message* of an existing
+    red; it never turns a red green, and it never fires when the toolchain IS
+    present (``package.json`` exists) so node/TS projects are unaffected.
+    """
+    if template_ref in _NODE_VERIFICATION_TEMPLATES:
+        if not (project_root / "package.json").is_file():
+            return (
+                "verification template requires a node test harness "
+                f"('{template_ref}') but no package.json exists at the project root. "
+                "Either select a language-native E2E harness for this project, or "
+                "provision a harness-owned node manifest declaring the test toolchain "
+                "(e.g. @playwright/test)."
+            )
+    return None
+
+
 def _skipped_result(node_id: str, reason: str) -> dict[str, Any]:
     if reason == "verification-test":
         output = "Skipped: verification-test by user request"

{codd_dev-2.42.0 → codd_dev-2.44.0}/codd/vb_marker_authenticity.py

@@ -79,6 +79,7 @@ evidence (the design's "unresolved helper = fail" rule).
 
 from __future__ import annotations
 
+import ast
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -1501,24 +1502,62 @@ def _ts_reexport_edges(module_text: str, symbol: str) -> list[tuple[str, str]]:
 
 # ── Python resolution ───────────────────────────────────────────────────────
 
-#: ``from pkg.mod import a, b as c`` / ``from .mod import x``.
-_PY_FROM_IMPORT_RE = re.compile(
-    r"^[ \t]*from\s+(?P<mod>[.\w]+)\s+import\s+(?P<names>[^\n#]+)", re.MULTILINE
-)
+#: ``from pkg.mod import a, b as c`` / ``from .mod import x`` — one top-level binding.
+@dataclass(frozen=True)
+class _PyFromImport:
+    mod: str
+    names: tuple[tuple[str, str], ...]  # (original, local)
+
+
+def _iter_py_from_imports(module_text: str) -> list[_PyFromImport]:
+    """TOP-LEVEL Python ``from X import ...`` bindings, parsed via ``ast.ImportFrom``.
+
+    Using Python's own parser (not a regex) makes parenthesized MULTI-LINE imports,
+    backslash continuations, aliases, inline comments, and ``*`` all parse by
+    SYNTAX. The previous regex (``names=[^\\n#]+``) truncated the load-bearing
+    ``from tests.e2e.helpers import (\\n  a,\\n  b,\\n)`` package-barrel form to
+    ``(`` — so a marker's assert-helper went unresolved and was wrongly reported
+    ``no_assertion`` (a false-RED that blocked Python greenfield;
+    ``PC-assertion-helper-package-barrel-falsered``). TOP-LEVEL only: a
+    function-local import is NOT a module binding (a broader ``ast.walk`` could
+    misattribute a local import and admit a false-green). A file that does not
+    parse degrades to ``[]`` (the compile layer owns SyntaxErrors; never raise).
+    """
+
+    try:
+        tree = ast.parse(module_text)
+    except (SyntaxError, ValueError):
+        return []
+    out: list[_PyFromImport] = []
+    for node in tree.body:
+        if not isinstance(node, ast.ImportFrom):
+            continue
+        mod = "." * int(node.level or 0) + (node.module or "")
+        if not mod:
+            continue
+        out.append(
+            _PyFromImport(
+                mod=mod,
+                names=tuple(
+                    (alias.name, alias.asname or alias.name) for alias in node.names
+                ),
+            )
+        )
+    return out
 
 
 def _py_imported_module(importer_text: str, symbol: str) -> str | None:
     """The module path a ``from <mod> import <symbol>`` binds ``symbol`` from."""
 
-    for match in _PY_FROM_IMPORT_RE.finditer(importer_text):
-        names = match.group("names")
-        for raw in names.replace("(", " ").replace(")", " ").split(","):
-            name = raw.strip()
-            if not name:
-                continue
-            local = name.split(" as ")[-1].strip()
+    for item in _iter_py_from_imports(importer_text):
+        for original, local in item.names:
             if local == symbol:
-                return match.group("mod")
+                return item.mod
+            # ``from helpers import *`` may bind the symbol; the downstream
+            # resolver still requires a real def/re-export + assertion evidence,
+            # so admitting the star here never passes on its own.
+            if original == "*":
+                return item.mod
     return None
 
 
@@ -1538,21 +1577,14 @@ def _py_reexport_edges(module_text: str, symbol: str) -> list[tuple[str, str]]:
     """
 
     edges: list[tuple[str, str]] = []
-    for match in _PY_FROM_IMPORT_RE.finditer(module_text):
-        mod = match.group("mod")
+    for item in _iter_py_from_imports(module_text):
+        mod = item.mod
         if not mod.startswith("."):
             continue
-        names = match.group("names")
-        for raw in names.replace("(", " ").replace(")", " ").split(","):
-            name = raw.strip()
-            if not name:
-                continue
-            if name == "*":
+        for original, local in item.names:
+            if original == "*":
                 edges.append((mod, symbol))  # star re-export forwards the name
                 continue
-            parts = [p.strip() for p in name.split(" as ")]
-            original = parts[0]
-            local = parts[-1]
             if local == symbol:
                 edges.append((mod, original))
     return edges

{codd_dev-2.42.0 → codd_dev-2.44.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codd-dev"
-version = "2.42.0"
+version = "2.44.0"
 description = "CoDD: Coherence-Driven Development — cross-artifact change impact analysis"
 readme = "README.md"
 license = "MIT"