devlensio 0.4.4 → 0.6.1

package/dist/filesystem/index.test.js

@@ -346,3 +346,277 @@ describe("analyzeFilesystem — React Router", () => {
         deleteFakeRepo(repoPath);
     });
 });
+// ─── Backend frameworks: Bun / Hono / Elysia / Express ───────────────────────────
+//
+// Covers three recognizers added for general backend route detection:
+//   1. route-table (object-literal) — hand-rolled [{method,pattern,handler}] routers
+//      (the OSS shape); framework-agnostic, fires in bun scan-all mode.
+//   2. imperative app.METHOD(path, handler) — Express/Hono/Elysia shared shape.
+//   3. Bun.serve fetch-handler — inline switch/if URL dispatch for bare-Bun apps.
+describe("analyzeFilesystem — Backend (Bun/Hono/Elysia/Express)", () => {
+    function createRepoWithFiles(files) {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devlens-be-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 backendFingerprint(framework) {
+        return makeFingerprint(framework, "none");
+    }
+    function findRoute(routes, method, urlPath) {
+        return routes.find((r) => r.type === "BACKEND_ROUTE" && r.httpMethod === method && r.urlPath === urlPath);
+    }
+    // ─── Route-table (object-literal) recognizer ─────────────────────────────
+    it("detects a route-table array (Bun.serve + hand-rolled router — the OSS shape)", () => {
+        const repoPath = createRepoWithFiles({
+            "src/server/router.ts": `
+        import { handlePreScan, handleGetGraph, handleAnalyze } from "./handlers.js";
+        interface Route { method: string; pattern: string; handler: (p: any, req: any) => any; }
+        const ROUTES: Route[] = [
+          { method: "GET",  pattern: "/api/health",   handler: () => Response.json({ status: "ok" }) },
+          { method: "GET",  pattern: "/api/pre-scan", handler: (_p, req) => handlePreScan(req) },
+          { method: "POST", pattern: "/api/analyze",  handler: (_p, req) => handleAnalyze(req) },
+        ];
+        export async function router(req: any) { return null; }
+      `,
+        });
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("bun"));
+        expect(routes.length).toBe(3);
+        // Inline self-contained handler → inlineHandler populated (no handlerName).
+        const health = findRoute(routes, "GET", "/api/health");
+        expect(health).toBeDefined();
+        expect(health?.handlerName).toBeUndefined();
+        expect(health?.inlineHandler).toBeDefined();
+        // Arrow delegating to a bare-name call → handlerName extracted.
+        const preScan = findRoute(routes, "GET", "/api/pre-scan");
+        expect(preScan?.handlerName).toBe("handlePreScan");
+        expect(preScan?.inlineHandler).toBeUndefined();
+        const analyze = findRoute(routes, "POST", "/api/analyze");
+        expect(analyze?.handlerName).toBe("handleAnalyze");
+    });
+    it("resolves a bare-identifier route-table handler by name", () => {
+        const repoPath = createRepoWithFiles({
+            "src/server/router.ts": `
+        import { createUser } from "./handlers.js";
+        const ROUTES = [
+          { method: "POST", path: "/users", handler: createUser },
+        ];
+      `,
+        });
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("bun"));
+        const route = findRoute(routes, "POST", "/users");
+        expect(route).toBeDefined();
+        expect(route?.handlerName).toBe("createUser");
+    });
+    it("accepts path-property aliases (url / route) and method alias (verb)", () => {
+        const repoPath = createRepoWithFiles({
+            "src/server/router.ts": `
+        const ROUTES = [
+          { verb: "GET", url: "/a", handler: () => null },
+          { method: "DELETE", route: "/b", handler: () => null },
+        ];
+      `,
+        });
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("bun"));
+        expect(findRoute(routes, "GET", "/a")).toBeDefined();
+        expect(findRoute(routes, "DELETE", "/b")).toBeDefined();
+    });
+    it("extracts dynamic params from a route-table pattern", () => {
+        const repoPath = createRepoWithFiles({
+            "src/server/router.ts": `
+        const ROUTES = [
+          { method: "GET", pattern: "/users/:userId/posts/:postId", handler: () => null },
+        ];
+      `,
+        });
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("bun"));
+        const route = findRoute(routes, "GET", "/users/:userId/posts/:postId");
+        expect(route?.isDynamic).toBe(true);
+        expect(route?.params).toEqual(expect.arrayContaining(["userId", "postId"]));
+    });
+    it("does NOT fire the route-table recognizer on a React Router children array", () => {
+        // React Router arrays use {path, element/component}, no `method` field.
+        const repoPath = createRepoWithFiles({
+            "src/router.tsx": `
+        const routes = [
+          { path: "/users", element: "<Users/>" },
+          { path: "/about", component: About },
+        ];
+      `,
+        });
+        // Use the react-router fingerprint so this never reaches the backend branch.
+        const routes = analyzeFilesystem(repoPath, makeFingerprint("react", "react-router"));
+        // React Router fixtures above aren't createBrowserRouter/useRoutes calls,
+        // so they produce no routes — but more importantly, no BACKEND_ROUTE.
+        expect(routes.every((r) => r.type !== "BACKEND_ROUTE")).toBe(true);
+        deleteFakeRepo(repoPath);
+    });
+    it("does NOT fire the route-table recognizer on an arbitrary config array", () => {
+        const repoPath = createRepoWithFiles({
+            "src/config.ts": `
+        const CONFIG = [
+          { name: "health", url: "/health" },
+          { name: "status", method: "ping", target: "/status" },
+        ];
+      `,
+        });
+        // Even in bun scan-all mode: first element has no method+"/path" combo, so the
+        // route-table gate rejects it and zero routes are emitted.
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("bun"));
+        expect(routes.every((r) => r.type !== "BACKEND_ROUTE")).toBe(true);
+        deleteFakeRepo(repoPath);
+    });
+    // ─── Imperative recognizer (Express/Hono/Elysia share this shape) ────────
+    it("detects Hono routes via app.METHOD(path, handler)", () => {
+        const repoPath = createRepoWithFiles({
+            "src/server/index.ts": `
+        import { Hono } from "hono";
+        import { getUser, createUser } from "./handlers.js";
+        const app = new Hono();
+        app.get("/users/:id", getUser);
+        app.post("/users", createUser);
+      `,
+        });
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("hono"));
+        expect(findRoute(routes, "GET", "/users/:id")?.handlerName).toBe("getUser");
+        expect(findRoute(routes, "POST", "/users")?.handlerName).toBe("createUser");
+        deleteFakeRepo(repoPath);
+    });
+    it("detects Elysia routes via the app.METHOD(path, handler) API", () => {
+        const repoPath = createRepoWithFiles({
+            "src/server/index.ts": `
+        import { Elysia } from "elysia";
+        import { echo } from "./handlers.js";
+        const app = new Elysia();
+        app.get("/", () => "hello");
+        app.post("/echo", echo);
+      `,
+        });
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("elysia"));
+        const root = findRoute(routes, "GET", "/");
+        expect(root).toBeDefined();
+        expect(root?.inlineHandler).toBeDefined(); // self-contained arrow
+        expect(findRoute(routes, "POST", "/echo")?.handlerName).toBe("echo");
+        deleteFakeRepo(repoPath);
+    });
+    it("detects an inline arrow handler on an imperative route (Express)", () => {
+        const repoPath = createRepoWithFiles({
+            "src/server/index.ts": `
+        import express from "express";
+        const app = express();
+        app.get("/ping", (req, res) => res.json({ ok: true }));
+      `,
+        });
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("express"));
+        const route = findRoute(routes, "GET", "/ping");
+        expect(route).toBeDefined();
+        expect(route?.inlineHandler).toBeDefined();
+        expect(route?.handlerName).toBeUndefined();
+        deleteFakeRepo(repoPath);
+    });
+    // ─── Bun.serve fetch-handler (inline switch / if dispatch) ────────────────
+    it("extracts ANY routes from a Bun.serve switch(pathname)", () => {
+        const repoPath = createRepoWithFiles({
+            "src/server/index.ts": `
+        Bun.serve({
+          port: 3000,
+          fetch(req) {
+            const url = new URL(req.url);
+            switch (url.pathname) {
+              case "/api/health": return Response.json({ ok: true });
+              case "/api/users":   return Response.json([]);
+              default: return new Response("not found", { status: 404 });
+            }
+          }
+        });
+      `,
+        });
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("bun"));
+        const health = findRoute(routes, "ANY", "/api/health");
+        const users = findRoute(routes, "ANY", "/api/users");
+        expect(health).toBeDefined();
+        expect(users).toBeDefined();
+        deleteFakeRepo(repoPath);
+    });
+    it("extracts ANY routes from a Bun.serve if-chain on req.url", () => {
+        const repoPath = createRepoWithFiles({
+            "src/server/index.ts": `
+        Bun.serve({
+          fetch: (req) => {
+            if (req.url === "/ping") return new Response("pong");
+            if ("/health" === req.url) return Response.json({ ok: true });
+            return new Response("404", { status: 404 });
+          }
+        });
+      `,
+        });
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("bun"));
+        expect(findRoute(routes, "ANY", "/ping")).toBeDefined();
+        expect(findRoute(routes, "ANY", "/health")).toBeDefined();
+        deleteFakeRepo(repoPath);
+    });
+    it("does NOT misfire on unrelated string equality compares inside fetch", () => {
+        const repoPath = createRepoWithFiles({
+            "src/server/index.ts": `
+        Bun.serve({
+          fetch(req) {
+            const status = process.env.STATUS === "/done" ? "ok" : "bad";
+            if (req.url === "/real") return new Response("hit");
+            return new Response(status, { status: 500 });
+          }
+        });
+      `,
+        });
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("bun"));
+        // Only the url-ish comparison should yield a route; the STATUS === "/done"
+        // compare has a non-url left side, so it must be ignored.
+        const backendRoutes = routes.filter((r) => r.type === "BACKEND_ROUTE" && r.urlPath === "/done");
+        expect(backendRoutes).toHaveLength(0);
+        expect(findRoute(routes, "ANY", "/real")).toBeDefined();
+        deleteFakeRepo(repoPath);
+    });
+    // ─── Regression ────────────────────────────────────────────────────────────
+    it("does not double-emit a route when recognized by multiple shapes", () => {
+        // A route-table entry and an imperative call for the same path+method must
+        // dedup to one node (shared `seen` set across recognizers).
+        const repoPath = createRepoWithFiles({
+            "src/server/index.ts": `
+        import { Hono } from "hono";
+        import { getUser } from "./handlers.js";
+        const app = new Hono();
+        app.get("/users/:id", getUser);
+        // Unrelated route table in the same file — different path, must still emit.
+        const EXTRA = [
+          { method: "GET", pattern: "/users/:id", handler: () => null },
+        ];
+      `,
+        });
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("hono"));
+        const matches = routes.filter((r) => r.type === "BACKEND_ROUTE" && r.httpMethod === "GET" && r.urlPath === "/users/:id");
+        expect(matches).toHaveLength(1);
+        deleteFakeRepo(repoPath);
+    });
+    it("handles a Bun.serve app whose fetch delegates to a named router (OSS index.ts)", () => {
+        // The entry file calls router(req) — no if/switch inside fetch, so the
+        // Bun.serve recognizer must emit ZERO duplicates; routes come from the table.
+        const repoPath = createRepoWithFiles({
+            "src/server/index.ts": `
+        import { router } from "./router.js";
+        Bun.serve({ port: 3000, fetch: async (req) =>-await router(req) });
+      `,
+            "src/server/router.ts": `
+        const ROUTES = [
+          { method: "GET", pattern: "/api/health", handler: () => null },
+        ];
+      `,
+        });
+        const routes = analyzeFilesystem(repoPath, backendFingerprint("bun"));
+        // Only one route, from the route table; fetch delegation emits nothing.
+        expect(routes.filter((r) => r.type === "BACKEND_ROUTE")).toHaveLength(1);
+        expect(findRoute(routes, "GET", "/api/health")).toBeDefined();
+        deleteFakeRepo(repoPath);
+    });
+});

package/dist/fingerprint/detectors.js

@@ -2,7 +2,7 @@ import fs from "fs";
 import path from "path";
 // Framework category arrays — used instead of type casts
 const FRONTEND_FRAMEWORKS = ["nextjs", "react"];
-const BACKEND_FRAMEWORKS = ["express", "fastify", "koa"];
+const BACKEND_FRAMEWORKS = ["express", "fastify", "koa", "hono", "elysia", "bun"];
 export function detectLanguage(repoPath) {
     if (fs.existsSync(path.join(repoPath, "tsconfig.json")))
         return "typescript";
@@ -19,6 +19,12 @@ export function detectFramework(deps) {
         return "fastify";
     if ("koa" in deps)
         return "koa";
+    if ("hono" in deps)
+        return "hono"; // hono is before bun for a reason -> hono may also use @types/bun, but we want to detect hono first or else wit would be detected as bun.
+    if ("elysia" in deps)
+        return "elysia";
+    if ("bun" in deps || "@types/bun" in deps)
+        return "bun"; //Many Bun-only projects don't list a bun package at all since  Bun is the runtime, not a dependency). @types/bun is the most reliable single signal
     return "unknown";
 }
 export function detectRouter(deps, framework, repoPath) {
@@ -95,7 +101,7 @@ export function detectProjectType(framework, deps, repoPath) {
     ];
     const backendDeps = [
         "express", "fastify", "koa",
-        "koa-router", "@fastify/router",
+        "koa-router", "@fastify/router", "hono", "elysia",
     ];
     const databaseDeps = [
         "prisma", "@prisma/client", "drizzle-orm",

package/dist/fingerprint/index.test.js

@@ -40,6 +40,60 @@ describe("analyzeFingerprint", () => {
         expect(fingerprint.framework).toBe("unknown");
         deleteFakeRepo(repoPath);
     });
+    // ─── Bun / Hono / Elysia Detection ───────────────────────────────────────
+    it("should detect a bare Bun project via the bun package", () => {
+        const repoPath = createFakeRepo({ bun: "1.1.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.framework).toBe("bun");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a bare Bun project via @types/bun (no bun package)", () => {
+        // Many Bun-only projects don't list a bun package — @types/bun is the signal.
+        const repoPath = createFakeRepo({ "@types/bun": "1.1.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.framework).toBe("bun");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a Hono project", () => {
+        const repoPath = createFakeRepo({ hono: "4.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.framework).toBe("hono");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect an Elysia project", () => {
+        const repoPath = createFakeRepo({ elysia: "1.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.framework).toBe("elysia");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect Hono over Bun when both deps appear (shadowing)", () => {
+        // Hono apps on Bun often carry @types/bun — must label as hono, not bun,
+        // because their routes are app.METHOD-shaped and label matters downstream.
+        const repoPath = createFakeRepo({ hono: "4.0.0", "@types/bun": "1.1.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.framework).toBe("hono");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect Elysia over Bun when both deps appear (shadowing)", () => {
+        const repoPath = createFakeRepo({ elysia: "1.0.0", "@types/bun": "1.1.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.framework).toBe("elysia");
+        deleteFakeRepo(repoPath);
+    });
+    it("should keep React framing when @types/bun is present alongside react", () => {
+        // Frontend wins over the bare-Bun heuristic — a React app using Bun as a
+        // dev runner must not be mislabelled as a Bun backend.
+        const repoPath = createFakeRepo({ react: "18.0.0", "@types/bun": "1.1.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.framework).toBe("react");
+        deleteFakeRepo(repoPath);
+    });
+    it("should still detect express when present (regression)", () => {
+        const repoPath = createFakeRepo({ express: "4.18.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.framework).toBe("express");
+        deleteFakeRepo(repoPath);
+    });
     // ─── Router Detection ──────────────────────────────────────────────────────
     it("should detect Next.js app router", () => {
         const repoPath = createFakeRepo({ next: "14.0.0" }, ["src/app"]);

package/dist/graph/edges/callEdges.js

@@ -90,8 +90,18 @@ export function detectCallEdges(nodes, lookupMp) {
                 }
             }
             // Skip non-third-party member-access calls (console.log, Math.round, etc.)
-            if (calledName.includes("."))
-                continue;
+            // const rootName = calledName.split(".")[0];
+            // const NOISE_ROOTS = new Set([
+            //     "console", "Math", "Object", "JSON", "Date", "document",
+            //     "Array", "String", "Number", "Boolean", "Promise", "Error",
+            //     "setTimeout", "setInterval", "clearTimeout", "clearInterval",
+            //     "parseInt", "parseFloat", "isNaN", "isFinite",
+            // ]);
+            // if (NOISE_ROOTS.has(rootName)) continue;
+            // // Check if a node exists with the full dotted name
+            // if (!lookupMp.nodesByName.has(calledName)) {
+            //     continue;
+            // }
             // ── Local node lookup ─────────────────────────────────────────
             const targets = lookupMp.nodesByName.get(calledName);
             if (!targets || targets.length === 0)

package/dist/index.d.ts

@@ -9,7 +9,8 @@ export * from "./pipeline/index.js";
 export * from "./config/types.js";
 export { queue } from "./jobs/index.js";
 export { storage } from "./storage/index.js";
-export { resolveConfig, initConfig, maskConfig, writeConfig } from "./config/index.js";
+export { resolveConfig, initConfig, maskConfig, writeConfig, resolveAllProviders, setActiveProvider, removeProvider as removeProviderConfig, } from "./config/index.js";
+export type { AllProvidersResult } from "./config/index.js";
 export { readPackageDependencies, categorizeLibrary } from "./graph/thirdPartyLibs.js";
 export { analyzePipeline } from "./pipeline/index.js";
 export { runSummarization } from "./summarizer/index.js";
@@ -18,3 +19,7 @@ export { EDGE_LABELS } from "./summarizer/prompts.js";
 export { CycleGroup, TopologicalResult } from "./summarizer/types.js";
 export { buildGraphIndex, getBlastRadius, getKHop, getSubgraph, findCycles, } from "./graph/traversal.js";
 export type { GraphIndex, TraversalHit, TraversalResult, TraversalOpts, SubgraphResult, } from "./graph/traversal.js";
+export { loadCatalog, findProvider, saveProvider, removeProvider, resetUserCatalog, listUserProviders, } from "./config/providers/catalog.js";
+export type { CatalogProvider, CatalogProviderInput } from "./config/providers/catalog.js";
+export { listModels } from "./summarizer/providers/models.js";
+export type { ListModelsOpts } from "./summarizer/providers/models.js";

package/dist/index.js

@@ -11,7 +11,7 @@ export * from "./config/types.js";
 export { queue } from "./jobs/index.js";
 export { storage } from "./storage/index.js";
 // Config helpers
-export { resolveConfig, initConfig, maskConfig, writeConfig } from "./config/index.js";
+export { resolveConfig, initConfig, maskConfig, writeConfig, resolveAllProviders, setActiveProvider, removeProvider as removeProviderConfig, } from "./config/index.js";
 // Pre-scan helpers
 export { readPackageDependencies, categorizeLibrary } from "./graph/thirdPartyLibs.js";
 // Pipeline & analysis
@@ -21,3 +21,7 @@ export { computeClusters } from "./clustering/index.js";
 export { EDGE_LABELS } from "./summarizer/prompts.js";
 // Graph traversal & queries (consumed by the MCP server)
 export { buildGraphIndex, getBlastRadius, getKHop, getSubgraph, findCycles, } from "./graph/traversal.js";
+// Provider catalog (consumed by DevLens OSS frontend & CLI)
+export { loadCatalog, findProvider, saveProvider, removeProvider, resetUserCatalog, listUserProviders, } from "./config/providers/catalog.js";
+// Dynamic model discovery (consumed by DevLens OSS CLI)
+export { listModels } from "./summarizer/providers/models.js";

package/dist/parser/extractors/components.js

@@ -2,6 +2,7 @@
 import { SyntaxKind } from "ts-morph";
 import { detectFunctionDirective } from "../directives.js";
 import { extractReturnTypeAnnotation, extractReferencedInterfaces, } from "../typeUtils.js";
+import { JS_BUILTINS } from "./functions.js";
 // Generates a unique id for a node
 function makeId(filePath, name) {
     return `${filePath}::${name}`;
@@ -69,6 +70,8 @@ function extractAllCalls(node) {
             continue; // skip hooks
         if (rootName.startsWith("React"))
             continue;
+        if (JS_BUILTINS.has(rootName))
+            continue;
         if (innerFunctionNames.has(rootName))
             continue; // skip calls to inner functions
         // Capture the full expression (e.g. "axios.get" not just "axios") so

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

@@ -1,6 +1,7 @@
 import { SourceFile } from "ts-morph";
 import type { CodeNode } from "../../types.js";
 import { type RenderingBoundary } from "../directives.js";
+export declare const JS_BUILTINS: Set<string>;
 export declare function extractFunctionCalls(node: any): string[];
 export declare function extractHookCalls(node: any): string[];
 export declare function extractApiCalls(node: any): string[];

package/dist/parser/extractors/functions.js

@@ -4,6 +4,14 @@ import { detectFunctionDirective } from "../directives.js";
 import { extractParams, extractReturnTypeAnnotation, extractBareTypeNames, extractReferencedInterfaces, } from "../typeUtils.js";
 // these are used to detect the routes in the Nextjs
 const HTTP_METHOD_EXPORTS = new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
+export const JS_BUILTINS = new Set([
+    "console", "Math", "JSON", "Object", "Date",
+    "Promise", "Error", "Array", "String", "Number", "Boolean", "document",
+    "setTimeout", "setInterval", "clearTimeout", "clearInterval",
+    "parseInt", "parseFloat", "isNaN", "isFinite",
+    "Reflect", "Proxy", "Intl", "BigInt", "Symbol", "Map", "Set",
+    "WeakMap", "WeakSet", "ArrayBuffer", "DataView",
+]);
 function makeId(filePath, name) {
     return `${filePath}::${name}`;
 }
@@ -15,8 +23,9 @@ export function extractFunctionCalls(node) {
         // Skip hooks, they are handled by hooks extractor
         if (name.startsWith("use"))
             continue;
-        // Skip console calls, they are noise
-        if (name.startsWith("console"))
+        // Skip console calls and other noise calls, they are noise
+        const rootName = name.split(".")[0];
+        if (JS_BUILTINS.has(rootName))
             continue;
         names.push(name);
     }

package/dist/parser/extractors/hooks.js

@@ -1,6 +1,7 @@
 import { SyntaxKind } from "ts-morph";
 import { detectFunctionDirective } from "../directives.js";
 import { extractParams, extractBareTypeNames, extractReferencedInterfaces, } from "../typeUtils.js";
+import { extractFunctionCalls } from "./functions.js";
 function makeId(filePath, name) {
     return `${filePath}::${name}`;
 }
@@ -58,6 +59,7 @@ export function extractHooks(file, fileDirective = null) {
         if (!/^use[A-Z]/.test(name))
             continue;
         const dependencies = extractDependencies(fn);
+        const calls = extractFunctionCalls(fn);
         const returnType = extractReturnType(fn);
         const isAsync = fn.isAsync();
         const contextRefs = extractContextRefs(fn);
@@ -75,6 +77,7 @@ export function extractHooks(file, fileDirective = null) {
             rawCode: fn.getText(),
             metadata: {
                 dependencies,
+                calls,
                 contextRefs,
                 returnType,
                 parameters: typedParams,
@@ -98,6 +101,7 @@ export function extractHooks(file, fileDirective = null) {
         if (!isArrow)
             continue;
         const dependencies = extractDependencies(initializer);
+        const calls = extractFunctionCalls(initializer);
         const returnType = extractReturnType(initializer);
         const isAsync = initializer.asKind(SyntaxKind.ArrowFunction)?.isAsync() ?? false;
         const contextRefs = extractContextRefs(initializer);
@@ -115,6 +119,7 @@ export function extractHooks(file, fileDirective = null) {
             rawCode: variable.getText(),
             metadata: {
                 dependencies,
+                calls,
                 contextRefs,
                 returnType,
                 parameters: typedParams,

package/dist/parser/index.test.js

@@ -133,6 +133,46 @@ describe("parseRepo", () => {
         expect(hook?.metadata.isAsync).toBe(true);
         deleteFakeRepo(repoPath);
     });
+    it("should capture non-hook calls in hook metadata.calls", () => {
+        const repoPath = createFakeRepo({
+            "src/useItems.ts": `
+        export const keys = {
+          all: () => ["items"] as const,
+        };
+        export function useItems() {
+          return useQuery({
+            queryKey: keys.all(),
+            queryFn: () => fetch("/api/items"),
+          });
+        }
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const hook = result.nodes.find((n) => n.name === "useItems");
+        expect(hook?.metadata.calls).toBeDefined();
+        expect(hook?.metadata.calls).toContain("keys.all");
+        // fetch is not a hook and not a JS_BUILTIN, so it passes through
+        expect(hook?.metadata.calls).toContain("fetch");
+        deleteFakeRepo(repoPath);
+    });
+    it("should filter JS_BUILTINS calls from hook metadata.calls", () => {
+        const repoPath = createFakeRepo({
+            "src/useLogger.ts": `
+        export function useLogger() {
+          const data = JSON.parse(localStorage.getItem("x") ?? "{}");
+          console.log(data);
+          return data;
+        }
+      `,
+        });
+        const result = parseRepo(repoPath);
+        const hook = result.nodes.find((n) => n.name === "useLogger");
+        expect(hook?.metadata.calls).toBeDefined();
+        // JSON.* and console.* should be filtered as JS_BUILTINS
+        expect(hook?.metadata.calls).not.toContain("JSON.parse");
+        expect(hook?.metadata.calls).not.toContain("console.log");
+        deleteFakeRepo(repoPath);
+    });
     // ─── Function Detection ────────────────────────────────────────────────────
     it("should detect a regular function", () => {
         const repoPath = createFakeRepo({

package/dist/summarizer/providers/anthropic.d.ts

@@ -1,9 +1,10 @@
 import type { LLMClient, LLMRequest, NodeSummaryOutput } from "./types.js";
 export declare class AnthropicClient implements LLMClient {
     readonly provider: "anthropic";
+    readonly providerName?: string;
     readonly model: string;
     private client;
-    constructor(apiKey: string, model: string);
+    constructor(apiKey: string, model: string, baseURL?: string, providerName?: string);
     summarize(request: LLMRequest): Promise<NodeSummaryOutput>;
     validateConnection(): Promise<void>;
 }

package/dist/summarizer/providers/anthropic.js

@@ -33,10 +33,11 @@ function parseResponse(raw) {
     };
 }
 export class AnthropicClient {
-    constructor(apiKey, model) {
+    constructor(apiKey, model, baseURL, providerName) {
         this.provider = "anthropic";
         this.model = model;
-        this.client = new Anthropic({ apiKey });
+        this.providerName = providerName;
+        this.client = new Anthropic({ apiKey, ...(baseURL ? { baseURL } : {}) });
     }
     async summarize(request) {
         const systemMessage = request.messages.find(m => m.role === "system");