codd-dev 2.0.0__tar.gz → 2.1.0__tar.gz

{codd_dev-2.0.0 → codd_dev-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.0.0
+Version: 2.1.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.0.0 → codd_dev-2.1.0}/codd/cli.py

@@ -2973,6 +2973,130 @@ def coverage_report_cmd(
     click.echo(f"Report: {_display_path(output_path, project_root)}")
 
 
+@coverage.command("check")
+@click.option(
+    "--lexicons",
+    default="all",
+    show_default=True,
+    help="Lexicons to include: all or a comma-separated id list.",
+)
+@click.option("--path", "project_path", default=".", show_default=True, help="Project root directory")
+@click.option(
+    "--threshold",
+    "global_threshold",
+    type=float,
+    default=None,
+    help="Global covered_text_match_pct threshold override.",
+)
+@click.option(
+    "--threshold-file",
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    default=None,
+    help="External threshold YAML file.",
+)
+@click.option(
+    "--format",
+    "format_name",
+    type=click.Choice(["human", "json", "md"]),
+    default="human",
+    show_default=True,
+    help="Output format.",
+)
+@click.option("--with-ai", is_flag=True, default=False, help="Use AI-backed elicit coverage mode.")
+@click.option("--ai-cmd", default=None, help="Override AI CLI command for --with-ai.")
+@click.option("--exit-zero", is_flag=True, default=False, help="Always exit 0 for threshold violations.")
+def coverage_check_cmd(
+    lexicons: str,
+    project_path: str,
+    global_threshold: float | None,
+    threshold_file: Path | None,
+    format_name: str,
+    with_ai: bool,
+    ai_cmd: str | None,
+    exit_zero: bool,
+) -> None:
+    """Run a lexicon coverage threshold gate."""
+    from dataclasses import asdict
+
+    from codd.lexicon_cli.formatters.json_fmt import to_json
+    from codd.lexicon_cli.reporter import CoverageReporter
+    from codd.lexicon_cli.threshold import ThresholdConfig, evaluate, load_thresholds
+
+    project_root = Path(project_path).resolve()
+    try:
+        report = CoverageReporter(project_root).build(lexicons, with_ai=with_ai, ai_command=ai_cmd)
+        config = load_thresholds(threshold_file or _default_threshold_path(project_root))
+        if global_threshold is not None:
+            config = ThresholdConfig(default_pct=global_threshold)
+        violations = evaluate(report, config)
+    except (OSError, ValueError, json.JSONDecodeError, yaml.YAMLError) as exc:
+        click.echo(f"Error: {exc}")
+        raise SystemExit(2)
+
+    payload = {
+        "status": "fail" if violations else "pass",
+        "thresholds": asdict(config),
+        "totals": report.totals,
+        "violations": [asdict(violation) for violation in violations],
+    }
+    if format_name == "json":
+        click.echo(to_json(payload), nl=False)
+    elif format_name == "md":
+        click.echo(_format_coverage_check_md(payload), nl=False)
+    else:
+        click.echo(_format_coverage_check_human(payload), nl=False)
+
+    raise SystemExit(0 if exit_zero or not violations else 1)
+
+
+def _default_threshold_path(project_root: Path) -> Path | None:
+    codd_dir = find_codd_dir(project_root)
+    return codd_dir / "codd.yaml" if codd_dir is not None else None
+
+
+def _format_coverage_check_human(payload: dict[str, Any]) -> str:
+    status = str(payload["status"]).upper()
+    totals = payload["totals"]
+    lines = [
+        f"Coverage check {status}",
+        f"Axes: {totals['covered']}/{totals['axes']} covered ({totals['covered_pct']:.2f}%)",
+    ]
+    violations = payload["violations"]
+    if violations:
+        lines.append("Violations:")
+        for violation in violations:
+            axis = violation["axis"] or "<overall>"
+            lines.append(
+                f"  - {violation['lexicon_id']} {axis}: "
+                f"{violation['observed_pct']:.2f}% < {violation['required_pct']:.2f}%"
+            )
+    return "\n".join(lines) + "\n"
+
+
+def _format_coverage_check_md(payload: dict[str, Any]) -> str:
+    totals = payload["totals"]
+    lines = [
+        "# Coverage Threshold Check",
+        "",
+        f"Status: **{str(payload['status']).upper()}**",
+        f"Axes: {totals['covered']}/{totals['axes']} covered ({totals['covered_pct']:.2f}%)",
+        "",
+        "| Lexicon | Axis | Observed | Required |",
+        "| --- | --- | ---: | ---: |",
+    ]
+    violations = payload["violations"]
+    if violations:
+        for violation in violations:
+            axis = violation["axis"] or "<overall>"
+            lines.append(
+                f"| {violation['lexicon_id']} | {axis} | "
+                f"{violation['observed_pct']:.2f}% | {violation['required_pct']:.2f}% |"
+            )
+    else:
+        lines.append("| - | - | - | - |")
+    return "\n".join(lines) + "\n"
+
+
 @main.command("deploy")
 @click.option("--target", default=None, help="Deploy target name from deploy.yaml")
 @click.option(

{codd_dev-2.0.0 → codd_dev-2.1.0}/codd/lexicon_cli/__init__.py

@@ -3,15 +3,18 @@
 from codd.lexicon_cli.inspector import AxisInspection, LexiconDiffResult, TextHit
 from codd.lexicon_cli.manager import InstallResult, LexiconManager, LexiconRecord
 from codd.lexicon_cli.reporter import CoverageMatrixReport, CoverageReporter, CoverageRow
+from codd.lexicon_cli.threshold import CoverageViolation, ThresholdConfig
 
 __all__ = [
     "AxisInspection",
     "CoverageMatrixReport",
     "CoverageReporter",
     "CoverageRow",
+    "CoverageViolation",
     "InstallResult",
     "LexiconDiffResult",
     "LexiconManager",
     "LexiconRecord",
     "TextHit",
+    "ThresholdConfig",
 ]

codd_dev-2.1.0/codd/lexicon_cli/threshold.py

@@ -0,0 +1,159 @@
+"""Threshold gate for lexicon coverage matrix reports."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Mapping
+
+import yaml
+
+from codd.lexicon_cli.reporter import CoverageMatrixReport, CoverageRow
+
+
+@dataclass(frozen=True)
+class ThresholdConfig:
+    default_pct: float = 0.0
+    per_lexicon: dict[str, float] = field(default_factory=dict)
+    per_axis: dict[str, dict[str, float]] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class CoverageViolation:
+    lexicon_id: str
+    axis: str | None
+    observed_pct: float
+    required_pct: float
+
+
+def load_thresholds(codd_yaml_path: Path | None) -> ThresholdConfig:
+    """Load coverage thresholds from codd.yaml, defaulting to no enforcement."""
+    if codd_yaml_path is None or not codd_yaml_path.exists():
+        return ThresholdConfig()
+
+    payload = yaml.safe_load(codd_yaml_path.read_text(encoding="utf-8")) or {}
+    if not isinstance(payload, Mapping):
+        raise ValueError(f"{codd_yaml_path} must contain a YAML mapping")
+
+    coverage = _mapping(payload.get("coverage"), "coverage", allow_missing=True)
+    thresholds = _mapping(coverage.get("thresholds"), "coverage.thresholds", allow_missing=True)
+    if not thresholds:
+        return ThresholdConfig()
+
+    default_pct = _threshold_pct(thresholds.get("default"), "coverage.thresholds.default", default=0.0)
+    per_lexicon = _load_per_lexicon(thresholds.get("per_lexicon"))
+    per_axis = _load_per_axis(thresholds.get("per_axis"))
+    return ThresholdConfig(default_pct=default_pct, per_lexicon=per_lexicon, per_axis=per_axis)
+
+
+def evaluate(matrix_report: CoverageMatrixReport, config: ThresholdConfig) -> list[CoverageViolation]:
+    """Compare a coverage matrix report with configured thresholds."""
+    violations: list[CoverageViolation] = []
+    rows_by_lexicon: dict[str, list[CoverageRow]] = defaultdict(list)
+    for row in matrix_report.rows:
+        rows_by_lexicon[row.lexicon_id].append(row)
+
+    for lexicon_id, rows in sorted(rows_by_lexicon.items()):
+        required_pct = config.per_lexicon.get(lexicon_id, config.default_pct)
+        observed_pct = _covered_pct(rows)
+        if _is_violation(observed_pct, required_pct):
+            violations.append(
+                CoverageViolation(
+                    lexicon_id=lexicon_id,
+                    axis=None,
+                    observed_pct=observed_pct,
+                    required_pct=required_pct,
+                )
+            )
+
+        axis_thresholds = config.per_axis.get(lexicon_id, {})
+        for row in rows:
+            if row.axis_type not in axis_thresholds:
+                continue
+            axis_observed_pct = 100.0 if _is_covered_status(row.status) else 0.0
+            axis_required_pct = axis_thresholds[row.axis_type]
+            if _is_violation(axis_observed_pct, axis_required_pct):
+                violations.append(
+                    CoverageViolation(
+                        lexicon_id=lexicon_id,
+                        axis=row.axis_type,
+                        observed_pct=axis_observed_pct,
+                        required_pct=axis_required_pct,
+                    )
+                )
+
+    return violations
+
+
+def _load_per_lexicon(value: Any) -> dict[str, float]:
+    data = _mapping(value, "coverage.thresholds.per_lexicon", allow_missing=True)
+    result: dict[str, float] = {}
+    for key, item in data.items():
+        lexicon_id = _non_empty_key(key, "coverage.thresholds.per_lexicon")
+        result[lexicon_id] = _threshold_pct(item, f"coverage.thresholds.per_lexicon.{lexicon_id}")
+    return result
+
+
+def _load_per_axis(value: Any) -> dict[str, dict[str, float]]:
+    data = _mapping(value, "coverage.thresholds.per_axis", allow_missing=True)
+    result: dict[str, dict[str, float]] = {}
+    for key, item in data.items():
+        lexicon_id = _non_empty_key(key, "coverage.thresholds.per_axis")
+        axes = _mapping(item, f"coverage.thresholds.per_axis.{lexicon_id}")
+        result[lexicon_id] = {
+            _non_empty_key(axis, f"coverage.thresholds.per_axis.{lexicon_id}"): _threshold_pct(
+                threshold,
+                f"coverage.thresholds.per_axis.{lexicon_id}.{axis}",
+            )
+            for axis, threshold in axes.items()
+        }
+    return result
+
+
+def _threshold_pct(value: Any, path: str, *, default: float | None = None) -> float:
+    if value is None and default is not None:
+        return default
+    if isinstance(value, Mapping):
+        if "covered_text_match_pct" not in value:
+            if default is not None:
+                return default
+            raise ValueError(f"{path}.covered_text_match_pct is required")
+        value = value["covered_text_match_pct"]
+    try:
+        pct = float(value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"{path}.covered_text_match_pct must be a number") from exc
+    if pct < 0 or pct > 100:
+        raise ValueError(f"{path}.covered_text_match_pct must be between 0 and 100")
+    return pct
+
+
+def _mapping(value: Any, path: str, *, allow_missing: bool = False) -> Mapping[str, Any]:
+    if value is None and allow_missing:
+        return {}
+    if not isinstance(value, Mapping):
+        raise ValueError(f"{path} must be a YAML mapping")
+    return value
+
+
+def _non_empty_key(value: Any, path: str) -> str:
+    text = str(value).strip()
+    if not text:
+        raise ValueError(f"{path} keys must be non-empty")
+    return text
+
+
+def _covered_pct(rows: list[CoverageRow]) -> float:
+    if not rows:
+        return 0.0
+    covered = sum(1 for row in rows if _is_covered_status(row.status))
+    return round((covered / len(rows)) * 100, 2)
+
+
+def _is_covered_status(status: str) -> bool:
+    return status.casefold() in {"covered", "covered_text_match", "implicit"}
+
+
+def _is_violation(observed_pct: float, required_pct: float) -> bool:
+    return observed_pct + 1e-9 < required_pct

{codd_dev-2.0.0 → codd_dev-2.1.0}/pyproject.toml

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