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

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

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

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

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

@@ -5862,6 +5862,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.1}/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:

{codd_dev-3.7.0 → codd_dev-3.7.1}/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.0 → codd_dev-3.7.1}/codd/extract_ai.py

@@ -13,7 +13,9 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from pathlib import Path
+import re
 from typing import Any
+import warnings
 
 import yaml
 
@@ -31,6 +33,11 @@ from codd.discovery import (
 
 PROMPT_TEMPLATE_FILE = Path(__file__).parent / "templates" / "extract_ai_prompt_baseline.md"
 
+# The extract prompt targets six MECE layers (L1 data … L6 tests). Recovering
+# fewer documents from the model's output is surfaced as an advisory warning
+# (never a hard failure: not every project populates all six layers).
+_EXPECTED_EXTRACT_LAYER_COUNT = 6
+
 # Files to always read if they exist (framework detection)
 FRAMEWORK_FILES = [
     "package.json", "requirements.txt", "Pipfile", "pyproject.toml",
@@ -107,6 +114,9 @@ class ExtractAIResult:
     generated_files: list[Path] = field(default_factory=list)
     ai_raw_output: str = ""
     module_count: int = 0
+    # Advisory parse warnings (e.g. fewer documents recovered than the six MECE
+    # layers expected) surfaced to the caller instead of silently dropping docs.
+    parse_warnings: list[str] = field(default_factory=list)
 
 
 # ═══════════════════════════════════════════════════════════
@@ -498,37 +508,218 @@ def _safe_output_path(output_dir: Path, name: str) -> Path:
     return candidate
 
 
-def _parse_ai_output(raw: str, output_dir: Path) -> list[Path]:
-    """Parse AI output separated by `--- FILE: <name> ---` markers.
+_FENCE_RE = re.compile(r"^\s*```+[A-Za-z0-9_-]*\s*$")
+_FILE_MARKER_RE = re.compile(r"^\s*---\s*FILE:\s*(?P<name>.+?)\s*---\s*$")
+_LAYER_HEADER_RE = re.compile(r"^\s*#{1,6}\s*L\d+\b.*$")
+
+
+def _strip_outer_fence(raw: str) -> str:
+    """Drop a single code-fence wrapper around the WHOLE response.
 
-    All writes are confined to *output_dir*; traversal/absolute names are
-    rejected (fail-closed) so extraction can never clobber source/user files.
+    Models routinely wrap their entire reply in ```` ```markdown … ``` ````.
+    Left in place, the leading fence lands at byte 0 and breaks frontmatter
+    normalization (which requires ``---`` at byte 0), and the trailing fence
+    leaks into the last document. Only the OUTER wrapper is removed: a fence as
+    the first non-blank line paired with a fence as the last non-blank line.
+    Inner code blocks inside a document body are untouched.
     """
-    files: list[Path] = []
+    lines = raw.split("\n")
+    first = next((i for i, ln in enumerate(lines) if ln.strip()), None)
+    if first is None:
+        return raw
+    last = next(i for i in range(len(lines) - 1, -1, -1) if lines[i].strip())
+    if first < last and _FENCE_RE.match(lines[first]) and _FENCE_RE.match(lines[last]):
+        return "\n".join(lines[first + 1 : last])
+    return raw
+
+
+def _strip_doc_fences(body: str) -> str:
+    """Strip a code-fence wrapper around a SINGLE parsed document segment.
+
+    Per-document fences appear when a model fences each doc individually (the
+    Flask shape mixed a single ``--- FILE:`` marker with per-doc fences). Only a
+    leading fence as the first non-blank line and/or a trailing fence as the
+    last non-blank line are removed, so a real code block in the middle of a
+    document body is preserved.
+    """
+    lines = body.split("\n")
+    start = 0
+    end = len(lines)
+    while start < end and not lines[start].strip():
+        start += 1
+    if start < end and _FENCE_RE.match(lines[start]):
+        lines = lines[:start] + lines[start + 1 :]
+        end = len(lines)
+    while end > 0 and not lines[end - 1].strip():
+        end -= 1
+    if end > 0 and _FENCE_RE.match(lines[end - 1]):
+        lines = lines[: end - 1] + lines[end:]
+    return "\n".join(lines)
+
+
+def _split_on_file_markers(raw: str) -> list[tuple[str | None, str]]:
+    """Split on ``--- FILE: <name> ---`` markers (the canonical format).
+
+    Returns ``(name, body)`` segments. A leading segment before the first
+    marker has ``name=None`` (it is preamble, not a file) — callers decide
+    whether to keep it.
+    """
+    segments: list[tuple[str | None, str]] = []
     current_name: str | None = None
     current_lines: list[str] = []
+    for line in raw.split("\n"):
+        match = _FILE_MARKER_RE.match(line)
+        if match:
+            segments.append((current_name, "\n".join(current_lines)))
+            current_name = match.group("name").strip()
+            current_lines = []
+        else:
+            current_lines.append(line)
+    segments.append((current_name, "\n".join(current_lines)))
+    return segments
+
+
+def _split_on_frontmatter_docs(raw: str) -> list[str] | None:
+    """Fallback: split a multi-document body on ``^---`` frontmatter blocks.
+
+    Used when the model separated docs by repeated ``---``-delimited frontmatter
+    rather than ``--- FILE:`` markers. A document starts at a ``---`` line whose
+    matching close ``---`` is followed by more content. Returns ``None`` when
+    fewer than two frontmatter docs are present (nothing to recover by this
+    strategy).
+    """
+    lines = raw.split("\n")
+    # Index every standalone ``---`` delimiter (frontmatter fences are bare ---).
+    delims = [i for i, ln in enumerate(lines) if ln.strip() == "---"]
+    if len(delims) < 4:  # need at least two open/close pairs for >=2 docs
+        return None
+    # A doc opens at delims[0], delims[2], delims[4], ... (every other delimiter
+    # is an opener; the one between is its closer).
+    openers = delims[0::2]
+    if len(openers) < 2:
+        return None
+    segments: list[str] = []
+    for idx, start in enumerate(openers):
+        end = openers[idx + 1] if idx + 1 < len(openers) else len(lines)
+        segments.append("\n".join(lines[start:end]))
+    return [seg for seg in segments if seg.strip()]
+
+
+def _split_on_layer_headers(raw: str) -> list[str] | None:
+    """Fallback: split on ``# L<n>: …`` layer headers.
+
+    Used when there is neither a ``--- FILE:`` marker nor per-doc frontmatter,
+    but the body carries the canonical six-layer ``# L1:`` … ``# L6:`` headers.
+    Returns ``None`` when fewer than two layer headers are present.
+    """
+    lines = raw.split("\n")
+    starts = [i for i, ln in enumerate(lines) if _LAYER_HEADER_RE.match(ln)]
+    if len(starts) < 2:
+        return None
+    segments: list[str] = []
+    for idx, start in enumerate(starts):
+        end = starts[idx + 1] if idx + 1 < len(starts) else len(lines)
+        segments.append("\n".join(lines[start:end]))
+    return [seg for seg in segments if seg.strip()]
 
-    def _flush(name: str, lines: list[str]) -> None:
+
+def _segment_node_name(body: str, index: int) -> str:
+    """Derive a stable output filename for a marker-less recovered segment.
+
+    Prefers an ``id:`` from the segment's frontmatter, then a ``# L<n>:`` header
+    token, finally a positional fallback. Always yields a ``.md`` name confined
+    later by :func:`_safe_output_path`.
+    """
+    fm = re.match(r"\A\s*---\s*\n(.*?)\n---\s*(?:\n|$)", body, re.DOTALL)
+    if fm:
+        try:
+            front = yaml.safe_load(fm.group(1)) or {}
+        except yaml.YAMLError:
+            front = {}
+        if isinstance(front, dict):
+            for key in ("node_id", "id", "name"):
+                value = front.get(key)
+                if isinstance(value, str) and value.strip():
+                    slug = re.sub(r"[^A-Za-z0-9._-]+", "_", value.strip()).strip("_")
+                    if slug:
+                        return slug if slug.endswith(".md") else f"{slug}.md"
+    header = _LAYER_HEADER_RE.match(body.lstrip("\n").split("\n", 1)[0] if body.strip() else "")
+    if header:
+        token = re.search(r"L\d+", header.group(0))
+        if token:
+            return f"{token.group(0)}_extracted.md"
+    return f"extracted_doc_{index + 1}.md"
+
+
+def _parse_ai_output(
+    raw: str,
+    output_dir: Path,
+    *,
+    expected_doc_count: int | None = None,
+    warnings_out: list[str] | None = None,
+) -> list[Path]:
+    """Parse AI extract output into per-document files (fence/format tolerant).
+
+    Resilient to two real failure modes seen in brownfield dogfood runs:
+
+    1. The model wraps its whole reply (or each document) in a ```` ```markdown ````
+       code fence — stripped so ``---`` lands at byte 0 for frontmatter
+       normalization.
+    2. The model separates documents by repeated ``^---`` frontmatter blocks or
+       ``# L<n>:`` layer headers instead of ``--- FILE:`` markers — recovered by
+       fallback splitting so documents are not silently collapsed/dropped.
+
+    When *expected_doc_count* is given and fewer files are persisted, a loud
+    warning is appended to *warnings_out* (surfaced in the extract result)
+    rather than dropping documents silently. All writes are confined to
+    *output_dir*; traversal/absolute names are rejected (fail-closed) so
+    extraction can never clobber source/user files.
+    """
+    warnings = warnings_out if warnings_out is not None else []
+    files: list[Path] = []
+
+    def _flush(name: str, body: str) -> None:
         out_path = _safe_output_path(output_dir, name)
         out_path.parent.mkdir(parents=True, exist_ok=True)
-        out_path.write_text("\n".join(lines), encoding="utf-8")
+        out_path.write_text(_strip_doc_fences(body), encoding="utf-8")
         files.append(out_path)
 
-    for line in raw.split("\n"):
-        stripped = line.strip()
-        if stripped.startswith("--- FILE:") and stripped.endswith("---"):
-            # Flush previous file
-            if current_name:
-                _flush(current_name, current_lines)
-            # Start new file
-            current_name = stripped.replace("--- FILE:", "").replace("---", "").strip()
-            current_lines = []
-        else:
-            current_lines.append(line)
+    de_fenced = _strip_outer_fence(raw)
+    marker_segments = _split_on_file_markers(de_fenced)
+    named = [(name, body) for name, body in marker_segments if name]
 
-    # Flush last file
-    if current_name:
-        _flush(current_name, current_lines)
+    if len(named) >= 2:
+        # Canonical multi-file format — keep historical behavior.
+        for name, body in named:
+            _flush(name, body)
+    else:
+        # 0-1 FILE markers: recover documents the model separated another way
+        # rather than collapsing everything into a single (or zero) file.
+        fallback = _split_on_frontmatter_docs(de_fenced) or _split_on_layer_headers(de_fenced)
+        if fallback:
+            if named:
+                # Preserve the one explicitly-named doc, then recover the rest.
+                name, body = named[0]
+                _flush(name, body)
+                fallback = [seg for seg in fallback if seg.strip() != _strip_doc_fences(body).strip()]
+            for index, segment in enumerate(fallback):
+                _flush(_segment_node_name(segment, index), segment)
+        elif named:
+            name, body = named[0]
+            _flush(name, body)
+        else:
+            # Single plain document (no markers, no recoverable separators):
+            # write it as one file instead of silently dropping it.
+            if de_fenced.strip():
+                _flush(_segment_node_name(de_fenced, 0), de_fenced)
+
+    if expected_doc_count is not None and len(files) < expected_doc_count:
+        warnings.append(
+            f"AI extract parsed only {len(files)} document(s) but {expected_doc_count} "
+            f"were expected — the model's output format may be malformed (check "
+            f"_raw_ai_output.txt). No documents were silently dropped; review the raw "
+            f"output and re-run extract if incomplete."
+        )
 
     return files
 
@@ -636,20 +827,33 @@ def run_extract_ai(
     # Phase 3: AI invocation
     raw_output = _invoke_ai_command(ai_command, prompt)
 
-    # Phase 4: Parse and write
-    generated = _parse_ai_output(raw_output, out)
+    # Always persist the raw output FIRST so it survives even if parsing below
+    # hits a fail-closed path-safety error — it is the recovery artifact when the
+    # model's format is malformed.
+    raw_path = out / "_raw_ai_output.txt"
+    raw_path.write_text(raw_output, encoding="utf-8")
+
+    # Phase 4: Parse and write. The extractor targets the six MECE layers
+    # (L1-L6); recovering fewer documents is surfaced as an advisory warning
+    # (never a silent drop) so an under-parse is visible at the call site.
+    parse_warnings: list[str] = []
+    generated = _parse_ai_output(
+        raw_output,
+        out,
+        expected_doc_count=_EXPECTED_EXTRACT_LAYER_COUNT,
+        warnings_out=parse_warnings,
+    )
+    for message in parse_warnings:
+        warnings.warn(message, stacklevel=2)
 
     # Phase 4b: Normalize node identity to canonical codd.node_id so the DAG can
     # link restored docs the same way it links greenfield-generated docs.
     _normalize_extracted_frontmatter(generated)
 
-    # Also save raw output
-    raw_path = out / "_raw_ai_output.txt"
-    raw_path.write_text(raw_output, encoding="utf-8")
-
     return ExtractAIResult(
         output_dir=out,
         generated_files=generated,
         ai_raw_output=raw_output,
         module_count=len(scan.source_files),
+        parse_warnings=parse_warnings,
     )

{codd_dev-3.7.0 → codd_dev-3.7.1}/codd/parsing/__init__.py

@@ -58,6 +58,7 @@ from codd.parsing.python_ast import (
     _PY_BUILTIN_CALLS,
     _detect_python_code_patterns_stdlib,
     _extract_python_call_graph_stdlib,
+    _extract_python_import_specifiers_stdlib,
     _extract_python_imports_stdlib,
     _extract_python_symbols_stdlib,
     _header_until_colon,

{codd_dev-3.7.0 → codd_dev-3.7.1}/codd/parsing/_shared.py

@@ -113,6 +113,18 @@ class LanguageExtractor(Protocol):
     ) -> tuple[dict[str, list[str]], set[str]]:
         """Return internal and external imports for the given source content."""
 
+    def extract_import_specifiers(self, content: str) -> list[str]:
+        """Return RAW import specifiers (un-resolved) for DAG edge building.
+
+        Distinct from :meth:`extract_imports` (which classifies into the
+        scanner's internal/external module graph): this returns the literal
+        specifier strings the DAG builder resolves against the node file-set
+        (e.g. Python ``.b`` / ``pkg.c``). Backends that don't carry intra-tree
+        specifiers (or where the builder already extracts them another way)
+        return ``[]``.
+        """
+        return []
+
     def detect_code_patterns(self, mod: ModuleInfo, content: str) -> None:
         """Mutate ModuleInfo with any detected structural patterns."""
 
@@ -151,6 +163,13 @@ class RegexExtractor:
             file_path,
         )
 
+    def extract_import_specifiers(self, content: str) -> list[str]:
+        # Best-effort fallback: the regex backend has no language-agnostic raw
+        # specifier extraction. Non-Python source files keep flowing through the
+        # builder's quoted-specifier path (``extract_imports`` in
+        # ``codd.dag.extractor``), so returning ``[]`` here is a no-op for them.
+        return []
+
     def detect_code_patterns(self, mod: ModuleInfo, content: str) -> None:
         from codd import extractor as extractor_module
 

{codd_dev-3.7.0 → codd_dev-3.7.1}/codd/parsing/python_ast.py

@@ -56,6 +56,32 @@ class PythonAstExtractor:
             return {}, set()
         return _extract_python_imports_stdlib(tree, content, file_path, project_root, src_dir)
 
+    def extract_import_specifiers(self, content: str) -> list[str]:
+        """Return raw Python import specifiers (dots preserved), in source order.
+
+        Unlike :meth:`extract_imports` — which classifies imports into the
+        scanner's internal/external module graph keyed by normalized module
+        names — this returns the RAW dotted module strings exactly as written,
+        with leading dots preserved for relative imports (``.b``, ``..pkg.x``,
+        ``.`` for a bare ``from . import name`` package ref). The DAG builder
+        resolves these against the actual node file-set, so it needs the literal
+        specifier, not a normalized key.
+
+        AST-based (stdlib ``ast``) so multi-line / parenthesized / aliased
+        imports and — critically — relative imports are all captured. The
+        previous regex seam (``PY_IMPORT_RE``) silently dropped every relative
+        import. Syntax errors yield ``[]`` (the file's other facts are kept by
+        the caller), matching the rest of this backend.
+        """
+
+        if self.category != "source":
+            return []
+        try:
+            tree = ast.parse(content)
+        except (SyntaxError, ValueError, TypeError):
+            return []
+        return _extract_python_import_specifiers_stdlib(tree)
+
     def detect_code_patterns(self, mod: ModuleInfo, content: str) -> None:
         if self.category != "source":
             return None
@@ -317,6 +343,51 @@ def _extract_python_imports_stdlib(
     external -= _python_stdlib()
     return internal, external
 
+def _extract_python_import_specifiers_stdlib(tree: ast.AST) -> list[str]:
+    """Return raw dotted import specifiers (relative dots preserved) in order.
+
+    * ``import os, pkg.sub`` → ``["os", "pkg.sub"]``
+    * ``from pkg.c import y`` → ``["pkg.c"]``
+    * ``from .b import x`` → ``[".b"]`` (one leading dot per ``node.level``)
+    * ``from . import d`` → ``[".d"]`` (the imported submodule of the package)
+    * ``from ..pkg2 import w`` → ``["..pkg2"]``
+
+    Deterministic source order (``ast.walk`` is BFS, so sort by line/col) and
+    de-duplicated while preserving first-seen order, so the DAG builds a stable
+    edge set across runs.
+    """
+
+    located: list[tuple[int, int, str]] = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name:
+                    located.append((node.lineno, node.col_offset, alias.name))
+        elif isinstance(node, ast.ImportFrom):
+            prefix = "." * node.level
+            if node.module:
+                located.append((node.lineno, node.col_offset, f"{prefix}{node.module}"))
+            elif prefix:
+                # ``from . import a, b`` — each name is a SUBMODULE of the
+                # relative package (``.a`` / ``.b``), so emit one specifier per
+                # imported name. The builder resolves each to its ``.py`` /
+                # package so the real intra-package edge forms. (``*`` cannot
+                # appear in a no-module relative import, so no filtering needed.)
+                for alias in node.names:
+                    if alias.name:
+                        located.append(
+                            (node.lineno, node.col_offset, f"{prefix}{alias.name}")
+                        )
+
+    located.sort(key=lambda item: (item[0], item[1]))
+    seen: set[str] = set()
+    specifiers: list[str] = []
+    for _lineno, _col, specifier in located:
+        if specifier not in seen:
+            seen.add(specifier)
+            specifiers.append(specifier)
+    return specifiers
+
 def _detect_python_code_patterns_stdlib(mod: ModuleInfo, tree: ast.AST, content: str) -> None:
     docstring = ast.get_docstring(tree, clean=True)
     if docstring: