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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 1.42.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
@@ -61,17 +61,18 @@ Description-Content-Type: text/markdown
 
 CoDD treats **requirements -> design -> implementation -> tests** as one DAG, mechanically verifies the coherence of every node, and lets an LLM repair inconsistencies automatically when they appear. Humans write only **what to build** and **where the boundaries are**.
 
-## Where We Are (v1.34.0)
+## Where We Are (v2.0.0 — Lexicon-Driven Completeness)
 
-The North Star is far, but **within bounded conditions, CoDD has reached practical use**:
+v2.0.0 is a **positioning shift, not just a version bump**. v1.x delivered the *extract → diagnose → repair* pipeline; v2.0 adds the **constraint side** as a first-class plug-in surface.
 
 - ✅ Dogfooded on a real project (Next.js + Prisma + TypeScript Web app)
-- ✅ `codd verify --auto-repair` completes with `PARTIAL_SUCCESS` on a real LMS project (attempts=4 / applied_patches=4 / unrepairable=2)
+- ✅ `codd verify --auto-repair` reaches `PARTIAL_SUCCESS` on a real LMS project (attempts=4 / applied_patches=4)
 - ✅ DAG completeness with 9 coherence checks operational
-- ⚠️ Single viewport / single persona assumed (Coverage Axis Layer C9 introduced in v1.32.0; axis variety is continuing work)
-- ⚠️ Specification completeness Level 1 (finding holes in requirements) is planned for v1.35.0 `codd elicit`
-- ⚠️ Other domains (Mobile / Desktop / CLI / Embedded / ML) are not yet validated
-- ⚠️ Reducing unrepairable items is continuing improvement
+- ✅ **31 lexicon plug-ins** across 7 domains (Methodology / Web / Mobile / Backend-API / Data / Ops / Compliance / Process)
+- ✅ **`codd elicit` / `codd diff` / `codd brownfield`** — coverage and drift discovery for greenfield + brownfield projects
+- ✅ **`codd init --suggest-lexicons`** — auto-detect stack from manifest files, suggest lexicons to install
+- ✅ **`codd lexicon list/install/diff` + `codd coverage report`** — plug-in management CLI + matrix reports (JSON / Markdown / HTML)
+- ✅ Generality Gate three-layer architecture (Layer A core / Layer B templates / Layer C plug-ins) — zero specific framework / domain literals in core code
 
 ```bash
 pip install codd-dev
@@ -85,14 +86,14 @@ pip install codd-dev
 
 ```bash
 pip install codd-dev
-codd --version  # 1.34.0 or later
+codd --version  # 2.0.0 or later
 ```
 
 ### 2. Add codd.yaml to your project
 
 ```yaml
 # codd.yaml
-codd_required_version: ">=1.34.0"
+codd_required_version: ">=2.0.0"
 
 dag:
   design_docs:
@@ -194,7 +195,36 @@ This structurally prevents incidents such as smartphone-only navigation disappea
 
 ---
 
-## v1.34.0 Key Features
+## What's New in v2.0
+
+### Lexicon-driven completeness — the missing constraint side
+
+The North Star says "write only requirements + constraints." v1.x mostly handled the requirements side. v2.0 makes the **constraint side** mechanical and reusable.
+
+A *lexicon* is a plug-in describing the coverage axes of an industry standard:
+
+```
+codd_plugins/lexicons/
+├── babok/                          # BABOK v3 elicitation lexicon
+├── web_a11y_wcag22_aa/             # WCAG 2.2 A/AA
+├── api_rest_openapi/               # REST + OpenAPI 3.1
+├── web_security_owasp/             # OWASP Top 10 + ASVS
+├── compliance_iso27001/            # ISO/IEC 27001:2022
+├── data_governance_appi_gdpr/      # GDPR + APPI
+├── ops_kubernetes/                 # Kubernetes contracts
+└── ... 24 more
+```
+
+Each lexicon ships a manifest, axes, severity rules, coverage matrix, and prompt extension — `codd elicit` and `codd coverage report` consume them dynamically.
+
+```bash
+codd init --suggest-lexicons       # detect stack → suggest lexicons
+codd lexicon install web_responsive web_a11y_wcag22_aa
+codd lexicon diff web_responsive   # text-grep coverage hint
+codd coverage report --format html # matrix across all installed lexicons
+```
+
+### v2.0.0 Key Features
 
 | Feature | Role |
 |---------|------|
