codd-dev 1.22.0__tar.gz → 1.23.0__tar.gz

{codd_dev-1.22.0 → codd_dev-1.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 1.22.0
+Version: 1.23.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
@@ -19,6 +19,7 @@ Requires-Dist: click>=8.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: tomli>=2.0.1; python_version < '3.11'
+Requires-Dist: watchdog>=4.0.0
 Provides-Extra: ai
 Provides-Extra: api-parsers
 Requires-Dist: graphql-core>=3.2.0; extra == 'api-parsers'
@@ -950,23 +951,49 @@ You:  yes
 
 ### Hook Integration — Set It Once, Never Think Again
 
-Add this hook and **you never run `codd scan` manually again.** Every file edit triggers it automatically — the dependency graph is always current, always accurate, zero mental overhead:
+CoDD ships copyable hook recipes in `codd/hooks/recipes/` so Claude, Codex, and Git can all trigger the same change-driven propagation path:
+`codd propagate-from --files <changed-file>`.
+
+#### Claude PostToolUse
+
+Use `codd/hooks/recipes/claude_settings_example.json` as the starting point for `.claude/settings.json`. It listens for Edit / Write / MultiEdit and extracts changed files from `TOOL_INPUT` before calling `propagate-from`.
 
 ```json
 {
   "hooks": {
     "PostToolUse": [{
-      "matcher": "Edit|Write",
+      "matcher": "Edit|Write|MultiEdit",
       "hooks": [{
         "type": "command",
-        "command": "codd scan --path ."
+        "command": "python -m codd propagate-from --files <changed-file> --source editor_hook --editor claude"
       }]
     }]
   }
 }
 ```
 
-With hooks active, your entire workflow becomes: **edit files normally, then run `/codd-impact` when you want to know what's affected.** That's it. The graph maintenance is invisible.
+#### Codex Post-Edit
+
+Use `codd/hooks/recipes/codex_hook.sh` when your Codex wrapper can pass edited files through `CODEX_EDITED_FILES`:
+
+```bash
+export CODEX_EDITED_FILES="src/app.ts,docs/design/api.md"
+bash codd/hooks/recipes/codex_hook.sh
+```
+
+#### Git Hooks
+
+Use the git recipes as a final catch for manual edits and non-editor workflows:
+
+```bash
+cp codd/hooks/recipes/git_pre_commit.sh .git/hooks/pre-commit
+cp codd/hooks/recipes/git_post_commit.sh .git/hooks/post-commit
+chmod +x .git/hooks/pre-commit .git/hooks/post-commit
+```
+
+The pre-commit hook runs `propagate-from` in `--dry-run` mode against staged files. The post-commit hook runs propagation against the committed file set.
+
+With hooks active, your entire workflow becomes: **edit files normally, and CoDD propagates the change from the files that actually changed.** The graph maintenance is invisible.
 
 ### Available Skills
 

{codd_dev-1.22.0 → codd_dev-1.23.0}/README.md

@@ -912,23 +912,49 @@ You:  yes
 
 ### Hook Integration — Set It Once, Never Think Again
 
-Add this hook and **you never run `codd scan` manually again.** Every file edit triggers it automatically — the dependency graph is always current, always accurate, zero mental overhead:
+CoDD ships copyable hook recipes in `codd/hooks/recipes/` so Claude, Codex, and Git can all trigger the same change-driven propagation path:
+`codd propagate-from --files <changed-file>`.
+
+#### Claude PostToolUse
+
+Use `codd/hooks/recipes/claude_settings_example.json` as the starting point for `.claude/settings.json`. It listens for Edit / Write / MultiEdit and extracts changed files from `TOOL_INPUT` before calling `propagate-from`.
 
 ```json
 {
   "hooks": {
     "PostToolUse": [{
-      "matcher": "Edit|Write",
+      "matcher": "Edit|Write|MultiEdit",
       "hooks": [{
         "type": "command",
-        "command": "codd scan --path ."
+        "command": "python -m codd propagate-from --files <changed-file> --source editor_hook --editor claude"
       }]
     }]
   }
 }
 ```
 
-With hooks active, your entire workflow becomes: **edit files normally, then run `/codd-impact` when you want to know what's affected.** That's it. The graph maintenance is invisible.
+#### Codex Post-Edit
+
+Use `codd/hooks/recipes/codex_hook.sh` when your Codex wrapper can pass edited files through `CODEX_EDITED_FILES`:
+
+```bash
+export CODEX_EDITED_FILES="src/app.ts,docs/design/api.md"
+bash codd/hooks/recipes/codex_hook.sh
+```
+
+#### Git Hooks
+
+Use the git recipes as a final catch for manual edits and non-editor workflows:
+
+```bash
+cp codd/hooks/recipes/git_pre_commit.sh .git/hooks/pre-commit
+cp codd/hooks/recipes/git_post_commit.sh .git/hooks/post-commit
+chmod +x .git/hooks/pre-commit .git/hooks/post-commit
+```
+
+The pre-commit hook runs `propagate-from` in `--dry-run` mode against staged files. The post-commit hook runs propagation against the committed file set.
+
+With hooks active, your entire workflow becomes: **edit files normally, and CoDD propagates the change from the files that actually changed.** The graph maintenance is invisible.
 
 ### Available Skills
 

{codd_dev-1.22.0 → codd_dev-1.23.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "1.22.0"
+__version__ = "1.23.0"

{codd_dev-1.22.0 → codd_dev-1.23.0}/codd/cli.py

@@ -344,23 +344,65 @@ def scan(path: str):
     run_scan(project_root, codd_dir)
 
 
-@main.command()
-@click.option("--diff", default="HEAD", help="Git diff target (default: HEAD, shows uncommitted changes)")
-@click.option("--path", default=".", help="Project root directory")
-@click.option("--output", default=None, help="Output file (default: stdout)")
-def impact(diff: str, path: str, output: str):
+@main.command()
+@click.option("--diff", default="HEAD", help="Git diff target (default: HEAD, shows uncommitted changes)")
+@click.option("--path", default=".", help="Project root directory")
+@click.option("--output", default=None, help="Output file (default: stdout)")
+def impact(diff: str, path: str, output: str):
     """Analyze change impact from git diff."""
     from codd.propagate import run_impact
     project_root = Path(path).resolve()
     codd_dir = _require_codd_dir(project_root)
-
-    run_impact(project_root, codd_dir, diff, output)
-
-
-@main.command()
-@click.option("--wave", required=True, type=click.IntRange(min=1), help="Wave number to generate")
-@click.option("--path", default=".", help="Project root directory")
-@click.option("--force", is_flag=True, help="Overwrite existing files")
+
+    run_impact(project_root, codd_dir, diff, output)
+
+
+@main.command("watch")
+@click.option("--project-path", "--path", default=".", show_default=True, help="Project root directory")
+@click.option("--debounce", default=500, show_default=True, type=int, help="Debounce interval in milliseconds")
+@click.option("--background", is_flag=True, default=False, help="Run watcher in background mode")
+@click.option("--status", is_flag=True, default=False, help="Show watcher status")
+def watch_cmd(project_path: str, debounce: int, background: bool, status: bool) -> None:
+    """Watch for file changes and emit CDAP file-change events."""
+    project_root = Path(project_path).resolve()
+    pid_file = project_root / ".codd" / "watch.pid"
+
+    if status:
+        if pid_file.exists():
+            click.echo(f"Watcher running (PID: {pid_file.read_text(encoding='utf-8').strip()})")
+        else:
+            click.echo("Watcher not running")
+        return
+
+    from codd.watch.events import FileChangeEvent
+    from codd.watch.watcher import start_watch
+
+    if not project_root.exists():
+        click.echo(f"Error: Project path does not exist: {project_root}")
+        raise SystemExit(1)
+    if not project_root.is_dir():
+        click.echo(f"Error: Project path is not a directory: {project_root}")
+        raise SystemExit(1)
+
+    pid_file.parent.mkdir(parents=True, exist_ok=True)
+    pid_file.write_text(f"{os.getpid()}\n", encoding="utf-8")
+
+    def on_change(event: FileChangeEvent) -> None:
+        preview = ", ".join(event.files[:3])
+        suffix = "" if len(event.files) <= 3 else f", ... {len(event.files) - 3} more"
+        click.echo(f"[watch] {len(event.files)} file(s) changed: {preview}{suffix}")
+
+    click.echo(f"Watching {project_root} (debounce={debounce}ms)")
+    observer = start_watch(project_root, on_change, debounce_ms=debounce, background=background)
+    if background:
+        click.echo(f"Watcher running in background mode (PID: {os.getpid()})")
+        observer.join(timeout=0)
+
+
+@main.command()
+@click.option("--wave", required=True, type=click.IntRange(min=1), help="Wave number to generate")
+@click.option("--path", default=".", help="Project root directory")
+@click.option("--force", is_flag=True, help="Overwrite existing files")
 @click.option(
     "--ai-cmd",
     default=None,
@@ -852,11 +894,47 @@ def propagate(diff: str, path: str, update: bool, verify: bool, do_commit: bool,
         click.echo(f"  [{status}] {doc.path} ({doc.node_id})")
         click.echo(f"    modules: {', '.join(doc.matched_modules)}")
 
-    if not update and result.affected_docs:
-        click.echo(f"\nRun with --update to update these docs via AI.")
-
-
-@main.command()
+    if not update and result.affected_docs:
+        click.echo(f"\nRun with --update to update these docs via AI.")
+
+
+@main.command("propagate-from")
+@click.option("--project-path", default=".", show_default=True, help="Project root directory")
+@click.option("--files", multiple=True, required=True, help="Changed file path. Can be repeated.")
+@click.option(
+    "--source",
+    default="manual",
+    show_default=True,
+    type=click.Choice(["watch", "git_hook", "editor_hook", "manual"]),
+    help="Change source that triggered propagation.",
+)
+@click.option(
+    "--editor",
+    default=None,
+    type=click.Choice(["claude", "codex", "manual"]),
+    help="Editor that produced the change, when known.",
+)
+@click.option("--dry-run", is_flag=True, default=False, help="Compute impact without propagate/fix/log writes.")
+def propagate_from(project_path: str, files: tuple[str, ...], source: str, editor: str | None, dry_run: bool):
+    """Run the CDAP propagation pipeline from changed files."""
+    from codd.watch.events import FileChangeEvent
+    from codd.watch.propagation_pipeline import run_propagation_pipeline
+
+    project_root = Path(project_path).resolve()
+    event = FileChangeEvent(files=list(files), source=source, editor=editor)
+    result = run_propagation_pipeline(project_root, list(files), dry_run=dry_run, event=event)
+
+    click.echo(f"Impacted nodes: {len(result.impacted_nodes)}")
+    click.echo(f"Propagated: {result.propagated_count}")
+    click.echo(f"Fixed: {result.fixed_count}")
+    if result.errors:
+        click.echo(f"Errors: {result.errors}", err=True)
+
+    if not result.success:
+        raise SystemExit(1)
+
+
+@main.command()
 @click.option("--path", default=".", help="Project root directory")
 @click.option("--task", default=None, help="Generate only one task by task ID or title match")
 @click.option("--clean", is_flag=True, default=False, help="Remove existing generated output before re-generating")
@@ -2183,6 +2261,28 @@ def mcp_server(project: str):
     run_stdio(project_root)
 
 
+@main.command("test")
+@click.option("--project-path", "--path", default=".", show_default=True, help="Project root directory")
+@click.option("--related", multiple=True, help="Run only tests related to these files")
+@click.option("--dry-run", is_flag=True, default=False, help="Print the related test command without running it")
+def test_cmd(project_path: str, related: tuple[str, ...], dry_run: bool):
+    """Run tests. Use --related <file> to run only related tests."""
+    from codd.watch.test_runner import run_related_tests
+
+    project_root = Path(project_path).resolve()
+    if not related:
+        click.echo("Use --related <file> to specify files. Full test run not supported via this command.")
+        return
+
+    result = run_related_tests(project_root, list(related), dry_run=dry_run)
+    click.echo(f"Related tests: {result['related']}")
+    if result.get("cmd"):
+        click.echo(f"Command: {result['cmd']}")
+    click.echo(f"Status: {result['status']}")
+    if result.get("exit_code") not in (None, 0):
+        raise SystemExit(1)
+
+
 @main.group()
 def dag():
     """DAG Completeness Gate commands."""

{codd_dev-1.22.0 → codd_dev-1.23.0}/codd/coherence_engine.py

@@ -80,7 +80,6 @@ def set_coherence_bus(bus: EventBus | None) -> None:
     """Set the opt-in coherence bus on detectors that publish DriftEvents."""
     for module_name in (
         "codd.drift",
-        "codd.drift_linkers.api",
         "codd.deployer",
         "codd.hitl_session",
         "codd.validator",

{codd_dev-1.22.0 → codd_dev-1.23.0}/codd/coverage_metrics.py

@@ -134,7 +134,7 @@ def compute_screen_flow_coverage(
     config: dict[str, Any],
     threshold: float = 100.0,
 ) -> CoverageResult:
-    """Measure screen-flow drift as a coverage gate metric."""
+    """Measure screen-flow route drift as a coverage gate metric."""
 
     try:
         from codd.cli import CoddCLIError
@@ -153,25 +153,9 @@ def compute_screen_flow_coverage(
             details=[f"error: {exc}"],
         )
 
-    design_drift_details: list[str] = []
-    design_drift_count = 0
-    try:
-        from codd.drift_linkers.screen_flow import ScreenFlowGate
-
-        gate_result = ScreenFlowGate(
-            project_root=project_root,
-            settings={**config, "apply": True},
-        ).run()
-        if not gate_result.skipped:
-            design_drift_count = gate_result.drift_count
-            design_drift_details = gate_result.details
-    except Exception as exc:  # pragma: no cover - defensive gate behavior
-        return _exception_result("screen_flow_coverage", threshold, exc)
-
-    drift_count = len(drifts) + design_drift_count
+    drift_count = len(drifts)
     pct = 100.0 if drift_count == 0 else max(0.0, 100.0 - drift_count * 10.0)
     details = [f"drift_count: {drift_count}"]
-    details.extend(design_drift_details)
     return CoverageResult(
         metric="screen_flow_coverage",
         total=1,

{codd_dev-1.22.0 → codd_dev-1.23.0}/codd/dag/builder.py

@@ -19,8 +19,10 @@ from codd.dag.extractor import extract_design_doc_metadata, extract_imports
 DEFAULTS_DIR = Path(__file__).parent / "defaults"
 DEFAULT_PROJECT_TYPE = "web"
 IMPLEMENTATION_SUFFIXES = (".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".java")
+TEST_SUFFIXES = (".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".bats")
 PLAN_HEADER_RE = re.compile(r"^#{2,6}\s+([A-Za-z0-9]+(?:[-_.][A-Za-z0-9]+)*)(?:\s+(.+))?$", re.MULTILINE)
 OUTPUTS_RE = re.compile(r"(?im)^outputs?[ \t]*:[ \t]*(.*)$")
+PY_IMPORT_RE = re.compile(r"(?m)^\s*(?:from\s+([A-Za-z_][\w.]*)(?:\s+import\s+)|import\s+([A-Za-z_][\w.]*))")
 
 
 def build_dag(project_root: Path, settings: dict[str, Any] | None = None) -> DAG:
@@ -35,9 +37,11 @@ def build_dag(project_root: Path, settings: dict[str, Any] | None = None) -> DAG
     dag = DAG()
     design_docs = _add_design_docs(dag, root, dag_settings)
     impl_nodes = _add_impl_files(dag, root, dag_settings)
+    test_nodes = _add_test_files(dag, root, dag_settings)
 
     _add_design_edges(dag, root, design_docs, impl_nodes)
     _add_import_edges(dag, root, impl_nodes, dag_settings)
+    _add_tested_by_edges(dag, root, impl_nodes, test_nodes, dag_settings)
     _add_plan_tasks(dag, root, dag_settings)
     _add_expected_nodes(dag, root, dag_settings, impl_nodes)
 
@@ -59,9 +63,12 @@ def load_dag_settings(project_root: Path, settings: dict[str, Any] | None = None
     merged = _read_default_settings(project_type)
     merged = _deep_merge(merged, _dag_overrides(project_config))
     merged = _deep_merge(merged, _dag_overrides(requested_settings))
+    _apply_scan_patterns(merged, project_config)
+    _apply_scan_patterns(merged, requested_settings)
     merged["project_type"] = project_type
     merged.setdefault("design_doc_patterns", [])
     merged.setdefault("impl_file_patterns", [])
+    merged.setdefault("test_file_patterns", [])
     merged.setdefault("plan_task_file", "docs/design/implementation_plan.md")
     merged.setdefault("lexicon_file", "project_lexicon.yaml")
     return merged
@@ -160,7 +167,11 @@ def _add_design_docs(dag: DAG, project_root: Path, settings: dict[str, Any]) ->
 def _add_impl_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> dict[str, Path]:
     impl_nodes: dict[str, Path] = {}
     for file_path in _glob_project_paths(project_root, settings.get("impl_file_patterns", [])):
-        if not file_path.is_file() or file_path.suffix not in IMPLEMENTATION_SUFFIXES:
+        if (
+            not file_path.is_file()
+            or file_path.suffix not in IMPLEMENTATION_SUFFIXES
+            or _is_test_file(file_path, project_root)
+        ):
             continue
         node_id = _relative_id(file_path, project_root)
         impl_nodes[node_id] = file_path.resolve()
@@ -179,6 +190,28 @@ def _add_impl_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> d
     return impl_nodes
 
 
+def _add_test_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> dict[str, Path]:
+    test_nodes: dict[str, Path] = {}
+    for file_path in _glob_project_paths(project_root, settings.get("test_file_patterns", [])):
+        if not file_path.is_file() or file_path.suffix not in TEST_SUFFIXES or not _is_test_file(file_path, project_root):
+            continue
+        node_id = _relative_id(file_path, project_root)
+        test_nodes[node_id] = file_path.resolve()
+        _add_node_once(
+            dag,
+            Node(
+                id=node_id,
+                kind="test_file",
+                path=node_id,
+                attributes={
+                    "language": _language_for_path(file_path),
+                    "imports": _extract_test_imports(file_path),
+                },
+            ),
+        )
+    return test_nodes
+
+
 def _add_design_edges(
     dag: DAG,
     project_root: Path,
@@ -217,6 +250,25 @@ def _add_import_edges(
                 dag.add_edge(Edge(from_id=node_id, to_id=target_id, kind="imports"))
 
 
+def _add_tested_by_edges(
+    dag: DAG,
+    project_root: Path,
+    impl_nodes: dict[str, Path],
+    test_nodes: dict[str, Path],
+    settings: dict[str, Any],
+) -> None:
+    path_to_node = {path: node_id for node_id, path in impl_nodes.items()}
+    aliases = _load_import_aliases(project_root, settings)
+    existing_edges = {(edge.from_id, edge.to_id, edge.kind) for edge in dag.edges}
+
+    for test_id, test_path in test_nodes.items():
+        for target_id in _infer_test_targets(test_path, project_root, path_to_node, aliases):
+            edge_key = (target_id, test_id, "tested_by")
+            if edge_key not in existing_edges:
+                dag.add_edge(Edge(from_id=target_id, to_id=test_id, kind="tested_by"))
+                existing_edges.add(edge_key)
+
+
 def _add_plan_tasks(dag: DAG, project_root: Path, settings: dict[str, Any]) -> None:
     plan_path = _project_path(project_root, str(settings.get("plan_task_file", "")))
     if not plan_path.is_file():
@@ -374,6 +426,52 @@ def _resolve_import_target(
     return None
 
 
+def _infer_test_targets(
+    test_path: Path,
+    project_root: Path,
+    path_to_node: dict[Path, str],
+    aliases: dict[str, list[str]],
+) -> set[str]:
+    targets: set[str] = set()
+
+    for import_ref in _extract_test_imports(test_path):
+        target_id = _resolve_import_target(import_ref, test_path, project_root, path_to_node, aliases)
+        if not target_id and "." in import_ref and not import_ref.startswith("."):
+            target_id = _resolve_python_import_target(import_ref, project_root, path_to_node)
+        if target_id:
+            targets.add(target_id)
+
+    convention_key = _test_convention_key(test_path, project_root)
+    if convention_key:
+        targets.update(_match_impl_by_convention(convention_key, path_to_node))
+        for candidate in _convention_path_candidates(test_path, project_root, convention_key):
+            target_id = _resolve_file_candidate(candidate, path_to_node)
+            if target_id:
+                targets.add(target_id)
+
+    return targets
+
+
+def _extract_test_imports(file_path: Path) -> list[str]:
+    imports = extract_imports(file_path)
+    if file_path.suffix != ".py":
+        return imports
+
+    content = file_path.read_text(encoding="utf-8", errors="ignore")
+    python_imports = [match.group(1) or match.group(2) for match in PY_IMPORT_RE.finditer(content)]
+    return [*imports, *python_imports]
+
+
+def _resolve_python_import_target(import_ref: str, project_root: Path, path_to_node: dict[Path, str]) -> str | None:
+    module_path = (project_root / import_ref.replace(".", "/")).resolve()
+    resolved = _resolve_file_candidate(module_path, path_to_node)
+    if resolved:
+        return resolved
+
+    init_path = module_path / "__init__.py"
+    return path_to_node.get(init_path)
+
+
 def _resolve_file_candidate(candidate: Path, path_to_node: dict[Path, str]) -> str | None:
     if candidate in path_to_node:
         return path_to_node[candidate]
@@ -388,9 +486,75 @@ def _resolve_file_candidate(candidate: Path, path_to_node: dict[Path, str]) -> s
         indexed = candidate / f"index{suffix}"
         if indexed in path_to_node:
             return path_to_node[indexed]
+    init_file = candidate / "__init__.py"
+    if init_file in path_to_node:
+        return path_to_node[init_file]
     return None
 
 
+def _test_convention_key(test_path: Path, project_root: Path) -> str | None:
+    relative_parts = _relative_id(test_path, project_root).split("/")
+    name = test_path.name
+
+    for marker in (".test.", ".spec."):
+        if marker in name:
+            return name.split(marker, 1)[0]
+
+    if test_path.suffix == ".py" and any(part in {"tests", "test"} for part in relative_parts[:-1]):
+        stem = test_path.stem
+        if stem.startswith("test_"):
+            return stem.removeprefix("test_")
+        if stem.endswith("_test"):
+            return stem.removesuffix("_test")
+
+    return None
+
+
+def _match_impl_by_convention(convention_key: str, path_to_node: dict[Path, str]) -> set[str]:
+    matches: set[str] = set()
+    for _impl_path, node_id in path_to_node.items():
+        if convention_key in _impl_convention_tokens(node_id):
+            matches.add(node_id)
+    return matches
+
+
+def _impl_convention_tokens(node_id: str) -> set[str]:
+    path = Path(node_id)
+    parts = [*path.with_suffix("").parts]
+    tokens = {path.stem}
+    if len(parts) >= 2:
+        tokens.add("_".join(parts[-2:]))
+    if len(parts) >= 3:
+        tokens.add("_".join(parts[-3:]))
+    return tokens
+
+
+def _convention_path_candidates(test_path: Path, project_root: Path, convention_key: str) -> list[Path]:
+    candidates: list[Path] = []
+    suffixes = [".py"] if test_path.suffix == ".py" else [".ts", ".tsx", ".js", ".jsx"]
+
+    if any(marker in test_path.name for marker in (".test.", ".spec.")):
+        candidates.append((test_path.parent / convention_key).resolve())
+
+    for root_name in ("codd", "src"):
+        for suffix in suffixes:
+            candidates.append((project_root / root_name / f"{convention_key}{suffix}").resolve())
+
+    return candidates
+
+
+def _is_test_file(file_path: Path, project_root: Path) -> bool:
+    relative_parts = _relative_id(file_path, project_root).split("/")
+    name = file_path.name
+    if any(marker in name for marker in (".test.", ".spec.")):
+        return True
+    if file_path.suffix == ".bats":
+        return True
+    if file_path.suffix == ".py" and any(part in {"tests", "test"} for part in relative_parts[:-1]):
+        return name.startswith("test_") or name.endswith("_test.py")
+    return False
+
+
 def _load_import_aliases(project_root: Path, settings: dict[str, Any]) -> dict[str, list[str]]:
     aliases: dict[str, list[str]] = {}
     configured = settings.get("import_aliases", {})
@@ -467,6 +631,7 @@ def _dag_overrides(config: dict[str, Any]) -> dict[str, Any]:
     direct_keys = {
         "design_doc_patterns",
         "impl_file_patterns",
+        "test_file_patterns",
         "plan_task_file",
         "lexicon_file",
         "import_aliases",
@@ -477,6 +642,31 @@ def _dag_overrides(config: dict[str, Any]) -> dict[str, Any]:
     return overrides
 
 
+def _apply_scan_patterns(settings: dict[str, Any], config: dict[str, Any]) -> None:
+    scan = config.get("scan", {})
+    if not isinstance(scan, dict):
+        return
+
+    source_dirs = _as_list(scan.get("source_dirs"))
+    test_dirs = _as_list(scan.get("test_dirs"))
+    doc_dirs = _as_list(scan.get("doc_dirs"))
+
+    if source_dirs:
+        _extend_unique(
+            settings,
+            "impl_file_patterns",
+            _file_patterns_for_dirs(source_dirs, IMPLEMENTATION_SUFFIXES),
+        )
+    if test_dirs:
+        _extend_unique(
+            settings,
+            "test_file_patterns",
+            _file_patterns_for_dirs(test_dirs, TEST_SUFFIXES),
+        )
+    if doc_dirs:
+        _extend_unique(settings, "design_doc_patterns", _file_patterns_for_dirs(doc_dirs, (".md",)))
+
+
 def _normalize_dag_section(section: dict[str, Any]) -> dict[str, Any]:
     normalized = deepcopy(section)
     node_extraction = normalized.pop("node_extraction", None)
@@ -485,6 +675,8 @@ def _normalize_dag_section(section: dict[str, Any]) -> dict[str, Any]:
             normalized["design_doc_patterns"] = node_extraction["design_glob"]
         if "impl_glob" in node_extraction:
             normalized["impl_file_patterns"] = node_extraction["impl_glob"]
+        if "test_glob" in node_extraction:
+            normalized["test_file_patterns"] = node_extraction["test_glob"]
         if "plan_path" in node_extraction:
             normalized["plan_task_file"] = node_extraction["plan_path"]
     return normalized
@@ -522,6 +714,27 @@ def _as_list(value: Any) -> list[Any]:
     return [value]
 
 
+def _file_patterns_for_dirs(dirs: list[Any], suffixes: tuple[str, ...]) -> list[str]:
+    patterns: list[str] = []
+    for directory in dirs:
+        if not isinstance(directory, str) or not directory.strip():
+            continue
+        base = directory.strip().strip("/")
+        if not base or base == ".":
+            base = "**"
+        for suffix in suffixes:
+            patterns.append(f"{base}/**/*{suffix}")
+    return patterns
+
+
+def _extend_unique(settings: dict[str, Any], key: str, values: list[str]) -> None:
+    current = [str(item) for item in _as_list(settings.get(key)) if item]
+    for value in values:
+        if value not in current:
+            current.append(value)
+    settings[key] = current
+
+
 def _add_node_once(dag: DAG, node: Node) -> None:
     if node.id not in dag.nodes:
         dag.add_node(node)

codd_dev-1.23.0/codd/dag/defaults/test_frameworks.yaml

@@ -0,0 +1,7 @@
+test_framework: pytest
+test_runners:
+  pytest: "python -m pytest {files} -q"
+  jest: "npx jest {files}"
+  vitest: "npx vitest run {files}"
+  bats: "bats {files}"
+  go_test: "go test {files}"

{codd_dev-1.22.0 → codd_dev-1.23.0}/codd/dag/defaults/web.yaml

@@ -11,4 +11,14 @@ impl_file_patterns:
   - "src/**/*.tsx"
   - "app/**/*.ts"
   - "app/**/*.tsx"
+test_file_patterns:
+  - "tests/**/*.py"
+  - "tests/**/*.ts"
+  - "tests/**/*.tsx"
+  - "tests/**/*.js"
+  - "tests/**/*.jsx"
+  - "**/*.test.ts"
+  - "**/*.test.tsx"
+  - "**/*.spec.ts"
+  - "**/*.spec.tsx"
 plan_task_file: "docs/design/implementation_plan.md"