codd-dev 1.35.0__tar.gz → 1.37.0__tar.gz

{codd_dev-1.35.0 → codd_dev-1.37.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 1.35.0
+Version: 1.37.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-1.35.0 → codd_dev-1.37.0}/codd/cli.py

@@ -288,13 +288,9 @@ def _resolve_bootstrap_codd_dir(project_root: Path) -> Path:
         return existing
 
     hidden_dir = project_root / ".codd"
-    default_dir = project_root / "codd"
     if hidden_dir.exists():
         return hidden_dir
-    if default_dir.exists():
-        # Avoid writing config into projects whose source package is already named codd/.
-        return hidden_dir
-    return default_dir
+    return hidden_dir
 
 
 def _format_yaml_list(items: list[str], *, indent: int = 4) -> str:
@@ -1028,6 +1024,75 @@ def elicit_apply_cmd(input_file: Path, format_name: str, project_path: str) -> N
         click.echo(f"Updated: {file_path}")
 
 
+@main.command("brownfield")
+@click.argument("target_path", type=click.Path(file_okay=False, path_type=Path))
+@click.option(
+    "--requirements",
+    "requirements_path",
+    type=click.Path(dir_okay=False, path_type=Path),
+    default=None,
+    help="Requirements file (default: <target>/.codd/requirements.md; skipped if absent).",
+)
+@click.option(
+    "--lexicon",
+    "lexicon_path",
+    type=click.Path(path_type=Path),
+    default=None,
+    help="Lexicon directory or manifest (default: <target>/.codd/lexicon; discovery mode if absent).",
+)
+@click.option(
+    "--format",
+    "format_name",
+    type=click.Choice(["json", "md"]),
+    default="md",
+    show_default=True,
+    help="Integrated report format.",
+)
+@click.option("--output", type=click.Path(dir_okay=False, path_type=Path), default=None, help="Output report file.")
+@click.option(
+    "--ai-cmd",
+    default=None,
+    help="Override AI CLI command for diff and elicit engines.",
+)
+def brownfield_cmd(
+    target_path: Path,
+    requirements_path: Path | None,
+    lexicon_path: Path | None,
+    format_name: str,
+    output: Path | None,
+    ai_cmd: str | None,
+) -> None:
+    """Run brownfield extract, diff, elicit, and merged reporting."""
+    from codd.brownfield.pipeline import BrownfieldPipeline, format_brownfield_result
+
+    project_root = target_path.expanduser().resolve()
+    try:
+        result = BrownfieldPipeline(ai_command=ai_cmd).run(
+            project_root,
+            requirements_path=requirements_path,
+            lexicon_path=lexicon_path,
+        )
+        formatted = format_brownfield_result(result, format_name)
+        output_path = _project_file(
+            project_root,
+            output,
+            f".codd/brownfield_report.{format_name}",
+        )
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(formatted, encoding="utf-8")
+    except (OSError, TypeError, ValueError, json.JSONDecodeError, yaml.YAMLError) as exc:
+        click.echo(f"Error: {exc}")
+        raise SystemExit(1)
+
+    click.echo(
+        "Brownfield pipeline complete: "
+        f"diff_findings={len(result.diff_findings)}, "
+        f"elicit_findings={len(result.elicit_findings)}, "
+        f"merged_findings={len(result.merged_findings)}"
+    )
+    click.echo(f"Output: {_display_path(output_path, project_root)}")
+
+
 @main.group("diff", invoke_without_command=True)
 @click.option("--extract-input", type=click.Path(dir_okay=False, path_type=Path), default=None)
 @click.option("--requirements", "requirements_path", type=click.Path(dir_okay=False, path_type=Path), default=None)
