polycodegraph 0.1.0__py3-none-any.whl

codegraph/analysis/metrics.py

@@ -0,0 +1,52 @@
+"""Aggregate graph metrics."""
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass, field
+
+import networkx as nx
+
+from codegraph.analysis._common import _kind_str
+
+
+@dataclass
+class GraphMetrics:
+    total_nodes: int = 0
+    total_edges: int = 0
+    nodes_by_kind: dict[str, int] = field(default_factory=dict)
+    edges_by_kind: dict[str, int] = field(default_factory=dict)
+    languages: dict[str, int] = field(default_factory=dict)
+    top_files_by_nodes: list[tuple[str, int]] = field(default_factory=list)
+    unresolved_edges: int = 0
+
+
+def compute_metrics(graph: nx.MultiDiGraph, *, top_files: int = 10) -> GraphMetrics:
+    metrics = GraphMetrics(total_nodes=graph.number_of_nodes())
+    kind_counter: Counter[str] = Counter()
+    lang_counter: Counter[str] = Counter()
+    file_counter: Counter[str] = Counter()
+    for _nid, attrs in graph.nodes(data=True):
+        kind = _kind_str(attrs.get("kind")) or "UNKNOWN"
+        kind_counter[kind] += 1
+        lang = str(attrs.get("language") or "unknown")
+        lang_counter[lang] += 1
+        file_path = attrs.get("file")
+        if isinstance(file_path, str) and file_path:
+            file_counter[file_path] += 1
+    metrics.nodes_by_kind = dict(sorted(kind_counter.items()))
+    metrics.languages = dict(sorted(lang_counter.items()))
+    metrics.top_files_by_nodes = file_counter.most_common(top_files)
+
+    edge_counter: Counter[str] = Counter()
+    unresolved = 0
+    total = 0
+    for _src, dst, _key, data in graph.edges(keys=True, data=True):
+        total += 1
+        ek = _kind_str(data.get("kind")) or "UNKNOWN"
+        edge_counter[ek] += 1
+        if isinstance(dst, str) and dst.startswith("unresolved::"):
+            unresolved += 1
+    metrics.total_edges = total
+    metrics.edges_by_kind = dict(sorted(edge_counter.items()))
+    metrics.unresolved_edges = unresolved
+    return metrics

codegraph/analysis/report.py

@@ -0,0 +1,222 @@
+"""Aggregate analyze + symbol-resolution helpers used by the CLI."""
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+import networkx as nx
+
+from codegraph.analysis import (
+    BlastRadiusResult,
+    CycleReport,
+    DeadNode,
+    GraphMetrics,
+    Hotspot,
+    UntestedNode,
+    blast_radius,
+    compute_metrics,
+    find_cycles,
+    find_dead_code,
+    find_hotspots,
+    find_untested,
+)
+from codegraph.graph.schema import NodeKind
+
+
+@dataclass
+class AnalyzeReport:
+    metrics: GraphMetrics
+    cycles: CycleReport
+    dead_code: list[DeadNode]
+    untested: list[UntestedNode]
+    hotspots: list[Hotspot]
+    warnings: list[str] = field(default_factory=list)
+
+    # pragma: codegraph-public-api
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "metrics": _metrics_to_dict(self.metrics),
+            "cycles": {
+                "import_cycles": [
+                    {"node_ids": c.node_ids, "qualnames": c.qualnames}
+                    for c in self.cycles.import_cycles
+                ],
+                "call_cycles": [
+                    {"node_ids": c.node_ids, "qualnames": c.qualnames}
+                    for c in self.cycles.call_cycles
+                ],
+                "total": self.cycles.total,
+            },
+            "dead_code": [asdict(d) for d in self.dead_code],
+            "untested": [asdict(u) for u in self.untested],
+            "hotspots": [asdict(h) for h in self.hotspots],
+            "warnings": list(self.warnings),
+        }
+
+
+def _metrics_to_dict(m: GraphMetrics) -> dict[str, Any]:
+    return {
+        "total_nodes": m.total_nodes,
+        "total_edges": m.total_edges,
+        "nodes_by_kind": dict(m.nodes_by_kind),
+        "edges_by_kind": dict(m.edges_by_kind),
+        "languages": dict(m.languages),
+        "top_files_by_nodes": [list(t) for t in m.top_files_by_nodes],
+        "unresolved_edges": m.unresolved_edges,
+    }
+
+
+def run_full_analyze(
+    graph: nx.MultiDiGraph, *, hotspot_limit: int = 20
+) -> AnalyzeReport:
+    return AnalyzeReport(
+        metrics=compute_metrics(graph),
+        cycles=find_cycles(graph),
+        dead_code=find_dead_code(graph),
+        untested=find_untested(graph),
+        hotspots=find_hotspots(graph, limit=hotspot_limit),
+    )
+
+
+def report_to_json(report: AnalyzeReport) -> str:
+    return json.dumps(report.to_dict(), indent=2, sort_keys=True)
+
+
+def report_to_markdown(report: AnalyzeReport) -> str:
+    m = report.metrics
+    lines: list[str] = ["# codegraph analysis", ""]
+    lines.append("## Metrics")
+    lines.append("")
+    lines.append(f"- Nodes: **{m.total_nodes}**")
+    lines.append(f"- Edges: **{m.total_edges}**")
+    lines.append(f"- Unresolved edges: **{m.unresolved_edges}**")
+    if m.nodes_by_kind:
+        lines.append("- Nodes by kind: " + ", ".join(
+            f"{k}={v}" for k, v in m.nodes_by_kind.items()
+        ))
+    if m.edges_by_kind:
+        lines.append("- Edges by kind: " + ", ".join(
+            f"{k}={v}" for k, v in m.edges_by_kind.items()
+        ))
+    if m.languages:
+        lines.append("- Languages: " + ", ".join(
+            f"{k}={v}" for k, v in m.languages.items()
+        ))
+    if m.top_files_by_nodes:
+        lines.append("")
+        lines.append("### Top files by node count")
+        lines.append("")
+        for path, count in m.top_files_by_nodes:
+            lines.append(f"- `{path}` — {count} nodes")
+
+    lines.append("")
+    lines.append("## Cycles")
+    lines.append("")
+    if not report.cycles.total:
+        lines.append("_None._")
+    else:
+        if report.cycles.import_cycles:
+            lines.append(f"### Import cycles ({len(report.cycles.import_cycles)})")
+            for cyc in report.cycles.import_cycles[:10]:
+                lines.append("- " + " → ".join(cyc.qualnames))
+        if report.cycles.call_cycles:
+            lines.append(f"### Call cycles ({len(report.cycles.call_cycles)})")
+            for cyc in report.cycles.call_cycles[:10]:
+                lines.append("- " + " → ".join(cyc.qualnames))
+
+    lines.append("")
+    lines.append(f"## Dead code ({len(report.dead_code)})")
+    lines.append("")
+    if not report.dead_code:
+        lines.append("_None._")
+    else:
+        for node in report.dead_code[:50]:
+            lines.append(
+                f"- `{node.qualname}` ({node.kind.lower()}) — "
+                f"{node.file}:{node.line_start}"
+            )
+        if len(report.dead_code) > 50:
+            lines.append(f"- … and {len(report.dead_code) - 50} more")
+
+    lines.append("")
+    lines.append(f"## Untested functions ({len(report.untested)})")
+    lines.append("")
+    if not report.untested:
+        lines.append("_None — every function has at least one test caller._")
+    else:
+        for u in report.untested[:50]:
+            lines.append(
+                f"- `{u.qualname}` ({u.kind.lower()}) — "
+                f"{u.file}:{u.line_start} (callers: {u.incoming_calls})"
+            )
+        if len(report.untested) > 50:
+            lines.append(f"- … and {len(report.untested) - 50} more")
+
+    lines.append("")
+    lines.append(f"## Hotspots (top {len(report.hotspots)})")
+    lines.append("")
+    if not report.hotspots:
+        lines.append("_None._")
+    else:
+        lines.append("| Symbol | File | Fan-in | Fan-out | LOC |")
+        lines.append("|---|---|---:|---:|---:|")
+        for h in report.hotspots:
+            lines.append(
+                f"| `{h.qualname}` | {h.file} | {h.fan_in} | "
+                f"{h.fan_out} | {h.loc} |"
+            )
+
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def find_symbol(graph: nx.MultiDiGraph, symbol: str) -> str | None:
+    """Resolve a CLI symbol string to a node id. Tries qualname, then name,
+    then file path, then unique substring match. Prefers callable kinds."""
+    callable_kinds = {NodeKind.FUNCTION.value, NodeKind.METHOD.value}
+    by_qualname: list[tuple[str, str]] = []
+    by_name: list[tuple[str, str]] = []
+    by_file: list[tuple[str, str]] = []
+    for nid, attrs in graph.nodes(data=True):
+        kind = str(attrs.get("kind") or "")
+        qn = str(attrs.get("qualname") or "")
+        name = str(attrs.get("name") or "")
+        file_path = str(attrs.get("file") or "")
+        if qn == symbol:
+            by_qualname.append((nid, kind))
+        if name == symbol:
+            by_name.append((nid, kind))
+        if file_path == symbol:
+            by_file.append((nid, kind))
+
+    for bucket in (by_qualname, by_name, by_file):
+        if not bucket:
+            continue
+        prefer = [nid for nid, kind in bucket if kind in callable_kinds]
+        if prefer:
+            return prefer[0]
+        return bucket[0][0]
+
+    # substring match across qualnames
+    candidates: list[tuple[str, str]] = []
+    for nid, attrs in graph.nodes(data=True):
+        qn = str(attrs.get("qualname") or "")
+        if symbol in qn:
+            candidates.append((nid, str(attrs.get("kind") or "")))
+    if len(candidates) == 1:
+        return candidates[0][0]
+    prefer = [nid for nid, kind in candidates if kind in callable_kinds]
+    if len(prefer) == 1:
+        return prefer[0]
+    return None
+
+
+__all__ = [
+    "AnalyzeReport",
+    "BlastRadiusResult",
+    "blast_radius",
+    "find_symbol",
+    "report_to_json",
+    "report_to_markdown",
+    "run_full_analyze",
+]

