devlensio 0.6.1 → 1.0.0

package/dist/graph/edges/callEdges.js

@@ -8,10 +8,11 @@ export function detectCallEdges(nodes, lookupMp) {
     // Lazily-created method nodes for default/namespace import member-access calls
     const createdMethodNodes = new Map();
     for (const node of nodes) {
-        // Only functions, hooks, and components make direct calls
+        // Only functions, hooks, components, and class methods make direct calls
         if (node.type !== "FUNCTION" &&
             node.type !== "HOOK" &&
-            node.type !== "COMPONENT")
+            node.type !== "COMPONENT" &&
+            node.type !== "METHOD")
             continue;
         const calls = node.metadata.calls;
         const uses = node.metadata.uses;
@@ -103,7 +104,20 @@ export function detectCallEdges(nodes, lookupMp) {
             //     continue;
             // }
             // ── Local node lookup ─────────────────────────────────────────
-            const targets = lookupMp.nodesByName.get(calledName);
+            // Direct name match first; if it misses, try substituting the
+            // root through the local-import alias map (`US.get()` where
+            // `import { UserService as US }` → resolve `UserService.get`).
+            let targets = lookupMp.nodesByName.get(calledName);
+            let resolvedName = calledName;
+            if ((!targets || targets.length === 0) && calledName.includes(".")) {
+                const rootName = calledName.split(".")[0];
+                const fileAliases = lookupMp.localImportSymbols.get(node.filePath);
+                const importedName = fileAliases?.get(rootName);
+                if (importedName) {
+                    resolvedName = importedName + calledName.slice(rootName.length);
+                    targets = lookupMp.nodesByName.get(resolvedName);
+                }
+            }
             if (!targets || targets.length === 0)
                 continue;
             const target = targets.length === 1
@@ -115,13 +129,13 @@ export function detectCallEdges(nodes, lookupMp) {
                 from: node.id,
                 to: target.id,
                 type: edgeType,
-                metadata: { calledName },
+                metadata: { calledName: resolvedName },
             });
             if (!resolvedCallsMap.has(node.id))
                 resolvedCallsMap.set(node.id, []);
             const existing = resolvedCallsMap.get(node.id);
             if (!existing.some(r => r.nodeId === target.id)) {
-                existing.push({ name: calledName, nodeId: target.id });
+                existing.push({ name: resolvedName, nodeId: target.id });
             }
         }
         // ── Hook / dependency names: third-party edges only ──────────────

package/dist/graph/edges/callEdges.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/graph/edges/callEdges.test.js