@@ -1068,7 +1133,7 @@ def diff_cmd(
     from codd.elicit.formatters.md import MdFormatter
 
     project_root = Path(project_path).resolve()
-    extract_path = _project_file(project_root, extract_input, "codd/extracted.md")
+    extract_path = _resolve_diff_extract_input(project_root, extract_input)
     req_path = _project_file(project_root, requirements_path, "docs/requirements/requirements.md")
     output_path = _project_file(project_root, output, "drift_findings.md") if output is not None or format_name == "md" else None
 
@@ -1161,6 +1226,37 @@ def _project_file(project_root: Path, value: Path | None, default: str) -> Path:
     return project_root / path
 
 
+def _resolve_diff_extract_input(project_root: Path, value: Path | None) -> Path:
+    """Locate the extract-input file, preferring isolated `.codd/extract/` output.
+
+    Order of resolution:
+    1. Explicit ``--extract-input`` value (absolute or project-relative).
+    2. ``.codd/extract/extracted.md`` (default Issue #17 isolation target).
+    3. Top-level ``extracted.md`` aggregated output if present.
+    4. First ``.codd/extract/modules/*.md`` module file (deterministic by name).
+    5. Legacy fallback ``codd/extracted.md`` (preserved for older projects).
+    """
+    if value is not None:
+        candidate = value.expanduser()
+        return candidate if candidate.is_absolute() else project_root / candidate
+
+    candidates: list[Path] = [
+        project_root / ".codd" / "extract" / "extracted.md",
+        project_root / "extracted.md",
+    ]
+    modules_dir = project_root / ".codd" / "extract" / "modules"
+    if modules_dir.is_dir():
+        module_files = sorted(modules_dir.glob("*.md"))
+        if module_files:
+            candidates.append(module_files[0])
+    candidates.append(project_root / "codd" / "extracted.md")
+
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    return candidates[0]
+
+
 def _build_diff_engine(engine_cls: Any, ai_cmd: str | None, project_root: Path) -> Any:
     attempts = (
         lambda: engine_cls(llm_client=ai_cmd, project_root=project_root),
@@ -2203,7 +2299,8 @@ def e2e_generate_legacy(path: str, base_url: str, output: str | None, framework:
 @click.option("--path", default=".", help="Project root directory")
 @click.option("--language", default=None, help="Override language detection (python/typescript/javascript/go — full support; java — symbols only)")
 @click.option("--source-dirs", default=None, help="Comma-separated source directories (default: auto-detect)")
-@click.option("--output", default=None, help="Output directory (default: <config-dir>/extracted/)")
+@click.option("--output", default=None, help="Output directory (default: <project-root>/.codd/extract/)")
+@click.option("--init", "initialize", is_flag=True, help="Add brownfield init metadata to generated YAML/Markdown")
 @click.option("--ai", is_flag=True, default=False, help="Use AI-powered extraction (6-layer MECE design docs)")
 @click.option(
     "--ai-cmd",
@@ -2237,6 +2334,7 @@ def extract(
     language: str | None,
     source_dirs: str | None,
     output: str | None,
+    initialize: bool,
     ai: bool,
     ai_cmd: str | None,
     prompt_file: str | None,
@@ -2249,9 +2347,8 @@ def extract(
     Default mode: static analysis (no AI, pure structural facts).
     With --ai: AI-powered 6-layer MECE extraction using claude --print.
 
-    Output goes to the discovered CoDD config dir as draft documents
-    (`codd/extracted/` or `.codd/extracted/`). Review and promote
-    confirmed docs when ready.
+    Output goes to `.codd/extract/` by default. Review and promote confirmed
+    docs when ready.
     """
     if ctx.invoked_subcommand is not None:
         return
@@ -2259,7 +2356,13 @@ def extract(
     project_root = Path(path).resolve()
     bootstrap_codd_dir = _resolve_bootstrap_codd_dir(project_root)
     dirs = [d.strip() for d in source_dirs.split(",") if d.strip()] if source_dirs else None
-    output_path = Path(output) if output else bootstrap_codd_dir / "extracted"
+    output_path = Path(output) if output else project_root / ".codd" / "extract"
+    if output and not output_path.is_absolute():
+        output_path = project_root / output_path
+    init_metadata = None
+    if initialize:
+        from codd.extractor import build_extract_init_metadata
+        init_metadata = build_extract_init_metadata(project_root)
 
     if layer == "routes":
         from codd.config import load_project_config
@@ -2314,6 +2417,9 @@ def extract(
         except Exception as exc:
             click.echo(f"Error: {exc}")
             raise SystemExit(1)
+        if init_metadata is not None:
+            from codd.extractor import add_extract_init_frontmatter
+            add_extract_init_frontmatter(result.generated_files, init_metadata)
 
         facts = extract_facts(project_root, language, dirs)
         config_path, generated_config = _ensure_bootstrap_codd_yaml(
@@ -2340,7 +2446,7 @@ def extract(
         from codd.extractor import run_extract
 
         try:
-            result = run_extract(project_root, language, dirs, str(output_path))
+            result = run_extract(project_root, language, dirs, str(output_path), init_metadata=init_metadata)
         except Exception as exc:
             click.echo(f"Error: {exc}")
             raise SystemExit(1)

{codd_dev-1.35.0 → codd_dev-1.37.0}/codd/elicit/finding.py

@@ -41,13 +41,12 @@ class Finding:
 
         finding_id = str(payload.get("id", "")).strip()
         kind = str(payload.get("kind", "")).strip()
-        severity = str(payload.get("severity", "")).strip()
+        raw_severity = str(payload.get("severity", "")).strip()
         if not finding_id:
             raise ValueError("Finding id is required")
         if not kind:
             raise ValueError("Finding kind is required")
-        if severity not in _SEVERITIES:
-            raise ValueError(f"Finding severity must be one of {sorted(_SEVERITIES)}")
+        severity = _coerce_severity(raw_severity)
 
         source = str(payload.get("source", "greenfield")).strip() or "greenfield"
         if source not in _SOURCES:
@@ -85,6 +84,41 @@ def _optional_text(value: Any) -> str | None:
     return text if text else None
 
 
+_SEVERITY_ALIASES = {
+    "blocker": "critical",
+    "fatal": "critical",
+    "severe": "critical",
+    "urgent": "critical",
+    "error": "high",
+    "major": "high",
+    "important": "high",
+    "warn": "medium",
+    "warning": "medium",
+    "moderate": "medium",
+    "minor": "info",
+    "low": "info",
+    "informational": "info",
+    "note": "info",
+    "trivial": "info",
+}
+
+
+def _coerce_severity(raw: str) -> str:
+    """Map a raw severity string into the canonical Literal set, with a safe fallback.
+
+    Strict membership is preserved for canonical values; common synonyms are mapped
+    deterministically; anything unknown defaults to ``info`` so downstream tools stay
+    operational rather than aborting on LLM drift. Generic mapping only — no stack /
+    framework / domain literals.
+    """
+    cleaned = raw.lower().strip()
+    if cleaned in _SEVERITIES:
+        return cleaned
+    if cleaned in _SEVERITY_ALIASES:
+        return _SEVERITY_ALIASES[cleaned]
+    return "info"
+
+
 @dataclass
 class ElicitResult:
     findings: list[Finding] = field(default_factory=list)

{codd_dev-1.35.0 → codd_dev-1.37.0}/codd/extract_ai.py

@@ -49,6 +49,12 @@ SCHEMA_PATTERNS = [
     "prisma/schema.prisma", "db/schema.rb", "alembic/versions",
 ]
 
+# Generic source extensions included in the AI context scan. The deterministic
+# parser decides language-specific structure later; this layer keeps raw text.
+SOURCE_EXTENSIONS = {
+    ".go", ".java", ".js", ".jsx", ".php", ".py", ".rb", ".ts", ".tsx", ".vue",
+}
+
 # Max file size to include in prompt (bytes)
 MAX_FILE_SIZE = 50_000
 
@@ -171,9 +177,45 @@ def _find_source_files(root: Path) -> list[Path]:
         # Filter out files in skip dirs
         found = [f for f in found if not any(s in f.parts for s in SKIP_DIRS)]
         files.extend(found)
+    files.extend(_find_source_files_by_extension(root))
     return sorted(set(files))
 
 
+def _find_source_files_by_extension(root: Path) -> list[Path]:
+    """Find source files generically by extension, preserving raw text for AI."""
+    files: list[Path] = []
+    for current, dirs, filenames in os.walk(root):
+        dirs[:] = [
+            d for d in dirs
+            if d not in SKIP_DIRS and not d.startswith(".")
+        ]
+        current_path = Path(current)
+        for filename in filenames:
+            path = current_path / filename
+            if path.suffix not in SOURCE_EXTENSIONS:
+                continue
+            try:
+                rel_parts = path.relative_to(root).parts
+            except ValueError:
+                continue
+            if _is_test_path(rel_parts) or any(part in SKIP_DIRS for part in rel_parts):
+                continue
+            files.append(path)
+    return files
+
+
+def _is_test_path(parts: tuple[str, ...]) -> bool:
+    if any(part in {"test", "tests", "spec", "__tests__"} for part in parts[:-1]):
+        return True
+    filename = parts[-1].lower() if parts else ""
+    return (
+        filename.startswith("test_")
+        or filename.endswith(("_test.py", "_spec.rb"))
+        or ".test." in filename
+        or ".spec." in filename
+    )
+
+
 def _find_iac_files(root: Path) -> list[Path]:
     """Find IaC and DevOps files."""
     iac: list[Path] = []
@@ -198,6 +240,8 @@ def _find_iac_files(root: Path) -> list[Path]:
 def _find_test_files(root: Path) -> list[Path]:
     """Find test files (paths only, not contents)."""
     patterns = [
+        "tests/test_*.py", "tests/**/test_*.py",
+        "test/test_*.py", "test/**/test_*.py",
         "tests/**/*.test.*", "tests/**/*.spec.*",
         "test/**/*.test.*", "test/**/*.spec.*",
         "src/**/*.test.*", "src/**/*.spec.*",
@@ -206,11 +250,21 @@ def _find_test_files(root: Path) -> list[Path]:
     tests: list[Path] = []
     for pattern in patterns:
         found = list(root.glob(pattern))
-        found = [f for f in found if not any(s in f.parts for s in SKIP_DIRS)]
+        found = [
+            f for f in found
+            if not any(s in _relative_parts(root, f) for s in SKIP_DIRS)
+        ]
         tests.extend(found)
     return sorted(set(tests))
 
 
+def _relative_parts(root: Path, path: Path) -> tuple[str, ...]:
+    try:
+        return path.relative_to(root).parts
+    except ValueError:
+        return path.parts
+
+
 def pre_scan(project_root: Path) -> PreScanResult:
     """Phase 1: Deterministic pre-scan of the project."""
     result = PreScanResult(
@@ -456,11 +510,11 @@ def run_extract_ai(
     Args:
         project_root: Path to the project to extract from.
         ai_command: AI CLI command (e.g. 'claude --print --model claude-opus-4-6').
-        output_dir: Output directory (default: {project_root}/codd/extracted/).
+        output_dir: Output directory (default: {project_root}/.codd/extract/).
         prompt_file: Path to a custom prompt file. Overrides the built-in baseline preset.
     """
     project_root = project_root.resolve()
-    out = Path(output_dir) if output_dir else project_root / "codd" / "extracted"
+    out = Path(output_dir) if output_dir else project_root / ".codd" / "extract"
     out.mkdir(parents=True, exist_ok=True)
 
     # Phase 1: Pre-scan

{codd_dev-1.35.0 → codd_dev-1.37.0}/codd/extractor.py

@@ -12,6 +12,7 @@ Two-phase architecture:
 import os
 import re
 from dataclasses import dataclass, field
+from datetime import datetime
 from pathlib import Path
 from typing import Any
 
@@ -125,6 +126,59 @@ class ExtractResult:
     source_dirs: list[str]
 
 
+def build_extract_init_metadata(project_root: Path, extracted_at: str | None = None) -> dict[str, str]:
+    """Build generic brownfield extraction metadata for generated YAML/Markdown."""
+    timestamp = extracted_at or datetime.now().astimezone().replace(microsecond=0).isoformat()
+    return {
+        "version": "1.0",
+        "extracted_at": timestamp,
+        "source": project_root.resolve().as_posix(),
+    }
+
+
+def add_extract_init_frontmatter(paths: list[Path], metadata: dict[str, str]) -> None:
+    """Add codd init metadata to generated Markdown frontmatter or YAML payloads."""
+    for path in paths:
+        suffix = path.suffix.lower()
+        if suffix in {".md", ".markdown"}:
+            _upsert_markdown_codd_metadata(path, metadata)
+        elif suffix in {".yaml", ".yml"}:
+            _upsert_yaml_codd_metadata(path, metadata)
+
+
+def _merge_codd_metadata(payload: Any, metadata: dict[str, str]) -> dict[str, Any]:
+    if not isinstance(payload, dict):
+        payload = {}
+    codd = payload.get("codd")
+    if not isinstance(codd, dict):
+        codd = {}
+    codd.update(metadata)
+    payload["codd"] = codd
+    return payload
+
+
+def _upsert_markdown_codd_metadata(path: Path, metadata: dict[str, str]) -> None:
+    text = path.read_text(encoding="utf-8")
+    match = re.match(r"\A---\s*\n(.*?)\n---\s*\n?", text, re.DOTALL)
+    if match:
+        frontmatter = yaml.safe_load(match.group(1)) or {}
+        body = text[match.end():]
+    else:
+        frontmatter = {}
+        body = text
+
+    payload = _merge_codd_metadata(frontmatter, metadata)
+    rendered = yaml.safe_dump(payload, sort_keys=False, allow_unicode=True)
+    separator = "" if body.startswith("\n") else "\n"
+    path.write_text(f"---\n{rendered}---\n{separator}{body}", encoding="utf-8")
+
+
+def _upsert_yaml_codd_metadata(path: Path, metadata: dict[str, str]) -> None:
+    payload = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    merged = _merge_codd_metadata(payload, metadata)
+    path.write_text(yaml.safe_dump(merged, sort_keys=False, allow_unicode=True), encoding="utf-8")
+
+
 # ═══════════════════════════════════════════════════════════
 # Phase 1: Extract Facts (deterministic, no AI)
 # ═══════════════════════════════════════════════════════════
@@ -695,28 +749,13 @@ def _detect_patterns(facts: ProjectFacts, project_root: Path):
 
 
 def _detect_python_patterns(facts: ProjectFacts, content: str):
-    frameworks = {
-        "fastapi": "FastAPI", "flask": "Flask", "django": "Django",
-        "starlette": "Starlette", "tornado": "Tornado", "aiohttp": "aiohttp",
-    }
-    orms = {
-        "sqlalchemy": "SQLAlchemy", "django": "Django ORM",
-        "tortoise-orm": "Tortoise ORM", "peewee": "Peewee",
-        "sqlmodel": "SQLModel", "prisma": "Prisma",
-    }
-    test_fw = {
-        "pytest": "pytest", "unittest": "unittest", "nose": "nose2",
-    }
+    """No-op: framework/ORM/test detection is delegated to LLM (extract --ai).
 
-    for key, name in frameworks.items():
-        if key in content.lower():
-            facts.detected_frameworks.append(name)
-    for key, name in orms.items():
-        if key in content.lower() and not facts.detected_orm:
-            facts.detected_orm = name
-    for key, name in test_fw.items():
-        if key in content.lower() and not facts.detected_test_framework:
-            facts.detected_test_framework = name
+    Removed in v1.36.0 to honor Generality Gate. Hard-coded framework/ORM/test
+    dictionaries violated the constraint that CoDD core must remain stack-agnostic.
+    The downstream AI extraction path (codd/extract_ai.py) infers these dynamically.
+    """
+    return
 
 
 def _detect_js_patterns(facts: ProjectFacts, content: str):
@@ -973,7 +1012,8 @@ def synth_architecture(facts: ProjectFacts, output_dir: Path) -> Path:
 
 def run_extract(project_root: Path, language: str | None = None,
                 source_dirs: list[str] | None = None,
-                output: str | None = None) -> ExtractResult:
+                output: str | None = None,
+                init_metadata: dict[str, str] | None = None) -> ExtractResult:
     """Run full extract pipeline: facts → docs."""
 
     # Try to load config if it exists
@@ -994,11 +1034,11 @@ def run_extract(project_root: Path, language: str | None = None,
     # Phase 2: Generate docs
     if output:
         output_dir = Path(output)
-    elif codd_dir is not None:
-        output_dir = codd_dir / "extracted"
     else:
-        output_dir = project_root / "codd" / "extracted"
+        output_dir = project_root / ".codd" / "extract"
     generated = synth_docs(facts, output_dir)
+    if init_metadata is not None:
+        add_extract_init_frontmatter(generated, init_metadata)
 
     return ExtractResult(
         output_dir=output_dir,