devlensio 0.4.2 → 0.4.3

package/README.md

@@ -29,7 +29,7 @@ Repo path
 [2] Filesystem scan extract routes (Next.js app/pages, Express, Fastify, Koa)
 [3] Parse (ts-morph) walk every .ts/.tsx/.js/.jsx → nodes (typed params, return types, prop types)
 [4] Edge detection  many detectors → CALLS, IMPORTS, READS_FROM, WRITES_TO, PROP_PASS, EMITS,
-                    LISTENS, WRAPPED_BY, GUARDS, HANDLES, TESTS, USES
+                    LISTENS, WRAPPED_BY, GUARDS, HANDLES, TESTS, USES, NEXTJS_API_CALL
 [5] Scoring         multi-pass importance scoring + noise filtering (no AI)
 [6] Clustering      cohesive cluster assignment
 [7] Summarize       (optional) topologically-ordered LLM summaries, checkpoint/resume, MapReduce
@@ -73,7 +73,7 @@ Also exported: all core types (`CodeNode`, `CodeEdge`, `NodeType`, `EdgeType`,
 ### Node & edge types
 
 - **Node types:** `COMPONENT`, `HOOK`, `FUNCTION`, `STATE_STORE`, `UTILITY`, `FILE`, `ROUTE`, `TEST`, `STORY`, `THIRD_PARTY` (+ internal `GHOST`).
-- **Edge types:** `CALLS`, `IMPORTS`, `READS_FROM`, `WRITES_TO`, `PROP_PASS`, `EMITS`, `LISTENS`, `WRAPPED_BY`, `GUARDS`, `HANDLES`, `TESTS`, `USES`.
+- **Edge types:** `CALLS`, `IMPORTS`, `READS_FROM`, `WRITES_TO`, `PROP_PASS`, `EMITS`, `LISTENS`, `WRAPPED_BY`, `GUARDS`, `HANDLES`, `TESTS`, `USES`, `NEXTJS_API_CALL` (frontend `fetch`/`axios`/`useSWR` call site → Next.js API route).
 - Each node carries an importance score and (after summarization) a technical summary, a business summary, and a security assessment (`none|low|medium|high` + notes).
 
 ---

package/dist/graph/edges/apiFetchEdges.js

@@ -207,6 +207,15 @@ function extractUrlFromArg(arg, sourceFile, project) {
 // For each call matching CALLER_CONFIG:
 //   - infers the HTTP method
 //   - extracts and resolves the URL argument
+// It additionally scans for backend routes used as a resource URL:
+//   - JSX src/href attributes — tag-agnostic, so it covers native elements
+//     (<video src="/api/..">, <iframe src={url}>, <a href={`/api/${id}`}>)
+//     AND third-party player components (<HlsPlayer src={url} />,
+//     <ReactHlsPlayer src={...} />).
+//   - object-literal src/href properties — config-object style usage where a
+//     route is handed to a third-party player/function, e.g.
+//     loadPlayer({ src: '/api/stream' }).
+// The browser issues a GET for any such resource, so these are emitted as GET.
 // The expensive AST traversal happens once per file here; callers then
 // attribute the resulting calls to nodes by line range (see detectNextjsApiCallEdges).
 // Note: useQuery/useMutation inner fetch/axios calls are captured naturally
@@ -270,6 +279,64 @@ function extractApiCallsFromFile(sourceFile, project) {
             },
         });
     }
+    // JSX src/href attributes — tag-agnostic, so native elements (video, iframe,
+    // a) and third-party player components (HlsPlayer, ReactHlsPlayer, …) are all
+    // covered. The browser fetches the resource with GET.
+    for (const attr of sourceFile.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
+        const attrName = attr.getNameNode().getText();
+        if (attrName !== "src" && attrName !== "href")
+            continue;
+        const initializer = attr.getInitializer();
+        if (!initializer)
+            continue;
+        // value is either a bare string (src="/api/x") or a JSX expression
+        // container (src={url} / src={`/api/${id}`})
+        let valueNode;
+        const initKind = initializer.getKind();
+        if (initKind === SyntaxKind.StringLiteral) {
+            valueNode = initializer;
+        }
+        else if (initKind === SyntaxKind.JsxExpression) {
+            valueNode = initializer.getExpression();
+        }
+        if (!valueNode)
+            continue;
+        const urlResult = extractUrlFromArg(valueNode, sourceFile, project);
+        if (!urlResult)
+            continue;
+        results.push({
+            startLine: attr.getStartLineNumber(),
+            call: {
+                callerType: `jsx-${attrName}`,
+                rawUrl: urlResult.rawUrl,
+                resolvedUrl: urlResult.resolvedUrl,
+                method: "GET",
+            },
+        });
+    }
+    // Object-literal src/href properties — config-object style usage where a
+    // backend route is passed to a third-party player/function, e.g.
+    // loadPlayer({ src: '/api/stream' }). Same GET semantics.
+    for (const prop of sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAssignment)) {
+        const name = prop.getName();
+        if (name !== "src" && name !== "href")
+            continue;
+        const init = prop.getInitializer();
+        if (!init)
+            continue;
+        const urlResult = extractUrlFromArg(init, sourceFile, project);
+        if (!urlResult)
+            continue;
+        results.push({
+            startLine: prop.getStartLineNumber(),
+            call: {
+                callerType: `prop-${name}`,
+                rawUrl: urlResult.rawUrl,
+                resolvedUrl: urlResult.resolvedUrl,
+                method: "GET",
+            },
+        });
+    }
     return results;
 }
 //MAIN FUNCTION 

