codd-dev 1.30.0__tar.gz → 1.32.0__tar.gz

{codd_dev-1.30.0 → codd_dev-1.32.0}/PKG-INFO

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

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "1.24.0"
+__version__ = "1.30.0"

{codd_dev-1.30.0 → codd_dev-1.32.0}/codd/cli.py

@@ -2,9 +2,12 @@
 
 from dataclasses import asdict, dataclass, is_dataclass
 from datetime import datetime, timezone
+import importlib.metadata
 import json
 import os
+import re
 import shutil
+import subprocess
 from pathlib import Path
 from typing import Any
 
@@ -29,9 +32,148 @@ class _CliVerificationResult:
     failure: Any | None = None
 
 
+@dataclass(frozen=True)
+class _VersionCheckResult:
+    installed_version: str
+    required_spec: str
+    satisfied: bool
+    strict: bool
+    message: str
+
+
+_SPECIFIER_RE = re.compile(r"^\s*(==|!=|<=|>=|<|>|~=)\s*([A-Za-z0-9.!+_-]+)\s*$")
+
+
+def _installed_codd_version() -> str:
+    try:
+        return importlib.metadata.version("codd-dev")
+    except importlib.metadata.PackageNotFoundError:
+        pass
+
+    try:
+        from codd import __version__
+
+        if __version__:
+            return str(__version__)
+    except Exception:  # pragma: no cover - best-effort fallback for source trees.
+        pass
+
+    pyproject_path = Path(__file__).resolve().parent.parent / "pyproject.toml"
+    try:
+        match = re.search(r'(?m)^version\s*=\s*"([^"]+)"', pyproject_path.read_text(encoding="utf-8"))
+    except OSError:
+        match = None
+    return match.group(1) if match else "unknown"
+
+
+def _evaluate_version_requirement(project_root: Path, *, strict_override: bool = False) -> _VersionCheckResult | None:
+    try:
+        config = load_project_config(project_root)
+    except (FileNotFoundError, ValueError):
+        return None
+
+    required = config.get("codd_required_version")
+    if not isinstance(required, str) or not required.strip():
+        return None
+
+    installed = _installed_codd_version()
+    required_spec = required.strip()
+    satisfied, error = _version_satisfies(installed, required_spec)
+    strict = bool(strict_override or config.get("codd_required_version_strict", False))
+    if error:
+        return _VersionCheckResult(
+            installed_version=installed,
+            required_spec=required_spec,
+            satisfied=False,
+            strict=strict,
+            message=f"WARN: invalid codd_required_version {required_spec!r}: {error}",
+        )
+    return _VersionCheckResult(
+        installed_version=installed,
+        required_spec=required_spec,
+        satisfied=satisfied,
+        strict=strict,
+        message=f"WARN: project requires codd {required_spec}, installed {installed}",
+    )
+
+
+def _warn_if_project_version_mismatch(project_root: Path) -> None:
+    result = _evaluate_version_requirement(project_root)
+    if result is None or result.satisfied:
+        return
+    click.echo(result.message, err=True)
+    if result.strict:
+        raise SystemExit(1)
+
+
+def _version_satisfies(installed: str, specifier: str) -> tuple[bool, str | None]:
+    try:
+        from packaging.specifiers import InvalidSpecifier, SpecifierSet
+        from packaging.version import InvalidVersion, Version
+
+        try:
+            return Version(installed) in SpecifierSet(specifier), None
+        except (InvalidSpecifier, InvalidVersion) as exc:
+            return False, str(exc)
+    except ImportError:
+        return _version_satisfies_fallback(installed, specifier)
+
+
+def _version_satisfies_fallback(installed: str, specifier: str) -> tuple[bool, str | None]:
+    installed_key = _version_key(installed)
+    if installed_key is None:
+        return False, f"unsupported installed version {installed!r}"
+
+    for raw_part in specifier.split(","):
+        part = raw_part.strip()
+        if not part:
+            continue
+        match = _SPECIFIER_RE.match(part)
+        if match is None:
+            return False, f"unsupported version specifier {part!r}; install packaging for full PEP 440 support"
+        op, expected = match.groups()
+        expected_key = _version_key(expected)
+        if expected_key is None:
+            return False, f"unsupported version {expected!r}"
+        if not _compare_version_keys(installed_key, op, expected_key):
+            return False, None
+    return True, None
+
+
+def _version_key(version: str) -> tuple[int, ...] | None:
+    release = version.split("+", 1)[0].split("-", 1)[0]
+    numbers = re.findall(r"\d+", release)
+    if not numbers:
+        return None
+    return tuple(int(item) for item in numbers)
+
+
+def _compare_version_keys(installed: tuple[int, ...], op: str, expected: tuple[int, ...]) -> bool:
+    size = max(len(installed), len(expected))
+    left = installed + (0,) * (size - len(installed))
+    right = expected + (0,) * (size - len(expected))
+    if op == "==":
+        return left == right
+    if op == "!=":
+        return left != right
+    if op == ">=":
+        return left >= right
+    if op == "<=":
+        return left <= right
+    if op == ">":
+        return left > right
+    if op == "<":
+        return left < right
+    if op == "~=":
+        upper = (expected[0] + 1, 0) if len(expected) <= 2 else (expected[0], expected[1] + 1, 0)
+        upper = upper + (0,) * (size - len(upper))
+        return left >= right and left < upper
+    return False
+
+
 def _run_pro_command(name: str, **kwargs):
     """Dispatch a Pro-only command when the bridge plugin is installed."""
