codd-dev 3.7.0__tar.gz → 3.7.2__tar.gz

{codd_dev-3.7.0 → codd_dev-3.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 3.7.0
+Version: 3.7.2
 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-3.7.0 → codd_dev-3.7.2}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "3.7.0"
+__version__ = "3.7.2"

{codd_dev-3.7.0 → codd_dev-3.7.2}/codd/cli.py

@@ -434,6 +434,30 @@ def _display_path(path: Path, project_root: Path) -> str:
         return path.as_posix()
 
 
+def _detect_bootstrap_test_dirs(project_root: Path) -> list[str]:
+    """Detect the project's test directories for the bootstrap codd.yaml.
+
+    Reuses the extractor's inventory (``test``/``tests``/``spec``/``__tests__``)
+    so a project that uses ``test/`` is not silently excluded by a hardcoded
+    ``tests/`` default (which yields a vacuous task_completion). Falls back to the
+    conventional ``tests/`` when none exist so the config stays valid + editable.
+    """
+    from codd.extractor import _detect_test_dirs
+
+    found = _detect_test_dirs(project_root)
+    return [f"{d}/" for d in found] if found else ["tests/"]
+
+
+def _detect_bootstrap_doc_dirs(project_root: Path) -> list[str]:
+    """Detect the project's documentation directories for the bootstrap codd.yaml.
+
+    Mirrors :func:`_detect_bootstrap_test_dirs`: prefer what exists (``docs``
+    vs ``doc``), fall back to the conventional ``docs/`` when none exist.
+    """
+    found = [d for d in ("docs", "doc", "documentation") if (project_root / d).is_dir()]
+    return [f"{d}/" for d in found] if found else ["docs/"]
+
+
 def _ensure_bootstrap_codd_yaml(
     project_root: Path,
     *,
@@ -456,6 +480,8 @@ def _ensure_bootstrap_codd_yaml(
             "project_name": project_root.name,
             "language": language,
             "source_dirs": _format_yaml_list(source_dirs),
+            "test_dirs": _format_yaml_list(_detect_bootstrap_test_dirs(project_root)),
+            "doc_dirs": _format_yaml_list(_detect_bootstrap_doc_dirs(project_root)),
             "graph_path": f"{codd_dir_name}/scan",
         },
     )
@@ -2323,11 +2349,15 @@ def init(
     (codd_dir / "reports").mkdir(parents=True)
     (codd_dir / "scan").mkdir(exist_ok=True)
 
-    # Copy templates
+    # Copy templates. Greenfield init uses the conventional test/doc layout
+    # (brownfield extract detects the project's real dirs instead — see
+    # _ensure_bootstrap_codd_yaml).
     _render_template("codd.yaml.tmpl", codd_dir / "codd.yaml", {
         "project_name": project_name,
         "language": language,
         "source_dirs": _format_yaml_list(["src/"]),
+        "test_dirs": _format_yaml_list(["tests/"]),
+        "doc_dirs": _format_yaml_list(["docs/"]),
         "graph_path": f"{config_dir}/scan",
     })
     _render_template("gitignore.tmpl", codd_dir / ".gitignore", {})
@@ -5862,6 +5892,8 @@ def extract(
         click.echo(f"Output: {output_display}/")
         for f in result.generated_files:
             click.echo(f"  {f.name}")
+        for warning in getattr(result, "parse_warnings", []):
+            click.echo(f"  WARNING: {warning}")
         if generated_config:
             click.echo(f"Generated: {config_display} (minimal brownfield config)")
 

{codd_dev-3.7.0 → codd_dev-3.7.2}/codd/dag/builder.py

@@ -44,7 +44,6 @@ LEGACY_IMPLEMENTATION_SUFFIXES = (".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".
 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.]*))")
 LEXICON_OUTPUT_PREFIX = "lexicon:"
 EXPECTED_ARTIFACT_ATTRIBUTE_KEYS = (
     "id",
@@ -298,7 +297,7 @@ def _add_impl_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> d
                 path=node_id,
                 attributes={
                     "language": _language_for_path(file_path),
-                    "imports": extract_imports(file_path),
+                    "imports": _extract_impl_imports(file_path),
                     "runtime_evidence": _runtime_evidence_for_file(file_path, node_id, capability_patterns),
                 },
             ),
@@ -913,13 +912,28 @@ def _resolve_import_target(
     aliases: dict[str, list[str]],
 ) -> str | None:
     candidates: list[Path] = []