@@ -0,0 +1,200 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { parseRepo } from "../../parser/index.js";
+import { buildLookupMaps } from "../buildLookup.js";
+import { detectImportEdges } from "./importEdges.js";
+import { detectCallEdges } from "./callEdges.js";
+import { buildThirdPartyNodes } from "../thirdPartyLibs.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function createFakeRepo(files) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devlens-calls-test-"));
+    for (const [filePath, content] of Object.entries(files)) {
+        const fullPath = path.join(tmpDir, filePath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, content);
+    }
+    return tmpDir;
+}
+function deleteFakeRepo(repoPath) {
+    fs.rmSync(repoPath, { recursive: true, force: true });
+}
+// Mirrors the real pipeline: parse → lookup maps → import edges (populates
+// thirdPartyImportAliases + localImportSymbols) → call edges.
+// Returns edges AND the mutated node list (detectCallEdges writes
+// metadata.resolvedCalls back onto nodes in place).
+function detectCalls(repoPath, extraNodes = []) {
+    const { nodes } = parseRepo(repoPath);
+    const all = [...nodes, ...extraNodes];
+    const lookup = buildLookupMaps(all);
+    detectImportEdges(lookup, repoPath);
+    const result = detectCallEdges(all, lookup);
+    return { ...result, all };
+}
+// ─── Tests ───────────────────────────────────────────────────────────────────
+describe("detectCallEdges with class methods", () => {
+    // 21. this.save() inside a class → CALLS edge to Class.save
+    it("resolves this.method() calls to the class METHOD node", () => {
+        const repo = createFakeRepo({
+            "src/svc.ts": `
+        export class UserService {
+          save() { return 1; }
+          persist() { return this.save(); }
+        }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        expect(edges).toContainEqual(expect.objectContaining({
+            from: "src/svc.ts::UserService.persist",
+            to: "src/svc.ts::UserService.save",
+            type: "CALLS",
+        }));
+        deleteFakeRepo(repo);
+    });
+    // 22. Class.staticMethod() from a plain function
+    it("resolves static calls made from outside the class", () => {
+        const repo = createFakeRepo({
+            "src/stat.ts": `
+        export class MathUtils {
+          static add(a: number, b: number) { return a + b; }
+        }
+        export function compute() { return MathUtils.add(1, 2); }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        expect(edges).toContainEqual(expect.objectContaining({
+            from: "src/stat.ts::compute",
+            to: "src/stat.ts::MathUtils.add",
+            type: "CALLS",
+        }));
+        deleteFakeRepo(repo);
+    });
+    // 23. Local-variable instance calls are unresolvable (engine-wide limitation)
+    it("does not resolve instance calls through local variables", () => {
+        const repo = createFakeRepo({
+            "src/local.ts": `
+        export class UserService {
+          get() { return 1; }
+        }
+        export function fetchUser() {
+          const svc = new UserService();
+          return svc.get();
+        }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        expect(edges.some((e) => e.type === "CALLS" && e.to === "src/local.ts::UserService.get")).toBe(false);
+        // Metadata preserved for LLM context
+        const caller = parseRepo(repo).nodes.find((n) => n.name === "fetchUser");
+        expect(caller?.metadata.calls).toContain("svc.get");
+        deleteFakeRepo(repo);
+    });
+    // 24. Cross-file static call via named import
+    it("resolves cross-file class method calls via dotted names", () => {
+        const repo = createFakeRepo({
+            "src/services.ts": `
+        export class UserService {
+          static get(id: string) { return id; }
+        }
+      `,
+            "src/use.ts": `
+        import { UserService } from "./services";
+        export function load(id: string) { return UserService.get(id); }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        expect(edges).toContainEqual(expect.objectContaining({
+            from: "src/use.ts::load",
+            to: "src/services.ts::UserService.get",
+            type: "CALLS",
+        }));
+        deleteFakeRepo(repo);
+    });
+    // 25. Aliased named import → localImportSymbols substitution
+    it("resolves aliased imports via the local symbol map", () => {
+        const repo = createFakeRepo({
+            "src/services.ts": `
+        export class UserService {
+          static get(id: string) { return id; }
+        }
+      `,
+            "src/use.ts": `
+        import { UserService as US } from "./services";
+        export function load(id: string) { return US.get(id); }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        expect(edges).toContainEqual(expect.objectContaining({
+            from: "src/use.ts::load",
+            to: "src/services.ts::UserService.get",
+            type: "CALLS",
+        }));
+        deleteFakeRepo(repo);
+    });
+    // 26. Same method name in two files → closestByPath picks the nearest
+    it("uses closestByPath for same-name method collisions", () => {
+        const repo = createFakeRepo({
+            "a/repo.ts": `export class Repo { get() { return "a"; } }`,
+            "b/repo.ts": `export class Repo { get() { return "b"; } }`,
+            "b/use.ts": `
+        import { Repo } from "./repo";
+        export function read() { return Repo.get(); }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        const edge = edges.find((e) => e.type === "CALLS" && e.from === "b/use.ts::read");
+        expect(edge?.to).toBe("b/repo.ts::Repo.get");
+        deleteFakeRepo(repo);
+    });
+    // 27. Method → plain function in the same file
+    it("resolves calls from a method to a plain function", () => {
+        const repo = createFakeRepo({
+            "src/mix.ts": `
+        function normalize(x: number) { return x; }
+        export class Pipeline {
+          run(x: number) { return normalize(x); }
+        }
+      `,
+        });
+        const { edges } = detectCalls(repo);
+        expect(edges).toContainEqual(expect.objectContaining({
+            from: "src/mix.ts::Pipeline.run",
+            to: "src/mix.ts::normalize",
+            type: "CALLS",
+        }));
+        deleteFakeRepo(repo);
+    });
+    // 28. Third-party call inside a method (axios.get → [npm]/axios::get)
+    it("creates third-party edges for member calls inside methods", () => {
+        const repo = createFakeRepo({
+            "src/api.ts": `
+        import axios from "axios";
+        export class ApiClient {
+          fetchUsers() { return axios.get("/users"); }
+        }
+      `,
+        });
+        const thirdParty = buildThirdPartyNodes(repo, ["axios"]);
+        const { edges } = detectCalls(repo, thirdParty);
+        const edge = edges.find((e) => e.type === "CALLS" && e.from === "src/api.ts::ApiClient.fetchUsers");
+        expect(edge).toBeDefined();
+        expect(edge?.to).toBe("[npm]/axios::get");
+        expect(edge?.metadata?.isThirdParty).toBe(true);
+        deleteFakeRepo(repo);
+    });
+    // resolvedCalls writeback on METHOD nodes
+    it("writes resolvedCalls back onto METHOD nodes", () => {
+        const repo = createFakeRepo({
+            "src/wb.ts": `
+        export class Counter {
+          inc() { return 1; }
+          bump() { return this.inc(); }
+        }
+      `,
+        });
+        const { all } = detectCalls(repo);
+        const bump = all.find((n) => n.name === "Counter.bump");
+        expect(bump?.metadata.resolvedCalls).toEqual(expect.arrayContaining([expect.objectContaining({ name: "Counter.inc", nodeId: "src/wb.ts::Counter.inc" })]));
+        deleteFakeRepo(repo);
+    });
+});

package/dist/graph/edges/importEdges.js

@@ -165,6 +165,18 @@ export function detectImportEdges(lookupMp, repoPath) {
                 }
                 continue; // always skip local-resolution path for non-local imports
             }
+            // ─── Local named-import symbol map ────────────────────────────
+            // Records localAlias → importedName so callEdges can resolve
+            // `US.get()` when `import { UserService as US } from "./services"`
+            // (the dotted METHOD node is named `UserService.get`).
+            const localAliases = lookupMp.localImportSymbols.get(sourceRelative) ?? new Map();
+            for (const specifier of importDecl.getNamedImports()) {
+                const localAlias = specifier.getAliasNode()?.getText() ?? specifier.getName();
+                localAliases.set(localAlias, specifier.getName());
+            }
+            if (localAliases.size > 0) {
+                lookupMp.localImportSymbols.set(sourceRelative, localAliases);
+            }
             // ─── Resolve the imported file path ───────────────────────────
             let resolvedPath;
             // First try ts-morph automatic resolution

package/dist/graph/edges/inheritanceEdges.d.ts

@@ -0,0 +1,3 @@
+import type { CodeEdge, CodeNode } from "../../types.js";
+import type { LookupMaps } from "../buildLookup.js";
+export declare function detectInheritanceEdges(nodes: CodeNode[], lookupMp: LookupMaps): CodeEdge[];

package/dist/graph/edges/inheritanceEdges.js

@@ -0,0 +1,73 @@
+// inheritanceEdges.ts — EXTENDS / IMPLEMENTS edge detector for the inline
+// JS/TS path.
+//
+// The classes extractor records `metadata.extendsType` (raw text, generics
+// included) and `metadata.implementsTypes` (string[]) on CLASS nodes. This
+// detector resolves those names against the lookup maps — mirroring how
+// callEdges reads `metadata.calls` — and emits:
+//
+//   class X extends Y      → EXTENDS    (Y must resolve to a local CLASS node)
+//   class X implements Y   → IMPLEMENTS (Y must resolve to a local CLASS node;
+//                                        interface targets are ignored — JS/TS
+//                                        deliberately has no INTERFACE nodes)
+//
+// Rules:
+//   - Extends generics are stripped (`React.Component<Props>` → `React.Component`),
+//     so third-party bases (no local node) are skipped, never dangling.
+//   - Dotted bases (`ns.Base`) don't match plain node names → skipped.
+//   - Name collisions resolve via closestByPath (same as callEdges).
+//   - Edges are deduped by from→to:type.
+import { closestByPath } from "./utils.js";
+import { stripGenerics } from "../../parser/extractors/classes.js";
+export function detectInheritanceEdges(nodes, lookupMp) {
+    const edges = [];
+    const created = new Set();
+    const resolveTarget = (typeName, fromFile) => {
+        const targets = lookupMp.nodesByName.get(typeName);
+        if (!targets || targets.length === 0)
+            return undefined;
+        return targets.length === 1 ? targets[0] : closestByPath(targets, fromFile);
+    };
+    for (const node of nodes) {
+        if (node.type !== "CLASS")
+            continue;
+        // ── EXTENDS ─────────────────────────────────────────────────────────
+        const extendsType = node.metadata.extendsType;
+        if (extendsType) {
+            const base = stripGenerics(extendsType);
+            const target = resolveTarget(base, node.filePath);
+            if (target && target.type === "CLASS" && target.id !== node.id) {
+                const key = `${node.id}→${target.id}:EXTENDS`;
+                if (!created.has(key)) {
+                    created.add(key);
+                    edges.push({
+                        from: node.id,
+                        to: target.id,
+                        type: "EXTENDS",
+                        metadata: { extendsType },
+                    });
+                }
+            }
+        }
+        // ── IMPLEMENTS (local CLASS targets only) ───────────────────────────
+        const implementsTypes = node.metadata.implementsTypes;
+        if (implementsTypes && implementsTypes.length > 0) {
+            for (const impl of implementsTypes) {
+                const target = resolveTarget(impl, node.filePath);
+                if (!target || target.type !== "CLASS" || target.id === node.id)
+                    continue;
+                const key = `${node.id}→${target.id}:IMPLEMENTS`;
+                if (!created.has(key)) {
+                    created.add(key);
+                    edges.push({
+                        from: node.id,
+                        to: target.id,
+                        type: "IMPLEMENTS",
+                        metadata: { implementsType: impl },
+                    });
+                }
+            }
+        }
+    }
+    return edges;
+}

package/dist/graph/edges/inheritanceEdges.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/graph/edges/inheritanceEdges.test.js

@@ -0,0 +1,140 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { parseRepo } from "../../parser/index.js";
+import { buildLookupMaps } from "../buildLookup.js";
+import { detectInheritanceEdges } from "./inheritanceEdges.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function createFakeRepo(files) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devlens-inh-test-"));
+    for (const [filePath, content] of Object.entries(files)) {
+        const fullPath = path.join(tmpDir, filePath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, content);
+    }
+    return tmpDir;
+}
+function deleteFakeRepo(repoPath) {
+    fs.rmSync(repoPath, { recursive: true, force: true });
+}
+function detect(repoPath) {
+    const { nodes } = parseRepo(repoPath);
+    return detectInheritanceEdges(nodes, buildLookupMaps(nodes));
+}
+// ─── Tests ───────────────────────────────────────────────────────────────────
+describe("detectInheritanceEdges", () => {
+    // 29. Same-file class → class EXTENDS
+    it("emits EXTENDS for a same-file class-to-class inheritance", () => {
+        const repo = createFakeRepo({
+            "src/inh.ts": `
+        export class Base {}
+        export class Child extends Base {}
+      `,
+        });
+        const edges = detect(repo);
+        expect(edges).toContainEqual(expect.objectContaining({ from: "src/inh.ts::Child", to: "src/inh.ts::Base", type: "EXTENDS" }));
+        expect(edges.filter((e) => e.type === "EXTENDS")).toHaveLength(1);
+        deleteFakeRepo(repo);
+    });
+    // 30. Cross-file EXTENDS
+    it("emits EXTENDS across files via name lookup", () => {
+        const repo = createFakeRepo({
+            "src/base.ts": `export class Base {}`,
+            "src/child.ts": `
+        import { Base } from "./base";
+        export class Child extends Base {}
+      `,
+        });
+        const edges = detect(repo);
+        expect(edges).toContainEqual(expect.objectContaining({ from: "src/child.ts::Child", to: "src/base.ts::Base", type: "EXTENDS" }));
+        deleteFakeRepo(repo);
+    });
+    // 31. Third-party extends → no edge (never dangling)
+    it("does not emit EXTENDS for third-party bases", () => {
+        const repo = createFakeRepo({
+            "src/react.tsx": `
+        import React from "react";
+        export class Dashboard extends React.Component<{ title: string }, {}> {
+          render() { return <div />; }
+        }
+      `,
+        });
+        const edges = detect(repo);
+        expect(edges.filter((e) => e.type === "EXTENDS")).toHaveLength(0);
+        deleteFakeRepo(repo);
+    });
+    // 32. Generic local base → generics stripped, EXTENDS emitted
+    it("strips generics from extends before resolving", () => {
+        const repo = createFakeRepo({
+            "src/gen.ts": `
+        export class Base<T> {}
+        export class Child extends Base<string> {}
+      `,
+        });
+        const edges = detect(repo);
+        expect(edges).toContainEqual(expect.objectContaining({ from: "src/gen.ts::Child", to: "src/gen.ts::Base", type: "EXTENDS" }));
+        expect(edges[0].metadata).toEqual({ extendsType: "Base<string>" }); // raw preserved
+        deleteFakeRepo(repo);
+    });
+    // 33+34. implements → only when target is a local CLASS
+    it("emits IMPLEMENTS only for local class targets, ignores interfaces", () => {
+        const repo = createFakeRepo({
+            "src/impl.ts": `
+        interface Contract { run(): void; }
+        export class BaseClass { run() {} }
+        export class Worker implements Contract, BaseClass {}
+      `,
+        });
+        const edges = detect(repo);
+        const implementsEdges = edges.filter((e) => e.type === "IMPLEMENTS");
+        expect(implementsEdges).toHaveLength(1); // only BaseClass — Contract has no node
+        expect(implementsEdges[0]).toEqual(expect.objectContaining({ from: "src/impl.ts::Worker", to: "src/impl.ts::BaseClass" }));
+        deleteFakeRepo(repo);
+    });
+    it("emits no IMPLEMENTS edge when every target is an interface", () => {
+        const repo = createFakeRepo({
+            "src/iface.ts": `
+        interface A { a(): void; }
+        interface B { b(): void; }
+        export class OnlyIfaces implements A, B {}
+      `,
+        });
+        const edges = detect(repo);
+        expect(edges.filter((e) => e.type === "IMPLEMENTS")).toHaveLength(0);
+        deleteFakeRepo(repo);
+    });
+    // 35. Dedup
+    it("dedupes repeated implements of the same class", () => {
+        const repo = createFakeRepo({
+            "src/dup.ts": `
+        export class Base {}
+        export class Dup implements Base, Base {}
+      `,
+        });
+        const edges = detect(repo);
+        const implementsEdges = edges.filter((e) => e.type === "IMPLEMENTS");
+        expect(implementsEdges).toHaveLength(1);
+        deleteFakeRepo(repo);
+    });
+    // Dotted / unresolvable names → skipped
+    it("skips dotted and unresolvable base names", () => {
+        const repo = createFakeRepo({
+            "src/dotted.ts": `
+        export class Local {}
+        export class A extends SomeMissing {}
+        export class B extends ns.Local {}
+      `,
+        });
+        const edges = detect(repo);
+        expect(edges.filter((e) => e.type === "EXTENDS")).toHaveLength(0);
+        deleteFakeRepo(repo);
+    });
+    // Classes without heritage produce nothing
+    it("emits nothing for standalone classes", () => {
+        const repo = createFakeRepo({
+            "src/plain.ts": `export class Standalone { run() {} }`,
+        });
+        expect(detect(repo)).toHaveLength(0);
+        deleteFakeRepo(repo);
+    });
+});

package/dist/graph/index.js

@@ -10,6 +10,7 @@ import { detectPropEdges } from "./edges/propEdges.js";
 import { detectRouteEdges } from "./edges/routeEdge.js";
 import { detectStateEdges } from "./edges/stateEdges.js";
 import { detectTestEdges } from "./edges/testEdges.js";
+import { detectInheritanceEdges } from "./edges/inheritanceEdges.js";
 export function detectEdges(nodes, routeNodes, repoPath, fingerprint) {
     console.log(`Building lookup maps for edge detection for ${nodes.length} nodes...`);
     //building lookup maps
@@ -29,6 +30,7 @@ export function detectEdges(nodes, routeNodes, repoPath, fingerprint) {
     // GUARDS — middleware to route protection
     const guardEdges = detectGuardEdges(nodes, lookupMp, routeNodes, repoPath, fingerprint);
     const testEdges = detectTestEdges(lookupMp, repoPath); // This does not needs nodes, as it detect edges from the file
+    const inheritanceEdges = detectInheritanceEdges(nodes, lookupMp);
     const nextjsApiCallEdges = detectNextjsApiCallEdges(nodes, repoPath);
     const navResult = detectNavigationEdges(nodes, repoPath);
     // Collect all dynamically-created third-party method nodes (dedup by id)
@@ -48,6 +50,7 @@ export function detectEdges(nodes, routeNodes, repoPath, fingerprint) {
     console.log(`  ROUTE edges:   ${routeEdges.length}`);
     console.log(`  GUARD edges: ${guardEdges.length}`);
     console.log(`  TEST edges: ${testEdges.length}`);
+    console.log(`  INHERITANCE edges (EXTENDS/IMPLEMENTS): ${inheritanceEdges.length}`);
     console.log(`  Ghost nodes created: ${eventResults.ghostNodes.length}`);
     console.log(`  Third-party method nodes: ${newThirdPartyNodes.length}`);
     console.log(` NEXTJS_API_CALL edges: ${nextjsApiCallEdges.length}`);
@@ -63,6 +66,7 @@ export function detectEdges(nodes, routeNodes, repoPath, fingerprint) {
         ...routeEdges,
         ...guardEdges,
         ...testEdges,
+        ...inheritanceEdges,
         ...nextjsApiCallEdges,
         ...navResult.edges,
     ];

package/dist/parser/classes.test.d.ts

@@ -0,0 +1 @@
+export {};