-    handler = get_command_handler(name)
+    handler = get_command_handler(name)
     if handler is None:
         click.echo(PRO_COMMAND_INSTALL_MESSAGE)
         raise SystemExit(1)
@@ -196,11 +338,40 @@ def _ensure_bootstrap_codd_yaml(
     return config_path, True
 
 
-@click.group()
-@click.version_option(package_name="codd-dev")
-def main():
+@click.group()
+@click.version_option(package_name="codd-dev")
+@click.pass_context
+def main(ctx: click.Context):
     """CoDD: Coherence-Driven Development."""
-    pass
+    if ctx.resilient_parsing or ctx.invoked_subcommand in {None, "version"}:
+        return
+    _warn_if_project_version_mismatch(Path.cwd())
+
+
+@main.command("version")
+@click.option("--check", "check_project", is_flag=True, help="Check installed CoDD against codd.yaml requirement")
+@click.option("--strict", is_flag=True, help="Exit non-zero when the version requirement is not satisfied")
+@click.option("--path", "project_path", default=".", help="Project root directory")
+def version_cmd(check_project: bool, strict: bool, project_path: str) -> None:
+    """Print the installed CoDD version."""
+    installed = _installed_codd_version()
+    click.echo(f"codd {installed}")
+    if not check_project:
+        return
+
+    project_root = Path(project_path).resolve()
+    result = _evaluate_version_requirement(project_root, strict_override=strict)
+    if result is None:
+        click.echo("Version check: no codd_required_version configured")
+        return
+    if result.satisfied:
+        click.echo(f"Version check: PASS (requires {result.required_spec})")
+        return
+
+    click.echo(result.message, err=True)
+    click.echo(f"Version check: FAIL (requires {result.required_spec})")
+    if result.strict:
+        raise SystemExit(1)
 
 
 @main.command("preflight")
@@ -539,6 +710,13 @@ def restore(wave: int, path: str, force: bool, ai_cmd: str | None, feedback: str
     default=False,
     help="Run CoverageAuditor 3-class requirement gap analysis.",
 )
+@click.option(
+    "--check",
+    "check_coverage",
+    is_flag=True,
+    default=False,
+    help="Check requirement-to-implementation coverage without generating requirements.",
+)
 @click.option(
     "--completeness-audit",
     is_flag=True,
@@ -556,6 +734,7 @@ def require(
     base_ref: str | None,
     apply_mode: bool,
     audit: bool,
+    check_coverage: bool,
     completeness_audit: bool,
 ):
     """Infer requirements from extracted codebase facts (brownfield).
@@ -582,6 +761,10 @@ def require(
 
     _require_codd_dir(project_root)
 
+    if check_coverage:
+        _run_require_check(project_root)
+        return
+
     if audit:
         from codd.coverage_auditor import CoverageAuditor
 
@@ -680,12 +863,39 @@ def require(
             generated += 1
         else:
             skipped += 1
-
-    click.echo(f"Requirements: {generated} generated, {skipped} skipped")
-
-
-@main.command()
-@click.option("--diff", default="HEAD", help="Git diff target (default: HEAD, shows uncommitted changes)")
+
+    click.echo(f"Requirements: {generated} generated, {skipped} skipped")
+
+
+def _run_require_check(project_root: Path) -> None:
+    from codd.dag import runner as dag_runner
+
+    try:
+        results = dag_runner.run_all_checks(project_root, check_names=["implementation_coverage"])
+    except (FileNotFoundError, ValueError) as exc:
+        click.echo(f"Error: {exc}")
+        raise SystemExit(1)
+
+    failed = []
+    for result in results:
+        check_name = str(getattr(result, "check_name", "implementation_coverage"))
+        message = str(getattr(result, "message", "") or "")
+        passed = bool(getattr(result, "passed", False))
+        status = "PASS" if passed else "FAIL"
+        suffix = f" - {message}" if message else ""
+        click.echo(f"{status}: {check_name}{suffix}")
+        for violation in getattr(result, "violations", []) or []:
+            click.echo(f"  - {violation}")
+        if not passed:
+            failed.append(result)
+
+    if failed:
+        raise SystemExit(1)
+    click.echo("Requirement check complete: implementation_coverage PASS")
+
+
+@main.command()
+@click.option("--diff", default="HEAD", help="Git diff target (default: HEAD, shows uncommitted changes)")
 @click.option("--path", default=".", help="Project root directory")
 @click.option("--update", is_flag=True, help="Actually update affected design docs via AI")
 @click.option("--verify", is_flag=True, help="Auto-apply green band, list amber/gray for HITL review")
@@ -1238,6 +1448,7 @@ def implement_augment_cmd(
     show_default=True,
     help="Seconds before one chunk is interrupted",
 )
+@click.option("--enable-typecheck-loop", is_flag=True, default=False, help="Run configured typecheck repair loop after implementation")
 def implement_run_cmd(
     task_id: str | None,
     project_path: str,
@@ -1245,12 +1456,21 @@ def implement_run_cmd(
     use_derived_steps: str,
     chunk_size: int | None,
     timeout_per_chunk: int,
+    enable_typecheck_loop: bool,
 ):
     """Run implementation with optional derived step injection."""
-    from codd.implementer import implement_tasks
+    from codd.implementer import auto_detect_task, implement_tasks
 
     project_root = Path(project_path).resolve()
     _require_codd_dir(project_root)
+    if task_id is None:
+        try:
+            task_id = auto_detect_task(project_root)
+        except ValueError as exc:
+            click.echo(f"Error: {exc}")
+            raise SystemExit(1)
+        click.echo(f"Auto-detected task: {task_id}")
+
     if chunk_size is not None:
         try:
             result = _run_chunked_implementation(
@@ -1267,6 +1487,16 @@ def implement_run_cmd(
         _echo_chunked_result(project_root, result)
         if result.status != "SUCCESS":
             raise SystemExit(1)
+        try:
+            _run_typecheck_loop_after_implement(
+                project_root=project_root,
+                modified_files=None,
+                ai_cmd=ai_cmd,
+                force_enabled=enable_typecheck_loop,
+            )
+        except (FileNotFoundError, ValueError, CoddCLIError) as exc:
+            click.echo(f"Error: {exc}")
+            raise SystemExit(1)
         return
 
     try:
@@ -1286,6 +1516,16 @@ def implement_run_cmd(
     click.echo(f"{sum(len(result.generated_files) for result in results)} files generated across {len(results) - len(failed)} task(s)")
     if failed:
         raise SystemExit(1)
+    try:
+        _run_typecheck_loop_after_implement(
+            project_root=project_root,
+            modified_files=[generated_file for result in results for generated_file in result.generated_files],
+            ai_cmd=ai_cmd,
+            force_enabled=enable_typecheck_loop,
+        )
+    except (FileNotFoundError, ValueError, CoddCLIError) as exc:
+        click.echo(f"Error: {exc}")
+        raise SystemExit(1)
 
 
 @implement.command("resume")
@@ -1391,9 +1631,71 @@ def _echo_chunked_result(project_root: Path, result) -> None:
         f"Chunked implementation {result.status}: "
         f"{len(result.completed_chunks)}/{result.total_chunks} chunks; history={history}"
     )
-
-
-@main.command()
+
+
+def _run_typecheck_loop_after_implement(
+    *,
+    project_root: Path,
+    modified_files: list[Path] | None,
+    ai_cmd: str | None,
+    force_enabled: bool,
+):
+    config = _load_optional_project_config(project_root)
+    if not force_enabled and not _typecheck_config_enabled(config):
+        return None
+    from codd.implementer import TypecheckRepairLoop
+
+    loop = TypecheckRepairLoop.from_config(config, force_enabled=force_enabled)
+    if not loop.enabled:
+        return None
+
+    result = loop.run_after_implement(
+        project_root,
+        modified_files if modified_files is not None else _git_modified_files(project_root),
+        ai_cmd or _configured_ai_command(config),
+    )
+    click.echo(f"Typecheck loop {result.status}")
+    if result.status == "REPAIR_EXHAUSTED":
+        raise CoddCLIError("typecheck repair loop exhausted")
+    return result
+
+
+def _configured_ai_command(config: dict[str, Any]) -> str:
+    command = config.get("ai_command")
+    return command if isinstance(command, str) else ""
+
+
+def _typecheck_config_enabled(config: dict[str, Any]) -> bool:
+    typecheck = config.get("typecheck")
+    return bool(typecheck.get("enabled")) if isinstance(typecheck, dict) else False
+
+
+def _git_modified_files(project_root: Path) -> list[Path]:
+    try:
+        completed = subprocess.run(
+            ["git", "-C", str(project_root), "status", "--porcelain=v1", "--untracked-files=all"],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            check=False,
+        )
+    except (OSError, ValueError):
+        return []
+    if completed.returncode != 0:
+        return []
+    paths: list[Path] = []
+    for line in completed.stdout.splitlines():
+        if len(line) < 4:
+            continue
+        raw_path = line[3:]
+        if " -> " in raw_path:
+            raw_path = raw_path.rsplit(" -> ", 1)[1]
+        if raw_path:
+            paths.append(project_root / raw_path)
+    return paths
+
+
+@main.command()
 @click.option("--path", default=".", help="Project root directory")
 @click.option("--output-dir", default=None, help="Output directory for assembled project (default: src/)")
 @click.option(
@@ -1457,7 +1759,7 @@ def verify(
         return
 
     project_root = Path(path).resolve()
-    result = _run_verify_once(path=path, sprint=sprint)
+    result = _run_verify_once(path=path, sprint=sprint, prefer_standalone=True)
     if result.passed:
         return
 
@@ -1471,7 +1773,7 @@ def verify(
         repair_config=repair_config,
         max_attempts=max_attempts,
         engine_name=engine_name,
-        verify_callable=lambda: _run_verify_once(path=path, sprint=sprint),
+        verify_callable=lambda: _run_verify_once(path=path, sprint=sprint, prefer_standalone=True),
     )
     click.echo(f"Repair outcome: {outcome.status}")
     click.echo(f"Repair history: {_display_path(outcome.history_session_dir, project_root)}")
@@ -3236,12 +3538,14 @@ def _load_optional_project_config(project_root: Path) -> dict[str, Any]:
         return {}
 
 
-def _run_verify_once(path: str, sprint: int | None = None) -> _CliVerificationResult:
-    if get_command_handler("verify") is None:
-        from codd.repair.verify_runner import run_standalone_verify
-
-        result = run_standalone_verify(Path(path).resolve())
-        return _cli_result_from_standalone_verify(result)
+def _run_verify_once(
+    path: str,
+    sprint: int | None = None,
+    *,
+    prefer_standalone: bool = False,
+) -> _CliVerificationResult:
+    if prefer_standalone or get_command_handler("verify") is None:
+        return _run_standalone_verify_once(path)
 
     try:
         _run_pro_command("verify", path=path, sprint=sprint)
@@ -3260,6 +3564,23 @@ def _run_verify_once(path: str, sprint: int | None = None) -> _CliVerificationRe
     return _CliVerificationResult(passed=True, exit_code=0, failure=None)
 
 
+def _run_standalone_verify_once(path: str) -> _CliVerificationResult:
+    from codd.repair.verify_runner import run_standalone_verify
+
+    result = run_standalone_verify(Path(path).resolve())
+    _echo_verification_warnings(result)
+    return _cli_result_from_standalone_verify(result)
+
+
+def _echo_verification_warnings(result: Any) -> None:
+    for warning in getattr(result, "warnings", []) or []:
+        text = str(warning)
+        if not text:
+            continue
+        prefix = "" if text.upper().startswith("WARNING:") else "WARNING: "
+        click.echo(f"{prefix}{text}")
+
+
 def _cli_result_from_standalone_verify(result: Any) -> _CliVerificationResult:
     return _CliVerificationResult(
         passed=bool(result.passed),
@@ -3769,19 +4090,32 @@ def dag_journeys(project_path: str, output_format: str):
 @dag.command("run-journey")
 @click.argument("journey_name")
 @click.option("--project-path", "--path", default=".", show_default=True, help="Project root directory")
+@click.option(
+    "--axis",
+    "axis_overrides",
+    multiple=True,
+    metavar="TYPE=VARIANT",
+    help="Runtime axis override. Repeat for multiple axes.",
+)
 @click.option(
     "--config-section",
     default="cdp_browser",
     show_default=True,
     help="verification.templates section used for browser config",
 )
-def dag_run_journey(journey_name: str, project_path: str, config_section: str):
+def dag_run_journey(
+    journey_name: str,
+    project_path: str,
+    axis_overrides: tuple[str, ...],
+    config_section: str,
+):
     """Run one declared user_journey with the CDP browser template."""
     from codd.dag.builder import build_dag
     from codd.deployment.providers.verification.cdp_browser import CdpBrowser
 
     project_root = Path(project_path).resolve()
     try:
+        parsed_axes = _parse_axis_overrides(axis_overrides)
         config = load_project_config(project_root)
         template_config = _journey_template_config(config, config_section)
         built_dag = build_dag(project_root)
@@ -3795,7 +4129,7 @@ def dag_run_journey(journey_name: str, project_path: str, config_section: str):
         raise SystemExit(2)
 
     command = json.dumps(
-        _journey_execution_plan(project_root, journey_record, template_config),
+        _journey_execution_plan(project_root, journey_record, template_config, parsed_axes),
         sort_keys=True,
     )
     result = CdpBrowser(config=template_config).execute(command)
@@ -3816,6 +4150,20 @@ def _journey_template_config(config: dict[str, Any], config_section: str) -> dic
     return dict(section)
 
 
+def _parse_axis_overrides(axis_overrides: tuple[str, ...]) -> dict[str, str]:
+    parsed: dict[str, str] = {}
+    for raw in axis_overrides:
+        if "=" not in raw:
+            raise ValueError("--axis must use TYPE=VARIANT")
+        axis_type, variant_id = raw.split("=", 1)
+        axis = axis_type.strip()
+        variant = variant_id.strip()
+        if not axis or not variant:
+            raise ValueError("--axis must use non-empty TYPE=VARIANT")
+        parsed[axis] = variant
+    return parsed
+
+
 def _find_dag_journey(
     dag: Any,
     journey_name: str,
@@ -3838,11 +4186,12 @@ def _journey_execution_plan(
     project_root: Path,
     journey_record: dict[str, Any],
     template_config: dict[str, Any],
+    axis_overrides: dict[str, str] | None = None,
 ) -> dict[str, Any]:
     journey = dict(journey_record["journey"])
     journey_name = str(journey.get("name") or "")
     steps = journey.get("steps")
-    return {
+    plan = {
         "template": "cdp_browser",
         "test_kind": "e2e",
         "target": _journey_target(journey),
@@ -3853,6 +4202,9 @@ def _journey_execution_plan(
         "design_doc": journey_record["design_doc"],
         "config": template_config,
     }
+    if axis_overrides:
+        plan["axis_overrides"] = dict(axis_overrides)
+    return plan
 
 
 def _journey_target(journey: dict[str, Any]) -> str:

{codd_dev-1.30.0 → codd_dev-1.32.0}/codd/coverage_auditor.py

@@ -3,7 +3,8 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from datetime import UTC, datetime
+from datetime import datetime, timezone
+UTC = timezone.utc
 from pathlib import Path
 import re
 from typing import Any, Literal

{codd_dev-1.30.0 → codd_dev-1.32.0}/codd/dag/builder.py

@@ -16,6 +16,7 @@ import yaml
 
 from codd.config import load_project_config
 from codd.dag import DAG, Edge, Node
+from codd.dag.coverage_axes import CoverageAxis, extract_coverage_axes_from_design_doc, extract_coverage_axes_from_lexicon
 from codd.dag.extractor import extract_design_doc_metadata, extract_imports, scan_capability_evidence
 from codd.llm.design_doc_extractor import (
     ExpectedExtraction,
@@ -88,6 +89,7 @@ def build_dag(project_root: Path, settings: dict[str, Any] | None = None) -> DAG
     _add_design_doc_expected_outcome_edges(dag, design_docs)
     _add_plan_tasks(dag, root, dag_settings)
     _add_deployment_graph(dag, root, design_docs, impl_nodes)
+    _attach_coverage_axes(dag, root, dag_settings)
 
     write_dag_json(dag, root, default_dag_json_path(root))
     return dag
@@ -151,7 +153,7 @@ def default_dag_mermaid_path(project_root: Path) -> Path:
 def dag_to_dict(dag: DAG, project_root: Path) -> dict[str, Any]:
     """Serialize a DAG using the stable `.codd/dag.json` schema."""
 
-    return {
+    payload = {
         "version": "1",
         "built_at": datetime.now(timezone.utc).isoformat(),
         "project_root": str(Path(project_root).resolve()),
@@ -167,6 +169,12 @@ def dag_to_dict(dag: DAG, project_root: Path) -> dict[str, Any]:
         "edges": [_edge_to_dict(edge) for edge in sorted(dag.edges, key=lambda item: (item.from_id, item.to_id, item.kind))],
         "cycles": dag.detect_cycles(),
     }
+    coverage_axes = getattr(dag, "coverage_axes", [])
+    if coverage_axes:
+        payload["coverage_axes"] = [
+            axis.to_dict() if isinstance(axis, CoverageAxis) else axis for axis in coverage_axes
+        ]
+    return payload
 
 
 def _edge_to_dict(edge: Edge) -> dict[str, Any]:
@@ -656,6 +664,32 @@ def _add_deployment_graph(
         existing_edges.add(edge_key)
 
 
+def _attach_coverage_axes(dag: DAG, project_root: Path, settings: dict[str, Any]) -> None:
+    lexicon_path = _project_path(project_root, str(settings.get("lexicon_file", "project_lexicon.yaml")))
+    axes = extract_coverage_axes_from_lexicon(lexicon_path)
+    for node in sorted(dag.nodes.values(), key=lambda item: item.id):
+        if node.kind == "design_doc":
+            axes.extend(extract_coverage_axes_from_design_doc(node))
+    dag.coverage_axes = _dedupe_coverage_axes(axes)
+
+
+def _dedupe_coverage_axes(axes: list[CoverageAxis]) -> list[CoverageAxis]:
+    deduped: list[CoverageAxis] = []
+    seen: set[tuple[str, tuple[str, ...], str, str]] = set()
+    for axis in axes:
+        key = (
+            axis.axis_type,
+            tuple(variant.id for variant in axis.variants),
+            axis.source,
+            axis.owner_section,
+        )
+        if key in seen:
+            continue
+        seen.add(key)
+        deduped.append(axis)
+    return deduped
+
+
 def _extract_outputs(section: str) -> list[str]:
     match = OUTPUTS_RE.search(section)
     if not match: