devlensio 0.6.2 → 1.0.0

package/extractors/java/src/devlens/extractor/edges/Inheritance.java

@@ -0,0 +1,79 @@
+package devlens.extractor.edges;
+
+import devlens.extractor.Contract;
+import devlens.extractor.LookupMaps;
+import devlens.extractor.Parser;
+import devlens.extractor.ThirdParty;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * EXTENDS / IMPLEMENTS edge resolution (mirrors edges/inheritance.py).
+ *
+ * Java is the EASIEST of all languages here — explicit keywords, zero
+ * heuristics:
+ *   extends Baz   → EXTENDS   (always)
+ *   implements A, B → IMPLEMENTS (always; interfaces extending interfaces
+ *                     also use extends → EXTENDS)
+ *
+ * Targets resolve via symbol maps → same-package → closest-by-name. Local
+ * bases become class edges; gated third-party bases become [mvn] edges;
+ * unresolved bases are skipped — NEVER a dangling edge.
+ */
+public final class Inheritance {
+
+    private Inheritance() {}
+
+    public static void resolve(List<Parser.ParsedFile> files, LookupMaps lookup,
+                               ThirdParty tp, List<Map<String, Object>> edgesOut) {
+        for (Parser.ParsedFile pf : files) {
+            if (pf.isTest) {
+                continue;
+            }
+            String pkg = pf.packageName;
+            for (Parser.TypeInfo t : pf.allTypes()) {
+                String nodeId = pf.relPath + "::" + t.dottedName;
+                if (t.extendedType != null && !t.extendedType.isEmpty()) {
+                    String target = resolveBase(t.extendedType, pf, lookup, tp);
+                    if (target != null) {
+                        edgesOut.add(Contract.edge("EXTENDS", nodeId, target, null));
+                    }
+                }
+                for (String impl : t.implementedTypes) {
+                    String target = resolveBase(impl, pf, lookup, tp);
+                    if (target != null) {
+                        edgesOut.add(Contract.edge("IMPLEMENTS", nodeId, target, null));
+                    }
+                }
+            }
+        }
+    }
+
+    private static String resolveBase(String simpleName, Parser.ParsedFile pf,
+                                      LookupMaps lookup, ThirdParty tp) {
+        String alias = lookup.symbolMap(pf.relPath).get(simpleName);
+        if (alias != null) {
+            // [mvn] aliases only exist when gated in (Imports checked `permitted`)
+            return alias;
+        }
+        if (!pf.packageName.isEmpty()) {
+            String fqcn = pf.packageName + "." + simpleName;
+            String rel = lookup.typeMap.get(fqcn);
+            if (rel != null) {
+                return rel + "::" + lookup.typeDottedMap.get(fqcn);
+            }
+        }
+        String closest = lookup.closestByName(simpleName, pf.relPath);
+        if (closest != null) {
+            Map<String, Object> node = lookup.nodeById.get(closest);
+            if (node != null) {
+                String type = (String) node.get("type");
+                if ("CLASS".equals(type) || "INTERFACE".equals(type) || "ENUM".equals(type)) {
+                    return closest;
+                }
+            }
+        }
+        return null;   // external/unresolved — skip, never dangling
+    }
+}

package/extractors/java/src/devlens/extractor/edges/OrmEdges.java

