codd-dev 3.7.4__tar.gz → 3.7.5__tar.gz

{codd_dev-3.7.4 → codd_dev-3.7.5}/PKG-INFO

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

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "3.7.4"
+__version__ = "3.7.5"

{codd_dev-3.7.4 → codd_dev-3.7.5}/codd/dag/builder.py

@@ -372,9 +372,11 @@ def _add_import_edges(
     for node_id, file_path in impl_nodes.items():
         imports = dag.nodes[node_id].attributes.get("imports", [])
         for import_ref in imports:
-            target_id = _resolve_import_target(import_ref, file_path, project_root, path_to_node, aliases)
-            if target_id and target_id != node_id:
-                dag.add_edge(Edge(from_id=node_id, to_id=target_id, kind="imports"))
+            for target_id in _resolve_import_targets(
+                import_ref, file_path, project_root, path_to_node, aliases
+            ):
+                if target_id and target_id != node_id:
+                    dag.add_edge(Edge(from_id=node_id, to_id=target_id, kind="imports"))
 
 
 def _add_tested_by_edges(
@@ -904,6 +906,29 @@ def _resolve_design_dependency(
     return None
 
 
+def _resolve_import_targets(
+    import_ref: str,
+    file_path: Path,
+    project_root: Path,
+    path_to_node: dict[Path, str],
+    aliases: dict[str, list[str]],
+) -> list[str]:
+    """Resolve one import specifier to ALL its in-tree target node ids.
+
+    Most languages have a single resolved target per specifier (Python module,
+    Java FQN, C++ ``#include`` path), so this delegates to the singular
+    ``_resolve_import_target`` and wraps its result. C# is the one intrinsically
+    MULTI-target language: a ``using`` names a namespace that many files declare,
+    so its ``.cs``-suffix branch resolves via the namespace reverse-index and may
+    return several node ids. Dispatch is by the importing file's suffix (DATA),
+    not a ``language ==`` core gate — adding a multi-target language is data.
+    """
+    if file_path.suffix == ".cs":
+        return _resolve_csharp_import_targets(import_ref, file_path, path_to_node)
+    single = _resolve_import_target(import_ref, file_path, project_root, path_to_node, aliases)
+    return [single] if single else []
+
+
 def _resolve_import_target(
     import_ref: str,
     file_path: Path,
@@ -1219,6 +1244,129 @@ def _cpp_header_root_dirs(path_to_node: dict[Path, str]) -> list[Path]:
 _CPP_HEADER_SUFFIXES = frozenset({".h", ".hpp", ".hh"})
 
 
+# ─────────────────────────────────────────────────────────────────────────────
+# C# NAMESPACE reverse-index resolution (the novel mechanism for this language).
+#
+# C# is the third structural model after Java (FQN→path synthesis) and C++
+# (PATH-based include). The divergence: a C# ``using`` names a NAMESPACE, and a
+# namespace is NOT directory-tied — ``namespace Dapper;`` is declared by many
+# files spread across different directories (Dapper/, Dapper.SqlBuilder/, …).
+# There is no path to synthesize. So resolution is two-phase:
+#   (1) a first pass over the file-set builds a namespace→declaring-files reverse
+#       index (each .cs file's declared ``namespace`` lines → that file);
+#   (2) a ``using Dapper.X`` resolves to the files declaring ``namespace
+#       Dapper.X`` (EXACT namespace match), which is a SET of files, not one.
+# Because one ``using`` legitimately depends on every file of the target
+# namespace, this is the one language whose resolution is intrinsically
+# multi-target (handled by ``_resolve_import_targets`` plural).
+# ─────────────────────────────────────────────────────────────────────────────
+
+#: C# namespace declaration — both file-scoped (``namespace X.Y;``) and block
+#: (``namespace X.Y {`` / ``namespace X.Y`` then ``{`` on the next line) forms.
+#: Mirrors ``regex_strategies._CSHARP_NAMESPACE_RE``.
+_CSHARP_NAMESPACE_DECL_RE = re.compile(
+    r'^\s*namespace\s+([\w.]+)\s*[;{]?\s*$',
+    re.MULTILINE,
+)
+
+#: Cap on how many files a SINGLE ``using`` may resolve to, so a using of a very
+#: large namespace cannot explode the edge count pathologically. When a namespace
+#: is declared by more files than this, we keep the edges deterministic (sorted)
+#: and truncate; the WARN-level reachability layer still sees a connected node.
+#: Generous enough that real same-namespace fan-out (Dapper declares its core
+#: namespace across ~dozens of files) is preserved.
+_CSHARP_NAMESPACE_FANOUT_CAP = 64
+
+#: Process-lifetime cache of the namespace reverse-index, keyed by the IDENTITY +
+#: size of the ``path_to_node`` map. ``_add_import_edges`` / ``_add_tested_by_edges``
+#: each build a fresh ``path_to_node`` and reuse it across every import in their
+#: loop, so caching by ``id()`` (guarded by ``len()`` against id-reuse after GC)
+#: builds the index ONCE per DAG-build phase instead of per-using.
+_CSHARP_NS_INDEX_CACHE: dict[tuple[int, int], dict[str, list[str]]] = {}
+
+
+def _csharp_namespace_index(path_to_node: dict[Path, str]) -> dict[str, list[str]]:
+    """Return the namespace→declaring-node-ids reverse-index (built once, cached).
+
+    First pass over the .cs file-set: every ``namespace X.Y`` declared in a file
+    (file-scoped OR block form) maps that namespace to the file's node id. A file
+    may declare multiple namespaces; a namespace may be declared by many files
+    (the whole point — namespaces are not directory-tied). Node-id lists are kept
+    sorted for deterministic edge output.
+    """
+    key = (id(path_to_node), len(path_to_node))
+    cached = _CSHARP_NS_INDEX_CACHE.get(key)
+    if cached is not None:
+        return cached
+
+    index: dict[str, set[str]] = {}
+    for file_path, node_id in path_to_node.items():
+        if file_path.suffix != ".cs":
+            continue
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        for namespace in _CSHARP_NAMESPACE_DECL_RE.findall(content):
+            index.setdefault(namespace, set()).add(node_id)
+
+    materialized = {ns: sorted(ids) for ns, ids in index.items()}
+    _CSHARP_NS_INDEX_CACHE[key] = materialized
+    return materialized
+
+
+def _csharp_using_namespaces(import_ref: str) -> list[str]:
+    """Candidate namespaces to look up for one ``using`` specifier (most-specific first).
+
+    * plain / global / alias ``using Dapper.X`` → ``["Dapper.X"]`` (exact).
+    * ``static Dapper.SqlMapper`` → ``["Dapper.SqlMapper", "Dapper"]``: a
+      ``using static`` targets a TYPE (``Dapper.SqlMapper``), whose declaring file
+      lives in the type's OWNING namespace (``Dapper``). We try the full path as a
+      namespace first (harmless if it is not one — just no match), then the parent
+      namespace (drop the type segment), which is the real resolution.
+    """
+    spec = import_ref
+    is_static = spec.startswith(_CSHARP_STATIC_SPECIFIER)
+    if is_static:
+        spec = spec[len(_CSHARP_STATIC_SPECIFIER):].strip()
+    if not spec:
+        return []
+    candidates = [spec]
+    if is_static:
+        parent = spec.rsplit(".", 1)[0] if "." in spec else ""
+        if parent and parent != spec:
+            candidates.append(parent)
+    return candidates
+
+
+def _resolve_csharp_import_targets(
+    import_ref: str,
+    file_path: Path,
+    path_to_node: dict[Path, str],
+) -> list[str]:
+    """Resolve one C# ``using`` to the node ids declaring its namespace (EXACT).
+
+    Sub-namespace handling: resolution is by EXACT namespace match only. A
+    ``using Dapper`` resolves to files declaring exactly ``namespace Dapper`` — it
+    does NOT transitively pull in ``Dapper.Tests`` / ``Dapper.SqlBuilder`` files.
+    This is both correct (a parent-namespace using does not import child
+    namespaces in C#; each child needs its own ``using``) and the primary
+    explosion guard (no namespace-prefix fan-out). For a ``using static`` the
+    type's owning namespace is the fallback candidate (see
+    ``_csharp_using_namespaces``); the first candidate that matches the index
+    wins, so a static import does not double-count.
+
+    Secondary explosion guard: a single using that matches a very large namespace
+    is truncated at ``_CSHARP_NAMESPACE_FANOUT_CAP`` (deterministic, sorted).
+    """
+    index = _csharp_namespace_index(path_to_node)
+    for namespace in _csharp_using_namespaces(import_ref):
+        node_ids = index.get(namespace)
+        if node_ids:
+            return node_ids[:_CSHARP_NAMESPACE_FANOUT_CAP]
+    return []
+
+
 def _infer_test_targets(
     test_path: Path,
     project_root: Path,
@@ -1228,11 +1376,15 @@ def _infer_test_targets(
     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)
+        resolved = _resolve_import_targets(import_ref, test_path, project_root, path_to_node, aliases)
+        if not resolved and "." in import_ref and not import_ref.startswith("."):
+            # Python absolute-dotted fallback (non-C#: the plural resolver returns
+            # at most one for those). C# usings already resolve via the namespace
+            # index inside ``_resolve_import_targets``, so this never double-fires.
+            python_target = _resolve_python_import_target(import_ref, project_root, path_to_node)
+            if python_target:
+                resolved = [python_target]
+        targets.update(resolved)
 
     convention_key = _test_convention_key(test_path, project_root)
     if convention_key:
@@ -1347,12 +1499,54 @@ def _extract_cpp_include_specifiers(file_path: Path) -> list[str]:
     return specifiers
 
 
+# C# ``using`` directives. Unlike C++ ``#include`` (path) or Java FQN→path, a C#
+# ``using`` names a NAMESPACE, which is NOT directory-tied — ``namespace Dapper;``
+# is declared across files in different dirs. So the resolver needs a
+# namespace→declaring-files reverse-index (built once over the file-set), not a
+# path probe. The extractor's job is just to surface the raw using forms:
+#   ``using X.Y;``              → ``X.Y``
+#   ``using static X.Y.Member;``→ ``static X.Y.Member``  (resolver drops Member)
+#   ``using Alias = X.Y;``      → ``X.Y``  (alias name is irrelevant to edges)
+#   ``global using X.Y;``       → ``X.Y``
+# Built-in regex (NOT routed through the registry): tree-sitter-c-sharp is NOT
+# installed, and ``RegexExtractor.extract_import_specifiers`` returns ``[]`` for
+# C#, so a self-contained regex is the source of these specifiers (mirrors the
+# C++ precedent of deferring tree-sitter wiring). The ``static`` marker is the
+# only shape distinction the resolver needs.
+_CSHARP_STATIC_SPECIFIER = "static "
+_CSHARP_USING_RE = re.compile(
+    r'^\s*(?:global\s+)?using\s+(static\s+)?(?:[\w.]+\s*=\s*)?([\w.]+)\s*;',
+    re.MULTILINE,
+)
+
+
+def _extract_csharp_import_specifiers(file_path: Path) -> list[str]:
+    """Return raw C# ``using`` specifiers (static-marked) for the DAG.
+
+    Mirrors ``_extract_cpp_include_specifiers`` / ``_extract_java_import_specifiers``
+    in role (suffix-dispatched raw specifier extraction) but uses a built-in
+    regex because tree-sitter-c-sharp is absent. ``using static X.Y.Member`` is
+    surfaced with a ``static `` prefix so the NAMESPACE-index resolver knows to
+    also try the parent namespace (the member's owning type's namespace); plain /
+    global / alias usings are surfaced as the bare imported namespace.
+    """
+
+    content = file_path.read_text(encoding="utf-8", errors="ignore")
+    specifiers: list[str] = []
+    for static_kw, namespace in _CSHARP_USING_RE.findall(content):
+        if static_kw:
+            specifiers.append(f"{_CSHARP_STATIC_SPECIFIER}{namespace}")
+        else:
+            specifiers.append(namespace)
+    return specifiers
+
+
 #: Suffix → raw-specifier extractor (DATA dispatch). A source file whose language
 #: carries its intra-tree dependency graph in DOTTED specifiers (Python modules,
-#: Java FQNs) or ``#include`` directives (C/C++) resolves edges from these,
-#: instead of the builder's quoted-string ``extract_imports`` seam (JS/TS
-#: ``from '…'`` / ``require('…')``). Adding a language here is pure data — no
-#: core ``if language ==`` branch.
+#: Java FQNs, C# namespaces) or ``#include`` directives (C/C++) resolves edges
+#: from these, instead of the builder's quoted-string ``extract_imports`` seam
+#: (JS/TS ``from '…'`` / ``require('…')``). Adding a language here is pure data —
+#: no core ``if language ==`` branch.
 _SUFFIX_SPECIFIER_EXTRACTORS: dict[str, "Callable[[Path], list[str]]"] = {
     ".py": _extract_python_import_specifiers,
     ".java": _extract_java_import_specifiers,
@@ -1362,6 +1556,7 @@ _SUFFIX_SPECIFIER_EXTRACTORS: dict[str, "Callable[[Path], list[str]]"] = {
     ".cc": _extract_cpp_include_specifiers,
     ".cpp": _extract_cpp_include_specifiers,
     ".cxx": _extract_cpp_include_specifiers,
+    ".cs": _extract_csharp_import_specifiers,
 }
 
 
@@ -1403,6 +1598,22 @@ def _resolve_python_import_target(import_ref: str, project_root: Path, path_to_n
     return path_to_node.get(init_path)
 
 
+#: ESM/TS extension-swap map (DATA, not a ``language ==`` branch). Under
+#: ``moduleResolution: NodeNext``/``Bundler`` a TypeScript import specifier MUST
+#: carry the EMITTED ``.js`` extension that resolves to the ``.ts`` SOURCE file
+#: (``import { x } from "./types.js"`` → ``types.ts``). Each emitted suffix maps
+#: to the source suffixes it can stand in for. Resolution tries these ONLY as a
+#: last-resort fallback (after exact-match and bare suffix-append both fail), so
+#: a real ``./foo.js`` target still wins by exact match — JS projects with real
+#: ``.js`` files are unaffected.
+_ESM_EXTENSION_SWAP: dict[str, tuple[str, ...]] = {
+    ".js": (".ts", ".tsx"),
+    ".jsx": (".tsx", ".ts"),
+    ".mjs": (".mts", ".ts"),
+    ".cjs": (".cts", ".ts"),
+}
+
+
 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]
@@ -1420,6 +1631,26 @@ def _resolve_file_candidate(candidate: Path, path_to_node: dict[Path, str]) -> s
     init_file = candidate / "__init__.py"
     if init_file in path_to_node:
         return path_to_node[init_file]
+
+    # FALLBACK (only after exact-match + suffix-append + index/__init__ all
+    # failed): the specifier carries an emitted ESM extension (``.js``/…) that
+    # should resolve to a ``.ts`` SOURCE file. Swap the emitted suffix for each
+    # candidate source suffix and retry both the file form (``./types.js`` →
+    # ``types.ts``) and the directory-index form (``./foo.js`` → ``foo/index.ts``).
+    source_suffixes = _ESM_EXTENSION_SWAP.get(candidate.suffix)
+    if source_suffixes:
+        # Strip ONLY the trailing emitted suffix as a string so inner dots are
+        # preserved (``types.test.js`` → base ``types.test``, not ``types``).
+        stem = candidate.name[: -len(candidate.suffix)]
+        swapped_base = candidate.parent / stem
+        for source_suffix in source_suffixes:
+            swapped = candidate.parent / f"{stem}{source_suffix}"
+            if swapped in path_to_node:
+                return path_to_node[swapped]
+        for source_suffix in source_suffixes:
+            indexed = swapped_base / f"index{source_suffix}"
+            if indexed in path_to_node:
+                return path_to_node[indexed]
     return None
 
 

{codd_dev-3.7.4 → codd_dev-3.7.5}/codd/extractor.py

@@ -310,6 +310,11 @@ def _detect_language(project_root: Path, exclude_patterns: list[str]) -> str:
         # ``cpp`` instead of vacuously falling back to ``python``.
         ".cc": "cpp", ".cpp": "cpp", ".cxx": "cpp",
         ".h": "cpp", ".hpp": "cpp", ".hh": "cpp",
+        # C# (.cs). Listed as DATA so a C# project like Dapper (157 .cs files,
+        # no .py at all) is detected as ``csharp`` instead of vacuously falling
+        # back to ``python`` — the single change that fixes the false-green where
+        # ``codd check`` PASSes on a 0-edge graph because the .cs files were inert.
+        ".cs": "csharp",
     }
 
     for root, dirs, files in os.walk(project_root):

{codd_dev-3.7.4 → codd_dev-3.7.5}/codd/parsing/regex_strategies.py

@@ -219,6 +219,82 @@ def _java_internal_key(fqn_parts: list[str], root_parts: list[str]) -> str:
     return fqn_parts[-2] if len(fqn_parts) >= 2 else fqn_parts[0]
 
 
+#: C# type-declaration keyword → emitted symbol kind. ``record`` collapses to the
+#: nearest existing kind (``class``) so downstream symbol consumers (which only
+#: know class/interface/enum/struct/function) stay unchanged; ``record struct`` is
+#: covered by the ``struct`` pattern. Access/`partial`/`sealed`/`abstract`/etc.
+#: modifiers are tolerated before the keyword.
+_CSHARP_MODIFIERS = r'(?:public|internal|protected|private|static|sealed|abstract|partial|readonly|ref|unsafe|new|file)'
+_CSHARP_TYPE_KEYWORD_KINDS = (
+    (re.compile(rf'^\s*(?:{_CSHARP_MODIFIERS}\s+)*class\s+(\w+)'), "class"),
+    (re.compile(rf'^\s*(?:{_CSHARP_MODIFIERS}\s+)*interface\s+(\w+)'), "interface"),
+    (re.compile(rf'^\s*(?:{_CSHARP_MODIFIERS}\s+)*enum\s+(\w+)'), "enum"),
+    (re.compile(rf'^\s*(?:{_CSHARP_MODIFIERS}\s+)*(?:record\s+)?struct\s+(\w+)'), "struct"),
+    (re.compile(rf'^\s*(?:{_CSHARP_MODIFIERS}\s+)*record\s+(?:class\s+)?(\w+)'), "class"),
+)
+
+
+def _symbols_csharp(content: str, rel_path: str) -> "list[Symbol]":
+    symbols: list = []
+    for i, line in enumerate(content.splitlines(), 1):
+        for pattern, kind in _CSHARP_TYPE_KEYWORD_KINDS:
+            m = pattern.match(line)
+            if m:
+                symbols.append(_symbol(m.group(1), kind, rel_path, i))
+                break
+    return symbols
+
+
+#: C# ``using`` directives + ``namespace`` declarations. Mirrors
+#: ``builder._CSHARP_USING_RE`` / ``builder._CSHARP_NAMESPACE_RE`` so the scan-path
+#: parser and the DAG builder agree on a C# project's using graph. ``using``
+#: covers plain / ``static`` / ``global`` / alias (``using Alias = X.Y;``) forms;
+#: the namespace regex covers BOTH file-scoped (``namespace X.Y;``) and block
+#: (``namespace X.Y {``) declarations (Dapper uses both).
+_CSHARP_USING_RE = re.compile(
+    r'^\s*(?:global\s+)?using\s+(?:static\s+)?'
+    r'(?:[\w.]+\s*=\s*)?'  # optional ``Alias =`` (we capture the RHS namespace)
+    r'([\w.]+)\s*;'
+)
+_CSHARP_NAMESPACE_RE = re.compile(r'^\s*namespace\s+([\w.]+)\s*[;{]?\s*$')
+
+#: C# framework / BCL namespace roots. A ``using`` rooted here is external (the
+#: analogue of Java ``java.*`` / C++ angle-form ``<…>``). Everything else is a
+#: candidate first-party namespace; the DAG builder owns the precise
+#: namespace→file resolution for edges via the reverse-index.
+_CSHARP_FRAMEWORK_ROOTS = frozenset({"System", "Microsoft", "Windows", "Mono"})
+
+
+def _imports_csharp(content, project_root, src_dir, file_path):
+    """Classify C# usings: first-party ``internal`` vs ``System.*``/framework.
+
+    The regex sibling of the DAG builder's using extraction (there is no
+    tree-sitter-c-sharp binding). A ``using Dapper.X;`` rooted outside the
+    framework roots is first-party (``internal``, bucketed by the namespace's
+    first segment); ``using System.Text;`` / ``using Microsoft.*`` is framework
+    (``external``, keyed by the full namespace). Returns the
+    ``(internal, external)`` shape every ``extract_imports`` strategy yields.
+    """
+    internal: dict[str, list[str]] = {}
+    external: set[str] = set()
+
+    for line in content.splitlines():
+        m = _CSHARP_USING_RE.match(line)
+        if not m:
+            continue
+        namespace = m.group(1)
+        top = namespace.split(".", 1)[0]
+        if top in _CSHARP_FRAMEWORK_ROOTS:
+            external.add(namespace)
+        else:
+            # Bucket by the first namespace segment (``Dapper`` for
+            # ``Dapper.ProviderTools``); the DAG builder owns the precise
+            # namespace→file resolution for edges via the reverse-index.
+            internal.setdefault(top, []).append(line.strip())
+
+    return internal, external
+
+
 def _symbols_go(content: str, rel_path: str) -> "list[Symbol]":
     symbols: list = []
     for i, line in enumerate(content.splitlines(), 1):
@@ -590,6 +666,20 @@ _CPP = RegexLanguageStrategy(
     guess_test_target=None,
 )
 
+_CSHARP = RegexLanguageStrategy(
+    name="csharp",
+    extensions=frozenset({".cs"}),
+    # stdlib stays EMPTY: ``_imports_csharp`` already classifies framework usings
+    # (``System.*``/``Microsoft.*``/…) into ``external`` itself; there is no fixed
+    # name-set to subtract (C# uses arbitrary dotted namespaces, not a list).
+    entry_points=("Program.cs", "Main.cs"),
+    extract_symbols=_symbols_csharp,
+    extract_imports=_imports_csharp,
+    detect_code_patterns=None,
+    file_to_module=_file_to_module_first_part,
+    guess_test_target=None,
+)
+
 #: The generic fallback for an unknown language — best-effort no-op analysis,
 #: matching the implicit ``else`` of every old ladder (empty symbols/imports,
 #: no patterns, first-path-part module name, no test-target, no extensions).
@@ -605,6 +695,7 @@ _STRATEGIES: dict[str, RegexLanguageStrategy] = {
     "java": _JAVA,
     "go": _GO,
     "cpp": _CPP,
+    "csharp": _CSHARP,
 }
 
 
@@ -791,6 +882,50 @@ def _resolve_cpp_include_path(
     return None
 
 
+#: C# ``using`` directive (mirrors the scan/builder regexes) for recovering the
+#: imported namespace from a stored ``internal`` line.
+_CSHARP_USING_LINE_RE = re.compile(
+    r'(?:global\s+)?using\s+(?:static\s+)?(?:[\w.]+\s*=\s*)?([\w.]+)\s*;'
+)
+
+
+def _ceg_targets_csharp(
+    internal: dict, project_root: Path, file_path: Path
+) -> "list[CegImportTarget]":
+    """C# internal usings → ``module`` CEG nodes keyed by first-party namespace.
+
+    Mirrors ``_ceg_targets_java`` (a stable ``module:`` identifier per imported
+    first-party unit) rather than probing the filesystem — C# resolution is
+    NAMESPACE-based, not path-based, so there is no single file a ``using``
+    points at; the DAG builder owns the precise namespace→declaring-files
+    resolution for import EDGES via its reverse-index. The ``internal`` map values
+    are the raw using lines (``using Dapper.ProviderTools;`` / ``using static
+    Dapper.SqlMapper;`` / ``using Foo = Dapper.X;``); we recover the imported
+    namespace for the node.
+    """
+    targets: list[CegImportTarget] = []
+    seen: set[str] = set()
+    for using_lines in internal.values():
+        for line in using_lines:
+            match = _CSHARP_USING_LINE_RE.search(line)
+            if not match:
+                continue
+            namespace = match.group(1)
+            if not namespace or namespace in seen:
+                continue
+            seen.add(namespace)
+            targets.append(
+                CegImportTarget(
+                    target_id=f"module:{namespace}",
+                    node_type="module",
+                    node_kwargs={"name": namespace},
+                    evidence_method="csharp_using",
+                    confidence=0.90,
+                )
+            )
+    return targets
+
+
 #: Per-language scanner CEG-import resolvers (registry DATA). Languages without
 #: an entry contribute NO import edges, byte-identical to the former scanner
 #: block that only handled python and typescript/javascript.
@@ -802,6 +937,7 @@ _CEG_IMPORT_RESOLVERS: dict[
     "python": _ceg_targets_python,
     "java": _ceg_targets_java,
     "cpp": _ceg_targets_cpp,
+    "csharp": _ceg_targets_csharp,
 }
 
 

{codd_dev-3.7.4 → codd_dev-3.7.5}/pyproject.toml

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