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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 1.35.0
+Version: 1.36.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.36.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:
@@ -2203,7 +2199,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 +2234,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 +2247,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 +2256,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 +2317,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 +2346,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.36.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.36.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,