@@ -0,0 +1,209 @@
+package devlens.extractor.edges;
+
+import devlens.extractor.Contract;
+import devlens.extractor.LookupMaps;
+import devlens.extractor.Parser;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * JPA data layer (mirrors edges/orm_edges.py — highest fidelity of all
+ * languages per the playbook).
+ *
+ * Models:    @Entity/@Table/@MappedSuperclass/@Embeddable → isModel
+ *            (type "jpa"); @Document → "mongodb". fields[] from the class.
+ * Repos:     interface extends JpaRepository<Entity, ID> etc → isRepository
+ *            + linkedModel = the entity generic arg (via rawCode regex).
+ * R/W edges: consumer → store, same direction as stateEdges.ts —
+ *   - repo's own derived methods (findByX, save, deleteByX) → R/W to entity
+ *   - calls INTO repo methods (from services/controllers) → R/W to entity
+ *   method-name grammar classifies: find|get|query|read|count|exists|select
+ *   = READ; save|insert|update|delete|remove|persist = WRITE.
+ */
+public final class OrmEdges {
+
+    private static final List<String> MODEL_ANNOTATIONS =
+            List.of("Entity", "Table", "MappedSuperclass", "Embeddable");
+    private static final List<String> REPO_TYPES = List.of(
+            "JpaRepository", "CrudRepository", "PagingAndSortingRepository",
+            "ListCrudRepository", "ListPagingAndSortingRepository",
+            "JpaSpecificationExecutor", "QuerydslPredicateExecutor",
+            "MongoRepository", "ReactiveCrudRepository", "R2dbcRepository",
+            "JdbcRepository", "ReactiveMongoRepository",
+            "Repository");   // Spring Data's base marker interface
+
+    private static final Pattern GENERIC_ARG =
+            Pattern.compile("extends\\s+[A-Za-z_][\\w.]*\\s*<\\s*([A-Za-z_][\\w.]*)");
+
+    private OrmEdges() {}
+
+    /**
+     * Detection pass — MUST run BEFORE Calls.resolve: model metadata
+     * (isModel/modelType/fields) + repository detection (isRepository,
+     * linkedModel) + derived-method R/W edges on repo interfaces.
+     */
+    public static void detect(LookupMaps lookup, List<Map<String, Object>> edgesOut) {
+        // ── 1. model metadata ─────────────────────────────────────────────
+        for (Map<String, Object> node : lookup.nodeById.values()) {
+            if (!"CLASS".equals(node.get("type"))) {
+                continue;
+            }
+            Map<String, Object> meta = (Map<String, Object>) node.get("metadata");
+            @SuppressWarnings("unchecked")
+            List<String> annotations = (List<String>) meta.get("annotations");
+            if (annotations == null) {
+                continue;
+            }
+            boolean isEntity = annotations.stream().anyMatch(MODEL_ANNOTATIONS::contains);
+            boolean isDocument = annotations.contains("Document");
+            if (isEntity || isDocument) {
+                meta.put("isModel", true);
+                meta.put("modelType", isDocument ? "mongodb" : "jpa");
+                // fields[] already on metadata from node build — expose explicitly
+                meta.putIfAbsent("fields", meta.get("fields") == null
+                        ? new ArrayList<Map<String, Object>>() : meta.get("fields"));
+            }
+        }
+
+        // ── 2. repository detection + derived-method R/W edges ────────────
+        for (Map<String, Object> node : lookup.nodeById.values()) {
+            String type = (String) node.get("type");
+            if (!"INTERFACE".equals(type)) {
+                continue;
+            }
+            Map<String, Object> meta = (Map<String, Object>) node.get("metadata");
+            String ext = (String) meta.get("extendsType");
+            if (ext == null || REPO_TYPES.stream().noneMatch(ext::equals)) {
+                continue;
+            }
+            meta.put("isRepository", true);
+            String entityId = entityGenericArg(node, lookup);
+            if (entityId != null) {
+                meta.put("linkedModel", entityId);
+                // derived query methods on the repo itself
+                for (Map<String, Object> m : lookup.nodeById.values()) {
+                    if (node.get("id").equals(parentClassId(m))) {
+                        String methodName = (String) m.get("name");
+                        String edgeType = readOrWrite(methodName);
+                        if (edgeType != null) {
+                            edgesOut.add(Contract.edge(edgeType, (String) node.get("id"), entityId,
+                                    Map.of("via", "repository-derived")));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Consumer pass — AFTER Calls.resolve: calls into repo methods become
+     * READS_FROM/WRITES_TO edges from the calling class to the entity.
+     */
+    public static void consumerEdges(LookupMaps lookup, List<Map<String, Object>> edgesOut) {
+        for (Map.Entry<String, List<Parser.CallInfo>> entry : lookup.methodCallFacts.entrySet()) {
+            Map<String, Object> methodNode = lookup.nodeById.get(entry.getKey());
+            if (methodNode == null) {
+                continue;
+            }
+            @SuppressWarnings("unchecked")
+            List<Map<String, String>> details =
+                    (List<Map<String, String>>) ((Map<String, Object>) methodNode.get("metadata"))
+                            .get("resolvedCallDetails");
+            if (details == null) {
+                continue;
+            }
+            String ownerClassId = ownerClassId(methodNode);
+            for (Map<String, String> d : details) {
+                String targetClass = d.get("class");
+                Map<String, Object> targetNode = lookup.nodeById.get(targetClass);
+                if (targetNode == null) {
+                    continue;
+                }
+                Map<String, Object> tmeta = (Map<String, Object>) targetNode.get("metadata");
+                if (!Boolean.TRUE.equals(tmeta.get("isRepository"))) {
+                    continue;
+                }
+                String entityId = (String) tmeta.get("linkedModel");
+                if (entityId == null) {
+                    continue;
+                }
+                String edgeType = readOrWrite(d.get("method"));
+                if (edgeType != null) {
+                    edgesOut.add(Contract.edge(edgeType, ownerClassId, entityId,
+                            Map.of("via", "repository-call")));
+                }
+            }
+        }
+    }
+
+    /** First generic arg of the extends clause: JpaRepository<User, Long> → User. */
+    private static String entityGenericArg(Map<String, Object> repoNode, LookupMaps lookup) {
+        String rawCode = (String) repoNode.get("rawCode");
+        if (rawCode == null) {
+            return null;
+        }
+        Matcher m = GENERIC_ARG.matcher(rawCode);
+        if (!m.find()) {
+            return null;
+        }
+        String entitySimple = Parser.simpleTypeName(m.group(1));
+        String relPath = (String) repoNode.get("filePath");
+        String pkg = packageOf(relPath);
+        return Calls.resolveTypeRef(entitySimple, lookup, relPath, pkg);
+    }
+
+    private static String readOrWrite(String methodName) {
+        if (methodName == null) {
+            return null;
+        }
+        // method node names are "Class.method" — classify on the method part
+        String n = methodName.contains(".")
+                ? methodName.substring(methodName.lastIndexOf('.') + 1) : methodName;
+        n = n.toLowerCase();
+        if (n.startsWith("find") || n.startsWith("get") || n.startsWith("query")
+                || n.startsWith("read") || n.startsWith("count") || n.startsWith("exists")
+                || n.startsWith("select") || n.startsWith("search")) {
+            return "READS_FROM";
+        }
+        if (n.startsWith("save") || n.startsWith("insert") || n.startsWith("update")
+                || n.startsWith("delete") || n.startsWith("remove") || n.startsWith("persist")
+                || n.startsWith("merge") || n.startsWith("flush")) {
+            return "WRITES_TO";
+        }
+        return null;
+    }
+
+    private static String parentClassId(Map<String, Object> methodNode) {
+        if (!"METHOD".equals(methodNode.get("type"))) {
+            return null;
+        }
+        String id = (String) methodNode.get("id");
+        int lastDot = id.lastIndexOf('.');
+        int colon = id.lastIndexOf("::");
+        return lastDot > colon ? id.substring(0, lastDot) : id;
+    }
+
+    private static String ownerClassId(Map<String, Object> methodNode) {
+        String id = parentClassId(methodNode);
+        return id == null ? (String) methodNode.get("id") : id;
+    }
+
+    private static String packageOf(String relPath) {
+        String p = relPath;
+        for (String root : new String[]{"src/main/java/", "src/test/java/"}) {
+            if (p.startsWith(root)) {
+                p = p.substring(root.length());
+                break;
+            }
+        }
+        if (p.endsWith(".java")) {
+            p = p.substring(0, p.length() - 5);
+        }
+        return p.replace('/', '.');
+    }
+}

package/extractors/java/src/devlens/extractor/edges/Routes.java

@@ -0,0 +1,143 @@
+package devlens.extractor.edges;
+
+import devlens.extractor.Contract;
+import devlens.extractor.LookupMaps;
+import devlens.extractor.Parser;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Spring MVC route detection (mirrors edges/routes/*.py).
+ *
+ * Annotation-driven — no type resolution needed:
+ *   class-level  @RestController / @Controller (+ @RequestMapping base path)
+ *   method-level @GetMapping/@PostMapping/@PutMapping/@DeleteMapping/
+ *                @PatchMapping/@RequestMapping(method = RequestMethod.X)
+ * Class prefix + method path compose; {id} path params → isDynamic + params.
+ *
+ * V1 scope: Spring MVC only. JAX-RS (@Path), @FeignClient, WebFlux
+ * functional routes are V2 (documented in java_graph_detection.html).
+ */
+public final class Routes {
+
+    private static final Pattern PATH_PARAM = Pattern.compile("\\{([^}]+)\\}");
+
+    private static final List<String> MAPPING_ANNOTATIONS = List.of(
+            "RequestMapping", "GetMapping", "PostMapping", "PutMapping",
+            "DeleteMapping", "PatchMapping");
+
+    private Routes() {}
+
+    public static final class RouteResult {
+        public final List<Map<String, Object>> routes = new ArrayList<>();
+        public final List<Map<String, Object>> routeNodes = new ArrayList<>();
+        public final List<Map<String, Object>> handlesEdges = new ArrayList<>();
+        final Set<String> seen = new HashSet<>();
+    }
+
+    public static RouteResult resolve(List<Parser.ParsedFile> files, LookupMaps lookup,
+                                      String framework) {
+        RouteResult result = new RouteResult();
+        String fw = framework == null || framework.equals("unknown") ? "spring" : framework;
+        for (Parser.ParsedFile pf : files) {
+            if (pf.isTest) {
+                continue;
+            }
+            for (Parser.TypeInfo t : pf.allTypes()) {
+                if (!isController(t)) {
+                    continue;
+                }
+                String base = pathValue(t.annotationValues.get("RequestMapping"));
+                for (Parser.MethodInfo m : t.methods) {
+                    for (String ann : MAPPING_ANNOTATIONS) {
+                        if (!m.annotations.contains(ann)) {
+                            continue;
+                        }
+                        String methodPath = pathValue(m.annotationValues.get(ann));
+                        String verb = verbFor(ann, m.annotationValues.get(ann + ".method"));
+                        String urlPath = join(base, methodPath);
+                        emit(pf, t, m, verb, urlPath, fw, result);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    private static boolean isController(Parser.TypeInfo t) {
+        return t.annotations.contains("RestController") || t.annotations.contains("Controller");
+    }
+
+    private static String verbFor(String ann, String methodAttr) {
+        if (!ann.equals("RequestMapping")) {
+            return ann.replace("Mapping", "").toUpperCase();
+        }
+        return methodAttr == null ? "ANY" : methodAttr.toUpperCase();
+    }
+
+    private static String pathValue(String raw) {
+        return raw == null ? "" : raw.trim();
+    }
+
+    private static String join(String base, String methodPath) {
+        String b = base == null ? "" : base;
+        String m = methodPath == null ? "" : methodPath;
+        if (b.isEmpty()) {
+            return m.isEmpty() ? "/" : normalize(m);
+        }
+        if (m.isEmpty()) {
+            return normalize(b);
+        }
+        if (m.startsWith("/")) {
+            m = m.substring(1);
+        }
+        return normalize(b + "/" + m);
+    }
+
+    private static String normalize(String p) {
+        String out = p;
+        if (!out.startsWith("/")) {
+            out = "/" + out;
+        }
+        while (out.endsWith("/") && out.length() > 1) {
+            out = out.substring(0, out.length() - 1);
+        }
+        return out;
+    }
+
+    private static void emit(Parser.ParsedFile pf, Parser.TypeInfo t, Parser.MethodInfo m,
+                             String verb, String urlPath, String fw, RouteResult result) {
+        String key = pf.relPath + "|" + verb + "|" + urlPath;
+        if (!result.seen.add(key)) {
+            return;
+        }
+        Matcher matcher = PATH_PARAM.matcher(urlPath);
+        boolean dynamic = matcher.find();
+        List<String> params = new ArrayList<>();
+        matcher.reset();
+        while (matcher.find()) {
+            params.add(matcher.group(1));
+        }
+
+        String handlerId = pf.relPath + "::" + t.dottedName + "." + m.name;
+        Map<String, Object> routeNode = Contract.routeNode(pf.relPath, verb, urlPath,
+                dynamic, params, fw, m.name);
+        Map<String, Object> backendRoute = Contract.backendRoute(urlPath, pf.relPath,
+                verb, fw, dynamic, params, m.name, (String) routeNode.get("id"));
+
+        result.routeNodes.add(routeNode);
+        result.routes.add(backendRoute);
+        Map<String, Object> handlesMeta = new LinkedHashMap<>();
+        handlesMeta.put("urlPath", urlPath);
+        handlesMeta.put("httpMethod", verb);
+        handlesMeta.put("routeKind", "backend");
+        result.handlesEdges.add(Contract.edge("HANDLES", (String) routeNode.get("id"), handlerId, handlesMeta));
+    }
+}

package/extractors/java/src/devlens/extractor/edges/Tests.java

@@ -0,0 +1,53 @@
+package devlens.extractor.edges;
+
+import devlens.extractor.Contract;
+import devlens.extractor.LookupMaps;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * TESTS edge resolution (mirrors edges/tests.py + JS testEdges).
+ *
+ * Test files are LEAF nodes — the parser still extracted their test methods
+ * (names land in metadata.testCases), but no test children enter the graph.
+ * TESTS edges point from the TEST file node → the production CLASS nodes it
+ * imports (symbol maps are the bridge — test files import production types).
+ */
+public final class Tests {
+
+    private Tests() {}
+
+    public static void resolve(LookupMaps lookup, List<Map<String, Object>> edgesOut) {
+        for (Map.Entry<String, Map<String, Object>> entry : lookup.fileNodesByPath.entrySet()) {
+            Map<String, Object> fileNode = entry.getValue();
+            if (!"TEST".equals(fileNode.get("type"))) {
+                continue;
+            }
+            String relPath = entry.getKey();
+            // metadata.testCases = @Test methods extracted at parse time
+            List<String> cases = lookup.testCases.get(relPath);
+            if (cases != null && !cases.isEmpty()) {
+                ((Map<String, Object>) fileNode.get("metadata")).put("testCases", cases);
+            }
+            // production symbols this test file imports
+            Map<String, String> sm = lookup.symbolMap(relPath);
+            List<String> targets = new ArrayList<>(sm.values());
+            java.util.Collections.sort(targets);
+            for (String target : targets) {
+                if (target.startsWith("[mvn]")) {
+                    continue;   // don't test third-party libs
+                }
+                Map<String, Object> node = lookup.nodeById.get(target);
+                if (node == null) {
+                    continue;
+                }
+                String type = (String) node.get("type");
+                if ("CLASS".equals(type) || "INTERFACE".equals(type) || "ENUM".equals(type)) {
+                    edgesOut.add(Contract.edge("TESTS", "file::" + relPath, target, null));
+                }
+            }
+        }
+    }
+}

package/extractors/python/devlens_extractors_python/__init__.py

@@ -0,0 +1,3 @@
+"""DevLens Python extractor package."""
+
+__version__ = "0.1.0"

package/extractors/python/devlens_extractors_python/__main__.py

@@ -0,0 +1,33 @@
+"""Entry point — invoked as: python3 -m devlens_extractors_python
+
+Reads the ExtractorInput JSON from stdin, runs extraction, writes the
+ExtractorResult JSON to stdout. stdout must stay PURE JSON (the Node.js
+orchestrator JSON.parses it verbatim) — all logging goes to stderr.
+"""
+from __future__ import annotations
+
+import json
+import sys
+
+from .extractor import extract
+
+def main() -> None:
+    raw = sys.stdin.read()
+
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        print(f"devlens extractor: invalid JSON on stdin: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    repo_path = payload.get("repoPath")
+    if not repo_path:
+        print("devlens extractor: missing 'repoPath' in input", file=sys.stderr)
+        sys.exit(1)
+
+    options = payload.get("options") or {}
+    result = extract(repo_path, options)
+    sys.stdout.write(json.dumps(result) + "\n")
+
+if __name__ == "__main__":
+    main()

package/extractors/python/devlens_extractors_python/contract.py

@@ -0,0 +1,94 @@
+"""
+contract Types - the JSON shape Devlens Engine expects.
+
+Every key here is camel  case to match the typescript interface in the devlens-engine. This file is the single
+source of truth for the output shape; other modules never spell keys by hand.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import hashlib
+from typing import Any
+
+def code_hash(raw_code: str) -> str:
+    """Return a SHA256 hash of the raw code string."""
+    return hashlib.sha256(raw_code.encode("utf-8")).hexdigest()[:16]  # first 16 chars of the hash
+
+@dataclass
+class Fingerprint:
+    language: str = "python"
+    projectType: str = "unknown"          # "backend" once a framework is detected
+    framework: str = "unknown"            # "fastapi" | "flask" | "django" | "unknown"
+    router: str = "none"
+    stateManagement: list = field(default_factory=list)  # always [] for Python
+    dataFetching: list = field(default_factory=list)     # always [] for Python
+    databases: list = field(default_factory=list)
+    rawDependencies: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "language": self.language,
+            "projectType": self.projectType,
+            "framework": self.framework,
+            "router": self.router,
+            "stateManagement": self.stateManagement,
+            "dataFetching": self.dataFetching,
+            "databases": self.databases,
+            "rawDependencies": self.rawDependencies,
+        }
+
+@dataclass
+class Stats:
+    totalFiles: int = 0
+    totalNodes: int = 0
+    skippedFiles: int = 0
+
+    def to_dict(self) -> dict:
+        return {
+            "totalFiles": self.totalFiles,
+            "totalNodes": self.totalNodes,
+            "skippedFiles": self.skippedFiles,
+        }
+
+@dataclass
+class ExtractorError:
+    file: str
+    error: str
+
+    def to_dict(self) -> dict:
+        return {"file": self.file, "error": self.error}
+
+def file_node(rel_path: str, end_line: int, node_type: str = "FILE",
+              language: str = "python") -> dict:
+    """FILE node — id format: file::rel/path.py (matches src/parser/index.ts)."""
+    return {
+        "id": f"file::{rel_path}",
+        "name": rel_path.split("/")[-1],
+        "type": node_type,                      # FILE | TEST
+        "filePath": rel_path,
+        "startLine": 1,
+        "endLine": end_line,
+        "parentFile": f"file::{rel_path}",      # file nodes parent themselves
+        "metadata": {
+            "nodeCount": 0,
+            "childNodeIds": [],
+            "language": language,
+        },
+    }
+
+def code_node(rel_path: str, name: str, node_type: str, start_line: int, end_line: int,
+              raw_code: str, metadata: dict, language: str = "python") -> dict:
+    """Function/Class/Method node. ID format: rel/path.py::name."""
+    return {
+        "id": f"{rel_path}::{name}",
+        "name": name,
+        "type": node_type,
+        "filePath": rel_path,
+        "startLine": start_line,
+        "endLine": end_line,
+        "rawCode": raw_code,
+        "codeHash": code_hash(raw_code),
+        "parentFile": f"file::{rel_path}",
+        "metadata": {"language": language, **metadata},
+    }

package/extractors/python/devlens_extractors_python/edges/__init__.py

@@ -0,0 +1,28 @@
+"""Edge detectors — import resolution, call resolution, routes, ORM data layer.
+
+Public API (all consume the shared LookupMaps built once by extractor.py):
+    resolve_file_imports(parsed, lookup, registry) -> (edges, imported_paths)
+    resolve_calls(lookup, registry)                 -> edges
+    detect_routes(parsed_files, lookup, fingerprint)-> RouteResult
+    detect_models(lookup)                           -> {model name → node id}
+    resolve_orm_edges(lookup, models)               -> edges
+"""
+from .calls import resolve_calls
+from .enrich import enrich_metadata
+from .imports import resolve_file_imports
+from .inheritance import resolve_inheritance
+from .orm_edges import detect_models, resolve_orm_edges
+from .routes import RouteResult, detect_routes
+from .tests import resolve_test_edges
+
+__all__ = [
+    "resolve_file_imports",
+    "resolve_calls",
+    "detect_routes",
+    "RouteResult",
+    "detect_models",
+    "resolve_orm_edges",
+    "enrich_metadata",
+    "resolve_inheritance",
+    "resolve_test_edges",
+]