codegraph/analysis/roles.py

@@ -0,0 +1,323 @@
+"""Architectural role classification for FUNCTION/METHOD/CLASS nodes.
+
+Stamps ``metadata["role"]`` with one of:
+
+* ``HANDLER`` - HTTP/route/endpoint entry points (FastAPI, Flask, NestJS,
+  Next.js route files, Express-style decorators).
+* ``SERVICE`` - business-logic classes (``*Service`` suffix, ``@Injectable``)
+  and their methods.
+* ``COMPONENT`` - React components (TS/JS only).
+* ``REPO`` - data-access classes (``*Repository`` suffix or SQLAlchemy
+  Session-using classes).
+
+Conflict priority: HANDLER > COMPONENT > SERVICE > REPO. Whichever fires
+first wins; subsequent rules do not overwrite.
+
+This pass is purely additive: it never mutates parser-emitted attributes
+besides the ``role`` key inside a node's ``metadata`` dict.
+"""
+from __future__ import annotations
+
+import re
+from typing import Final
+
+import networkx as nx
+
+from codegraph.analysis._common import _kind_str
+from codegraph.graph.schema import EdgeKind, NodeKind
+
+Role = str  # "HANDLER" | "SERVICE" | "COMPONENT" | "REPO"
+
+HANDLER: Final[Role] = "HANDLER"
+SERVICE: Final[Role] = "SERVICE"
+COMPONENT: Final[Role] = "COMPONENT"
+REPO: Final[Role] = "REPO"
+
+_ROLE_PRIORITY: Final[dict[Role, int]] = {
+    HANDLER: 4,
+    COMPONENT: 3,
+    SERVICE: 2,
+    REPO: 1,
+}
+
+# HTTP verb decorator pattern: matches @anything.get / @anything.post / etc.,
+# also @anything.route / @anything.websocket / @anything.endpoint.
+_HTTP_VERBS: Final[tuple[str, ...]] = (
+    "get", "post", "put", "delete", "patch", "head", "options",
+    "route", "websocket", "endpoint",
+)
+_HTTP_DECORATOR_RE: Final[re.Pattern[str]] = re.compile(
+    r"@[\w\.]+\.(?:" + "|".join(_HTTP_VERBS) + r")\b",
+)
+# Substring fallback: catches things like @route(...) or @endpoint(...).
+_ROUTE_SUBSTRINGS: Final[tuple[str, ...]] = ("route", "endpoint")
+
+_TS_LIKE_LANGS: Final[frozenset[str]] = frozenset(
+    {"typescript", "javascript", "tsx", "jsx"}
+)
+_TSX_EXTS: Final[tuple[str, ...]] = (".tsx", ".jsx")
+
+
+def _decorators(attrs: dict[str, object]) -> list[str]:
+    metadata = attrs.get("metadata") or {}
+    if not isinstance(metadata, dict):
+        return []
+    raw = metadata.get("decorators") or []
+    if not isinstance(raw, list):
+        return []
+    return [str(x) for x in raw]
+
+
+def _is_http_decorator(text: str) -> bool:
+    if _HTTP_DECORATOR_RE.search(text):
+        return True
+    # Substring match (case-insensitive) on the decorator name itself.
+    lowered = text.lower()
+    return any(sub in lowered for sub in _ROUTE_SUBSTRINGS)
+
+
+def _has_handler_decorator(decorators: list[str]) -> bool:
+    return any(_is_http_decorator(d) for d in decorators)
+
+
+def _has_injectable_decorator(decorators: list[str]) -> bool:
+    return any(d.lstrip("@").startswith("Injectable") for d in decorators)
+
+
+def _has_controller_decorator(decorators: list[str]) -> bool:
+    return any(d.lstrip("@").startswith("Controller") for d in decorators)
+
+
+def _is_next_route_file(file_path: str) -> bool:
+    """Match Next.js app router or pages/api conventions."""
+    norm = file_path.replace("\\", "/")
+    if re.search(r"(?:^|/)app/.*?/route\.(?:ts|js|tsx|jsx)$", norm):
+        return True
+    return bool(re.search(r"(?:^|/)pages/api/.*\.(?:ts|js|tsx|jsx)$", norm))
+
+
+def _is_tsx_file(file_path: str) -> bool:
+    norm = file_path.lower()
+    return norm.endswith(_TSX_EXTS)
+
+
+def _is_pascal_case(name: str) -> bool:
+    return bool(name) and name[0].isupper() and not name.isupper()
+
+
+def _has_params(attrs: dict[str, object]) -> bool:
+    sig = attrs.get("signature")
+    if not isinstance(sig, str):
+        return False
+    # Heuristic: a parameter list with at least one non-empty token between
+    # parentheses. ``foo()`` has no params; ``foo(props)`` does.
+    m = re.search(r"\(([^)]*)\)", sig)
+    if not m:
+        return False
+    return bool(m.group(1).strip())
+
+
+def _class_inherits_react_component(
+    graph: nx.MultiDiGraph, class_id: str
+) -> bool:
+    """True if class has an INHERITS edge to React.Component / Component."""
+    for _src, _dst, _key, data in graph.out_edges(class_id, keys=True, data=True):
+        if data.get("kind") != EdgeKind.INHERITS.value:
+            continue
+        target = ""
+        meta = data.get("metadata") or {}
+        if isinstance(meta, dict):
+            target = str(meta.get("target_name") or "")
+        if not target:
+            continue
+        if target in {"React.Component", "Component", "React.PureComponent",
+                      "PureComponent"}:
+            return True
+    return False
+
+
+def _members_of_class(
+    graph: nx.MultiDiGraph, class_id: str
+) -> list[str]:
+    """Return method/function nodes whose DEFINED_IN edge points to class."""
+    members: list[str] = []
+    for src, _dst, _key, data in graph.in_edges(class_id, keys=True, data=True):
+        if data.get("kind") != EdgeKind.DEFINED_IN.value:
+            continue
+        attrs = graph.nodes.get(src) or {}
+        kind = _kind_str(attrs.get("kind"))
+        if kind in (NodeKind.METHOD.value, NodeKind.FUNCTION.value):
+            members.append(src)
+    return members
+
+
+def _enclosing_class(
+    graph: nx.MultiDiGraph, node_id: str
+) -> str | None:
+    """Return the CLASS node id this method is DEFINED_IN, if any."""
+    for _src, dst, _key, data in graph.out_edges(node_id, keys=True, data=True):
+        if data.get("kind") != EdgeKind.DEFINED_IN.value:
+            continue
+        attrs = graph.nodes.get(dst) or {}
+        if _kind_str(attrs.get("kind")) == NodeKind.CLASS.value:
+            return str(dst)
+    return None
+
+
+def _set_role(
+    graph: nx.MultiDiGraph, node_id: str, role: Role
+) -> bool:
+    """Set role on the node, respecting priority. Returns True if changed."""
+    attrs = graph.nodes.get(node_id)
+    if attrs is None:
+        return False
+    metadata = attrs.get("metadata")
+    if not isinstance(metadata, dict):
+        metadata = {}
+        attrs["metadata"] = metadata
+    current = metadata.get("role")
+    if (
+        isinstance(current, str)
+        and current in _ROLE_PRIORITY
+        and _ROLE_PRIORITY[role] <= _ROLE_PRIORITY[current]
+    ):
+        return False
+    metadata["role"] = role
+    return True
+
+
+def _classify_handler(
+    graph: nx.MultiDiGraph, node_id: str, attrs: dict[str, object]
+) -> bool:
+    kind = _kind_str(attrs.get("kind"))
+    if kind not in (NodeKind.FUNCTION.value, NodeKind.METHOD.value):
+        return False
+    decorators = _decorators(attrs)
+    if _has_handler_decorator(decorators):
+        return _set_role(graph, node_id, HANDLER)
+    # NestJS: methods on a class decorated with @Controller(...) are handlers.
+    if kind == NodeKind.METHOD.value:
+        cls_id = _enclosing_class(graph, node_id)
+        if cls_id is not None:
+            cls_attrs = graph.nodes.get(cls_id) or {}
+            if _has_controller_decorator(_decorators(cls_attrs)):
+                return _set_role(graph, node_id, HANDLER)
+    # Next.js app/**/route.{ts,js} or pages/api/**.{ts,js} files.
+    if kind == NodeKind.FUNCTION.value:
+        file_path = str(attrs.get("file") or "")
+        language = str(attrs.get("language") or "").lower()
+        if language in _TS_LIKE_LANGS and _is_next_route_file(file_path):
+            return _set_role(graph, node_id, HANDLER)
+    return False
+
+
+def _classify_service_class(
+    graph: nx.MultiDiGraph, node_id: str, attrs: dict[str, object]
+) -> bool:
+    if _kind_str(attrs.get("kind")) != NodeKind.CLASS.value:
+        return False
+    name = str(attrs.get("name") or "")
+    if name.endswith("Service"):
+        return _set_role(graph, node_id, SERVICE)
+    if _has_injectable_decorator(_decorators(attrs)):
+        return _set_role(graph, node_id, SERVICE)
+    return False
+
+
+def _classify_repo_class(
+    graph: nx.MultiDiGraph, node_id: str, attrs: dict[str, object]
+) -> bool:
+    if _kind_str(attrs.get("kind")) != NodeKind.CLASS.value:
+        return False
+    name = str(attrs.get("name") or "")
+    if name.endswith("Repository"):
+        return _set_role(graph, node_id, REPO)
+    return False
+
+
+def _classify_component(
+    graph: nx.MultiDiGraph, node_id: str, attrs: dict[str, object]
+) -> bool:
+    """COMPONENT detection (TS/JS only).
+
+    Rules:
+    * CLASS extending ``React.Component`` / ``Component`` / ``PureComponent``.
+    * FUNCTION whose file extension is ``.tsx``/``.jsx`` AND name is
+      PascalCase AND it accepts at least one parameter.
+    """
+    language = str(attrs.get("language") or "").lower()
+    if language not in _TS_LIKE_LANGS:
+        return False
+    kind = _kind_str(attrs.get("kind"))
+    file_path = str(attrs.get("file") or "")
+    if kind == NodeKind.CLASS.value:
+        if _class_inherits_react_component(graph, node_id):
+            return _set_role(graph, node_id, COMPONENT)
+        return False
+    if kind == NodeKind.FUNCTION.value:
+        if not _is_tsx_file(file_path):
+            return False
+        name = str(attrs.get("name") or "")
+        if not _is_pascal_case(name):
+            return False
+        if not _has_params(attrs):
+            return False
+        return _set_role(graph, node_id, COMPONENT)
+    return False
+
+
+def classify_roles(graph: nx.MultiDiGraph) -> int:
+    """Walk the graph and stamp metadata['role'] on FUNCTION/METHOD/CLASS.
+
+    Returns the number of nodes that received a non-None role assignment
+    (counts each node at most once, even if multiple rules matched).
+    """
+    annotated: set[str] = set()
+
+    # Pass 1: HANDLERs first (highest priority on functions/methods).
+    for nid, attrs in graph.nodes(data=True):
+        if _classify_handler(graph, nid, attrs):
+            annotated.add(nid)
+
+    # Pass 2: classes — REPO, SERVICE, COMPONENT (CLASS branch).
+    service_classes: list[str] = []
+    repo_classes: list[str] = []
+    for nid, attrs in graph.nodes(data=True):
+        kind = _kind_str(attrs.get("kind"))
+        if kind != NodeKind.CLASS.value:
+            continue
+        # COMPONENT class extending React.Component takes priority over
+        # SERVICE/REPO suffix coincidences.
+        if _classify_component(graph, nid, attrs):
+            annotated.add(nid)
+            continue
+        if _classify_service_class(graph, nid, attrs):
+            annotated.add(nid)
+            service_classes.append(nid)
+            continue
+        if _classify_repo_class(graph, nid, attrs):
+            annotated.add(nid)
+            repo_classes.append(nid)
+
+    # Pass 3: COMPONENT functions.
+    for nid, attrs in graph.nodes(data=True):
+        if _kind_str(attrs.get("kind")) != NodeKind.FUNCTION.value:
+            continue
+        if _classify_component(graph, nid, attrs):
+            annotated.add(nid)
+
+    # Pass 4: propagate SERVICE/REPO to class members. _set_role respects
+    # priority, so methods already tagged HANDLER stay HANDLER.
+    for cls_id in service_classes:
+        for member_id in _members_of_class(graph, cls_id):
+            if _set_role(graph, member_id, SERVICE):
+                annotated.add(member_id)
+    for cls_id in repo_classes:
+        for member_id in _members_of_class(graph, cls_id):
+            if _set_role(graph, member_id, REPO):
+                annotated.add(member_id)
+
+    return len(annotated)
+
+
+__all__ = ["COMPONENT", "HANDLER", "REPO", "SERVICE", "classify_roles"]

