codd-dev 2.68.0__tar.gz → 2.70.0__tar.gz

{codd_dev-2.68.0 → codd_dev-2.70.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.68.0
+Version: 2.70.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.68.0 → codd_dev-2.70.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.68.0"
+__version__ = "2.70.0"

{codd_dev-2.68.0 → codd_dev-2.70.0}/codd/greenfield/pipeline.py

@@ -3124,44 +3124,30 @@ def _certify_verify_executed(project_root: Path, result: Any) -> str:
     )
 
 
-# Language ecosystems whose CI needs a toolchain bootstrap before the test
-# command can run. Keyed by a marker file; the value is the GitHub Actions
-# setup steps to prepend. An unrecognised ecosystem still gets checkout + the
-# detected test command (authentic — it runs the real suite — just without a
-# toolchain step). This per-ecosystem dispatch is the v3.0 short-term bridge;
-# v3.1 moves the CI template into the language/stack profile (profile-driven CI).
-_CI_SETUP_STEPS: tuple[tuple[str, list[dict[str, Any]]], ...] = (
-    ("go.mod", [{"uses": "actions/setup-go@v5", "with": {"go-version": "stable"}}]),
-    (
-        "package.json",
-        [
-            {"uses": "actions/setup-node@v4", "with": {"node-version": "lts/*"}},
-            {"run": "npm ci"},
-        ],
-    ),
-    (
-        "pyproject.toml",
-        [
-            {"uses": "actions/setup-python@v5", "with": {"python-version": "3.x"}},
-            {"run": "python -m pip install --upgrade pip && pip install -e ."},
-        ],
-    ),
-    (
-        "setup.py",
-        [
-            {"uses": "actions/setup-python@v5", "with": {"python-version": "3.x"}},
-            {"run": "python -m pip install --upgrade pip && pip install -e ."},
-        ],
-    ),
-    ("Cargo.toml", [{"uses": "dtolnay/rust-toolchain@stable"}]),
-)
-
-
 def _ci_setup_steps(project_root: Path) -> list[dict[str, Any]]:
-    for marker, steps in _CI_SETUP_STEPS:
-        if (project_root / marker).exists():
-            return [dict(step) for step in steps]
-    return []
+    """CI toolchain setup steps from the resolved language profile (``profile.ci``).
+
+    Contract-driven (Contract Kernel, v2.70): the steps come from the project's
+    language profile — the pipeline core does NOT branch on a language name or a
+    marker file. No CoDD config, no resolvable language, or no ``ci`` section →
+    no setup steps (the workflow still runs checkout + the real test command; an
+    unsupported ecosystem simply gets no toolchain bootstrap, the honest
+    pluggable default). The per-marker hardcoded table (v2.67.0) is gone.
+    """
+    from codd.config import load_project_config
+    from codd.languages import resolve_language_profile
+
+    try:
+        config = load_project_config(project_root)
+    except (FileNotFoundError, ValueError):
+        return []
+    try:
+        profile = resolve_language_profile(config)
+    except Exception:  # noqa: BLE001 — unknown/unsupported language → no setup, never a crash.
+        return []
+    if profile is None or profile.ci is None:
+        return []
+    return [dict(step) for step in profile.ci.setup_steps]
 
 
 def _ci_opt_out_declared(project_root: Path) -> bool:

