codd-dev 2.41.0__tar.gz → 2.43.0__tar.gz

{codd_dev-2.41.0 → codd_dev-2.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.41.0
+Version: 2.43.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.41.0 → codd_dev-2.43.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.41.0"
+__version__ = "2.43.0"

{codd_dev-2.41.0 → codd_dev-2.43.0}/codd/greenfield/pipeline.py

@@ -926,16 +926,23 @@ class GreenfieldPipeline:
         self._ensure_test_runner(project_root)
 
         # The path→owning-task index for the SCOPED rerun: declared task outputs
-        # UNION the config-derived output paths. Built once; the gate consults it
-        # to localize each rerun to the diagnostics' owners. The config-derived
-        # paths are resolved ONCE here so the owner-uniqueness gate and the index
-        # see the SAME path set.
+        # UNION the config-derived output paths (incl. the permissive
+        # ``_output_paths_for_task`` fallback so the index knows where to LOOK).
         config_output_paths = self._resolve_oracle_config_output_paths(tasks, config)
         # HARD owner-uniqueness gate (contract artifact.owner.unique.v1): runs
         # BEFORE the index build (and OUTSIDE its best-effort except) so an
         # ambiguous-ownership topology honest-fails deterministically rather than
         # letting the index's first-owner-wins setdefault silently pick a winner.
-        self._certify_output_owner_uniqueness(tasks, config_output_paths)
+        # It reasons over EXCLUSIVE ownership CLAIMS only — declared task outputs
+        # (read internally) + config-DECLARED default_output_paths — NOT the
+        # permissive fallback the index uses. Passing the fallback false-RED's a
+        # NORMAL Python src-layout (source_root nests package_root) whenever ≥2
+        # tasks with no declared output fall to ``_route_source_into_package``'s
+        # ``src`` + ``src/<pkg>`` accept-list (a "may write here", not an exclusive
+        # claim). See ``_resolve_owner_uniqueness_config_paths``.
+        self._certify_output_owner_uniqueness(
+            tasks, self._resolve_owner_uniqueness_config_paths(tasks, config)
+        )
         scope_index = self._build_oracle_scope_index(
             project_root, tasks, config, config_output_paths=config_output_paths
         )
@@ -992,6 +999,42 @@ class GreenfieldPipeline:
                 config_output_paths[task.task_id] = list(task.output_paths or ())
         return config_output_paths
 
+    def _resolve_owner_uniqueness_config_paths(
+        self,
+        tasks: list[ImplementTaskRef],
+        config: dict[str, Any],
+    ) -> dict[str, list[str]]:
+        """Per-task EXCLUSIVE-ownership CLAIMS for the owner-uniqueness gate.
+
+        Distinct from :meth:`_resolve_oracle_config_output_paths` (the oracle
+        scope index input): the uniqueness gate must reason over what a task
+        EXCLUSIVELY CLAIMS to own, not where it MAY write. The gate already reads
+        each task's declared ``output_paths`` internally, so this adds only the
+        config-DECLARED ``implement.default_output_paths`` / ``implement_targets``
+        mapping for the task's design node. It deliberately does NOT fall back to
+        ``_output_paths_for_task`` — that fallback returns the permissive
+        ``source_root`` + ``package_root`` accept-list (``_route_source_into_package``),
+        which is "this task MAY write under here", not an exclusive claim. Feeding
+        it to the gate false-RED's a normal Python src-layout (``src`` nests
+        ``src/<pkg>``) whenever ≥2 undeclared tasks share that fallback — the
+        v2.41 regression this resolves. TS was unaffected only because its
+        ``source_root == package_root`` (no nesting); the fix is layout-agnostic.
+        """
+        from codd.implementer import _configured_output_path_groups
+
+        try:
+            declared = _configured_output_path_groups(config)
+        except Exception:  # noqa: BLE001 — a malformed config maps to "nothing declared".
+            declared = {}
+        out: dict[str, list[str]] = {}
+        for task in tasks:
+            design = getattr(task, "design_node", None)
+            if design and design in declared:
+                paths = [str(p) for p in declared[design] if str(p).strip()]
+                if paths:
+                    out[task.task_id] = paths
+        return out
+
     def _certify_output_owner_uniqueness(
         self,
         tasks: list[ImplementTaskRef],

{codd_dev-2.41.0 → codd_dev-2.43.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.41.0 → codd_dev-2.43.0}/pyproject.toml

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