package/dist/parser/extractors/functions.d.ts

@@ -1,4 +1,9 @@
 import { SourceFile } from "ts-morph";
 import type { CodeNode } from "../../types.js";
 import { type RenderingBoundary } from "../directives.js";
+export declare function extractFunctionCalls(node: any): string[];
+export declare function extractHookCalls(node: any): string[];
+export declare function extractApiCalls(node: any): string[];
+export declare function hasErrorHandling(node: any): boolean;
+export declare function extractThrowStatements(node: any): boolean;
 export declare function extractFunctions(file: SourceFile, fileDirective?: RenderingBoundary): CodeNode[];

package/dist/parser/extractors/functions.js

@@ -7,7 +7,7 @@ const HTTP_METHOD_EXPORTS = new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "H
 function makeId(filePath, name) {
     return `${filePath}::${name}`;
 }
-function extractFunctionCalls(node) {
+export function extractFunctionCalls(node) {
     const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
     const names = [];
     for (const call of calls) {
@@ -22,7 +22,7 @@ function extractFunctionCalls(node) {
     }
     return [...new Set(names)];
 }
-function extractHookCalls(node) {
+export function extractHookCalls(node) {
     const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
     const hooks = [];
     for (const call of calls) {
@@ -34,7 +34,7 @@ function extractHookCalls(node) {
     }
     return [...new Set(hooks)];
 }
-function extractApiCalls(node) {
+export function extractApiCalls(node) {
     const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
     const apiCalls = [];
     for (const call of calls) {
@@ -75,11 +75,11 @@ function extractApiCalls(node) {
     }
     return [...new Set(apiCalls)];
 }
-function hasErrorHandling(node) {
+export function hasErrorHandling(node) {
     const tryCatch = node.getDescendantsOfKind(SyntaxKind.TryStatement);
     return tryCatch.length > 0;
 }
-function extractThrowStatements(node) {
+export function extractThrowStatements(node) {
     const throws = node.getDescendantsOfKind(SyntaxKind.ThrowStatement);
     return throws.length > 0;
 }

package/dist/parser/extractors/objectMethods.d.ts

@@ -0,0 +1,4 @@
+import { SourceFile } from "ts-morph";
+import type { CodeNode } from "../../types.js";
+import { type RenderingBoundary } from "../directives.js";
+export declare function extractObjectMethods(file: SourceFile, fileDirective?: RenderingBoundary): CodeNode[];

package/dist/parser/extractors/objectMethods.js

@@ -0,0 +1,141 @@
+import { SyntaxKind } from "ts-morph";
+import { detectFunctionDirective } from "../directives.js";
+import { extractFunctionCalls, extractHookCalls, extractApiCalls, hasErrorHandling, extractThrowStatements, } from "./functions.js";
+import { extractParams, extractReturnTypeAnnotation, extractBareTypeNames, extractReferencedInterfaces, } from "../typeUtils.js";
+// Extracts function-valued properties of object literals as FUNCTION nodes.
+//
+// Many React/Next.js modules keep their logic inside an exported object literal
+// (provider adapters, route tables, command maps, strategy/config objects). The
+// other extractors (declarations, var-assigned arrows, components, hooks) never
+// descend into object literals, so those functions had no node to anchor edges
+// to — every CALLS / NEXTJS_API_CALL / READS_FROM edge silently dropped.
+//
+// The node `name` encodes the dotted access path (e.g.
+// "providersConfig.zoro.streamingData"). index.ts builds the id as
+// `${relativePath}::${name}`, so this yields the desired node identity for free.
+function makeId(filePath, name) {
+    return `${filePath}::${name}`;
+}
+// Unwraps `as const` / `as Foo` and parenthesized expressions, returning the
+// underlying ObjectLiteralExpression node, or null if it isn't one.
+function asObjectLiteral(node) {
+    let n = node;
+    while (n &&
+        (n.getKind() === SyntaxKind.AsExpression ||
+            n.getKind() === SyntaxKind.ParenthesizedExpression)) {
+        n = n.getExpression?.();
+    }
+    return n && n.getKind() === SyntaxKind.ObjectLiteralExpression ? n : null;
+}
+// True for `async (...) => {}`, `async function () {}`, `async key() {}`.
+function isAsyncFn(fnNode) {
+    if (typeof fnNode.isAsync === "function")
+        return fnNode.isAsync();
+    return fnNode.getText().trimStart().startsWith("async");
+}
+// Builds a FUNCTION node from a function-like node + the span node that should
+// own its line range / rawCode. The metadata shape mirrors functions.ts exactly
+// so callEdges / apiFetchEdges treat these like any other FUNCTION node.
+//   fnNode  — ArrowFunction | FunctionExpression | MethodDeclaration (params/body)
+//   spanNode— the PropertyAssignment (`key: fn`) or the MethodDeclaration itself,
+//             so the inner call's line falls inside [startLine, endLine].
+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 isAsync = isAsyncFn(fnNode);
+    const hasErrors = hasErrorHandling(fnNode);
+    const throws = extractThrowStatements(fnNode);
+    const renderingBoundary = detectFunctionDirective(fnNode.getBody?.()) ?? fileDirective;
+    const returnType = extractReturnTypeAnnotation(fnNode);
+    const bareTypeNames = extractBareTypeNames([...typedParams.map((p) => p.type), returnType]);
+    const referencedTypes = extractReferencedInterfaces(file, bareTypeNames);
+    return {
+        id: makeId(filePath, dottedName),
+        name: dottedName,
+        type: "FUNCTION",
+        filePath,
+        startLine: spanNode.getStartLineNumber(),
+        endLine: spanNode.getEndLineNumber(),
+        rawCode: spanNode.getText(),
+        metadata: {
+            params: typedParams.map((p) => p.name),
+            parameters: typedParams,
+            returnType,
+            referencedTypes,
+            calls,
+            hookCalls,
+            apiCalls,
+            isAsync,
+            hasErrorHandling: hasErrors,
+            throws,
+            lineCount: spanNode.getEndLineNumber() - spanNode.getStartLineNumber(),
+            isHttpHandler: false,
+            httpMethod: undefined,
+            ...(renderingBoundary !== null && { renderingBoundary }),
+        },
+    };
+}
+// Recursively walks an object literal, emitting a node per function-valued
+// property and descending into nested object literals to arbitrary depth.
+function walkObject(file, objLiteral, prefix, fileDirective, out) {
+    // getProperties() returns a union (PropertyAssignment | ShorthandPropertyAssignment
+    // | SpreadAssignment | MethodDeclaration | Get/SetAccessor) — guard every getter.
+    for (const prop of objLiteral.getProperties()) {
+        const kind = prop.getKind();
+        // Shorthand method:  streamingData(args) { ... }  (incl. async)
+        if (kind === SyntaxKind.MethodDeclaration) {
+            const name = prop.getName?.();
+            if (!name)
+                continue;
+            out.push(buildNode(file, `${prefix}.${name}`, prop, prop, fileDirective));
+            continue;
+        }
+        // Everything else we handle needs a name + initializer.
+        if (kind !== SyntaxKind.PropertyAssignment)
+            continue; // skip spread/shorthand/get/set
+        const name = prop.getName?.();
+        const init = prop.getInitializer?.();
+        if (!name || !init)
+            continue;
+        const ik = init.getKind();
+        if (ik === SyntaxKind.ArrowFunction || ik === SyntaxKind.FunctionExpression) {
+            // span = the PropertyAssignment so the range wraps `key: <fn>`.
+            out.push(buildNode(file, `${prefix}.${name}`, init, prop, fileDirective));
+            continue;
+        }
+        // Nested object → recurse (unwrap `as const` / parens).
+        const nested = asObjectLiteral(init);
+        if (nested) {
+            walkObject(file, nested, `${prefix}.${name}`, fileDirective, out);
+        }
+    }
+}
+export function extractObjectMethods(file, fileDirective = null) {
+    const out = [];
+    // Roots: named object literals — `const x = { ... }` (incl. `as const`).
+    for (const variable of file.getVariableDeclarations()) {
+        const init = variable.getInitializer();
+        if (!init)
+            continue;
+        const obj = asObjectLiteral(init);
+        if (!obj)
+            continue;
+        walkObject(file, obj, variable.getName(), fileDirective, out);
+    }
+    // Root: `export default { ... }` — fall back to the "default" prefix.
+    for (const assign of file.getExportAssignments()) {
+        if (assign.isExportEquals?.())
+            continue; // skip `export = ...`
+        const expr = assign.getExpression?.();
+        if (!expr)
+            continue;
+        const obj = asObjectLiteral(expr);
+        if (!obj)
+            continue;
+        walkObject(file, obj, "default", fileDirective, out);
+    }
+    return out;
+}

package/dist/parser/index.js

@@ -5,6 +5,7 @@ import { extractComponents } from "./extractors/components.js";
 import { extractHooks } from "./extractors/hooks.js";
 import { extractFunctions } from "./extractors/functions.js";
 import { extractStores } from "./extractors/stores.js";
+import { extractObjectMethods } from "./extractors/objectMethods.js";
 import { detectFileDirective } from "./directives.js";
 import { createHash } from "crypto";
 // Directories to skip entirely while walking
@@ -107,7 +108,8 @@ export function parseRepo(repoPath) {
             const hooks = extractHooks(file, fileDirective);
             const functions = extractFunctions(file, fileDirective);
             const stores = extractStores(file);
-            const extracted = [...components, ...hooks, ...functions, ...stores];
+            const objectMethods = extractObjectMethods(file, fileDirective);
+            const extracted = [...components, ...hooks, ...functions, ...stores, ...objectMethods];
             for (const node of extracted) {
                 // Normalize all extracted nodes to relative paths so every node in the
                 // graph uses the same coordinate system as the FILE nodes.

package/dist/parser/index.test.js

@@ -316,4 +316,134 @@ describe("parseRepo", () => {
         expect(configNode).toBeUndefined();
         deleteFakeRepo(repoPath);
     });
+    // ─── Object-literal Method Extraction ──────────────────────────────────────
+    it("should detect an arrow-function value in an object literal", () => {
+        const repoPath = createFakeRepo({
+            "src/cfg.ts": `
+        export const cfg = {
+          load: () => doThing(),
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "cfg.load");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        expect(fn?.startLine).toBeGreaterThanOrEqual(1);
+        expect(fn?.endLine).toBeGreaterThanOrEqual(fn.startLine);
+        expect(fn?.metadata.calls).toContain("doThing");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect an async arrow value calling axios (nested object)", () => {
+        const repoPath = createFakeRepo({
+            "src/providersConfig.js": `
+        export const providersConfig = {
+          zoro: {
+            streamingData: async (episodeId) => {
+              const response = await axios.get('/api/v2/zoro/watch/' + episodeId);
+              return response.data;
+            },
+          },
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "providersConfig.zoro.streamingData");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        expect(fn?.metadata.isAsync).toBe(true);
+        expect((fn?.metadata.apiCalls).length).toBeGreaterThan(0);
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a function-expression value in an object literal", () => {
+        const repoPath = createFakeRepo({
+            "src/cfg.ts": `
+        export const cfg = {
+          run: function (x) { return helper(x); },
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "cfg.run");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        expect(fn?.metadata.params).toContain("x");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a shorthand method in an object literal", () => {
+        const repoPath = createFakeRepo({
+            "src/cfg.ts": `
+        export const cfg = {
+          fetchData(url) { return fetch(url); },
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "cfg.fetchData");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a concise-body arrow value in an object literal", () => {
+        const repoPath = createFakeRepo({
+            "src/cfg.ts": `
+        export const cfg = {
+          pick: (u) => u.id,
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "cfg.pick");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a function in a two-level nested object", () => {
+        const repoPath = createFakeRepo({
+            "src/api.ts": `
+        export const api = {
+          v2: {
+            users: {
+              list: async () => fetch('/api/users'),
+            },
+          },
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "api.v2.users.list");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a function in an export-default object", () => {
+        const repoPath = createFakeRepo({
+            "src/handler.ts": `
+        export default {
+          handler: async () => fetch('/api/x'),
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const fn = result.nodes.find((n) => n.name === "default.handler");
+        expect(fn).toBeDefined();
+        expect(fn?.type).toBe("FUNCTION");
+        deleteFakeRepo(repoPath);
+    });
+    it("should not double-extract or collide with top-level hooks", () => {
+        const repoPath = createFakeRepo({
+            "src/mix.ts": `
+        export const useThing = () => { return 1; };
+        export const cfg = {
+          a: () => doA(),
+        };
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const objMethods = result.nodes.filter((n) => n.name === "cfg.a");
+        expect(objMethods.length).toBe(1);
+        const hook = result.nodes.find((n) => n.name === "useThing");
+        expect(hook?.type).toBe("HOOK");
+        deleteFakeRepo(repoPath);
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlensio",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Codebase intelligence engine for TypeScript/JavaScript/Reactjs/Nextjs repositories.",
   "type": "module",
   "main": "./dist/index.js",