devlensio 1.0.3 → 1.1.0

package/dist/parser/extractors/functions.js

@@ -15,74 +15,107 @@ export const JS_BUILTINS = new Set([
 function makeId(filePath, name) {
     return `${filePath}::${name}`;
 }
-export function extractFunctionCalls(node) {
-    const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
-    const names = [];
-    for (const call of calls) {
-        const name = call.getExpression().getText();
-        // Skip hooks, they are handled by hooks extractor
-        if (name.startsWith("use"))
-            continue;
-        // Skip console calls and other noise calls, they are noise
-        const rootName = name.split(".")[0];
-        if (JS_BUILTINS.has(rootName))
-            continue;
-        names.push(name);
-    }
-    return [...new Set(names)];
-}
-export function extractHookCalls(node) {
-    const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
-    const hooks = [];
-    for (const call of calls) {
-        const name = call.getExpression().getText();
-        // Only capture custom hooks — use[A-Z] pattern
-        // Built-in React hooks (useState etc.) are not in our node graph
-        if (/^use[A-Z]/.test(name))
-            hooks.push(name);
+// Cheap arg-type inference without the type checker: literal/object/array/
+// function/new expressions map to coarse type tags; identifiers and property
+// accesses stay undefined (resolving those needs the checker, too slow for
+// whole-repo analysis).
+function inferArgType(arg) {
+    const kind = arg.getKind?.();
+    if (kind === SyntaxKind.StringLiteral || kind === SyntaxKind.TemplateExpression)
+        return "string";
+    if (kind === SyntaxKind.NumericLiteral)
+        return "number";
+    if (kind === SyntaxKind.TrueKeyword || kind === SyntaxKind.FalseKeyword)
+        return "boolean";
+    if (kind === SyntaxKind.ObjectLiteralExpression)
+        return "object";
+    if (kind === SyntaxKind.ArrayLiteralExpression)
+        return "array";
+    if (kind === SyntaxKind.ArrowFunction || kind === SyntaxKind.FunctionExpression)
+        return "function";
+    if (kind === SyntaxKind.NewExpression) {
+        const ident = arg.getExpression?.();
+        return typeof ident?.getName === "function" ? ident.getName() : undefined;
     }
-    return [...new Set(hooks)];
+    return undefined;
 }
-export function extractApiCalls(node) {
-    const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
+// Arg-shape tags for the API-call families, used by the single-walk
+// classifier below.
+const API_HOOK_FAMILIES = new Set(["useQuery", "useMutation", "useInfiniteQuery", "useSuspenseQuery", "useSWR", "useSWRMutation"]);
+const AXIOS_METHODS = new Set(["axios.get", "axios.post", "axios.put", "axios.delete", "axios.patch", "axios"]);
+// SINGLE traversal over all call expressions producing every call-derived
+// output at once: structured call sites + legacy bare names, custom hook
+// calls, and API-call strings. The per-aspect extractors used to walk the
+// same descendants tree four times per function-like; whole-repo cost is now
+// one walk.
+export function extractCallsWithSites(node) {
+    const callExprs = node.getDescendantsOfKind(SyntaxKind.CallExpression);
+    const sites = [];
+    const seenSites = new Set();
+    const hookCalls = [];
     const apiCalls = [];
-    for (const call of calls) {
-        const text = call.getText();
-        const expr = call.getExpression().getText();
-        // ─── fetch ────────────────────────────────────────────────────────────────
-        if (expr === "fetch") {
-            const args = call.getArguments();
-            if (args.length > 0)
-                apiCalls.push(`fetch(${args[0].getText()})`);
-        }
-        // ─── axios ────────────────────────────────────────────────────────────────
-        if (expr === "axios.get" ||
-            expr === "axios.post" ||
-            expr === "axios.put" ||
-            expr === "axios.delete" ||
-            expr === "axios.patch" ||
-            expr === "axios") {
-            const args = call.getArguments();
-            if (args.length > 0)
-                apiCalls.push(`${expr}(${args[0].getText()})`);
+    const dependencyNames = [];
+    const contextRefs = [];
+    for (const call of callExprs) {
+        const name = call.getExpression().getText();
+        // use* family: custom hooks (^use[A-Z]) plus ALL use* names (incl.
+        // built-ins like useState) for hook dependency tracking
+        if (name.startsWith("use")) {
+            if (/^use[A-Z]/.test(name) && !hookCalls.includes(name))
+                hookCalls.push(name);
+            if (!dependencyNames.includes(name))
+                dependencyNames.push(name);
+            if (name === "useContext") {
+                const ctxArg = call.getArguments()[0];
+                if (ctxArg && !contextRefs.includes(ctxArg.getText()))
+                    contextRefs.push(ctxArg.getText());
+            }
         }
-        // ─── React Query (useQuery, useMutation, useInfiniteQuery) ────────────────
-        if (expr === "useQuery" ||
-            expr === "useMutation" ||
-            expr === "useInfiniteQuery" ||
-            expr === "useSuspenseQuery") {
+        // API-call families: fetch / axios.* / React Query / SWR
+        if (name === "fetch" || AXIOS_METHODS.has(name) || API_HOOK_FAMILIES.has(name)) {
             const args = call.getArguments();
             if (args.length > 0)
-                apiCalls.push(`${expr}(${args[0].getText()})`);
+                apiCalls.push(`${name}(${args[0].getText()})`);
         }
-        // ─── SWR ──────────────────────────────────────────────────────────────────
-        if (expr === "useSWR" || expr === "useSWRMutation") {
-            const args = call.getArguments();
-            if (args.length > 0)
-                apiCalls.push(`${expr}(${args[0].getText()})`);
+        // Plain calls/sites skip hooks and builtin noise
+        if (name.startsWith("use"))
+            continue;
+        const rootName = name.split(".")[0];
+        if (JS_BUILTINS.has(rootName))
+            continue;
+        const args = call.getArguments();
+        let hasSpread = false;
+        const argTypes = [];
+        for (const arg of args) {
+            if (arg.getKind?.() === SyntaxKind.SpreadElement) {
+                hasSpread = true;
+                argTypes.push("unknown");
+            }
+            else {
+                argTypes.push(inferArgType(arg) ?? "unknown");
+            }
         }
+        // One record per (name, arity, argTypes) triple — two calls to the same
+        // name with different arg counts OR arg type shapes are both overload
+        // signals (same arity + different literal types can hit different
+        // overloads, and each deserves its own edge).
+        const key = `${name}/${args.length}/${argTypes.join(",")}`;
+        if (seenSites.has(key))
+            continue;
+        seenSites.add(key);
+        sites.push({ name, argCount: args.length, argTypes, ...(hasSpread && { hasSpread: true }) });
     }
-    return [...new Set(apiCalls)];
+    return {
+        calls: [...new Set(sites.map((cs) => cs.name))],
+        callSites: sites,
+        hookCalls,
+        apiCalls,
+        dependencyNames,
+        contextRefs,
+    };
+}
+export function extractFunctionCalls(node) {
+    return extractCallsWithSites(node).calls;
 }
 export function hasErrorHandling(node) {
     const tryCatch = node.getDescendantsOfKind(SyntaxKind.TryStatement);
@@ -109,9 +142,7 @@ export function extractFunctions(file, fileDirective = null) {
         if (/^use[A-Z]/.test(name))
             continue;
         const typedParams = extractParams(fn);
-        const calls = extractFunctionCalls(fn);
-        const hookCalls = extractHookCalls(fn);
-        const apiCalls = extractApiCalls(fn);
+        const { calls, callSites, hookCalls, apiCalls } = extractCallsWithSites(fn);
         const isAsync = fn.isAsync();
         const hasErrors = hasErrorHandling(fn);
         const throws = extractThrowStatements(fn);
@@ -119,6 +150,9 @@ export function extractFunctions(file, fileDirective = null) {
         const returnType = extractReturnTypeAnnotation(fn);
         const bareTypeNames = extractBareTypeNames([...typedParams.map((p) => p.type), returnType]);
         const referencedTypes = extractReferencedInterfaces(file, bareTypeNames);
+        // Overload signatures have no body — flagged so the disambiguator can
+        // collapse them into the implementation when signatures match.
+        const isOverloadSignature = !fn.getBody();
         nodes.push({
             id: makeId(filePath, name),
             name,
@@ -133,6 +167,8 @@ export function extractFunctions(file, fileDirective = null) {
                 returnType,
                 referencedTypes,
                 calls,
+                callSites,
+                ...(isOverloadSignature && { isOverloadSignature: true }),
                 hookCalls,
                 apiCalls,
                 isAsync,
@@ -144,6 +180,40 @@ export function extractFunctions(file, fileDirective = null) {
                 ...(renderingBoundary !== null && { renderingBoundary }),
             },
         });
+        // Overload signature declarations — ts-morph's getFunctions() returns only
+        // the implementation; signatures hang off getOverloads(). Each becomes its
+        // own FUNCTION node (no body) so the disambiguator can give it a
+        // signature-derived id or collapse it into an identical implementation.
+        for (const overload of fn.getOverloads() ?? []) {
+            const ovParams = extractParams(overload);
+            const ovReturnType = extractReturnTypeAnnotation(overload);
+            nodes.push({
+                id: makeId(filePath, name),
+                name,
+                type: "FUNCTION",
+                filePath,
+                startLine: overload.getStartLineNumber(),
+                endLine: overload.getEndLineNumber(),
+                rawCode: overload.getText(),
+                metadata: {
+                    params: ovParams.map((p) => p.name),
+                    parameters: ovParams,
+                    returnType: ovReturnType,
+                    referencedTypes: [],
+                    calls: [],
+                    callSites: [],
+                    hookCalls: [],
+                    apiCalls: [],
+                    isAsync: false,
+                    hasErrorHandling: false,
+                    throws: false,
+                    lineCount: overload.getEndLineNumber() - overload.getStartLineNumber(),
+                    isHttpHandler: HTTP_METHOD_EXPORTS.has(name),
+                    httpMethod: HTTP_METHOD_EXPORTS.has(name) ? name : undefined,
+                    isOverloadSignature: true,
+                },
+            });
+        }
     }
     // ─── Arrow Function Declarations ───────────────────────────────────────────
     for (const variable of file.getVariableDeclarations()) {
@@ -161,9 +231,7 @@ export function extractFunctions(file, fileDirective = null) {
         if (!isArrow)
             continue;
         const typedParams = extractParams(initializer);
-        const calls = extractFunctionCalls(initializer);
-        const hookCalls = extractHookCalls(initializer);
-        const apiCalls = extractApiCalls(initializer);
+        const { calls, callSites, hookCalls, apiCalls } = extractCallsWithSites(initializer);
         const isAsync = initializer.getText().startsWith("async");
         const hasErrors = hasErrorHandling(initializer);
         const throws = extractThrowStatements(initializer);
@@ -185,6 +253,7 @@ export function extractFunctions(file, fileDirective = null) {
                 returnType,
                 referencedTypes,
                 calls,
+                callSites,
                 hookCalls,
                 apiCalls,
                 isAsync,
@@ -230,6 +299,7 @@ export function extractFunctions(file, fileDirective = null) {
                 metadata: {
                     params: [],
                     calls: [],
+                    callSites: [],
                     apiCalls: [],
                     isAsync: false,
                     hasErrorHandling: false,

package/dist/parser/extractors/hooks.js

@@ -1,32 +1,10 @@
 import { SyntaxKind } from "ts-morph";
 import { detectFunctionDirective } from "../directives.js";
 import { extractParams, extractBareTypeNames, extractReferencedInterfaces, } from "../typeUtils.js";
-import { extractFunctionCalls } from "./functions.js";
+import { extractCallsWithSites } from "./functions.js";
 function makeId(filePath, name) {
     return `${filePath}::${name}`;
 }
-function extractDependencies(node) {
-    const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
-    const deps = [];
-    for (const call of calls) {
-        const name = call.getExpression().getText();
-        if (name.startsWith("use")) {
-            deps.push(name);
-        }
-    }
-    return [...new Set(deps)];
-}
-function extractContextRefs(node) {
-    const refs = [];
-    for (const call of node.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-        if (call.getExpression().getText() === "useContext") {
-            const arg = call.getArguments()[0];
-            if (arg)
-                refs.push(arg.getText());
-        }
-    }
-    return [...new Set(refs)];
-}
 // Try explicit annotation first; fall back to shape heuristic.
 function extractReturnType(node) {
     const explicit = node.getReturnTypeNode?.()?.getText();
@@ -58,11 +36,9 @@ export function extractHooks(file, fileDirective = null) {
         // Hooks must start with "use" followed by uppercase
         if (!/^use[A-Z]/.test(name))
             continue;
-        const dependencies = extractDependencies(fn);
-        const calls = extractFunctionCalls(fn);
+        const { calls, callSites, dependencyNames: dependencies, contextRefs } = extractCallsWithSites(fn);
         const returnType = extractReturnType(fn);
         const isAsync = fn.isAsync();
-        const contextRefs = extractContextRefs(fn);
         const renderingBoundary = detectFunctionDirective(fn.getBody()) ?? fileDirective;
         const typedParams = extractParams(fn);
         const bareTypeNames = extractBareTypeNames([...typedParams.map((p) => p.type), returnType]);
@@ -78,6 +54,7 @@ export function extractHooks(file, fileDirective = null) {
             metadata: {
                 dependencies,
                 calls,
+                callSites,
                 contextRefs,
                 returnType,
                 parameters: typedParams,
@@ -100,11 +77,9 @@ export function extractHooks(file, fileDirective = null) {
         const isArrow = initializer.getKind() === SyntaxKind.ArrowFunction;
         if (!isArrow)
             continue;
-        const dependencies = extractDependencies(initializer);
-        const calls = extractFunctionCalls(initializer);
+        const { calls, callSites, dependencyNames: dependencies, contextRefs } = extractCallsWithSites(initializer);
         const returnType = extractReturnType(initializer);
         const isAsync = initializer.asKind(SyntaxKind.ArrowFunction)?.isAsync() ?? false;
-        const contextRefs = extractContextRefs(initializer);
         const renderingBoundary = detectFunctionDirective(initializer.getBody?.()) ?? fileDirective;
         const typedParams = extractParams(initializer);
         const bareTypeNames = extractBareTypeNames([...typedParams.map((p) => p.type), returnType]);
@@ -120,6 +95,7 @@ export function extractHooks(file, fileDirective = null) {
             metadata: {
                 dependencies,
                 calls,
+                callSites,
                 contextRefs,
                 returnType,
                 parameters: typedParams,

package/dist/parser/extractors/objectMethods.js

@@ -1,6 +1,6 @@
 import { SyntaxKind } from "ts-morph";
 import { detectFunctionDirective } from "../directives.js";
-import { extractFunctionCalls, extractHookCalls, extractApiCalls, hasErrorHandling, extractThrowStatements, } from "./functions.js";
+import { extractCallsWithSites, hasErrorHandling, extractThrowStatements, } from "./functions.js";
 import { extractParams, extractReturnTypeAnnotation, extractBareTypeNames, extractReferencedInterfaces, } from "../typeUtils.js";
 // Extracts function-valued properties of object literals as FUNCTION nodes.
 //
@@ -42,9 +42,7 @@ function isAsyncFn(fnNode) {
 function buildNode(file, dottedName, fnNode, spanNode, fileDirective) {
     const filePath = file.getFilePath();
     const typedParams = extractParams(fnNode);
-    const calls = extractFunctionCalls(fnNode);
-    const hookCalls = extractHookCalls(fnNode);
-    const apiCalls = extractApiCalls(fnNode);
+    const { calls, callSites, hookCalls, apiCalls } = extractCallsWithSites(fnNode);
     const isAsync = isAsyncFn(fnNode);
     const hasErrors = hasErrorHandling(fnNode);
     const throws = extractThrowStatements(fnNode);
@@ -66,6 +64,7 @@ function buildNode(file, dottedName, fnNode, spanNode, fileDirective) {
             returnType,
             referencedTypes,
             calls,
+            callSites,
             hookCalls,
             apiCalls,
             isAsync,

package/dist/parser/index.js

@@ -8,6 +8,7 @@ import { extractStores } from "./extractors/stores.js";
 import { extractObjectMethods } from "./extractors/objectMethods.js";
 import { extractClasses } from "./extractors/classes.js";
 import { detectFileDirective } from "./directives.js";
+import { applyOverloadDisambiguation } from "./overloads.js";
 import { createHash } from "crypto";
 // Directories to skip entirely while walking
 const IGNORE_DIRS = [
@@ -123,13 +124,17 @@ export function parseRepo(repoPath) {
                     node.codeHash = createHash("sha256").update(node.rawCode).digest("hex").slice(0, 16);
                 }
             }
+            // Same-name function-likes in one file (overloads) get arity/signature
+            // discriminator suffixes; signature-identical declarations collapse.
+            applyOverloadDisambiguation(extracted, relativePath);
+            const overloads = extracted.filter((n) => !n.metadata.isDuplicateOverload);
             if (fileType === "TEST" || fileType === "STORY") {
                 // Do not add child nodes for test/story files — they are test helpers,
-                fileNode.metadata.testCases = extracted.map(n => n.name);
+                fileNode.metadata.testCases = overloads.map(n => n.name);
                 fileNode.metadata.nodeCount = 0;
                 fileNode.metadata.childNodeIds = [];
                 // File hash based on all child code combined
-                const fileRawCode = extracted.map(n => n.rawCode ?? "").join("\n");
+                const fileRawCode = overloads.map(n => n.rawCode ?? "").join("\n");
                 if (fileRawCode.trim()) {
                     fileNode.codeHash = createHash("sha256")
                         .update(fileRawCode).digest("hex").slice(0, 16);
@@ -137,14 +142,14 @@ export function parseRepo(repoPath) {
                 allNodes.push(fileNode); // only the file node, no children
             }
             else {
-                fileNode.metadata.nodeCount = extracted.length;
-                fileNode.metadata.childNodeIds = extracted.map(n => n.id);
+                fileNode.metadata.nodeCount = overloads.length;
+                fileNode.metadata.childNodeIds = overloads.map(n => n.id);
                 // File node hash — based on all child code combined
-                const fileRawCode = extracted.map(n => n.rawCode ?? "").join("\n");
+                const fileRawCode = overloads.map(n => n.rawCode ?? "").join("\n");
                 if (fileRawCode.trim()) {
                     fileNode.codeHash = createHash("sha256").update(fileRawCode).digest("hex").slice(0, 16);
                 }
-                allNodes.push(fileNode, ...extracted);
+                allNodes.push(fileNode, ...overloads);
             }
         }
         catch (error) {

package/dist/parser/overloads.d.ts

@@ -0,0 +1,2 @@
+import type { CodeNode } from "../types.js";
+export declare function applyOverloadDisambiguation(nodes: CodeNode[], relativePath: string): void;

package/dist/parser/overloads.js

@@ -0,0 +1,96 @@
+// Overload disambiguation — same-name function-likes in the same file.
+//
+// Node ids are `${relativePath}::${name}`, so a file with two `formatValue`
+// functions (or an overloaded `Logger.log` method pair) produced two nodes
+// with ONE id; downstream dedupe (buildGraphResponse, summarizer, storage)
+// silently dropped all but the first and every CALLS edge picked arbitrarily.
+//
+// Convention (mirrored by the Go/Java/Python/Rust extractors — keep in sync,
+// see MULTI_LANGUAGE_EXPANSION.md):
+//   - Unique name in file  → id unchanged (`utils.ts::formatValue`)
+//   - Collision, distinct arities → `#arity` suffix (`utils.ts::formatValue#2`)
+//   - Collision, same arity, different param types → `#arity#<sig8>` where
+//     sig8 = first 8 hex of sha256 over the normalized param-type list
+//   - Arity-suffix never uses ordinals: the suffix is the declaration's own
+//     parameter count, so reordering functions in a file cannot change ids
+//
+// Signature-identical declarations (a TS overload signature plus an
+// implementation with the same param list) collapse into ONE node, keeping
+// the one with a body — they are the same callable.
+import { createHash } from "crypto";
+const OVERLOADABLE_TYPES = new Set(["FUNCTION", "METHOD"]);
+function paramTypes(node) {
+    const parameters = node.metadata?.parameters;
+    if (!Array.isArray(parameters))
+        return [];
+    return parameters.map((p) => {
+        const t = typeof p?.type === "string" && p.type.length > 0 ? p.type : "unknown";
+        if (p?.isRest)
+            return `...${t}`;
+        if (p?.isOptional)
+            return `${t}?`;
+        return t;
+    });
+}
+function signatureKey(node) {
+    return `(${paramTypes(node).join(",")})`;
+}
+function hasBody(node) {
+    return node.metadata?.isOverloadSignature !== true;
+}
+export function applyOverloadDisambiguation(nodes, relativePath) {
+    // Group function-likes by name (METHOD names are dotted `Class.method`, so
+    // same-name methods on different classes never collide here).
+    const groups = new Map();
+    for (const node of nodes) {
+        if (!OVERLOADABLE_TYPES.has(node.type))
+            continue;
+        if (!groups.has(node.name))
+            groups.set(node.name, []);
+        groups.get(node.name).push(node);
+    }
+    for (const [name, group] of groups) {
+        if (group.length < 2)
+            continue;
+        group.sort((a, b) => a.startLine - b.startLine);
+        // Collapse signature-identical declarations, preferring the one with a body.
+        // Single pass — each node's signature key is computed exactly once.
+        const bySignature = new Map();
+        const keys = new Map();
+        for (const node of group) {
+            const key = signatureKey(node);
+            keys.set(node, key);
+            const existing = bySignature.get(key);
+            if (!existing) {
+                bySignature.set(key, node);
+                continue;
+            }
+            // Keep the implementation; drop the bare signature duplicate.
+            if (!hasBody(existing) && hasBody(node))
+                bySignature.set(key, node);
+        }
+        const survivors = [...bySignature.values()].sort((a, b) => a.startLine - b.startLine);
+        if (survivors.length < group.length) {
+            const kept = new Set(survivors);
+            for (const node of group) {
+                if (!kept.has(node))
+                    node.metadata.isDuplicateOverload = true;
+            }
+        }
+        // Single survivor after collapse → the name is unique again, no suffix.
+        if (survivors.length < 2)
+            continue;
+        // Distinct arities within the group → readable `#arity` suffix.
+        const arities = new Set(survivors.map((n) => n.metadata?.params?.length ?? 0));
+        const useArityOnly = arities.size === survivors.length;
+        for (const node of survivors) {
+            const arity = node.metadata?.params?.length ?? 0;
+            let suffix = `#${arity}`;
+            if (!useArityOnly) {
+                const sig8 = createHash("sha256").update(keys.get(node)).digest("hex").slice(0, 8);
+                suffix = `#${arity}#${sig8}`;
+            }
+            node.id = `${relativePath}::${name}${suffix}`;
+        }
+    }
+}

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

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