-    if import_ref.startswith("."):
+    if _is_js_relative_specifier(import_ref):
+        # JS/TS relative: ``./foo`` / ``../foo`` — resolve against the file dir
+        # exactly as before (a path with a separator after the dots).
         candidates.append((file_path.parent / import_ref).resolve())
+    elif import_ref.startswith("."):
+        # Python relative: ``.b`` / ``..pkg.x`` / ``.`` — leading dots select a
+        # package directory (1 dot = current package, 2 = parent, …) and the
+        # dotted remainder maps to a sub-path. Distinct from JS ``./`` because
+        # Python uses ``.`` as the component separator, so ``pkg/.b`` (the old
+        # JS-style join) never matched ``pkg/b.py``.
+        candidates.extend(_python_relative_candidates(import_ref, file_path))
     elif import_ref.startswith("/"):
         candidates.append((project_root / import_ref.lstrip("/")).resolve())
     else:
         candidates.extend(_alias_candidates(import_ref, project_root, aliases))
         candidates.append((project_root / import_ref).resolve())
+        # Absolute dotted module specifier (``pkg.c`` / ``a.b.c``): also try the
+        # dotted→path mapping rooted at the project, so a Python absolute import
+        # resolves to ``pkg/c.py`` (``__init__.py`` handled downstream). The
+        # plain join above keeps ``pkg/sub`` directory-style specifiers working.
+        if "." in import_ref:
+            candidates.append((project_root / Path(*import_ref.split("."))).resolve())
 
     for candidate in candidates:
         resolved = _resolve_file_candidate(candidate, path_to_node)