@@ -252,26 +282,28 @@ C9 `environment_coverage` verified all axis x variant coverage for viewport (sma
 
 ## Architecture - 4-Release Evolution and Next Plans
 
-### Achieved (v1.31.0 - v1.34.0)
+### Achieved (v1.31.0 - v2.0.0)
 
 | Release | Milestone |
 |---------|-----------|
-| v1.31.0 | Inner 100% (internal coherence) - eliminated manual type fixes with the typecheck repair loop |
-| v1.32.0 | Outer 100% (target environment coverage Layer C9) - absorbed viewport/RBAC/locale and related axes through a unified abstraction |
-| v1.33.0 | Caveat-resolution path proven - real CDP run-journey + LLM auto-repair attempt passed |
-| **v1.34.0** | **Full pipeline proven** - auto-repair reached PARTIAL_SUCCESS through dogfooding on a single Next.js Web project |
-
-### Next (v1.35.0 - v2.0.0, Roadmap)
-
-| Release | Plan |
-|---------|------|
-| **v1.35.0** | **`codd elicit`** - Discovery Engine that lets an LLM extract axis candidates and spec holes from requirements |
-| v1.36.0 | BABOK lexicon (`@codd/lexicon/babok`) bundle + multi-formatter (md / json / PR comment) |
-| v1.37.0 | **`codd diff`** - brownfield drift detection between requirements and implementation |
-| v1.38.0 | extract -> diff -> elicit pipeline, complete brownfield flow |
-| v1.39.0 | Reduce unrepairable items (RepairLoop strategy generalization) |
-| v1.40.0 | Multi-domain dogfooding (Mobile / CLI / embedded, etc.) |
-| (v2.0.0) | elicit + verify bidirectional loop, closest approach to the "fully automated" North Star |
+| v1.31.0 | Inner 100% (internal coherence) — eliminated manual type fixes with the typecheck repair loop |
+| v1.32.0 | Outer 100% (target environment coverage Layer C9) — absorbed viewport / RBAC / locale axes through a unified abstraction |
+| v1.33.0 | Caveat-resolution path proven — real CDP run-journey + LLM auto-repair attempt passed |
+| v1.34.0 | Full pipeline proven — auto-repair reached PARTIAL_SUCCESS through dogfooding on a single Next.js Web project |
+| v1.35.0 | `codd elicit` — Discovery Engine with lexicon-aware coverage-mode |
+| v1.36.0 | RepairLoop strategy v2 — generic fallback chain replaces stack-specific hardcoding |
+| v1.37.0 | `codd diff` — brownfield drift detection (implementation_only / requirement_only / drift) |
+| v1.38.0 | `codd brownfield` pipeline — extract → diff → elicit orchestration |
+| v1.39.0 / v1.40.0 | Lexicon plug-ins 30 across 7 domains (Web / Mobile / Backend-API / Data / Ops / Compliance / Process) |
+| v1.41.0 | `codd init --suggest-lexicons` — manifest-file scan → suggested lexicons appended |
+| v1.42.0 | `codd lexicon list/install/diff` + `codd coverage report` — plug-in management CLI + matrix reports |
+| **v2.0.0** | **Lexicon-Driven Completeness milestone** — 31 lexicons (~280 axes), constraint side now mechanical |
+
+### Next (v2.x roadmap, in flux)
+
+- Multi-domain dogfooding beyond Web (Mobile / CLI / embedded)
+- elicit + verify bidirectional loop — proposed-finding apply → re-verify cycle
+- AI-default coverage classification (`covered` / `implicit` / `gap`) replacing text-grep hints
 
 See [CHANGELOG.md](CHANGELOG.md).
 
@@ -339,6 +371,19 @@ Recipes live under `codd/hooks/recipes/`.
 
 ---
 
+## Contributors
+
+CoDD is shaped by the following people:
+
+- **[@yohey-w](https://github.com/yohey-w)** — Maintainer / Architect
+- **[@Seika86](https://github.com/Seika86)** — Sprint regex insight (PR #11)
+- **[@v-kato](https://github.com/v-kato)** — Brownfield reproduction reports (Issues #17 / #18 / #19)
+- **[@dev-komenzar](https://github.com/dev-komenzar)** — `source_dirs` bug reproduction (Issue #13)
+
+External signals (issues / PRs / lexicon suggestions) are welcome — see [Issues](https://github.com/yohey-w/codd-dev/issues).
+
+---
+
 ## License
 
 MIT License - see [LICENSE](LICENSE).

{codd_dev-1.42.0 → codd_dev-2.1.0}/README.md

@@ -21,17 +21,18 @@
 
 CoDD treats **requirements -> design -> implementation -> tests** as one DAG, mechanically verifies the coherence of every node, and lets an LLM repair inconsistencies automatically when they appear. Humans write only **what to build** and **where the boundaries are**.
 
-## Where We Are (v1.34.0)
+## Where We Are (v2.0.0 — Lexicon-Driven Completeness)
 
-The North Star is far, but **within bounded conditions, CoDD has reached practical use**:
+v2.0.0 is a **positioning shift, not just a version bump**. v1.x delivered the *extract → diagnose → repair* pipeline; v2.0 adds the **constraint side** as a first-class plug-in surface.
 
 - ✅ Dogfooded on a real project (Next.js + Prisma + TypeScript Web app)
-- ✅ `codd verify --auto-repair` completes with `PARTIAL_SUCCESS` on a real LMS project (attempts=4 / applied_patches=4 / unrepairable=2)
+- ✅ `codd verify --auto-repair` reaches `PARTIAL_SUCCESS` on a real LMS project (attempts=4 / applied_patches=4)
 - ✅ DAG completeness with 9 coherence checks operational
-- ⚠️ Single viewport / single persona assumed (Coverage Axis Layer C9 introduced in v1.32.0; axis variety is continuing work)
-- ⚠️ Specification completeness Level 1 (finding holes in requirements) is planned for v1.35.0 `codd elicit`
-- ⚠️ Other domains (Mobile / Desktop / CLI / Embedded / ML) are not yet validated
-- ⚠️ Reducing unrepairable items is continuing improvement
+- ✅ **31 lexicon plug-ins** across 7 domains (Methodology / Web / Mobile / Backend-API / Data / Ops / Compliance / Process)
+- ✅ **`codd elicit` / `codd diff` / `codd brownfield`** — coverage and drift discovery for greenfield + brownfield projects
+- ✅ **`codd init --suggest-lexicons`** — auto-detect stack from manifest files, suggest lexicons to install
+- ✅ **`codd lexicon list/install/diff` + `codd coverage report`** — plug-in management CLI + matrix reports (JSON / Markdown / HTML)
+- ✅ Generality Gate three-layer architecture (Layer A core / Layer B templates / Layer C plug-ins) — zero specific framework / domain literals in core code
 
 ```bash
 pip install codd-dev
@@ -45,14 +46,14 @@ pip install codd-dev
 
 ```bash
 pip install codd-dev
-codd --version  # 1.34.0 or later
+codd --version  # 2.0.0 or later
 ```
 
 ### 2. Add codd.yaml to your project
 
 ```yaml
 # codd.yaml
-codd_required_version: ">=1.34.0"
+codd_required_version: ">=2.0.0"
 
 dag:
   design_docs:
@@ -154,7 +155,36 @@ This structurally prevents incidents such as smartphone-only navigation disappea
 
 ---
 
-## v1.34.0 Key Features
+## What's New in v2.0
+
+### Lexicon-driven completeness — the missing constraint side
+
+The North Star says "write only requirements + constraints." v1.x mostly handled the requirements side. v2.0 makes the **constraint side** mechanical and reusable.
+
+A *lexicon* is a plug-in describing the coverage axes of an industry standard:
+
+```
+codd_plugins/lexicons/
+├── babok/                          # BABOK v3 elicitation lexicon
+├── web_a11y_wcag22_aa/             # WCAG 2.2 A/AA
+├── api_rest_openapi/               # REST + OpenAPI 3.1
+├── web_security_owasp/             # OWASP Top 10 + ASVS
+├── compliance_iso27001/            # ISO/IEC 27001:2022
+├── data_governance_appi_gdpr/      # GDPR + APPI
+├── ops_kubernetes/                 # Kubernetes contracts
+└── ... 24 more
+```
+
+Each lexicon ships a manifest, axes, severity rules, coverage matrix, and prompt extension — `codd elicit` and `codd coverage report` consume them dynamically.
+
+```bash
+codd init --suggest-lexicons       # detect stack → suggest lexicons
+codd lexicon install web_responsive web_a11y_wcag22_aa
+codd lexicon diff web_responsive   # text-grep coverage hint
+codd coverage report --format html # matrix across all installed lexicons
+```
+
+### v2.0.0 Key Features
 
 | Feature | Role |
 |---------|------|
@@ -212,26 +242,28 @@ C9 `environment_coverage` verified all axis x variant coverage for viewport (sma
 
 ## Architecture - 4-Release Evolution and Next Plans
 
-### Achieved (v1.31.0 - v1.34.0)
+### Achieved (v1.31.0 - v2.0.0)
 
 | Release | Milestone |
 |---------|-----------|
-| v1.31.0 | Inner 100% (internal coherence) - eliminated manual type fixes with the typecheck repair loop |
-| v1.32.0 | Outer 100% (target environment coverage Layer C9) - absorbed viewport/RBAC/locale and related axes through a unified abstraction |
-| v1.33.0 | Caveat-resolution path proven - real CDP run-journey + LLM auto-repair attempt passed |
-| **v1.34.0** | **Full pipeline proven** - auto-repair reached PARTIAL_SUCCESS through dogfooding on a single Next.js Web project |
-
-### Next (v1.35.0 - v2.0.0, Roadmap)
-
-| Release | Plan |
-|---------|------|
-| **v1.35.0** | **`codd elicit`** - Discovery Engine that lets an LLM extract axis candidates and spec holes from requirements |
-| v1.36.0 | BABOK lexicon (`@codd/lexicon/babok`) bundle + multi-formatter (md / json / PR comment) |
-| v1.37.0 | **`codd diff`** - brownfield drift detection between requirements and implementation |
-| v1.38.0 | extract -> diff -> elicit pipeline, complete brownfield flow |
-| v1.39.0 | Reduce unrepairable items (RepairLoop strategy generalization) |
-| v1.40.0 | Multi-domain dogfooding (Mobile / CLI / embedded, etc.) |
-| (v2.0.0) | elicit + verify bidirectional loop, closest approach to the "fully automated" North Star |
+| v1.31.0 | Inner 100% (internal coherence) — eliminated manual type fixes with the typecheck repair loop |
+| v1.32.0 | Outer 100% (target environment coverage Layer C9) — absorbed viewport / RBAC / locale axes through a unified abstraction |
+| v1.33.0 | Caveat-resolution path proven — real CDP run-journey + LLM auto-repair attempt passed |
+| v1.34.0 | Full pipeline proven — auto-repair reached PARTIAL_SUCCESS through dogfooding on a single Next.js Web project |
+| v1.35.0 | `codd elicit` — Discovery Engine with lexicon-aware coverage-mode |
+| v1.36.0 | RepairLoop strategy v2 — generic fallback chain replaces stack-specific hardcoding |
+| v1.37.0 | `codd diff` — brownfield drift detection (implementation_only / requirement_only / drift) |
+| v1.38.0 | `codd brownfield` pipeline — extract → diff → elicit orchestration |
+| v1.39.0 / v1.40.0 | Lexicon plug-ins 30 across 7 domains (Web / Mobile / Backend-API / Data / Ops / Compliance / Process) |
+| v1.41.0 | `codd init --suggest-lexicons` — manifest-file scan → suggested lexicons appended |
+| v1.42.0 | `codd lexicon list/install/diff` + `codd coverage report` — plug-in management CLI + matrix reports |
+| **v2.0.0** | **Lexicon-Driven Completeness milestone** — 31 lexicons (~280 axes), constraint side now mechanical |
+
+### Next (v2.x roadmap, in flux)
+
+- Multi-domain dogfooding beyond Web (Mobile / CLI / embedded)
+- elicit + verify bidirectional loop — proposed-finding apply → re-verify cycle
+- AI-default coverage classification (`covered` / `implicit` / `gap`) replacing text-grep hints
 
 See [CHANGELOG.md](CHANGELOG.md).
 
@@ -299,6 +331,19 @@ Recipes live under `codd/hooks/recipes/`.
 
 ---
 
+## Contributors
+
+CoDD is shaped by the following people:
+
+- **[@yohey-w](https://github.com/yohey-w)** — Maintainer / Architect
+- **[@Seika86](https://github.com/Seika86)** — Sprint regex insight (PR #11)
+- **[@v-kato](https://github.com/v-kato)** — Brownfield reproduction reports (Issues #17 / #18 / #19)
+- **[@dev-komenzar](https://github.com/dev-komenzar)** — `source_dirs` bug reproduction (Issue #13)
+
+External signals (issues / PRs / lexicon suggestions) are welcome — see [Issues](https://github.com/yohey-w/codd-dev/issues).
+
+---
+
 ## License
 
 MIT License - see [LICENSE](LICENSE).

{codd_dev-1.42.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-1.42.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-1.42.0 → codd_dev-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codd-dev"
-version = "1.42.0"
+version = "2.1.0"
 description = "CoDD: Coherence-Driven Development — cross-artifact change impact analysis"
 readme = "README.md"
 license = "MIT"
@@ -67,10 +67,10 @@ include = [
     "codd/hooks/recipes/*.sh",
     "codd/templates/**/*.j2",
     "codd/templates/**/*.tmpl",
-    "codd/hooks/pre-commit",
-    "codd_plugins/**/*.yaml",
-    "codd_plugins/**/*.md",
-    "README.md",
+    "codd/hooks/pre-commit",
+    "codd_plugins/**/*.yaml",
+    "codd_plugins/**/*.md",
+    "README.md",
     "LICENSE",
 ]