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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.2.0
+Version: 2.4.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.2.0 → codd_dev-2.4.0}/codd/dag/builder.py

@@ -610,6 +610,42 @@ def _add_deployment_graph(
     )
     verification_tests = extract_verification_tests(project_root, project_config, design_docs)
 
+    from codd.deployment.extractor import (
+        auto_runtime_states_for_impl,
+        discover_deployment_impl_candidates,
+    )
+
+    capability_patterns = _capability_patterns(project_config)
+    auto_impl_paths: list[Path] = []
+    for impl_path in discover_deployment_impl_candidates(project_root, deployment_docs):
+        rel_id = impl_path.relative_to(project_root).as_posix()
+        if rel_id in dag.nodes:
+            continue
+        _add_node_once(
+            dag,
+            Node(
+                id=rel_id,
+                kind="impl_file",
+                path=rel_id,
+                attributes={
+                    "language": _language_for_path(impl_path),
+                    "imports": [],
+                    "runtime_evidence": _runtime_evidence_for_file(impl_path, rel_id, capability_patterns),
+                    "auto_registered_for_deployment": True,
+                },
+            ),
+        )
+        impl_nodes[rel_id] = impl_path.resolve()
+        auto_impl_paths.append(impl_path)
+
+    if auto_impl_paths:
+        existing_state_ids = {state.identifier for state in runtime_states}
+        for runtime_state in auto_runtime_states_for_impl(auto_impl_paths, project_root):
+            if runtime_state.identifier in existing_state_ids:
+                continue
+            runtime_states.append(runtime_state)
+            existing_state_ids.add(runtime_state.identifier)
+
     for deployment_doc in deployment_docs:
         _add_node_once(
             dag,

{codd_dev-2.2.0 → codd_dev-2.4.0}/codd/deployment/extractor.py

@@ -31,6 +31,17 @@ SMOKE_TEST_PATTERNS = ("tests/smoke/*.test.ts", "tests/smoke/*.spec.ts", "tests/
 E2E_TEST_PATTERNS = ("tests/e2e/*.spec.ts", "tests/e2e/*.test.ts")
 RUNTIME_CAPABILITY_INFERENCE_DEFAULTS = Path(__file__).parent / "defaults" / "runtime_capability_inference.yaml"
 
+DEPLOYMENT_SECTION_IMPL_PATTERNS: dict[str, tuple[str, ...]] = {
+    "migrate": ("prisma/migrations/**/*", "schema.prisma", "**/migrations/**/*.sql"),
+    "seed": ("prisma/seed.ts", "prisma/seed.js", "scripts/seed.ts", "scripts/seed.js"),
+    "build": ("Dockerfile", "Containerfile", "package.json"),
+    "start": (
+        "main.ts", "main.js", "server.ts", "server.js",
+        "app.ts", "app.js", "index.ts", "index.js",
+        "src/main.ts", "src/main.js", "src/server.ts", "src/server.js",
+    ),
+}
+
 
 def extract_deployment_nodes(project_root: Path, codd_config: dict[str, Any] | None = None) -> dict[str, list]:
     """Extract deployment document, runtime state, and verification test nodes."""
@@ -181,6 +192,129 @@ def extract_verification_tests(
     return [tests[key] for key in sorted(tests)]
 
 
+_DEPLOYMENT_BINDINGS_CACHE: list[dict[str, Any]] | None = None
+
+
+def load_deployment_bindings() -> list[dict[str, Any]]:
+    """Load impl_pattern → runtime_state bindings from codd_plugins/stack_map.yaml.
+
+    Returns a list of dicts with normalized keys (compiled `impl_re`,
+    `runtime_state_kind`, `runtime_state_target`). The mapping itself lives
+    in the plug-in YAML so CoDD core stays free of stack-specific filenames.
+    """
+    global _DEPLOYMENT_BINDINGS_CACHE
+    if _DEPLOYMENT_BINDINGS_CACHE is not None:
+        return _DEPLOYMENT_BINDINGS_CACHE
+
+    candidates = [
+        Path(__file__).resolve().parents[2] / "codd_plugins" / "stack_map.yaml",
+        Path.cwd() / "codd_plugins" / "stack_map.yaml",
+    ]
+    payload: dict[str, Any] | None = None
+    for candidate in candidates:
+        if candidate.is_file():
+            payload = yaml.safe_load(candidate.read_text(encoding="utf-8")) or {}
+            break
+
+    bindings: list[dict[str, Any]] = []
+    raw_bindings = (payload or {}).get("deployment_bindings", [])
+    if isinstance(raw_bindings, list):
+        for entry in raw_bindings:
+            if not isinstance(entry, dict):
+                continue
+            pattern = str(entry.get("impl_pattern", "")).strip()
+            kind_str = str(entry.get("runtime_state_kind", "")).strip()
+            target = str(entry.get("runtime_state_target", "")).strip()
+            if not pattern or not kind_str or not target:
+                continue
+            try:
+                kind = RuntimeStateKind(kind_str)
+            except ValueError:
+                continue
+            try:
+                impl_re = re.compile(pattern)
+            except re.error:
+                continue
+            bindings.append({
+                "impl_re": impl_re,
+                "runtime_state_kind": kind,
+                "runtime_state_target": target,
+            })
+    _DEPLOYMENT_BINDINGS_CACHE = bindings
+    return bindings
+
+
+def reset_deployment_bindings_cache() -> None:
+    """Clear the cached bindings (used by tests)."""
+    global _DEPLOYMENT_BINDINGS_CACHE
+    _DEPLOYMENT_BINDINGS_CACHE = None
+
+
+def auto_runtime_states_for_impl(impl_paths: list[Path], project_root: Path) -> list[RuntimeStateNode]:
+    """Generate runtime_state nodes for auto-discovered impl artifacts.
+
+    For each impl path, the first matching deployment binding produces one
+    RuntimeStateNode keyed `runtime:<kind>:<target>`. Duplicates (same
+    identifier) are coalesced.
+    """
+    bindings = load_deployment_bindings()
+    if not bindings:
+        return []
+    seen: dict[str, RuntimeStateNode] = {}
+    root = Path(project_root)
+    for path in impl_paths:
+        rel = path.relative_to(root).as_posix() if path.is_absolute() else str(path)
+        for binding in bindings:
+            if not binding["impl_re"].search(rel):
+                continue
+            target = binding["runtime_state_target"]
+            kind = binding["runtime_state_kind"]
+            identifier = f"runtime:{kind.value}:{target}"
+            if identifier in seen:
+                break
+            seen[identifier] = RuntimeStateNode(
+                identifier=identifier,
+                kind=kind,
+                target=target,
+                expected_value=None,
+                actual_check_command=None,
+                capabilities_provided=[],
+            )
+            break
+    return list(seen.values())
+
+
+def discover_deployment_impl_candidates(
+    project_root: Path,
+    deployment_docs: list[DeploymentDocNode],
+) -> list[Path]:
+    """Return existing standard impl artifacts referenced by deployment doc sections.
+
+    Walks each deployment document's sections and matches keywords against
+    DEPLOYMENT_SECTION_IMPL_PATTERNS, then keeps the patterns that resolve to a
+    real file under ``project_root``. The mapping itself stays inside the
+    deployment plug-in so DAG core code can remain free of stack-specific
+    filenames; this helper just runs an existence check.
+    """
+
+    root = Path(project_root)
+    seen: dict[str, Path] = {}
+    for doc in deployment_docs:
+        for section in doc.sections or []:
+            normalized = str(section).lower()
+            for keyword, patterns in DEPLOYMENT_SECTION_IMPL_PATTERNS.items():
+                if keyword not in normalized:
+                    continue
+                for pattern in patterns:
+                    for path in root.glob(pattern):
+                        if not path.is_file():
+                            continue
+                        rel = path.relative_to(root).as_posix()
+                        if rel not in seen:
+                            seen[rel] = path
+    return list(seen.values())
+
+
 def infer_deployment_edges(
     project_root: Path,
     deployment_docs: list[DeploymentDocNode],
@@ -527,6 +661,10 @@ def _runtime_kind_for_impl(impl_id: str) -> RuntimeStateKind | None:
         return RuntimeStateKind.DB_SEED
     if name in {"main.ts", "main.js", "server.ts", "server.js", "app.ts", "app.js", "index.ts", "index.js"}:
         return RuntimeStateKind.SERVER_RUNNING
+
+    for binding in load_deployment_bindings():
+        if binding["impl_re"].search(impl_id):
+            return binding["runtime_state_kind"]
     return None
 
 
@@ -544,6 +682,13 @@ def _verification_matches_runtime(
         return _mentions_any(target, ("schema", "migration", "migrate", "database", "db"))
     if runtime_state.kind is RuntimeStateKind.SERVER_RUNNING:
         return _mentions_any(target, ("health", "server", "start", "running", "home"))
+    if runtime_state.kind is RuntimeStateKind.FILE_PRESENT:
+        return _mentions_any(
+            target,
+            ("build", "image", "container", "deploy", "compose", "smoke", "artifact"),
+        )
+    if runtime_state.kind is RuntimeStateKind.ENV_VAR_SET:
+        return _mentions_any(target, ("env", "config", "secret"))
     return False
 
 

{codd_dev-2.2.0 → codd_dev-2.4.0}/codd_plugins/stack_map.yaml

@@ -76,3 +76,21 @@ stack_map:
     suggested_lexicons:
       - babok
 
+# Deployment artifact bindings — used by the deployment plug-in to wire
+# auto-discovered impl_file nodes (cmd_448) to runtime_state nodes
+# (cmd_450). Keys: impl_pattern (regex against impl_id), runtime_state_kind
+# (one of RuntimeStateKind values), runtime_state_target (string label used
+# to form `runtime:<kind>:<target>` and to match verification tests).
+# Adding entries does not require core code changes; CoDD core loads this
+# block as data.
+deployment_bindings:
+  - impl_pattern: "(^|/)Dockerfile$|(^|/)Containerfile$"
+    runtime_state_kind: file_present
+    runtime_state_target: build_artifact
+  - impl_pattern: "(^|/)docker-compose(\\.production|\\.staging)?\\.ya?ml$|(^|/)compose\\.ya?ml$"
+    runtime_state_kind: file_present
+    runtime_state_target: container_compose
+  - impl_pattern: "(^|/)package\\.json$"
+    runtime_state_kind: file_present
+    runtime_state_target: build_artifact
+

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

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