codd-dev 2.75.0__tar.gz → 2.77.0__tar.gz

{codd_dev-2.75.0 → codd_dev-2.77.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.75.0
+Version: 2.77.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.75.0 → codd_dev-2.77.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.75.0"
+__version__ = "2.77.0"

{codd_dev-2.75.0 → codd_dev-2.77.0}/codd/implement_oracle.py

@@ -3012,8 +3012,11 @@ def _resolve_registry_composite_oracle(
         lang_profile = default_registry.resolve(lang)
     except Exception:  # noqa: BLE001 — no registry profile ⇒ NO-OP, not a crash.
         return None
-    oracle_decl = lang_profile.extra.get("implement_oracle") if lang_profile.extra else None
-    if not isinstance(oracle_decl, Mapping) or oracle_decl.get("kind") != "composite":
+    # implement_oracle is now a modeled first-class field (Contract Kernel §1),
+    # no longer a raw mapping in ``.extra``. Behaviour is preserved: only a Go
+    # profile declaring kind="composite" synthesizes the composite spec below.
+    oracle_decl = lang_profile.implement_oracle
+    if oracle_decl is None or oracle_decl.kind != "composite":
         return None
     module_root = _norm(getattr(lang_profile.layout, "module_root", ".") or ".") or "."
     synthetic = LayoutProfile(

{codd_dev-2.75.0 → codd_dev-2.77.0}/codd/languages/__init__.py

@@ -21,6 +21,8 @@ from .profile import (
     CommandSpec,
     DependencyIntegrityFile,
     Identity,
+    ImplementOracleProfileSpec,
+    ImplementOracleStepSpec,
     ImportsSpec,
     LanguageProfile,
     LayoutSpec,
@@ -75,6 +77,8 @@ __all__ = [
     "CommandSpec",
     "DependencyIntegrityFile",
     "Identity",
+    "ImplementOracleProfileSpec",
+    "ImplementOracleStepSpec",
     "ImportsSpec",
     "LanguageProfile",
     "LayoutSpec",

{codd_dev-2.75.0 → codd_dev-2.77.0}/codd/languages/loader.py

@@ -25,6 +25,8 @@ from .profile import (
     CommandSpec,
     DependencyIntegrityFile,
     Identity,
+    ImplementOracleProfileSpec,
+    ImplementOracleStepSpec,
     ImportsSpec,
     LanguageProfile,
     LayoutSpec,
@@ -367,6 +369,94 @@ def _parse_ci(doc: Mapping[str, Any]) -> CiSpec | None:
     )
 
 
+_IMPLEMENT_ORACLE_KINDS = frozenset({"command", "composite", "adapter"})
+
+
+def _parse_implement_oracle(
+    doc: Mapping[str, Any], commands: Mapping[str, Any]
+) -> ImplementOracleProfileSpec | None:
+    """Parse + FAIL-CLOSED validate the ``implement_oracle:`` block.
+
+    Contract Kernel §1: the oracle declaration references command ids / an
+    adapter id; it never carries argv/cwd/env. Every malformed shape is a hard
+    :class:`LanguageProfileError` (a profile is a contract, not a way to slip a
+    broken / silent-green oracle past the gate).
+    """
+    raw = doc.get("implement_oracle")
+    if raw is None:
+        return None
+    where = "implement_oracle"
+    m = _as_mapping(raw, where=where)
+
+    kind = m.get("kind")
+    if kind not in _IMPLEMENT_ORACLE_KINDS:
+        raise LanguageProfileError(
+            f"{where}: unknown kind {kind!r}; expected one of "
+            f"{sorted(_IMPLEMENT_ORACLE_KINDS)}"
+        )
+
+    # Every kind needs an adapter id (never inferred from the language id).
+    adapter = m.get("adapter")
+    if adapter is None or not str(adapter).strip():
+        raise LanguageProfileError(f"{where}: missing required key 'adapter'")
+    adapter = str(adapter)
+
+    command = m.get("command")
+    command = str(command) if command is not None else None
+    raw_steps = _as_tuple(m.get("steps"))
+
+    if kind == "command":
+        if command is None:
+            raise LanguageProfileError(
+                f"{where}: kind 'command' requires a 'command' id"
+            )
+        if raw_steps:
+            raise LanguageProfileError(
+                f"{where}: kind 'command' must not declare 'steps'"
+            )
+        if command not in commands:
+            raise LanguageProfileError(
+                f"{where}: command {command!r} is not declared in 'commands'"
+            )
+        return ImplementOracleProfileSpec(kind="command", adapter=adapter, command=command)
+
+    if kind == "composite":
+        if command is not None:
+            raise LanguageProfileError(
+                f"{where}: kind 'composite' must not declare 'command' "
+                f"(use 'steps')"
+            )
+        if not raw_steps:
+            raise LanguageProfileError(
+                f"{where}: kind 'composite' requires a non-empty 'steps' list"
+            )
+        steps: list[ImplementOracleStepSpec] = []
+        for i, raw_step in enumerate(raw_steps):
+            sm = _as_mapping(raw_step, where=f"{where}.steps[{i}]")
+            step_cmd = _require(sm, "command", where=f"{where}.steps[{i}]")
+            step_cmd = str(step_cmd)
+            if step_cmd not in commands:
+                raise LanguageProfileError(
+                    f"{where}.steps[{i}]: command {step_cmd!r} is not declared "
+                    f"in 'commands'"
+                )
+            steps.append(ImplementOracleStepSpec(command=step_cmd))
+        return ImplementOracleProfileSpec(
+            kind="composite", adapter=adapter, steps=tuple(steps)
+        )
+
+    # kind == "adapter": the adapter does everything; no command/steps.
+    if command is not None:
+        raise LanguageProfileError(
+            f"{where}: kind 'adapter' must not declare 'command'"
+        )
+    if raw_steps:
+        raise LanguageProfileError(
+            f"{where}: kind 'adapter' must not declare 'steps'"
+        )
+    return ImplementOracleProfileSpec(kind="adapter", adapter=adapter)
+
+
 # ---------------------------------------------------------------------------
 # public entry point
 # ---------------------------------------------------------------------------
@@ -388,6 +478,7 @@ _KNOWN_TOP_LEVEL = frozenset(
         "artifacts",
         "scaffold",
         "ci",
+        "implement_oracle",
     }
 )
 
@@ -420,17 +511,19 @@ def load_language_profile(path: str | Path) -> LanguageProfile:
 
     extra = {k: v for k, v in doc.items() if k not in _KNOWN_TOP_LEVEL}
 
+    commands = _parse_commands(doc)
     return LanguageProfile(
         identity=_parse_identity(doc),
         layout=_parse_layout(doc),
         toolchain=_parse_toolchain(doc),
-        commands=_parse_commands(doc),
+        commands=commands,
         imports=_parse_imports(doc),
         tests=_parse_tests(doc),
         verify=_parse_verify(doc),
         artifacts=_parse_artifacts(doc),
         scaffold=_parse_scaffold(doc),
         ci=_parse_ci(doc),
+        implement_oracle=_parse_implement_oracle(doc, commands),
         extra=extra,
         raw=dict(doc),
     )

{codd_dev-2.75.0 → codd_dev-2.77.0}/codd/languages/profile.py

@@ -446,6 +446,57 @@ class AdapterRef:
     id: str
 
 
+# ---------------------------------------------------------------------------
+# implement_oracle declaration (Contract Kernel oracle dispatch §1)
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class ImplementOracleStepSpec:
+    """One step of a composite implement-oracle (Contract Kernel §1).
+
+    ``command`` is an id that MUST reference an entry in
+    ``LanguageProfile.commands`` — the step carries NO argv/cwd/env of its own
+    (those live on the referenced :class:`CommandSpec`). The loader fail-closes
+    if the referenced command id is not declared.
+    """
+
+    command: str
+
+
+@dataclass(frozen=True)
+class ImplementOracleProfileSpec:
+    """The PROFILE's declaration of its implement-time oracle (Contract Kernel §1).
+
+    This is the *declaration* the language profile carries in YAML — NOT the
+    gate's runtime spec (:class:`codd.project_types.ImplementOracleSpec`, which
+    the dispatch still synthesizes). Distinct on purpose: this model only names
+    *what kind* of oracle the language has and *which command ids / adapter* it
+    references; it never duplicates argv/cwd/env.
+
+    * ``kind`` — one of:
+        - ``"command"``   — a single static checker (TS: ``tsc --noEmit``),
+          named by ``command`` (a command id). ``steps`` MUST be empty.
+        - ``"composite"`` — a sequence of weaker checkers unioned (Go:
+          ``typecheck`` + ``vet``), named by ``steps``. ``command`` MUST be
+          unset.
+        - ``"adapter"``   — an in-process custom executor (Python's compile +
+          import-resolver + collect-only composite). Neither ``command`` nor
+          ``steps`` is set; the ``adapter`` id does all the work.
+    * ``adapter`` — the (always-required) adapter id that resolves the oracle's
+      tool semantics (scope certify / output normalize, and execute for the
+      ``adapter`` kind). The profile declares it EXPLICITLY — it is never
+      inferred from the language id (an implicit naming convention would create
+      silent-green on a declaration typo).
+    * ``command`` / ``steps`` — command-id references only (see above).
+    """
+
+    kind: Literal["command", "composite", "adapter"]
+    adapter: str
+    command: str | None = None
+    steps: tuple[ImplementOracleStepSpec, ...] = ()
+
+
 # ---------------------------------------------------------------------------
 # top-level profile
 # ---------------------------------------------------------------------------
@@ -456,9 +507,10 @@ class LanguageProfile:
     """The full declarative language contract (design §1).
 
     Sub-structures that are not yet load-bearing for Phase 1 are optional.
-    ``path_rules``, ``implement_oracle`` and any unknown top-level keys are
-    preserved verbatim in ``raw`` / ``extra`` so a later phase can consume
-    them without re-parsing the YAML.
+    ``path_rules`` and any unknown top-level keys are preserved verbatim in
+    ``raw`` / ``extra`` so a later phase can consume them without re-parsing the
+    YAML. ``implement_oracle`` is now modeled as a first-class field (Contract
+    Kernel §1) — no longer left in ``extra``.
     """
 
     identity: Identity
@@ -473,7 +525,10 @@ class LanguageProfile:
     artifacts: ArtifactsSpec | None = None
     scaffold: ScaffoldSpec | None = None
     ci: CiSpec | None = None
-    #: ``path_rules``, ``implement_oracle`` etc., preserved but not modeled in Phase 1.
+    #: The implement-time oracle declaration (Contract Kernel §1). ``None`` when
+    #: the profile declares no ``implement_oracle:`` block.
+    implement_oracle: "ImplementOracleProfileSpec | None" = None
+    #: ``path_rules`` etc., preserved but not modeled in Phase 1.
     extra: Mapping[str, Any] = field(default_factory=lambda: MappingProxyType({}))
     #: The full parsed YAML mapping, for round-trip / debugging.
     raw: Mapping[str, Any] = field(default_factory=lambda: MappingProxyType({}))

{codd_dev-2.75.0 → codd_dev-2.77.0}/codd/languages/profiles/go.yaml

@@ -185,9 +185,11 @@ commands:
     scope:
       must_include_test_sets: ["colocated", "e2e"]
 
-# Preserved verbatim (modeled as profile.extra in Phase 1).
+# Implement-time oracle (Contract Kernel §1): a composite of typecheck + vet,
+# resolved by the go-toolchain adapter. References command ids only.
 implement_oracle:
   kind: composite
+  adapter: go-toolchain
   steps:
     - command: typecheck
     - command: vet

{codd_dev-2.75.0 → codd_dev-2.77.0}/codd/languages/profiles/python.yaml

@@ -94,8 +94,8 @@ commands:
       format: junit-xml
       adapter: pytest-junit-xml
 
-# Preserved verbatim (modeled as profile.extra in Phase 1). Python uses a
-# composite oracle, registered as an adapter in a later phase (design §4 Phase 4).
+# Implement-time oracle (Contract Kernel §1): Python's compile + import-resolver
+# + collect-only composite is an in-process custom executor, so kind=adapter.
 implement_oracle:
   kind: adapter
   adapter: python-composite

{codd_dev-2.75.0 → codd_dev-2.77.0}/codd/languages/profiles/typescript.yaml

@@ -96,10 +96,11 @@ commands:
       format: vitest-json
       adapter: vitest-json
 
-# Preserved verbatim (modeled as profile.extra in Phase 1). tsc --noEmit is a
-# sufficient oracle, so a plain command spec works (design §4 Phase 4).
+# Implement-time oracle (Contract Kernel §1): tsc --noEmit is a sufficient static
+# checker, so kind=command (the typecheck command id), resolved by typescript-tsc.
 implement_oracle:
   kind: command
+  adapter: typescript-tsc
   command: typecheck
 
 tests:

{codd_dev-2.75.0 → codd_dev-2.77.0}/codd/languages/verify_plan.py

@@ -91,6 +91,26 @@ class VerifyRunPlan:
         return " ".join(self.argv)
 
 
+def _substitute_layout_placeholders(value: str | None, layout) -> str | None:
+    """Resolve the layout path placeholders a verify command's ``cwd``/``env`` may
+    carry (``{module_root}`` / ``{repo_root}`` / ``{manifest_root}``).
+
+    Profiles keep these as LITERAL template strings (per design — full template
+    substitution is PathPlanner's job, a later phase). But the verify EXECUTOR
+    must run in a real directory: an unsubstituted ``cwd: "{module_root}"`` makes
+    the run spawn in ``<project>/{module_root}`` (a path that does not exist) →
+    a spurious TOOL_MISSING. So the plan resolves exactly the layout roots the
+    verify command needs to be runnable; everything else stays a literal template.
+    """
+    if value is None:
+        return None
+    return (
+        value.replace("{module_root}", layout.module_root)
+        .replace("{repo_root}", layout.repo_root)
+        .replace("{manifest_root}", layout.manifest_root)
+    )
+
+
 def build_verify_plan(contract: ResolvedLanguageContract) -> VerifyRunPlan | None:
     """Derive the verify run plan from ``contract.profile.commands['verify']``.
 
@@ -98,13 +118,15 @@ def build_verify_plan(contract: ResolvedLanguageContract) -> VerifyRunPlan | Non
     stays on the legacy path). A declared ``report.path`` means the command is
     expected to PRODUCE that report — its absence after a run is REPORT_MISSING
     (a not-green outcome), enforced once adapters land (v2.72) / the switch
-    happens (v2.69b).
+    happens (v2.69b). ``cwd``/``env`` layout placeholders are resolved so the
+    executor runs in a real directory.
     """
     cmd = contract.profile.commands.get("verify")
     if cmd is None:
         return None
     report = cmd.report
     scope = cmd.scope
+    layout = contract.profile.layout
     must_include = scope.must_include_test_sets if scope else ()
     # Resolve each must_include id to its TestSet ROOT (the scope check in the
     # executor matches executed_files against roots, so it needs roots, not ids).
@@ -122,8 +144,11 @@ def build_verify_plan(contract: ResolvedLanguageContract) -> VerifyRunPlan | Non
     return VerifyRunPlan(
         language_id=contract.language_id,
         argv=tuple(cmd.argv),
-        cwd=cmd.cwd,
-        env=dict(cmd.env),
+        cwd=_substitute_layout_placeholders(cmd.cwd, layout),
+        env={
+            str(k): _substitute_layout_placeholders(str(v), layout)
+            for k, v in cmd.env.items()
+        },
         report_path=(report.path if report else None),
         report_adapter=(report.adapter if report else None),
         report_required=bool(report and report.path),

{codd_dev-2.75.0 → codd_dev-2.77.0}/pyproject.toml

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