codd-dev 2.4.0__tar.gz → 2.6.0__tar.gz

{codd_dev-2.4.0 → codd_dev-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.4.0
+Version: 2.6.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.4.0 → codd_dev-2.6.0}/codd/cli.py

@@ -16,7 +16,7 @@ import yaml
 
 from codd.bridge import PRO_COMMAND_INSTALL_MESSAGE, get_command_handler
 from codd.config import find_codd_dir, load_project_config
-from codd.lexicon import LEXICON_FILENAME, load_lexicon
+from codd.lexicon import LEXICON_FILENAME, load_lexicon, load_project_extends
 
 TEMPLATES_DIR = Path(__file__).parent / "templates"
 
@@ -1087,7 +1087,7 @@ def elicit(
 
     project_root = Path(project_path).resolve()
     try:
-        lexicon_config = _load_elicit_lexicon(project_root, lexicon_path) if lexicon_path else None
+        lexicon_config = _load_elicit_lexicon_configs(project_root, lexicon_path)
         elicit_result = ElicitEngine(ai_command=ai_cmd).run(project_root, lexicon_config=lexicon_config)
     except (OSError, ValueError, json.JSONDecodeError, yaml.YAMLError) as exc:
         click.echo(f"Error: {exc}")
@@ -1128,6 +1128,18 @@ def elicit(
     click.echo(f"Output: {_display_path(output_path, project_root)}")
 
 
+def _load_elicit_lexicon_configs(project_root: Path, lexicon_path: str | None):
+    selectors = _split_elicit_lexicon_selectors(lexicon_path) if lexicon_path else load_project_extends(project_root)
+    if not selectors:
+        return None
+    configs = [_load_elicit_lexicon(project_root, selector) for selector in selectors]
+    return configs[0] if len(configs) == 1 else configs
+
+
+def _split_elicit_lexicon_selectors(value: str) -> list[str]:
+    return [item.strip() for item in value.split(",") if item.strip()]
+
+
 def _load_elicit_lexicon(project_root: Path, lexicon_path: str):
     from codd.elicit.lexicon_loader import load_lexicon
 

{codd_dev-2.4.0 → codd_dev-2.6.0}/codd/elicit/engine.py

@@ -2,10 +2,12 @@
 
 from __future__ import annotations
 
-from collections.abc import Callable, Mapping
 import json
-from pathlib import Path
 import re
+import warnings
+from collections.abc import Callable, Mapping
+from dataclasses import replace
+from pathlib import Path
 from typing import Any
 
 import yaml
@@ -36,15 +38,30 @@ class ElicitEngine:
     def run(self, project_root: Path, lexicon_config: Any | None = None) -> ElicitResult:
         root = Path(project_root)
         project_scope, project_phase = _project_scope_phase(root)
+        lexicon_configs = _as_lexicon_configs(lexicon_config)
+        if len(lexicon_configs) > 1:
+            return self._run_many(root, lexicon_configs, scope=project_scope, phase=project_phase)
+        config = lexicon_configs[0] if lexicon_configs else None
+        return self._run_one(root, config, scope=project_scope, phase=project_phase)
+
+    def _run_one(
+        self,
+        root: Path,
+        lexicon_config: Any | None,
+        *,
+        scope: str,
+        phase: str,
+    ) -> ElicitResult:
         prompt = self.build_prompt(root, lexicon_config=lexicon_config)
         raw_output = self.invoke(prompt, root)
         result = self.deserialize_result(raw_output)
         result.findings = _apply_scope_phase(
             result.findings,
             lexicon_config=lexicon_config,
-            scope=project_scope,
-            phase=project_phase,
+            scope=scope,
+            phase=phase,
         )
+        _attach_lexicon_source(result.findings, _string_attr(lexicon_config, "lexicon_name"))
         result.findings = ElicitPersistence(root).filter_known(result.findings)
         if not result.findings and result.lexicon_coverage_report:
             non_gap = all(
@@ -55,6 +72,42 @@ class ElicitEngine:
                 result.all_covered = True
         return result
 
+    def _run_many(
+        self,
+        root: Path,
+        lexicon_configs: list[Any],
+        *,
+        scope: str,
+        phase: str,
+    ) -> ElicitResult:
+        prepared = _prepare_lexicon_configs(lexicon_configs)
+        combined = ElicitResult()
+        for config, duplicate_axes in prepared:
+            result = self._run_one(root, config, scope=scope, phase=phase)
+            if duplicate_axes:
+                result.findings = [
+                    finding
+                    for finding in result.findings
+                    if _finding_axis(finding) not in duplicate_axes
+                ]
+            combined.findings.extend(result.findings)
+            for axis, status in result.lexicon_coverage_report.items():
+                if axis in combined.lexicon_coverage_report:
+                    warnings.warn(
+                        f"duplicate lexicon dimension '{axis}' ignored; first lexicon wins",
+                        RuntimeWarning,
+                        stacklevel=2,
+                    )
+                    continue
+                combined.lexicon_coverage_report[axis] = status
+
+        if combined.lexicon_coverage_report and not combined.findings:
+            combined.all_covered = all(
+                str(status).lower() != "gap"
+                for status in combined.lexicon_coverage_report.values()
+            )
+        return combined
+
     def build_prompt(self, project_root: Path, lexicon_config: Any | None = None) -> str:
         root = Path(project_root)
         template = self._template_text(lexicon_config)
@@ -86,6 +139,9 @@ class ElicitEngine:
         return ElicitResult.from_payload(payload)
 
     def _template_text(self, lexicon_config: Any | None) -> str:
+        configs = _as_lexicon_configs(lexicon_config)
+        if configs:
+            lexicon_config = configs[0]
         extension = _string_attr(lexicon_config, "prompt_extension_content")
         if extension:
             return extension
@@ -147,6 +203,60 @@ def _read_documents(paths: list[Path], project_root: Path, max_chars: int) -> st
     return "\n".join(chunks) if chunks else "(none provided)"
 
 
+def _as_lexicon_configs(lexicon_config: Any | None) -> list[Any]:
+    if lexicon_config is None:
+        return []
+    if isinstance(lexicon_config, (list, tuple)):
+        return [item for item in lexicon_config if item is not None]
+    return [lexicon_config]
+
+
+def _prepare_lexicon_configs(lexicon_configs: list[Any]) -> list[tuple[Any, set[str]]]:
+    prepared: list[tuple[Any, set[str]]] = []
+    seen_axes: set[str] = set()
+    for config in lexicon_configs:
+        kept_axes: list[dict[str, Any]] = []
+        duplicate_axes: set[str] = set()
+        for axis in _list_attr(config, "coverage_axes"):
+            if not isinstance(axis, Mapping):
+                continue
+            axis_type = axis.get("axis_type")
+            if not isinstance(axis_type, str) or not axis_type.strip():
+                kept_axes.append(dict(axis))
+                continue
+            normalized_axis = axis_type.strip()
+            if normalized_axis in seen_axes:
+                duplicate_axes.add(normalized_axis)
+                warnings.warn(
+                    f"duplicate lexicon dimension '{normalized_axis}' ignored; first lexicon wins",
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+                continue
+            seen_axes.add(normalized_axis)
+            kept_axes.append(dict(axis))
+        prepared.append((_with_coverage_axes(config, kept_axes), duplicate_axes))
+    return prepared
+
+
+def _with_coverage_axes(config: Any, coverage_axes: list[dict[str, Any]]) -> Any:
+    if isinstance(config, Mapping):
+        updated = dict(config)
+        updated["coverage_axes"] = coverage_axes
+        return updated
+    try:
+        return replace(config, coverage_axes=coverage_axes)
+    except TypeError:
+        return config
+
+
+def _attach_lexicon_source(findings: list[Finding], lexicon_name: str | None) -> None:
+    if not lexicon_name:
+        return
+    for finding in findings:
+        finding.details["lexicon_source"] = lexicon_name
+
+
 def _project_lexicon_text(project_root: Path, lexicon_config: Any | None, max_chars: int) -> str:
     chunks: list[str] = []
     for name in ("project_lexicon.yaml", "project_lexicon.yml"):
@@ -154,12 +264,13 @@ def _project_lexicon_text(project_root: Path, lexicon_config: Any | None, max_ch
         if path.is_file():
             chunks.append(path.read_text(encoding="utf-8", errors="replace").strip())
             break
-    lexicon_name = _string_attr(lexicon_config, "lexicon_name")
-    recommended = getattr(lexicon_config, "recommended_kinds", None)
-    if lexicon_name:
-        chunks.append(f"loaded_lexicon: {lexicon_name}")
-    if isinstance(recommended, list) and recommended:
-        chunks.append(yaml.safe_dump({"recommended_kinds": recommended}, sort_keys=False).strip())
+    for config in _as_lexicon_configs(lexicon_config):
+        lexicon_name = _string_attr(config, "lexicon_name")
+        recommended = getattr(config, "recommended_kinds", None)
+        if lexicon_name:
+            chunks.append(f"loaded_lexicon: {lexicon_name}")
+        if isinstance(recommended, list) and recommended:
+            chunks.append(yaml.safe_dump({"recommended_kinds": recommended}, sort_keys=False).strip())
     text = "\n\n".join(chunk for chunk in chunks if chunk)
     return text[:max_chars] if text else "(none provided)"
 

{codd_dev-2.4.0 → codd_dev-2.6.0}/codd/init/lexicon_suggest.py

@@ -5,12 +5,15 @@ from __future__ import annotations
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
 import re
 
 import yaml
 
-from codd.lexicon import LEXICON_FILENAME
+from codd.lexicon import (
+    LEXICON_FILENAME,
+    merge_lexicon_entries,
+    normalize_project_lexicon_data,
+)
 
 
 @dataclass(frozen=True)
@@ -77,17 +80,10 @@ def describe_lexicons(lexicon_ids: Iterable[str], lexicon_root: Path | None = No
 def append_suggested_lexicons(project_root: Path, lexicon_ids: Sequence[str]) -> Path:
     path = Path(project_root) / LEXICON_FILENAME
     data = _load_project_lexicon(path)
-    current = data.get("suggested_lexicons", [])
+    current = data.get("extends", [])
     if not isinstance(current, list):
-        raise ValueError("project_lexicon.yaml suggested_lexicons must be a list")
-    known = {_lexicon_id(item) for item in current}
-    merged = list(current)
-    for lexicon_id in lexicon_ids:
-        if lexicon_id in known:
-            continue
-        merged.append(lexicon_id)
-        known.add(lexicon_id)
-    data["suggested_lexicons"] = merged
+        raise ValueError("project_lexicon.yaml extends must be a list")
+    data["extends"] = merge_lexicon_entries(current, list(lexicon_ids))
     path.write_text(yaml.safe_dump(data, sort_keys=False, allow_unicode=True), encoding="utf-8")
     return path
 
@@ -97,7 +93,7 @@ def _load_project_lexicon(path: Path) -> dict[str, Any]:
         payload = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
         if not isinstance(payload, dict):
             raise ValueError("project_lexicon.yaml must contain a YAML mapping")
-        return payload
+        return normalize_project_lexicon_data(payload)
     return {
         "version": "1.0",
         "node_vocabulary": [],
@@ -106,12 +102,3 @@ def _load_project_lexicon(path: Path) -> dict[str, Any]:
             "Review suggested lexicons before treating project conventions as approved.",
         ],
     }
-
-
-def _lexicon_id(item: Any) -> str:
-    if isinstance(item, str):
-        return item
-    if isinstance(item, dict):
-        return str(item.get("id", item.get("name", item.get("lexicon_name", ""))))
-    return str(item)
-

{codd_dev-2.4.0 → codd_dev-2.6.0}/codd/lexicon.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import warnings
 from copy import deepcopy
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
@@ -15,6 +16,9 @@ LEXICON_FILENAME = "project_lexicon.yaml"
 REQUIRED_ARTIFACT_SOURCES = {"ai_derived", "user_override", "default_template"}
 DEFAULT_SCOPE = "full"
 DEFAULT_PHASE = "production"
+LEGACY_SUGGESTED_LEXICONS_WARNING = (
+    "suggested_lexicons is deprecated, renamed to extends; auto-merged"
+)
 
 
 @dataclass
@@ -45,7 +49,7 @@ class AskItem:
     answered_at: str = ""
 
 
-class LexiconError(Exception):
+class LexiconError(ValueError):
     """Raised when a project lexicon is malformed."""
 
 
@@ -90,6 +94,10 @@ class ProjectLexicon:
             for item in self._data.get("coverage_decisions", [])
         ]
 
+    @property
+    def extends(self) -> list[str]:
+        return lexicon_ids_from_entries(self._data.get("extends", []))
+
     @property
     def required_artifacts(self) -> list[dict[str, Any]]:
         return deepcopy(self._data.get("required_artifacts", []))
@@ -152,10 +160,83 @@ def load_lexicon(project_root: str | Path) -> ProjectLexicon | None:
     if not path.exists():
         return None
     data = yaml.safe_load(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise LexiconError("project_lexicon.yaml must contain a YAML mapping")
+    data = normalize_project_lexicon_data(data)
     validate_lexicon(data)
     return ProjectLexicon(data)
 
 
+def load_project_extends(project_root: str | Path) -> list[str]:
+    """Load project-level lexicon IDs from extends, with legacy shim support."""
+    path = Path(project_root) / LEXICON_FILENAME
+    if not path.exists():
+        return []
+    data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    if not isinstance(data, dict):
+        raise LexiconError("project_lexicon.yaml must contain a YAML mapping")
+    normalized = normalize_project_lexicon_data(data)
+    return lexicon_ids_from_entries(normalized.get("extends", []))
+
+
+def normalize_project_lexicon_data(data: dict[str, Any]) -> dict[str, Any]:
+    """Return lexicon data with legacy suggested_lexicons merged into extends.
+
+    The legacy field remains in the returned mapping for backward compatibility;
+    only the canonical runtime list is merged into ``extends``.
+    """
+    normalized = deepcopy(data)
+    current = _optional_lexicon_entries(normalized, "extends")
+    if "suggested_lexicons" not in normalized:
+        return normalized
+
+    legacy = _optional_lexicon_entries(normalized, "suggested_lexicons")
+    warnings.warn(
+        LEGACY_SUGGESTED_LEXICONS_WARNING,
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    normalized["extends"] = merge_lexicon_entries(current, legacy)
+    return normalized
+
+
+def merge_lexicon_entries(primary: list[Any], secondary: list[Any]) -> list[Any]:
+    merged = list(primary)
+    known = set(lexicon_ids_from_entries(merged))
+    for item in secondary:
+        lexicon_id = lexicon_id_from_entry(item)
+        if not lexicon_id or lexicon_id in known:
+            continue
+        merged.append(item)
+        known.add(lexicon_id)
+    return merged
+
+
+def lexicon_ids_from_entries(entries: Any) -> list[str]:
+    if not isinstance(entries, list):
+        return []
+    seen: set[str] = set()
+    ids: list[str] = []
+    for item in entries:
+        lexicon_id = lexicon_id_from_entry(item)
+        if not lexicon_id or lexicon_id in seen:
+            continue
+        seen.add(lexicon_id)
+        ids.append(lexicon_id)
+    return ids
+
+
+def lexicon_id_from_entry(item: Any) -> str:
+    if isinstance(item, str):
+        return item.strip()
+    if isinstance(item, dict):
+        for key in ("id", "name", "lexicon_name"):
+            value = item.get(key)
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+    return str(item).strip()
+
+
 def ask_option_from_dict(data: dict[str, Any]) -> AskOption:
     """Build an AskOption from YAML-safe dict data."""
     if not isinstance(data, dict):
@@ -258,6 +339,10 @@ def validate_lexicon(data: dict[str, Any]) -> None:
     if not isinstance(design_principles, list):
         raise LexiconError("design_principles must be a list")
 
+    for field_name in ("extends", "suggested_lexicons"):
+        if field_name in data and not isinstance(data[field_name], list):
+            raise LexiconError(f"{field_name} must be a list")
+
     failure_modes = data.get("failure_modes", [])
     _validate_list_of_mappings(failure_modes, "failure_modes")
 
@@ -323,6 +408,15 @@ def _validate_list_of_mappings(value: Any, name: str) -> None:
             raise LexiconError(f"{name} items must be mappings: {item}")
 
 
+def _optional_lexicon_entries(data: dict[str, Any], field_name: str) -> list[Any]:
+    value = data.get(field_name, [])
+    if value is None:
+        return []
+    if not isinstance(value, list):
+        raise LexiconError(f"{field_name} must be a list")
+    return list(value)
+
+
 def _optional_str(value: Any) -> str | None:
     if value is None:
         return None

{codd_dev-2.4.0 → codd_dev-2.6.0}/codd/lexicon_cli/manager.py

@@ -9,7 +9,7 @@ from typing import Any
 import yaml
 
 from codd.init.lexicon_suggest import append_suggested_lexicons, default_lexicon_root
-from codd.lexicon import LEXICON_FILENAME, load_lexicon as load_project_lexicon
+from codd.lexicon import LEXICON_FILENAME, load_project_extends
 
 
 @dataclass(frozen=True)
@@ -44,21 +44,14 @@ class LexiconManager:
         if not path.is_file():
             return []
 
-        data: dict[str, Any] | None = None
         try:
-            loaded = load_project_lexicon(self.project_root)
-            data = loaded.as_dict() if loaded is not None else None
+            return load_project_extends(self.project_root)
         except Exception:
             payload = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
-            if isinstance(payload, dict):
-                data = payload
-        if not data:
+        if not isinstance(payload, dict):
             return []
-
-        raw = data.get("suggested_lexicons", [])
-        if not isinstance(raw, list):
-            return []
-        return _dedupe(_lexicon_id(item) for item in raw)
+        raw = payload.get("extends", payload.get("suggested_lexicons", []))
+        return _dedupe(_lexicon_id(item) for item in raw) if isinstance(raw, list) else []
 
     def available(self) -> list[LexiconRecord]:
         installed = set(self.installed_ids())

{codd_dev-2.4.0 → codd_dev-2.6.0}/pyproject.toml

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