@@ -928,6 +942,45 @@ def _resolve_import_target(
     return None
 
 
+def _is_js_relative_specifier(import_ref: str) -> bool:
+    """True for JS/TS relative specifiers (``./x`` / ``../x`` / ``.`` / ``..``).
+
+    The discriminator is purely the SHAPE of the specifier (data), not a
+    language flag: JS relative imports put a path separator after the leading
+    dots (or are the bare ``.`` / ``..`` directory refs), whereas Python
+    relative imports use ``.`` as the module-component separator (``.b``,
+    ``..pkg.mod``). Keeping the JS branch byte-identical preserves the existing
+    TS/JS edge behavior.
+    """
+
+    if import_ref in (".", ".."):
+        return True
+    return import_ref.startswith("./") or import_ref.startswith("../")
+
+
+def _python_relative_candidates(import_ref: str, file_path: Path) -> list[Path]:
+    """Resolve a Python relative import specifier to filesystem candidates.
+
+    Mirrors Python's own relative-import semantics: ``leading_dots`` counts the
+    package levels (1 = the importing file's package == its directory, 2 = the
+    parent package, …); the remaining dotted name becomes sub-directories.
+    ``_resolve_file_candidate`` then appends the real suffix / ``__init__.py``.
+    """
+
+    leading_dots = len(import_ref) - len(import_ref.lstrip("."))
+    remainder = import_ref[leading_dots:]
+
+    # 1 dot → current package dir (the file's own directory); each extra dot
+    # walks one package up.
+    base = file_path.parent
+    for _ in range(leading_dots - 1):
+        base = base.parent
+
+    if not remainder:
+        return [base.resolve()]
+    return [(base / Path(*remainder.split("."))).resolve()]
+
+
 def _infer_test_targets(
     test_path: Path,
     project_root: Path,
@@ -954,14 +1007,48 @@ def _infer_test_targets(
     return targets
 
 
+def _extract_python_import_specifiers(file_path: Path) -> list[str]:
+    """Return raw Python import specifiers (relative dots preserved) via AST.
+
+    Dispatches to the registry's Python ``source`` backend
+    (:class:`codd.parsing.PythonAstExtractor`) so the SAME stdlib-``ast``
+    extraction that the scanner uses produces the DAG's specifiers — including
+    relative imports (``.b`` / ``from . import d`` / ``..pkg.x``) that the old
+    line-anchored regex (a ``from ([A-Za-z_]…)`` pattern that could not match a
+    leading-dot module) silently dropped. Selection is registry-DATA-driven
+    (``get_extractor``), not a ``language ==`` branch.
+    """
+
+    from codd.parsing import get_extractor
+
+    content = file_path.read_text(encoding="utf-8", errors="ignore")
+    return get_extractor("python", "source").extract_import_specifiers(content)
+
+
+def _extract_impl_imports(file_path: Path) -> list[str]:
+    """Return raw import specifiers for an implementation file.
+
+    Python impl files go through AST-based specifier extraction (the same path
+    test files use) so impl→impl import edges form for Python — the core of the
+    fix. Every other language keeps the existing quoted-specifier extractor
+    (``extract_imports``: JS/TS ``from '…'`` / ``require('…')``), unchanged.
+    Dispatch is by file suffix (DATA), mirroring ``_extract_test_imports``.
+    """
+
+    if file_path.suffix == ".py":
+        return _extract_python_import_specifiers(file_path)
+    return extract_imports(file_path)
+
+
 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]
+    # AST-based Python specifiers (relative imports included). Combined with the
+    # quoted-specifier pass above so a polyglot test file (e.g. a ``.py`` test
+    # that also embeds a JS ``require('…')`` literal in a string) keeps both.
+    return [*imports, *_extract_python_import_specifiers(file_path)]
 
 
 def _resolve_python_import_target(import_ref: str, project_root: Path, path_to_node: dict[Path, str]) -> str | None:
@@ -1056,6 +1143,9 @@ def _convention_path_candidates(test_path: Path, project_root: Path, convention_
     return candidates
 
 
+_TEST_DIR_NAMES = {"tests", "test", "spec", "__tests__"}
+
+
 def _is_test_file(file_path: Path, project_root: Path) -> bool:
     relative_parts = _relative_id(file_path, project_root).split("/")
     name = file_path.name
@@ -1066,9 +1156,19 @@ def _is_test_file(file_path: Path, project_root: Path) -> bool:
         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
+    in_test_dir = any(part in _TEST_DIR_NAMES for part in relative_parts[:-1])
+    if file_path.suffix == ".py":
+        # Python keeps the stricter pytest/unittest convention even under a test
+        # directory (``test_*.py`` / ``*_test.py``) to avoid pulling fixtures.
+        if in_test_dir:
+            return name.startswith("test_") or name.endswith("_test.py")
+        return False
+    # Other languages: a source file living under a conventional test directory
+    # is a test even without a ``.test.`` infix — e.g. Mocha/Tape ``test/app.js``
+    # (Express) or ``spec/foo.js``. The caller already gates on ``test_suffixes``
+    # and the configured ``test_file_patterns`` (scoped to the project's test
+    # dirs), so this never sweeps in arbitrary source files.
+    return in_test_dir
 
 
 def _load_import_aliases(project_root: Path, settings: dict[str, Any]) -> dict[str, list[str]]:

{codd_dev-3.7.0 → codd_dev-3.7.2}/codd/dag/checks/ci_health.py

@@ -24,10 +24,19 @@ _DEFAULT_PROVIDER = "github" + "_actions"
 _OPT_OUT_PROVIDER = "none"
 
 
+# GitHub Actions officially loads workflow files with EITHER ``.yml`` or
+# ``.yaml``. The default glob therefore matches both extensions (comma-separated
+# union — see ``_locate_workflows``). A user who narrows ``workflow_glob`` to a
+# single pattern keeps exact control (an explicit ``*.yaml`` pulls in only
+# ``.yaml``); only the DEFAULT spans both so the common ``.yaml``-only project
+# (e.g. Flask) is not mis-RED-flagged ``ci_workflow_missing``.
+_DEFAULT_WORKFLOW_GLOB = ".github/workflows/*.yml,.github/workflows/*.yaml"
+
+
 @dataclass
 class CiConfig:
     provider: str = _DEFAULT_PROVIDER
-    workflow_glob: str = ".github/workflows/*.yml"
+    workflow_glob: str = _DEFAULT_WORKFLOW_GLOB
     required_triggers: list[str] = field(default_factory=lambda: ["push", "pull_request"])
     runtime_check: bool = False
     staleness_days: int = 14
@@ -241,7 +250,43 @@ class CiHealthCheck(DagCheck):
         project_root: Path,
         workflow_glob: str,
     ) -> tuple[list[Path], list[str]]:
-        """Resolve in-root workflow files via the shared path_safety jail.
+        """Resolve in-root workflow files for one OR MORE comma-separated globs.
+
+        ``workflow_glob`` may carry several patterns separated by commas (the
+        default spans both ``*.yml`` and ``*.yaml`` because GitHub Actions loads
+        either extension). Each sub-glob is resolved independently through the
+        shared path_safety jail (see :meth:`_locate_one_glob`); the in-root
+        matches are unioned + de-duplicated, and any out-of-root markers are
+        accumulated so a single escaping sub-glob still surfaces a structured red
+        finding. A single (comma-free) pattern behaves exactly as before, so a
+        user who narrows ``workflow_glob`` to one pattern keeps exact control.
+        """
+
+        sub_globs = [part.strip() for part in workflow_glob.split(",") if part.strip()]
+        if not sub_globs:
+            return [], []
+
+        seen: set[Path] = set()
+        in_root: list[Path] = []
+        out_of_root: list[str] = []
+        for sub in sub_globs:
+            files, escaped = self._locate_one_glob(project_root, sub)
+            for path in files:
+                if path not in seen:
+                    seen.add(path)
+                    in_root.append(path)
+            for marker in escaped:
+                if marker not in out_of_root:
+                    out_of_root.append(marker)
+        in_root.sort()
+        return in_root, out_of_root
+
+    def _locate_one_glob(
+        self,
+        project_root: Path,
+        workflow_glob: str,
+    ) -> tuple[list[Path], list[str]]:
+        """Resolve in-root workflow files for ONE glob via the path_safety jail.
 
         The glob root is validated *before* enumeration. An absolute
         ``workflow_glob`` whose static (non-magic) base escapes the project root

codd_dev-3.7.2/codd/dag/checks/transitive_closure.py

@@ -0,0 +1,211 @@
+"""Transitive closure DAG completeness check."""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from codd.dag.checks import register_dag_check
+
+
+@dataclass
+class TransitiveClosureResult:
+    check_name: str = "transitive_closure"
+    severity: str = "amber"
+    unreachable_nodes: list[str] = field(default_factory=list)
+    common_node_count: int = 0
+    passed: bool = True
+    # ``status``/``skipped``/``checked_count`` close a vacuous-pass hole: an empty
+    # DAG (or one whose every node is ``common`` and therefore exempt from
+    # reachability) used to return a green PASS having examined zero nodes.
+    # ``checked_count`` is the number of non-common nodes whose reachability was
+    # actually evaluated; when it is 0 the run is a SKIP, not a clean pass.
+    status: str = "pass"
+    skipped: bool = False
+    checked_count: int = 0
+
+
+# Edge kinds that represent an in-project source-import dependency
+# (importer -> imported). Used to identify *code-entry roots*: source nodes that
+# nothing in the project imports. This is a structural classification of edges,
+# not a language/framework branch.
+_IMPORT_EDGE_KINDS = frozenset({"imports"})
+
+# Node kinds that are NOT first-class source nodes for entry-root detection:
+# design docs are handled by their own root rule, and ``common`` nodes are shared
+# infrastructure exempt from reachability. Anything else (``impl_file`` and any
+# future source kind) is treated as a source node — no per-language literal.
+_NON_SOURCE_KINDS = frozenset({"design_doc", "common"})
+
+
+@register_dag_check("transitive_closure")
+class TransitiveClosureCheck:
+    """Report unreachable nodes without blocking deploy.
+
+    A node is *reachable* if it can be reached from **any entry root**:
+
+    - **design_doc roots** — ``design_doc`` nodes with no incoming edge (the
+      classic "every artifact descends from a design document" model); and
+    - **code-entry roots** — source nodes (everything that is neither a
+      ``design_doc`` nor a ``common`` node) with no incoming in-project *import*
+      edge, i.e. the package's public entry points (e.g. a package
+      ``__init__`` or a CLI ``__main__`` that nothing else imports).
+
+    Seeding from the *union* of these makes reachability meaningful on doc-less
+    BROWNFIELD projects (raw external code with zero design docs but a fully
+    connected import graph) while leaving doc-rooted projects unchanged:
+    code-entry roots are purely additive. Only nodes unreachable from ALL entries
+    are flagged — genuine orphans.
+
+    Entry-root detection is structural (incoming-edge analysis on import-kind
+    edges), never a ``language ==`` branch.
+
+    Cycle / no-entry fallback: if a project has source nodes but none qualify as
+    a code-entry root (every source node has an in-project importer — a pure
+    cycle), reachability falls back to seeding from *all* source nodes for that
+    project, so connectivity is still measured rather than reported as a false
+    "everything unreachable". Cycles are traversed safely (visited-set guard).
+
+    Nodes with ``kind == "common"`` (shared infrastructure declared via
+    ``common_node_patterns`` or frontmatter ``node_type: common``) remain exempt
+    from unreachable detection. They participate in the DAG so change-impact
+    analysis still sees them, but they do not need to be the descendant of a
+    single design document.
+    """
+
+    def __init__(self, dag=None, project_root: Path | None = None, settings: dict[str, Any] | None = None):
+        self.dag = dag
+        self.project_root = project_root
+        self.settings = settings or {}
+
+    def run(
+        self,
+        dag=None,
+        project_root: Path | None = None,
+        settings: dict[str, Any] | None = None,
+    ) -> TransitiveClosureResult:
+        dag = dag or self.dag
+        if dag is None or not dag.nodes:
+            # No nodes at all → reachability examined nothing → SKIP (not a
+            # vacuous green PASS).
+            return TransitiveClosureResult(
+                status="skip",
+                skipped=True,
+                checked_count=0,
+            )
+
+        to_ids = {edge.to_id for edge in dag.edges}
+        design_roots = [
+            node.id
+            for node in dag.nodes.values()
+            if node.kind == "design_doc" and node.id not in to_ids
+        ]
+        code_roots = self._code_entry_roots(dag)
+
+        # Reachable from ANY entry: design-doc roots OR code-entry roots. The
+        # union keeps doc-rooted projects unchanged (design roots still seed) and
+        # makes doc-less brownfield projects measurable (code roots seed the
+        # connected impl graph).
+        roots = list(dict.fromkeys([*design_roots, *code_roots]))
+
+        visited = self._reachable_from(dag, roots)
+        common_count = sum(
+            1 for node in dag.nodes.values() if node.kind == "common"
+        )
+        # Common nodes are exempt from unreachable detection, so the number of
+        # nodes whose reachability is actually evaluated is the non-common set.
+        checked = sum(1 for node in dag.nodes.values() if node.kind != "common")
+        unreachable = [
+            node_id
+            for node_id, node in dag.nodes.items()
+            if node_id not in visited and node.kind != "common"
+        ]
+
+        if checked == 0:
+            # Every node is exempt (all ``common``): reachability examined nothing.
+            # A clean PASS here is a vacuous false-green → SKIP instead.
+            return TransitiveClosureResult(
+                unreachable_nodes=[],
+                common_node_count=common_count,
+                passed=True,
+                status="skip",
+                skipped=True,
+                checked_count=0,
+            )
+
+        return TransitiveClosureResult(
+            unreachable_nodes=unreachable,
+            common_node_count=common_count,
+            passed=True,
+            status="pass",
+            skipped=False,
+            checked_count=checked,
+        )
+
+    def _code_entry_roots(self, dag) -> list[str]:
+        """Public entry points of the import graph (heads nothing imports).
+
+        A *source node* is any node that is neither a ``design_doc`` (handled by
+        its own root rule) nor a ``common`` node (exempt infrastructure). A source
+        node is a *code-entry root* when it **participates in the import graph as a
+        head**: it has at least one outgoing in-project import edge (it imports
+        something) AND no incoming import edge (nothing imports it). These are the
+        package's public entry points (e.g. ``__init__`` / ``__main__``).
+
+        Requiring an *outgoing* import edge is what preserves no-false-green: a
+        node with zero import edges (isolated -- imported by nothing and importing
+        nothing) is a genuine orphan, NOT an entry root, and therefore stays
+        flagged. Only nodes that actually anchor an import chain seed reachability.
+
+        Fallback (pure cycle / no head): if no source node qualifies as a head but
+        some source nodes still *participate* in the import graph (a cycle where
+        every node has an importer), seed from all participating source nodes so
+        connectivity is still measured instead of a false "everything
+        unreachable". Isolated orphans (no import edges) are never seeded and stay
+        flagged even in the fallback.
+        """
+        source_ids = {
+            node.id
+            for node in dag.nodes.values()
+            if node.kind not in _NON_SOURCE_KINDS
+        }
+        if not source_ids:
+            return []
+
+        import_to: set[str] = set()
+        import_from: set[str] = set()
+        for edge in dag.edges:
+            if edge.kind in _IMPORT_EDGE_KINDS:
+                import_to.add(edge.to_id)
+                import_from.add(edge.from_id)
+
+        # Heads: import something in-project, imported by nothing in-project.
+        entry_roots = [
+            nid
+            for nid in source_ids
+            if nid in import_from and nid not in import_to
+        ]
+        if entry_roots:
+            return entry_roots
+
+        # No clean head (pure cycle): seed from source nodes that participate in
+        # the import graph at all, so connectivity is still measured. Nodes with
+        # no import edges remain genuine orphans (never seeded here).
+        return [nid for nid in source_ids if nid in import_to or nid in import_from]
+
+    def _reachable_from(self, dag, roots: list[str]) -> set[str]:
+        visited: set[str] = set()
+        queue = deque(roots)
+
+        while queue:
+            current = queue.popleft()
+            if current in visited:
+                continue
+            visited.add(current)
+            for edge in dag.edges:
+                if edge.from_id == current and edge.to_id not in visited:
+                    queue.append(edge.to_id)
+
+        return visited