codd-dev 2.6.1__tar.gz → 2.8.0__tar.gz

{codd_dev-2.6.1 → codd_dev-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.6.1
+Version: 2.8.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.6.1 → codd_dev-2.8.0}/codd/cli.py

@@ -463,6 +463,18 @@ def _format_preflight_ntfy(result: Any) -> str:
     default=True,
     help="Detect project manifests and offer lexicon plug-in suggestions.",
 )
+@click.option(
+    "--llm-enhanced",
+    is_flag=True,
+    default=False,
+    help="Use AI to recommend lexicons from requirements and design context.",
+)
+@click.option(
+    "--auto-approve",
+    is_flag=True,
+    default=False,
+    help="Apply high and medium confidence AI lexicon recommendations without prompting.",
+)
 def init(
     project_name: str,
     language: str,
@@ -470,6 +482,8 @@ def init(
     requirements: str | None,
     config_dir: str,
     suggest_lexicons: bool,
+    llm_enhanced: bool,
+    auto_approve: bool,
 ):
     """Initialize CoDD in a project directory."""
     dest_path = Path(dest).resolve()
@@ -521,10 +535,15 @@ def init(
         click.echo(f"  or: codd generate --wave 2  (auto-generates everything)")
 
     if suggest_lexicons:
-        _offer_lexicon_suggestions(dest_path)
+        _offer_lexicon_suggestions(dest_path, llm_enhanced=llm_enhanced, auto_approve=auto_approve)
 
 
-def _offer_lexicon_suggestions(project_root: Path) -> None:
+def _offer_lexicon_suggestions(
+    project_root: Path,
+    *,
+    llm_enhanced: bool = False,
+    auto_approve: bool = False,
+) -> None:
     from codd.init.lexicon_suggest import (
         append_suggested_lexicons,
         describe_lexicons,
@@ -533,6 +552,42 @@ def _offer_lexicon_suggestions(project_root: Path) -> None:
     )
     from codd.init.stack_detector import StackDetector
 
+    if llm_enhanced:
+        from codd.init.llm_lexicon_suggester import llm_recommend_lexicons
+
+        llm_result = llm_recommend_lexicons(project_root)
+        if llm_result.recommendations:
+            descriptions = describe_lexicons(rec.lexicon_id for rec in llm_result.recommendations)
+            click.echo("")
+            click.echo("[LLM-enhanced] Analyzing project ...")
+            click.echo("[LLM-enhanced] Detected:")
+            click.echo(f"  - Domain: {llm_result.detected_domain or 'unknown'}")
+            click.echo(f"  - Compliance: {_format_detected_items(llm_result.detected_compliance)}")
+            click.echo(f"  - Tech stack: {_format_detected_items(llm_result.detected_tech_stack)}")
+            click.echo(f"  - Integrations: {_format_detected_items(llm_result.detected_integrations)}")
+            click.echo("")
+            click.echo("[LLM-enhanced] Recommended lexicons:")
+            for index, recommendation in enumerate(llm_result.recommendations, start=1):
+                description = descriptions.get(recommendation.lexicon_id, "")
+                suffix = f" ({description})" if description else ""
+                click.echo(
+                    f"  {index}. {_confidence_icon(recommendation.confidence)} "
+                    f"{recommendation.lexicon_id}{suffix} [{recommendation.confidence}]"
+                )
+                if recommendation.reason:
+                    click.echo(f"     {recommendation.reason}")
+
+            selected = _select_llm_recommendations(llm_result, auto_approve=auto_approve)
+            if not selected:
+                click.echo("LLM-enhanced lexicons not added.")
+                return
+            path = append_suggested_lexicons(project_root, selected)
+            rel_path = path.relative_to(project_root).as_posix()
+            click.echo(f"{rel_path} updated ({len(selected)} suggested lexicons)")
+            return
+        click.echo("")
+        click.echo("[LLM-enhanced] No usable recommendation; falling back to stack-based suggestions.")
+
     detection = StackDetector().detect(project_root)
     if not detection.stack_hints:
         return
@@ -559,6 +614,51 @@ def _offer_lexicon_suggestions(project_root: Path) -> None:
     click.echo(f"{rel_path} updated ({len(suggestions)} suggested lexicons)")
 
 
+def _format_detected_items(items: list[str]) -> str:
+    return ", ".join(items) if items else "none"
+
+
+def _confidence_icon(confidence: str) -> str:
+    return {"high": "✅", "medium": "⚠️", "low": "△"}.get(confidence, "△")
+
+
+def _select_llm_recommendations(llm_result: Any, *, auto_approve: bool) -> list[str]:
+    if auto_approve:
+        return [
+            recommendation.lexicon_id
+            for recommendation in llm_result.recommendations
+            if recommendation.confidence in {"high", "medium"}
+        ]
+
+    choice = click.prompt("Apply all recommended? [Y/n/select]", default="Y", show_default=False).strip().lower()
+    if choice in {"y", "yes", ""}:
+        return [
+            recommendation.lexicon_id
+            for recommendation in llm_result.recommendations
+            if recommendation.confidence in {"high", "medium"}
+        ]
+    if choice in {"n", "no"}:
+        return []
+    if choice != "select":
+        click.echo("Invalid selection; suggested lexicons not added.")
+        return []
+
+    raw_numbers = click.prompt("Select recommendation numbers", default="", show_default=False).strip()
+    selected: list[str] = []
+    for token in re.split(r"[\s,]+", raw_numbers):
+        if not token:
+            continue
+        try:
+            index = int(token)
+        except ValueError:
+            continue
+        if 1 <= index <= len(llm_result.recommendations):
+            lexicon_id = llm_result.recommendations[index - 1].lexicon_id
+            if lexicon_id not in selected:
+                selected.append(lexicon_id)
+    return selected
+
+
 @main.group("lexicon")
 def lexicon_cmd() -> None:
     """Manage bundled lexicon plug-ins."""

{codd_dev-2.6.1 → codd_dev-2.8.0}/codd/elicit/engine.py

@@ -292,18 +292,23 @@ def _existing_axes_text(project_root: Path) -> str:
 
 
 def _project_scope_phase(project_root: Path) -> tuple[str, str]:
+    # cmd_455: default scope = system_implementation matches CoDD's design
+    # focus. Projects that want every dimension (including business goals,
+    # UAT detail, risk register) opt in via `scope: full` in project_lexicon.yaml.
+    from codd.lexicon import DEFAULT_PHASE, DEFAULT_SCOPE
+
     for name in ("project_lexicon.yaml", "project_lexicon.yml"):
         path = project_root / name
         if not path.is_file():
             continue
         payload = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
         if not isinstance(payload, Mapping):
-            return "full", "production"
+            return DEFAULT_SCOPE, DEFAULT_PHASE
         return (
-            str(payload.get("scope") or "full"),
-            str(payload.get("phase") or "production"),
+            str(payload.get("scope") or DEFAULT_SCOPE),
+            str(payload.get("phase") or DEFAULT_PHASE),
         )
-    return "full", "production"
+    return DEFAULT_SCOPE, DEFAULT_PHASE
 
 
 def _apply_scope_phase(

codd_dev-2.8.0/codd/init/llm_lexicon_suggester.py

@@ -0,0 +1,234 @@
+"""LLM-backed lexicon recommendation from project context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any, Literal, Protocol
+
+import yaml
+
+from codd.deployment.providers.ai_command import AiCommandError, SubprocessAiCommand
+from codd.init.lexicon_suggest import default_lexicon_root
+from codd.init.stack_detector import StackDetector
+
+
+Confidence = Literal["high", "medium", "low"]
+_CONFIDENCES: set[str] = {"high", "medium", "low"}
+_MAX_DOC_CHARS = 24_000
+_MAX_FILE_CHARS = 4_000
+
+
+class AiCommand(Protocol):
+    def invoke(self, prompt: str, model: str | None = None) -> str:
+        """Return an AI response for the supplied prompt."""
+
+
+@dataclass(frozen=True)
+class LlmLexiconRecommendation:
+    lexicon_id: str
+    confidence: Confidence
+    reason: str
+
+
+@dataclass(frozen=True)
+class LlmLexiconResult:
+    detected_domain: str
+    detected_compliance: list[str]
+    detected_tech_stack: list[str]
+    detected_integrations: list[str]
+    recommendations: list[LlmLexiconRecommendation]
+
+
+def llm_recommend_lexicons(
+    project_root: Path,
+    *,
+    ai_command: AiCommand | None = None,
+) -> LlmLexiconResult:
+    """Recommend lexicons via AI, returning an empty result on unusable input."""
+
+    root = Path(project_root)
+    context = _collect_project_context(root)
+    if not context["requirements"]:
+        return _empty_result()
+
+    available = _available_lexicons()
+    if not available:
+        return _empty_result()
+
+    command = ai_command or SubprocessAiCommand(project_root=root)
+    prompt = _build_prompt(context, available)
+    try:
+        raw_output = command.invoke(prompt)
+        payload = json.loads(_extract_json_object(raw_output))
+    except (AiCommandError, OSError, TypeError, ValueError, json.JSONDecodeError):
+        return _empty_result()
+    return _result_from_payload(payload, set(available))
+
+
+def _collect_project_context(project_root: Path) -> dict[str, Any]:
+    requirements = _read_matching_files(
+        project_root,
+        [
+            "requirements.md",
+            ".codd/requirements.md",
+            "codd/requirements.md",
+            "docs/requirements.md",
+            "docs/requirements*.md",
+            "docs/requirements/**/*.md",
+        ],
+    )
+    designs = _read_matching_files(
+        project_root,
+        [
+            "design/*.md",
+            ".codd/design/*.md",
+            "codd/design/*.md",
+            "docs/design/*.md",
+        ],
+    )
+    detection = StackDetector().detect(project_root)
+    return {
+        "requirements": requirements,
+        "designs": designs,
+        "tech_stack_hints": detection.stack_hints,
+        "detected_signals": detection.detected_signals,
+    }
+
+
+def _read_matching_files(project_root: Path, patterns: list[str]) -> list[dict[str, str]]:
+    seen: set[Path] = set()
+    files: list[dict[str, str]] = []
+    budget = _MAX_DOC_CHARS
+    for pattern in patterns:
+        for path in sorted(project_root.glob(pattern)):
+            if path in seen or not path.is_file():
+                continue
+            seen.add(path)
+            if budget <= 0:
+                return files
+            text = path.read_text(encoding="utf-8", errors="replace")[: min(_MAX_FILE_CHARS, budget)]
+            budget -= len(text)
+            files.append({"path": path.relative_to(project_root).as_posix(), "content": text})
+    return files
+
+
+def _available_lexicons() -> dict[str, str]:
+    root = default_lexicon_root()
+    available: dict[str, str] = {}
+    if not root.is_dir():
+        return available
+    for manifest in sorted(root.glob("*/manifest.yaml")):
+        try:
+            payload = yaml.safe_load(manifest.read_text(encoding="utf-8")) or {}
+        except (OSError, yaml.YAMLError):
+            continue
+        if not isinstance(payload, dict):
+            continue
+        lexicon_id = manifest.parent.name
+        if not lexicon_id:
+            continue
+        available[lexicon_id] = str(payload.get("description") or "").strip()
+    return available
+
+
+def _build_prompt(context: dict[str, Any], available_lexicons: dict[str, str]) -> str:
+    payload = {
+        "available_lexicons": available_lexicons,
+        "project_context": context,
+        "required_output_schema": {
+            "detected_domain": "string",
+            "detected_compliance": ["string"],
+            "detected_tech_stack": ["string"],
+            "detected_integrations": ["string"],
+            "recommendations": [
+                {
+                    "lexicon_id": "string from available_lexicons keys",
+                    "confidence": "high | medium | low",
+                    "reason": "short explanation",
+                }
+            ],
+        },
+    }
+    return (
+        "You are a requirements engineer. Analyze the project's documentation and "
+        "technology signals. Identify the business domain, compliance obligations, "
+        "technology stack, and external integrations using only the supplied project "
+        "context. From the available lexicons, recommend the most relevant entries. "
+        "Return JSON only. Do not include Markdown fences or prose.\n\n"
+        f"{json.dumps(payload, ensure_ascii=False, indent=2)}"
+    )
+
+
+def _extract_json_object(raw_output: str) -> str:
+    text = raw_output.strip()
+    if text.startswith("```"):
+        lines = text.splitlines()
+        if lines and lines[0].startswith("```"):
+            lines = lines[1:]
+        if lines and lines[-1].strip() == "```":
+            lines = lines[:-1]
+        text = "\n".join(lines).strip()
+    start = text.find("{")
+    end = text.rfind("}")
+    if start == -1 or end == -1 or end < start:
+        raise ValueError("LLM output did not contain a JSON object")
+    return text[start : end + 1]
+
+
+def _result_from_payload(payload: Any, available_ids: set[str]) -> LlmLexiconResult:
+    if not isinstance(payload, dict):
+        return _empty_result()
+
+    recommendations: list[LlmLexiconRecommendation] = []
+    seen: set[str] = set()
+    rows = payload.get("recommendations", [])
+    if isinstance(rows, list):
+        for row in rows:
+            if not isinstance(row, dict):
+                continue
+            lexicon_id = str(row.get("lexicon_id") or "").strip()
+            confidence = str(row.get("confidence") or "").strip().lower()
+            if lexicon_id not in available_ids or confidence not in _CONFIDENCES or lexicon_id in seen:
+                continue
+            seen.add(lexicon_id)
+            recommendations.append(
+                LlmLexiconRecommendation(
+                    lexicon_id=lexicon_id,
+                    confidence=confidence,  # type: ignore[arg-type]
+                    reason=str(row.get("reason") or "").strip(),
+                )
+            )
+
+    return LlmLexiconResult(
+        detected_domain=str(payload.get("detected_domain") or "").strip(),
+        detected_compliance=_string_list(payload.get("detected_compliance")),
+        detected_tech_stack=_string_list(payload.get("detected_tech_stack")),
+        detected_integrations=_string_list(payload.get("detected_integrations")),
+        recommendations=recommendations,
+    )
+
+
+def _string_list(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(item).strip() for item in value if str(item).strip()]
+
+
+def _empty_result() -> LlmLexiconResult:
+    return LlmLexiconResult(
+        detected_domain="",
+        detected_compliance=[],
+        detected_tech_stack=[],
+        detected_integrations=[],
+        recommendations=[],
+    )
+
+
+__all__ = [
+    "AiCommand",
+    "LlmLexiconRecommendation",
+    "LlmLexiconResult",
+    "llm_recommend_lexicons",
+]

{codd_dev-2.6.1 → codd_dev-2.8.0}/codd/lexicon.py

@@ -14,7 +14,11 @@ import yaml
 SCHEMA_PATH = Path(__file__).parent / "templates" / "lexicon_schema.yaml"
 LEXICON_FILENAME = "project_lexicon.yaml"
 REQUIRED_ARTIFACT_SOURCES = {"ai_derived", "user_override", "default_template"}
-DEFAULT_SCOPE = "full"
+# cmd_455: CoDD's responsibility is system-implementation coherence. Business
+# concerns (goal/KPI, acceptance/UAT detail, risk register) belong upstream of
+# the DAG and should not surface as findings unless the project opts in
+# explicitly with `scope: full` or `scope: business_only`.
+DEFAULT_SCOPE = "system_implementation"
 DEFAULT_PHASE = "production"
 LEGACY_SUGGESTED_LEXICONS_WARNING = (
     "suggested_lexicons is deprecated, renamed to extends; auto-merged"

{codd_dev-2.6.1 → codd_dev-2.8.0}/pyproject.toml

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