{codd_dev-2.68.0 → codd_dev-2.70.0}/codd/languages/__init__.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 from .profile import (
     AdapterRef,
     ArtifactsSpec,
+    CiSpec,
     CommandSpec,
     DependencyIntegrityFile,
     Identity,
@@ -50,6 +51,15 @@ from .contract import (
     resolve_language_contract,
     resolve_language_profile,
 )
+from .verify_plan import (
+    ShadowComparison,
+    VerifyClass,
+    VerifyOutcome,
+    VerifyRunPlan,
+    build_verify_plan,
+    classify_verify_outcome,
+    shadow_compare,
+)
 from .compat import (
     UnsupportedLayoutShape,
     layout_profile_from_language_profile,
@@ -60,6 +70,7 @@ __all__ = [
     # model
     "AdapterRef",
     "ArtifactsSpec",
+    "CiSpec",
     "CommandSpec",
     "DependencyIntegrityFile",
     "Identity",
@@ -92,6 +103,14 @@ __all__ = [
     "build_language_contract",
     "resolve_language_contract",
     "resolve_language_profile",
+    # verify run plan + semantic classifier (v2.69a, shadow)
+    "ShadowComparison",
+    "VerifyClass",
+    "VerifyOutcome",
+    "VerifyRunPlan",
+    "build_verify_plan",
+    "classify_verify_outcome",
+    "shadow_compare",
     # compat shim (LanguageProfile -> legacy LayoutProfile)
     "UnsupportedLayoutShape",
     "layout_profile_from_language_profile",

{codd_dev-2.68.0 → codd_dev-2.70.0}/codd/languages/loader.py

@@ -21,6 +21,7 @@ import yaml
 
 from .profile import (
     ArtifactsSpec,
+    CiSpec,
     CommandSpec,
     DependencyIntegrityFile,
     Identity,
@@ -338,6 +339,21 @@ def _parse_scaffold(doc: Mapping[str, Any]) -> ScaffoldSpec | None:
     )
 
 
+def _parse_ci(doc: Mapping[str, Any]) -> CiSpec | None:
+    raw = doc.get("ci")
+    if raw is None:
+        return None
+    m = _as_mapping(raw, where="ci")
+    steps = tuple(
+        _as_mapping(s, where=f"ci.setup_steps[{i}]")
+        for i, s in enumerate(_as_tuple(m.get("setup_steps")))
+    )
+    return CiSpec(
+        setup_steps=steps,
+        runs_on=str(m.get("runs_on", "ubuntu-latest")),
+    )
+
+
 # ---------------------------------------------------------------------------
 # public entry point
 # ---------------------------------------------------------------------------
@@ -358,6 +374,7 @@ _KNOWN_TOP_LEVEL = frozenset(
         "verify",
         "artifacts",
         "scaffold",
+        "ci",
     }
 )
 
@@ -400,6 +417,7 @@ def load_language_profile(path: str | Path) -> LanguageProfile:
         verify=_parse_verify(doc),
         artifacts=_parse_artifacts(doc),
         scaffold=_parse_scaffold(doc),
+        ci=_parse_ci(doc),
         extra=extra,
         raw=dict(doc),
     )

{codd_dev-2.68.0 → codd_dev-2.70.0}/codd/languages/profile.py

@@ -331,6 +331,26 @@ class ScaffoldSpec:
     templates: tuple[Mapping[str, Any], ...] = ()
 
 
+# ---------------------------------------------------------------------------
+# ci scaffold (design §v2.70)
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class CiSpec:
+    """CI scaffold contract — the toolchain bootstrap a generated CI workflow
+    needs before it can run the project's verify/test command.
+
+    Declarative GitHub-Actions step mappings (``{uses: ..., with: {...}}`` /
+    ``{run: ...}``) so greenfield's ``ci_scaffold`` reads them from the language
+    profile instead of a hardcoded per-marker table in the pipeline core (the
+    Contract Kernel: the core never branches on a language name).
+    """
+
+    setup_steps: tuple[Mapping[str, Any], ...] = ()
+    runs_on: str = "ubuntu-latest"
+
+
 # ---------------------------------------------------------------------------
 # generic adapter reference
 # ---------------------------------------------------------------------------
@@ -373,6 +393,7 @@ class LanguageProfile:
     verify: VerifySpec | None = None
     artifacts: ArtifactsSpec | None = None
     scaffold: ScaffoldSpec | None = None
+    ci: CiSpec | None = None
     #: ``path_rules``, ``implement_oracle`` 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.

{codd_dev-2.68.0 → codd_dev-2.70.0}/codd/languages/profiles/go.yaml

@@ -275,3 +275,10 @@ artifacts:
   ignored:
     - "*.test"
     - "coverage.out"
+
+# CI scaffold (design §v2.70): toolchain bootstrap for a generated CI workflow.
+ci:
+  setup_steps:
+    - uses: actions/setup-go@v5
+      with:
+        go-version: stable

{codd_dev-2.68.0 → codd_dev-2.70.0}/codd/languages/profiles/python.yaml

@@ -153,3 +153,11 @@ artifacts:
   ignored:
     - ".pytest_cache/**"
     - "*.pyc"
+
+# CI scaffold (design §v2.70): toolchain bootstrap for a generated CI workflow.
+ci:
+  setup_steps:
+    - uses: actions/setup-python@v5
+      with:
+        python-version: "3.x"
+    - run: python -m pip install --upgrade pip && pip install -e .

{codd_dev-2.68.0 → codd_dev-2.70.0}/codd/languages/profiles/typescript.yaml

@@ -157,3 +157,11 @@ artifacts:
   ignored:
     - "node_modules/**"
     - "dist/**"
+
+# CI scaffold (design §v2.70): toolchain bootstrap for a generated CI workflow.
+ci:
+  setup_steps:
+    - uses: actions/setup-node@v4
+      with:
+        node-version: lts/*
+    - run: npm ci

codd_dev-2.70.0/codd/languages/verify_plan.py

@@ -0,0 +1,192 @@
+"""Verify run plan + semantic-class classifier (v2.69a — shadow only).
+
+Builds a verify run plan from the resolved language contract's
+``commands["verify"]`` (the declarative verify command: argv/cwd/env/report)
+and classifies a verify outcome into one of six semantic classes. This runs in
+SHADOW alongside the legacy ``detect_test_command`` path — it does NOT switch
+verify behaviour (that is v2.69b). The point of the shadow stage is to prove,
+on fixtures and on live runs, that the contract-driven plan classifies outcomes
+the SAME way the legacy verifier does (or is intentionally stricter) BEFORE the
+switch.
+
+Anti-false-green: the classifier is a PURE mapping of already-computed signals
+to a class — it never re-derives the zero-tests / report heuristics itself (the
+caller supplies them, reusing the single legacy source), so there is no risk of
+a second, drifting copy of the anti-false-green logic. The class ordering puts
+every not-green verdict (TOOL_MISSING / timeout-FAIL / CONFIG_ERROR /
+ZERO_TESTS / REPORT_MISSING) BEFORE the exit-0 PASS, so a run that exits 0 while
+observing nothing is never classified green.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Mapping
+
+from .contract import ResolvedLanguageContract
+
+
+class VerifyClass(str, Enum):
+    """Semantic class of a verify outcome (design §v2.69a)."""
+
+    PASS = "PASS"
+    FAIL = "FAIL"
+    ZERO_TESTS = "ZERO_TESTS"
+    REPORT_MISSING = "REPORT_MISSING"
+    TOOL_MISSING = "TOOL_MISSING"
+    CONFIG_ERROR = "CONFIG_ERROR"
+
+    @property
+    def is_green(self) -> bool:
+        return self is VerifyClass.PASS
+
+
+@dataclass(frozen=True)
+class VerifyRunPlan:
+    """The contract-derived verify command (declarative, not yet executed)."""
+
+    language_id: str
+    argv: tuple[str, ...]
+    cwd: str | None
+    env: Mapping[str, str]
+    report_path: str | None
+    report_adapter: str | None
+    report_required: bool
+    must_include_test_sets: tuple[str, ...]
+
+    @property
+    def command_str(self) -> str:
+        return " ".join(self.argv)
+
+
+def build_verify_plan(contract: ResolvedLanguageContract) -> VerifyRunPlan | None:
+    """Derive the verify run plan from ``contract.profile.commands['verify']``.
+
+    Returns ``None`` when the profile declares no verify command (the caller
+    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).
+    """
+    cmd = contract.profile.commands.get("verify")
+    if cmd is None:
+        return None
+    report = cmd.report
+    scope = cmd.scope
+    return VerifyRunPlan(
+        language_id=contract.language_id,
+        argv=tuple(cmd.argv),
+        cwd=cmd.cwd,
+        env=dict(cmd.env),
+        report_path=(report.path if report else None),
+        report_adapter=(report.adapter if report else None),
+        report_required=bool(report and report.path),
+        must_include_test_sets=(scope.must_include_test_sets if scope else ()),
+    )
+
+
+@dataclass(frozen=True)
+class VerifyOutcome:
+    """Observed signals from running a verify command.
+
+    The signals are computed by the CALLER (reusing the single legacy source for
+    the zero-tests heuristic, the report adapter for report presence, etc.) — this
+    keeps the classifier a pure mapping with no duplicated anti-false-green logic.
+    """
+
+    spawned: bool  # did the tool execute at all? (False ⇒ tool missing / spawn error)
+    returncode: int | None = None
+    timed_out: bool = False
+    zero_tests_observed: bool = False  # runner started but collected/ran 0 tests
+    config_error: bool = False  # runner usage/config error (e.g. pytest exit 4)
+    report_present: bool | None = None  # None ⇒ no report expected / not yet checked
+
+
+def classify_verify_outcome(
+    outcome: VerifyOutcome, plan: VerifyRunPlan | None = None
+) -> VerifyClass:
+    """Map an observed verify outcome to a semantic class (pure, anti-false-green).
+
+    Not-green verdicts are checked BEFORE the exit-0 PASS so a command that exits
+    0 while observing nothing (zero tests, missing required report) can never be
+    classified green.
+    """
+    if not outcome.spawned:
+        return VerifyClass.TOOL_MISSING
+    if outcome.timed_out:
+        return VerifyClass.FAIL  # a timeout is a failure, never green
+    if outcome.config_error:
+        return VerifyClass.CONFIG_ERROR
+    if outcome.zero_tests_observed:
+        return VerifyClass.ZERO_TESTS
+    if outcome.returncode == 0:
+        if plan is not None and plan.report_required and outcome.report_present is False:
+            return VerifyClass.REPORT_MISSING
+        return VerifyClass.PASS
+    return VerifyClass.FAIL
+
+
+@dataclass(frozen=True)
+class ShadowComparison:
+    """Result of comparing the contract verify plan against the legacy command."""
+
+    language_id: str
+    legacy_command: str
+    profile_command: str | None
+    commands_identical: bool
+    legacy_class: VerifyClass
+    profile_class: VerifyClass
+    classes_match: bool
+    note: str = ""
+
+    def to_trace(self) -> dict[str, object]:
+        return {
+            "shadow_language_id": self.language_id,
+            "legacy_command": self.legacy_command,
+            "profile_command": self.profile_command,
+            "commands_identical": self.commands_identical,
+            "legacy_verify_class": self.legacy_class.value,
+            "profile_verify_class": self.profile_class.value,
+            "verify_classes_match": self.classes_match,
+            "shadow_note": self.note,
+        }
+
+
+def shadow_compare(
+    contract: ResolvedLanguageContract,
+    *,
+    legacy_command: str,
+    legacy_outcome: VerifyOutcome,
+) -> ShadowComparison | None:
+    """Compare the contract verify plan to the legacy command for one run.
+
+    SHADOW ONLY — never changes behaviour. The legacy outcome's signals are
+    reused to classify what the profile plan WOULD report; divergence (or an
+    intentionally stricter profile, e.g. Go's ``-json`` report variant) is
+    recorded for review before the v2.69b switch.
+    """
+    plan = build_verify_plan(contract)
+    if plan is None:
+        return None
+    legacy_class = classify_verify_outcome(legacy_outcome, plan=None)
+    profile_class = classify_verify_outcome(legacy_outcome, plan=plan)
+    identical = plan.command_str == legacy_command.strip()
+    note = ""
+    if not identical:
+        note = (
+            f"profile verify command differs from legacy "
+            f"(profile={plan.command_str!r} vs legacy={legacy_command!r})"
+        )
+        if plan.report_required:
+            note += "; profile is stricter (declares a required machine-readable report)"
+    return ShadowComparison(
+        language_id=contract.language_id,
+        legacy_command=legacy_command,
+        profile_command=plan.command_str,
+        commands_identical=identical,
+        legacy_class=legacy_class,
+        profile_class=profile_class,
+        classes_match=(legacy_class is profile_class),
+        note=note,
+    )

{codd_dev-2.68.0 → codd_dev-2.70.0}/pyproject.toml

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