codd-dev 1.25.0__tar.gz → 1.26.0__tar.gz

{codd_dev-1.25.0 → codd_dev-1.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 1.25.0
+Version: 1.26.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
@@ -20,6 +20,7 @@ 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
+Requires-Dist: websocket-client>=1.8.0
 Provides-Extra: ai
 Provides-Extra: api-parsers
 Requires-Dist: graphql-core>=3.2.0; extra == 'api-parsers'

{codd_dev-1.25.0 → codd_dev-1.26.0}/codd/cli.py

@@ -2283,6 +2283,119 @@ def test_cmd(project_path: str, related: tuple[str, ...], dry_run: bool):
         raise SystemExit(1)
 
 
+@main.group()
+def llm():
+    """Manage LLM-derived considerations."""
+    pass
+
+
+@llm.command("derive")
+@click.argument("design_doc", type=click.Path(exists=True, dir_okay=False, path_type=Path))
+@click.option("--path", "project_path", default=".", help="Project root directory")
+@click.option("--ai-cmd", default=None, help="Override AI CLI command")
+@click.option("--model", default=None, help="Override AI model")
+@click.option("--force", is_flag=True, help="Bypass cached derived considerations")
+def llm_derive(design_doc: Path, project_path: str, ai_cmd: str | None, model: str | None, force: bool):
+    """Derive considerations for a design document."""
+    from codd.deployment.providers.ai_command import SubprocessAiCommand
+    from codd.deployment.providers.llm_consideration import LlmConsiderationProvider
+    from codd.llm.approval import notify_pending_considerations
+
+    project_root = Path(project_path).resolve()
+    config = _load_optional_project_config(project_root)
+    provider = LlmConsiderationProvider(
+        SubprocessAiCommand(command=ai_cmd, project_root=project_root, config=config),
+        project_root=project_root,
+        cache_dir=project_root / ".codd" / "consideration_cache",
+        model=model,
+        use_cache=not force,
+    )
+    result = provider.provide(design_doc.read_text(encoding="utf-8"), {"model": model} if model else {})
+    notify_pending_considerations(result.considerations, config)
+    click.echo(f"Derived considerations: {len(result.considerations)}")
+
+
+@llm.command("approve")
+@click.argument("consideration_id", required=False)
+@click.option("--all", "approve_all", is_flag=True, help="Approve all pending considerations")
+@click.option("--path", "project_path", default=".", help="Project root directory")
+def llm_approve(consideration_id: str | None, approve_all: bool, project_path: str):
+    """Approve one or all pending considerations."""
+    from codd.llm.approval import ApprovalCache, consideration_status, load_cached_considerations
+
+    project_root = Path(project_path).resolve()
+    considerations = load_cached_considerations(project_root)
+    by_id = {consideration.id: consideration for consideration in considerations}
+
+    if approve_all:
+        targets = [
+            consideration
+            for consideration in considerations
+            if consideration_status(consideration, project_root) == "pending"
+        ]
+    else:
+        if not consideration_id:
+            click.echo("Error: consideration_id or --all is required")
+            raise SystemExit(2)
+        if consideration_id not in by_id:
+            click.echo(f"Error: consideration not found: {consideration_id}")
+            raise SystemExit(1)
+        targets = [by_id[consideration_id]]
+
+    for consideration in targets:
+        ApprovalCache.save(consideration.id, "approved", project_root)
+    click.echo(f"Approved considerations: {len(targets)}")
+
+
+@llm.command("skip")
+@click.argument("consideration_id")
+@click.option("--path", "project_path", default=".", help="Project root directory")
+def llm_skip(consideration_id: str, project_path: str):
+    """Skip one consideration."""
+    from codd.llm.approval import ApprovalCache, load_cached_considerations
+
+    project_root = Path(project_path).resolve()
+    known = {consideration.id for consideration in load_cached_considerations(project_root)}
+    if consideration_id not in known:
+        click.echo(f"Error: consideration not found: {consideration_id}")
+        raise SystemExit(1)
+    ApprovalCache.save(consideration_id, "skipped", project_root)
+    click.echo(f"Skipped consideration: {consideration_id}")
+
+
+@llm.command("list")
+@click.option("--path", "project_path", default=".", help="Project root directory")
+@click.option("--format", "output_format", default="text", type=click.Choice(["text", "json"]))
+def llm_list(project_path: str, output_format: str):
+    """List generated considerations with approval status."""
+    from codd.llm.approval import consideration_status, consideration_to_dict, load_cached_considerations
+
+    project_root = Path(project_path).resolve()
+    rows = []
+    for consideration in sorted(load_cached_considerations(project_root), key=lambda item: item.id):
+        row = consideration_to_dict(consideration)
+        row["status"] = consideration_status(consideration, project_root)
+        rows.append(row)
+
+    if output_format == "json":
+        click.echo(json.dumps(rows, ensure_ascii=False, indent=2))
+        return
+
+    if not rows:
+        click.echo("No considerations found")
+        return
+    for row in rows:
+        description = str(row.get("description") or "")
+        click.echo(f"{row['id']}\t{row['status']}\t{description}")
+
+
+def _load_optional_project_config(project_root: Path) -> dict[str, Any]:
+    try:
+        return load_project_config(project_root)
+    except (FileNotFoundError, ValueError):
+        return {}
+
+
 @main.group()
 def dag():
     """DAG Completeness Gate commands."""
@@ -2429,7 +2542,7 @@ def dag_journeys(project_path: str, output_format: str):
         click.echo(f"Error: {exc}")
         raise SystemExit(1)
 
-    journeys = _collect_dag_journeys(built_dag)
+    journeys = _collect_dag_journeys(built_dag, project_root, _load_optional_project_config(project_root))
     if output_format == "json":
         click.echo(json.dumps(journeys, ensure_ascii=False, indent=2))
         return
@@ -2447,12 +2560,120 @@ def dag_journeys(project_path: str, output_format: str):
         click.echo(f"  {journey['name']} [{journey['criticality']}]  requires: {requires}")
 
 
-def _collect_dag_journeys(dag: Any) -> list[dict[str, Any]]:
+@dag.command("run-journey")
+@click.argument("journey_name")
+@click.option("--project-path", "--path", default=".", show_default=True, help="Project root directory")
+@click.option(
+    "--config-section",
+    default="cdp_browser",
+    show_default=True,
+    help="verification.templates section used for browser config",
+)
+def dag_run_journey(journey_name: str, project_path: str, config_section: str):
+    """Run one declared user_journey with the CDP browser template."""
+    from codd.dag.builder import build_dag
+    from codd.deployment.providers.verification.cdp_browser import CdpBrowser
+
+    project_root = Path(project_path).resolve()
+    try:
+        config = load_project_config(project_root)
+        template_config = _journey_template_config(config, config_section)
+        built_dag = build_dag(project_root)
+    except (FileNotFoundError, ValueError) as exc:
+        click.echo(f"Error: {exc}")
+        raise SystemExit(2)
+
+    journey_record = _find_dag_journey(built_dag, journey_name, project_root, config)
+    if journey_record is None:
+        click.echo(f"Error: user_journey not found: {journey_name}")
+        raise SystemExit(2)
+
+    command = json.dumps(
+        _journey_execution_plan(project_root, journey_record, template_config),
+        sort_keys=True,
+    )
+    result = CdpBrowser(config=template_config).execute(command)
+    if result.output:
+        click.echo(result.output)
+    raise SystemExit(0 if result.passed else 1)
+
+
+def _journey_template_config(config: dict[str, Any], config_section: str) -> dict[str, Any]:
+    verification = config.get("verification")
+    templates = verification.get("templates") if isinstance(verification, dict) else None
+    if not isinstance(templates, dict) or config_section not in templates:
+        raise ValueError(f"verification.templates.{config_section} config not found")
+
+    section = templates[config_section]
+    if not isinstance(section, dict):
+        raise ValueError(f"verification.templates.{config_section} must be a mapping")
+    return dict(section)
+
+
+def _find_dag_journey(
+    dag: Any,
+    journey_name: str,
+    project_root: Path | None = None,
+    settings: dict[str, Any] | None = None,
+) -> dict[str, Any] | None:
+    for node in sorted(dag.nodes.values(), key=lambda item: item.id):
+        if node.kind != "design_doc":
+            continue
+        for journey in _node_user_journeys(node, project_root, settings):
+            if str(journey.get("name") or "") == journey_name:
+                return {
+                    "design_doc": node.path or node.id,
+                    "journey": dict(journey),
+                }
+    return None
+
+
+def _journey_execution_plan(
+    project_root: Path,
+    journey_record: dict[str, Any],
+    template_config: dict[str, Any],
+) -> dict[str, Any]:
+    journey = dict(journey_record["journey"])
+    journey_name = str(journey.get("name") or "")
+    steps = journey.get("steps")
+    return {
+        "template": "cdp_browser",
+        "test_kind": "e2e",
+        "target": _journey_target(journey),
+        "identifier": f"journey:{journey_name}",
+        "journey": journey_name,
+        "steps": steps if isinstance(steps, list) else [],
+        "project_root": str(project_root),
+        "design_doc": journey_record["design_doc"],
+        "config": template_config,
+    }
+
+
+def _journey_target(journey: dict[str, Any]) -> str:
+    steps = journey.get("steps")
+    if isinstance(steps, list):
+        for step in steps:
+            if not isinstance(step, dict):
+                continue
+            if step.get("action") == "navigate":
+                target = step.get("target") or step.get("url")
+                if target:
+                    return str(target)
+
+    target = journey.get("target") or journey.get("url")
+    return str(target or "")
+
+
+def _collect_dag_journeys(
+    dag: Any,
+    project_root: Path | None = None,
+    settings: dict[str, Any] | None = None,
+) -> list[dict[str, Any]]:
     journeys: list[dict[str, Any]] = []
     for node in sorted(dag.nodes.values(), key=lambda item: item.id):
         if node.kind != "design_doc":
             continue
-        for journey in _node_user_journeys(node):
+        for journey in _node_user_journeys(node, project_root, settings):
             journeys.append(
                 {
                     "design_doc": node.path or node.id,
@@ -2464,7 +2685,16 @@ def _collect_dag_journeys(dag: Any) -> list[dict[str, Any]]:
     return journeys
 
 
-def _node_user_journeys(node: Any) -> list[dict[str, Any]]:
+def _node_user_journeys(
+    node: Any,
+    project_root: Path | None = None,
+    settings: dict[str, Any] | None = None,
+) -> list[dict[str, Any]]:
+    if project_root is not None:
+        from codd.dag.checks.user_journey_coherence import UserJourneyCoherenceCheck
+
+        return UserJourneyCoherenceCheck(project_root=project_root, settings=settings or {})._journey_entries(node)
+
     attributes = getattr(node, "attributes", {}) or {}
     value = attributes.get("user_journeys")
     if not isinstance(value, list):

{codd_dev-1.25.0 → codd_dev-1.26.0}/codd/dag/builder.py

@@ -29,9 +29,9 @@ from codd.deployment.extractor import (
 
 LOGGER = logging.getLogger(__name__)
 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")
+DEFAULT_PROJECT_TYPE = "generic"
+LEGACY_IMPLEMENTATION_SUFFIXES = (".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".java")
+LEGACY_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.]*))")
@@ -88,17 +88,21 @@ def build_dag(project_root: Path, settings: dict[str, Any] | None = None) -> DAG
 def load_dag_settings(project_root: Path, settings: dict[str, Any] | None = None) -> dict[str, Any]:
     """Load project-type defaults and apply ``codd.yaml dag:`` overrides."""
 
-    project_config = _load_project_config_or_empty(project_root)
+    root = Path(project_root).resolve()
+    project_config = _load_project_config_or_empty(root)
 
     requested_settings = settings or {}
-    project_type = _project_type(requested_settings) or _project_type(project_config) or DEFAULT_PROJECT_TYPE
+    project_type = _project_type(requested_settings) or _project_type(project_config) or _detect_project_type(root)
     merged = _read_default_settings(project_type)
     merged = _deep_merge(merged, _dag_overrides(project_config))
     merged = _deep_merge(merged, _dag_overrides(requested_settings))
+    merged["project_type"] = project_type
+    implementation_suffixes, test_suffixes = _load_suffix_config(root, merged)
+    merged["implementation_suffixes"] = implementation_suffixes
+    merged["test_suffixes"] = test_suffixes
     _apply_scan_patterns(merged, project_config)
     _apply_scan_patterns(merged, requested_settings)
     merged["coherence"] = _coherence_settings(project_config, requested_settings)
-    merged["project_type"] = project_type
     merged.setdefault("design_doc_patterns", [])
     merged.setdefault("impl_file_patterns", [])
     merged.setdefault("test_file_patterns", [])
@@ -214,10 +218,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] = {}
     capability_patterns = _capability_patterns(settings)
+    implementation_suffixes = _suffix_tuple(settings.get("implementation_suffixes")) or LEGACY_IMPLEMENTATION_SUFFIXES
     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
+            or file_path.suffix not in implementation_suffixes
             or _is_test_file(file_path, project_root)
         ):
             continue
@@ -241,8 +246,9 @@ def _add_impl_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> d
 
 def _add_test_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> dict[str, Path]:
     test_nodes: dict[str, Path] = {}
+    test_suffixes = _suffix_tuple(settings.get("test_suffixes")) or LEGACY_TEST_SUFFIXES
     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):
+        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()
@@ -445,8 +451,9 @@ def _add_deployment_graph(
         project_root,
         deployment_docs,
         [{"id": node_id, **metadata} for node_id, metadata in design_docs.items()],
+        project_config,
     )
-    verification_tests = extract_verification_tests(project_root)
+    verification_tests = extract_verification_tests(project_root, project_config, design_docs)
 
     for deployment_doc in deployment_docs:
         _add_node_once(
@@ -768,7 +775,18 @@ def _impl_convention_tokens(node_id: str) -> set[str]:
 
 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"]
+    suffix_groups = {
+        ".py": [".py"],
+        ".rs": [".rs"],
+        ".rb": [".rb"],
+        ".cs": [".cs"],
+        ".kt": [".kt", ".kts"],
+        ".swift": [".swift"],
+        ".exs": [".ex", ".exs"],
+        ".scala": [".scala"],
+        ".cpp": [".cpp", ".c", ".h", ".hpp"],
+    }
+    suffixes = suffix_groups.get(test_path.suffix, [".ts", ".tsx", ".js", ".jsx"])
 
     if any(marker in test_path.name for marker in (".test.", ".spec.")):
         candidates.append((test_path.parent / convention_key).resolve())
@@ -859,6 +877,128 @@ def _read_default_settings(project_type: str) -> dict[str, Any]:
     return payload if isinstance(payload, dict) else {}
 
 
+def _detect_project_type(project_root: Path) -> str:
+    root = Path(project_root)
+    if (root / "Cargo.toml").is_file():
+        return "rust"
+    if (root / "Gemfile").is_file():
+        return "ruby"
+    if (root / "package.json").is_file():
+        return "web"
+    if (root / "go.mod").is_file():
+        return "go"
+    if any(root.glob("*.csproj")) or any(root.glob("*.sln")):
+        return "csharp"
+    if (root / "CMakeLists.txt").is_file() or (
+        (root / "Makefile").is_file() and _has_any_file(root, ("*.c", "*.cpp"))
+    ):
+        return "cpp_embedded"
+    if any(root.glob("*.gradle.kts")):
+        return "kotlin"
+    if (root / "pom.xml").is_file():
+        return "java"
+    if (root / "build.gradle").is_file() or any(root.glob("*.gradle")):
+        if _has_any_file(root, ("*.kt", "*.kts")):
+            return "kotlin"
+        return "java"
+    if (root / "mix.exs").is_file():
+        return "elixir"
+    if (root / "build.sbt").is_file():
+        return "scala"
+    if _has_any_file(root, ("*.swift",)):
+        return "swift"
+    return "generic"
+
+
+def _has_any_file(project_root: Path, patterns: tuple[str, ...]) -> bool:
+    for pattern in patterns:
+        if any(path.is_file() for path in project_root.rglob(pattern)):
+            return True
+    return False
+
+
+def _load_suffix_config(project_root: Path, codd_yaml: dict[str, Any]) -> tuple[tuple[str, ...], tuple[str, ...]]:
+    implementation_suffixes = _suffixes_from_config(codd_yaml, "implementation_suffixes")
+    test_suffixes = _suffixes_from_config(codd_yaml, "test_suffixes")
+    project_type = _project_type(codd_yaml) or _detect_project_type(project_root)
+    defaults = _read_suffix_default_mapping(project_type)
+
+    if implementation_suffixes is None:
+        implementation_suffixes = _suffixes_from_config(defaults, "implementation_suffixes")
+        if implementation_suffixes is None:
+            LOGGER.warning(
+                "DAG suffix defaults for project_type=%s missing implementation_suffixes; using legacy fallback",
+                project_type,
+            )
+            implementation_suffixes = LEGACY_IMPLEMENTATION_SUFFIXES
+    if test_suffixes is None:
+        test_suffixes = _suffixes_from_config(defaults, "test_suffixes")
+        if test_suffixes is None:
+            LOGGER.warning(
+                "DAG suffix defaults for project_type=%s missing test_suffixes; using legacy fallback",
+                project_type,
+            )
+            test_suffixes = LEGACY_TEST_SUFFIXES
+
+    implementation_suffixes = _extend_suffixes(
+        implementation_suffixes,
+        _suffixes_from_config(codd_yaml, "implementation_suffixes_extend"),
+    )
+    test_suffixes = _extend_suffixes(
+        test_suffixes,
+        _suffixes_from_config(codd_yaml, "test_suffixes_extend"),
+    )
+    return implementation_suffixes, test_suffixes
+
+
+def _read_suffix_default_mapping(project_type: str) -> dict[str, Any]:
+    for suffix_type in (project_type, DEFAULT_PROJECT_TYPE):
+        path = DEFAULTS_DIR / f"{suffix_type}.yaml"
+        if not path.is_file():
+            continue
+        try:
+            payload = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+        except yaml.YAMLError as exc:
+            LOGGER.warning("Could not load DAG suffix defaults from %s: %s", path, exc)
+            return {}
+        if isinstance(payload, dict):
+            return payload
+        LOGGER.warning("DAG suffix defaults %s must contain a YAML mapping; using legacy fallback", path)
+        return {}
+    LOGGER.warning("DAG suffix defaults for project_type=%s not found; using legacy fallback", project_type)
+    return {}
+
+
+def _suffixes_from_config(config: dict[str, Any], key: str) -> tuple[str, ...] | None:
+    value = config.get(key)
+    if value is None and isinstance(config.get("dag"), dict):
+        value = config["dag"].get(key)
+    return _suffix_tuple(value)
+
+
+def _suffix_tuple(value: Any) -> tuple[str, ...] | None:
+    if value is None:
+        return None
+    suffixes: list[str] = []
+    for item in _as_list(value):
+        if not isinstance(item, str) or not item.strip():
+            continue
+        suffix = item.strip()
+        if not suffix.startswith("."):
+            suffix = f".{suffix}"
+        if suffix not in suffixes:
+            suffixes.append(suffix)
+    return tuple(suffixes) if suffixes else None
+
+
+def _extend_suffixes(base: tuple[str, ...], extensions: tuple[str, ...] | None) -> tuple[str, ...]:
+    suffixes = list(base)
+    for suffix in extensions or ():
+        if suffix not in suffixes:
+            suffixes.append(suffix)
+    return tuple(suffixes)
+
+
 def _dag_overrides(config: dict[str, Any]) -> dict[str, Any]:
     overrides: dict[str, Any] = {}
     dag_section = config.get("dag", {})
@@ -869,6 +1009,10 @@ def _dag_overrides(config: dict[str, Any]) -> dict[str, Any]:
         "design_doc_patterns",
         "impl_file_patterns",
         "test_file_patterns",
+        "implementation_suffixes",
+        "implementation_suffixes_extend",
+        "test_suffixes",
+        "test_suffixes_extend",
         "plan_task_file",
         "lexicon_file",
         "import_aliases",
@@ -922,13 +1066,16 @@ def _apply_scan_patterns(settings: dict[str, Any], config: dict[str, Any]) -> No
         _extend_unique(
             settings,
             "impl_file_patterns",
-            _file_patterns_for_dirs(source_dirs, IMPLEMENTATION_SUFFIXES),
+            _file_patterns_for_dirs(
+                source_dirs,
+                _suffix_tuple(settings.get("implementation_suffixes")) or LEGACY_IMPLEMENTATION_SUFFIXES,
+            ),
         )
     if test_dirs:
         _extend_unique(
             settings,
             "test_file_patterns",
-            _file_patterns_for_dirs(test_dirs, TEST_SUFFIXES),
+            _file_patterns_for_dirs(test_dirs, _suffix_tuple(settings.get("test_suffixes")) or LEGACY_TEST_SUFFIXES),
         )
     if doc_dirs:
         _extend_unique(settings, "design_doc_patterns", _file_patterns_for_dirs(doc_dirs, (".md",)))
@@ -1034,11 +1181,25 @@ def _language_for_path(path: Path) -> str:
         ".jsx": "javascript",
         ".go": "go",
         ".java": "java",
+        ".rs": "rust",
+        ".rb": "ruby",
+        ".cs": "csharp",
+        ".c": "c",
+        ".cpp": "cpp",
+        ".h": "cpp",
+        ".hpp": "cpp",
+        ".kt": "kotlin",
+        ".kts": "kotlin",
+        ".swift": "swift",
+        ".ex": "elixir",
+        ".exs": "elixir",
+        ".scala": "scala",
     }.get(path.suffix, "unknown")
 
 
 def _looks_like_project_path(value: str) -> bool:
-    return "/" in value and Path(value).suffix in IMPLEMENTATION_SUFFIXES
+    generic_suffixes, _ = _load_suffix_config(Path.cwd(), {"project_type": DEFAULT_PROJECT_TYPE})
+    return "/" in value and Path(value).suffix in generic_suffixes
 
 
 def _mermaid_id(node_id: str) -> str:

{codd_dev-1.25.0 → codd_dev-1.26.0}/codd/dag/checks/task_completion.py

@@ -122,7 +122,9 @@ class TaskCompletionCheck:
     def _impl_file_exists(self, impl_node: Any, fallback_path: str, project_root: Path | None) -> bool:
         if project_root is None:
             return True
-        node_path = getattr(impl_node, "path", None) or fallback_path
+        attributes = getattr(impl_node, "attributes", {}) or {}
+        attribute_path = attributes.get("path") if isinstance(attributes, dict) else None
+        node_path = getattr(impl_node, "path", None) or attribute_path or fallback_path
         candidate = Path(node_path)
         if not candidate.is_absolute():
             candidate = project_root / candidate