codegraph/analysis/untested.py

@@ -0,0 +1,79 @@
+"""Untested-symbol detection."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import networkx as nx
+
+from codegraph.analysis._common import (
+    _kind_str,
+    in_protocol_class,
+    in_test_module,
+    is_excluded_path,
+)
+from codegraph.graph.schema import EdgeKind, NodeKind
+
+_CANDIDATE_KINDS: frozenset[str] = frozenset(
+    {NodeKind.FUNCTION.value, NodeKind.METHOD.value}
+)
+
+
+@dataclass
+class UntestedNode:
+    id: str
+    name: str
+    qualname: str
+    kind: str
+    file: str
+    line_start: int
+    incoming_calls: int
+
+
+def find_untested(graph: nx.MultiDiGraph) -> list[UntestedNode]:
+    """Functions/methods with no incoming CALLS edge from a test module.
+
+    Skips functions that themselves live in a test module and skips dunder
+    helpers (``__init__``, etc.) since users rarely test them directly.
+    """
+    out: list[UntestedNode] = []
+    for nid, attrs in graph.nodes(data=True):
+        kind = _kind_str(attrs.get("kind"))
+        if kind not in _CANDIDATE_KINDS:
+            continue
+        name = str(attrs.get("name") or "")
+        if name.startswith("__") and name.endswith("__"):
+            continue
+        if in_test_module(graph, nid):
+            continue
+        # Skip test fixtures and static frontend assets — same exclusion as
+        # the dead-code analyzer.
+        if is_excluded_path(str(attrs.get("file") or "")):
+            continue
+        # Skip methods defined inside a ``typing.Protocol`` class: Protocol
+        # methods are structural type definitions, not runtime code, so
+        # "untested" is meaningless for them.
+        if kind == NodeKind.METHOD.value and in_protocol_class(graph, nid):
+            continue
+        incoming = 0
+        from_test = 0
+        for src, _dst, key in graph.in_edges(nid, keys=True):
+            if key != EdgeKind.CALLS.value:
+                continue
+            incoming += 1
+            if in_test_module(graph, src):
+                from_test += 1
+        if from_test > 0:
+            continue
+        out.append(
+            UntestedNode(
+                id=nid,
+                name=name,
+                qualname=str(attrs.get("qualname") or name),
+                kind=kind,
+                file=str(attrs.get("file") or ""),
+                line_start=int(attrs.get("line_start") or 0),
+                incoming_calls=incoming,
+            )
+        )
+    out.sort(key=lambda u: (-u.incoming_calls, u.file, u.line_start))
+    return out