codd-dev 2.7.0__tar.gz → 2.9.0__tar.gz

{codd_dev-2.7.0 → codd_dev-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.7.0
+Version: 2.9.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.7.0 → codd_dev-2.9.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,41 @@ 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"  - Data types: {_format_detected_items(llm_result.detected_data_types)}")
+            click.echo(f"  - Function traits: {_format_detected_items(llm_result.detected_function_traits)}")
+            click.echo(f"  - Tech stack: {_format_detected_items(llm_result.detected_tech_stack)}")
+            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 +613,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.7.0 → codd_dev-2.9.0}/codd/coverage_auditor.py

@@ -109,7 +109,7 @@ class CoverageAuditor:
             lowered = text.lower()
             text_terms = _terms(lowered)
             if (
-                {"lms", "e-learning", "elearning"} & text_terms
+                {"e-learning", "elearning"} & text_terms
                 or "learning management" in lowered
                 or len(
                     {
@@ -244,7 +244,7 @@ class CoverageAuditor:
             },
         ]
 
-        lms = [
+        learning_platform = [
             *base_web,
             *self._build_auth_ui_surface_checklist(),
             {
@@ -362,7 +362,7 @@ class CoverageAuditor:
         ]
 
         checklists = {
-            "LMS/EdTech": lms,
+            "LMS/EdTech": learning_platform,
             "FinTech": [
                 *base_web,
                 {

codd_dev-2.9.0/codd/init/llm_lexicon_suggester.py

@@ -0,0 +1,242 @@
+"""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_data_types: list[str]
+    detected_function_traits: list[str]
+    detected_tech_stack: 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_data_types": ["string"],
+            "detected_function_traits": ["string"],
+            "detected_tech_stack": ["string"],
+            "recommendations": [
+                {
+                    "lexicon_id": "string from available_lexicons keys",
+                    "confidence": "high | medium | low",
+                    "reason": "short explanation referencing a data type or function trait",
+                }
+            ],
+        },
+    }
+    return (
+        "You are a requirements engineer. Analyze this project's documentation and tech stack.\n"
+        "Identify:\n"
+        "- Data types handled (personal information / credit card data / medical records / "
+        "video content / etc.)\n"
+        "- Function traits present (authentication flow / payment processing / public API / "
+        "video streaming / etc.)\n"
+        "- Tech stack (frameworks, databases, cloud platforms)\n\n"
+        "Reasoning rules (apply dynamically):\n"
+        "- personal information present -> recommend data_governance_appi_gdpr (or GDPR equivalent)\n"
+        "- credit card data present -> recommend compliance_pci_dss_4\n"
+        "- medical data present -> recommend compliance_hipaa\n"
+        "- authentication flow present -> consider web_authn_webauthn\n"
+        "- public REST API present -> recommend api_rest_openapi\n"
+        "- etc.\n\n"
+        "From the available lexicons, recommend the most relevant ones with lexicon_id, "
+        "confidence (high/medium/low), and reason referencing the data type or function trait. "
+        "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_data_types=_string_list(payload.get("detected_data_types")),
+        detected_function_traits=_string_list(payload.get("detected_function_traits")),
+        detected_tech_stack=_string_list(payload.get("detected_tech_stack")),
+        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_data_types=[],
+        detected_function_traits=[],
+        detected_tech_stack=[],
+        recommendations=[],
+    )
+
+
+__all__ = [
+    "AiCommand",
+    "LlmLexiconRecommendation",
+    "LlmLexiconResult",
+    "llm_recommend_lexicons",
+]

{codd_dev-2.7.0 → codd_dev-2.9.0}/pyproject.toml

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