devlensio 0.6.0 → 0.6.1

package/dist/filesystem/backendRoutes.d.ts

@@ -1,2 +1,2 @@
-import type { BackendRouteNode } from "../types.js";
-export declare function analyzeBackendRoutes(repoPath: string): BackendRouteNode[];
+import type { BackendRouteNode, Framework } from "../types.js";
+export declare function analyzeBackendRoutes(repoPath: string, framework: Framework): BackendRouteNode[];

package/dist/filesystem/backendRoutes.js

@@ -7,12 +7,15 @@ const HTTP_METHODS = [
 ];
 const APP_INSTANCE_NAMES = [
     "app", "router", "fastify",
-    "server", "api", "koa",
+    "server", "api", "koa", "hono", "elysia",
 ];
 const IGNORE_DIRS = [
     "node_modules", "dist", "build",
     ".next", "coverage", ".git",
 ];
+const METHOD_PROP_NAMES = ["method", "verb"];
+const PATH_PROP_NAMES = ["pattern", "path", "url", "pathname", "route"];
+const HANDLER_PROP_NAMES = ["handler", "handlerFunc", "handlerFn", "action", "callback", "middleware"];
 function extractParams(urlPath) {
     const matches = urlPath.match(/:([a-zA-Z0-9_]+)/g) || [];
     return matches.map((m) => m.replace(":", ""));
@@ -20,23 +23,295 @@ function extractParams(urlPath) {
 function normalizeMethod(method) {
     return method.toUpperCase();
 }
+// ─── Route-table (object-literal) recognizer ─────────────────────────────────
+//
+// Detects routes declared as an array of object literals, e.g.:
+//
+//   const ROUTES: Route[] = [
+//     { method: "GET",  pattern: "/api/health",   handler: () => Response.json(...) },
+//     { method: "GET",  pattern: "/api/pre-scan", handler: (_p, req) => handlePreScan(req) },
+//     { method: "POST", pattern: "/users/:id",   handler: createUser },
+//   ];
+//
+// This is framework-agnostic — it covers hand-rolled routers used by bare
+// Bun.serve apps, plain Node http servers, and any project that doesn't use a
+// router library. The `method`-property requirement is the discriminator that
+// prevents confusing this with React Router config arrays (path + element) or
+// arbitrary config arrays.
+//
+// Handler resolution mirrors the imperative recognizer:
+//   • handler is an Identifier                  → handlerName (resolved later by routeEdge.ts)
+//   • handler is an arrow/function body whose
+//     first bare-name call is a local function  → handlerName (the delegated handler)
+//                                                 e.g. (_p, req) => handlePreScan(req) → "handlePreScan"
+//   • otherwise (self-contained inline)         → inlineHandler (synthetic node created
+//                                                 by routesToCodeNodes in pipeline)
+// Set form for O(1) HTTP-verb checks on the `method` property value.
+const HTTP_METHODS_SET = new Set(HTTP_METHODS);
+// Reads the first matching string-literal property from an object literal.
+// Tries each alias in `propNames` and returns the literal text of the first hit.
+function readStringProperty(obj, propNames) {
+    for (const name of propNames) {
+        const prop = obj.getProperty(name);
+        if (prop && prop.getInitializer) {
+            const v = literalStringValue(prop.getInitializer());
+            if (v !== null)
+                return v;
+        }
+    }
+    return null;
+}
+// True if `obj` is a route-table element — has BOTH a literal `method` that is
+// an HTTP verb AND a literal path-like property starting with "/". This strict
+// gate keeps the recognizer from misfiring on config objects.
+function hasRouteTableShape(obj) {
+    const methodRaw = readStringProperty(obj, METHOD_PROP_NAMES);
+    if (methodRaw === null)
+        return false;
+    if (!HTTP_METHODS_SET.has(methodRaw.toLowerCase()))
+        return false;
+    const pathRaw = readStringProperty(obj, PATH_PROP_NAMES);
+    if (pathRaw === null || !pathRaw.startsWith("/"))
+        return false;
+    return true;
+}
+// From an arrow/function-literal handler, return the name it delegates to
+// (first CallExpression with a bare-Identifier callee), else keep it inline.
+// Skips PropertyAccessExpression callees like Response.json / req.json so we
+// don't grab noise as the handler name.
+function resolveHandlerLiteral(init) {
+    if (!init)
+        return {};
+    const k = init.getKind();
+    // handler: createUser          → resolve by name only
+    if (k === SyntaxKind.Identifier) {
+        return { handlerName: init.getText() };
+    }
+    // handler: (_p, req) => handlePreScan(req)   → "handlePreScan"
+    // handler: () => Response.json({ ... })       → inline (no delegated name)
+    if (k === SyntaxKind.ArrowFunction || k === SyntaxKind.FunctionExpression) {
+        const calls = init.getDescendantsOfKind(SyntaxKind.CallExpression);
+        for (const c of calls) {
+            const callee = c.getExpression();
+            if (callee.getKind() === SyntaxKind.Identifier) {
+                return { handlerName: callee.getText() };
+            }
+        }
+        // No delegation to a named handler → treat as self-contained inline handler.
+        return {
+            inlineHandler: {
+                rawCode: init.getText(),
+                startLine: init.getStartLineNumber(),
+                endLine: init.getEndLineNumber(),
+            },
+        };
+    }
+    return {};
+}
+// Finds array literals shaped like a route table and emits one BackendRouteNode
+// per qualifying element. Gated on the FIRST element having route-table shape so
+// we don't iterate arbitrary object arrays.
+function detectRouteTableRoutes(file, filePath, framework, out, seen) {
+    for (const arr of file.getDescendantsOfKind(SyntaxKind.ArrayLiteralExpression)) {
+        const elements = arr.getElements();
+        if (elements.length === 0)
+            continue;
+        // Gate — first element must be a route-shaped object literal. This skips
+        // React Router children arrays, plain config arrays, etc.
+        if (elements[0].getKind() !== SyntaxKind.ObjectLiteralExpression)
+            continue;
+        if (!hasRouteTableShape(elements[0]))
+            continue;
+        for (const el of elements) {
+            if (el.getKind() !== SyntaxKind.ObjectLiteralExpression)
+                continue;
+            if (!hasRouteTableShape(el))
+                continue;
+            const methodRaw = readStringProperty(el, METHOD_PROP_NAMES);
+            const urlPath = readStringProperty(el, PATH_PROP_NAMES);
+            // Handler (optional — some entries may be middleware-only)
+            let handlerName;
+            let inlineHandler;
+            for (const name of HANDLER_PROP_NAMES) {
+                const prop = el.getProperty(name);
+                if (!prop || !prop.getInitializer)
+                    continue;
+                const res = resolveHandlerLiteral(prop.getInitializer());
+                handlerName = res.handlerName;
+                inlineHandler = res.inlineHandler;
+                if (handlerName || inlineHandler)
+                    break;
+            }
+            // Dedup against the imperative + bun.serve recognizers (disjoint shapes,
+            // but defensive — same route won't be emitted twice).
+            const key = `${filePath}::${normalizeMethod(methodRaw)}::${urlPath}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const params = extractParams(urlPath);
+            out.push({
+                type: "BACKEND_ROUTE",
+                urlPath,
+                filePath,
+                httpMethod: normalizeMethod(methodRaw),
+                handlerName,
+                inlineHandler,
+                framework,
+                isDynamic: params.length > 0,
+                params: params.length > 0 ? params : undefined,
+            });
+        }
+    }
+}
+// ─── Bun.serve fetch-handler recognizer ───────────────────────────────────────
+//
+// For bare `Bun.serve({ fetch(req) { ... } })` apps that dispatch routes inline
+// (if/switch on the URL instead of a route table or app.METHOD), extract route
+// nodes from:
+//   • Binary comparisons:  req.url === '/api/health'   pathname === '/users'
+//   • switch (pathname) { case '/x': ...; case '/y': ... }
+//
+// Method cannot be reliably inferred from a path-only comparison, so emitted
+// routes use httpMethod "ANY". Handler wiring is NOT attempted here — these
+// routes appear as entry-point ROUTE nodes (consistent with routeEdge.ts's
+// documented behavior that an unresolved route node is still a valid graph
+// node, useful for "unconnected entry points" analysis). The valuable
+// handler→route edges for structured routers come from detectRouteTableRoutes
+// and the imperative recognizer above.
+function makeAnyRoute(urlPath, filePath, framework, out, seen) {
+    if (!urlPath.startsWith("/"))
+        return;
+    const key = `${filePath}::ANY::${urlPath}`;
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    const params = extractParams(urlPath);
+    out.push({
+        type: "BACKEND_ROUTE",
+        urlPath,
+        filePath,
+        httpMethod: "ANY",
+        framework,
+        isDynamic: params.length > 0,
+        params: params.length > 0 ? params : undefined,
+    });
+}
+// True if an expression reads something URL-ish (req.url, request.url, url,
+// pathname, req.path, …). Used to validate the non-string side of a `=== '/path'`
+// comparison so we don't pick up unrelated string compares like `status === "/done"`.
+function isUrlReference(node) {
+    if (!node)
+        return false;
+    const k = node.getKind();
+    if (k === SyntaxKind.Identifier) {
+        return ["url", "pathname", "path", "req"].includes(node.getText());
+    }
+    if (k === SyntaxKind.PropertyAccessExpression) {
+        const text = node.getText().toLowerCase();
+        return (text.endsWith(".url") ||
+            text.endsWith(".pathname") ||
+            text.endsWith(".path"));
+    }
+    return false;
+}
+// Extracts route nodes from a Bun.serve() call whose fetch handler dispatches
+// via inline if/switch. Only fires when the config object literal has a `fetch`
+// property whose body is a Block — covers both `fetch(req) { ... }` and
+// `fetch: (req) => { ... }` / `fetch: async (req) => { ... }`.
+function detectBunServeRoutes(file, filePath, framework, out, seen) {
+    for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        if (call.getExpression().getText() !== "Bun.serve")
+            continue;
+        const args = call.getArguments();
+        if (args.length === 0)
+            continue;
+        const cfg = args[0];
+        if (cfg.getKind() !== SyntaxKind.ObjectLiteralExpression)
+            continue;
+        // The `fetch` member can be:
+        //   • a method shorthand:  fetch(req) { ... }   → MethodDeclaration, body IS the block
+        //   • a property assignment: fetch: (req) => { ... } / fetch: async (req) => {...}
+        //     → PropertyAssignment with an ArrowFunction/FunctionExpression initializer
+        // Find the fetch body block across both shapes.
+        const fetchProp = cfg.getProperty("fetch");
+        if (!fetchProp)
+            continue;
+        let fetchBody = null;
+        if (fetchProp.getKind() === SyntaxKind.MethodDeclaration) {
+            // fetch(req) { ... } — the method itself has a body.
+            fetchBody = fetchProp.getBody?.() ?? null;
+        }
+        else if (fetchProp.getInitializer) {
+            // { fetch: <initializer> } — unwrap to the function body.
+            const fetchInit = fetchProp.getInitializer();
+            if (fetchInit) {
+                fetchBody =
+                    fetchInit.getKind() === SyntaxKind.Block
+                        ? fetchInit
+                        : fetchInit.getBody?.();
+            }
+        }
+        if (!fetchBody || !fetchBody.getDescendantsOfKind)
+            continue;
+        // Pattern: `something === '/path'` where one side is a string literal
+        // starting with "/" and the other is a url-ish reference.
+        for (const bin of fetchBody.getDescendantsOfKind(SyntaxKind.BinaryExpression)) {
+            const op = bin.getOperatorToken().getKind();
+            if (op !== SyntaxKind.EqualsEqualsEqualsToken &&
+                op !== SyntaxKind.EqualsEqualsToken)
+                continue;
+            const left = bin.getLeft();
+            const right = bin.getRight();
+            const leftLit = literalStringValue(left);
+            const rightLit = literalStringValue(right);
+            const lit = leftLit ?? rightLit;
+            if (!lit || !lit.startsWith("/"))
+                continue;
+            const otherSide = leftLit !== null ? right : left;
+            if (!isUrlReference(otherSide))
+                continue;
+            makeAnyRoute(lit, filePath, framework, out, seen);
+        }
+        // Pattern: switch (pathname) { case '/x': ...; case '/y': ... }
+        for (const caseClause of fetchBody.getDescendantsOfKind(SyntaxKind.CaseClause)) {
+            const lit = literalStringValue(caseClause.getExpression());
+            if (lit && lit.startsWith("/")) {
+                makeAnyRoute(lit, filePath, framework, out, seen);
+            }
+        }
+    }
+}
+function includesImport(fileContent, mod) {
+    return (fileContent.includes(`from '${mod}'`) ||
+        fileContent.includes(`from "${mod}"`) ||
+        fileContent.includes(`require('${mod}')`) ||
+        fileContent.includes(`require("${mod}")`));
+}
+// Reads a string-literal value from a property initializer (single/double/backtick).                                                                                   
+// Returns null for non-literal (computed) values. 
+function literalStringValue(node) {
+    if (!node)
+        return null;
+    const nodeKind = node.getKind();
+    if (nodeKind === SyntaxKind.StringLiteral || nodeKind === SyntaxKind.NoSubstitutionTemplateLiteral) {
+        return node.getLiteralText();
+    }
+    return null;
+}
 // Detects backend framework from file import statements
 function detectFileFramework(fileContent) {
-    if (fileContent.includes("from 'express'") ||
-        fileContent.includes('from "express"') ||
-        fileContent.includes("require('express')") ||
-        fileContent.includes('require("express")'))
+    if (includesImport(fileContent, "elysia"))
+        return "elysia";
+    if (includesImport(fileContent, "hono"))
+        return "hono";
+    if (includesImport(fileContent, "express"))
         return "express";
-    if (fileContent.includes("from 'fastify'") ||
-        fileContent.includes('from "fastify"') ||
-        fileContent.includes("require('fastify')") ||
-        fileContent.includes('require("fastify")'))
+    if (includesImport(fileContent, "fastify"))
         return "fastify";
-    if (fileContent.includes("from 'koa'") ||
-        fileContent.includes('from "koa"') ||
-        fileContent.includes("require('koa')") ||
-        fileContent.includes('require("koa")'))
+    if (includesImport(fileContent, "koa"))
         return "koa";
+    if (fileContent.includes("Bun.serve(") || includesImport(fileContent, "bun"))
+        return "bun"; // Bun is a runtime, not a framework, so we check for Bun.serve() usage or bun import.
     return null;
 }
 function findBackendFiles(dir, files = []) {
@@ -62,7 +337,7 @@ function findBackendFiles(dir, files = []) {
     }
     return files;
 }
-export function analyzeBackendRoutes(repoPath) {
+export function analyzeBackendRoutes(repoPath, framework) {
     const nodes = [];
     const project = new Project({
         compilerOptions: {
@@ -73,19 +348,37 @@ export function analyzeBackendRoutes(repoPath) {
         skipAddingFilesFromTsConfig: true,
     });
     const files = findBackendFiles(repoPath);
+    const scanFiles = framework === "bun";
+    const fileFrameWorks = new Map();
     // Only add files that actually import a backend framework
     for (const filePath of files) {
         const content = fs.readFileSync(filePath, "utf-8");
-        if (detectFileFramework(content)) {
+        const detectedFramework = detectFileFramework(content);
+        if (detectedFramework) {
+            fileFrameWorks.set(filePath, detectedFramework);
+            project.addSourceFileAtPath(filePath);
+        }
+        else if (scanFiles) {
+            // No framework import, but in bun mode we still scan: route tables are framework-agnostic                                                                         
             project.addSourceFileAtPath(filePath);
         }
     }
+    // Dedup across recognizers (key = filePath::METHOD::path).                             
+    const seen = new Set();
     for (const file of project.getSourceFiles()) {
         const filePath = file.getFilePath();
         const content = fs.readFileSync(filePath, "utf-8");
-        const framework = detectFileFramework(content);
-        if (!framework)
-            continue;
+        // Per-file framework label; fall back to the project framework for files that
+        // had no framework import but were scanned in bun mode (route tables + Bun.serve
+        // dispatch code often import nothing framework-specific).
+        const framework = fileFrameWorks.get(filePath) ?? detectFileFramework(content) ?? "bun";
+        // Route-table (object-literal) recognizer — runs on every scanned file.
+        // Independent of the imperative recognizer below; the two match disjoint
+        // shapes, so a single route is never emitted twice.
+        detectRouteTableRoutes(file, filePath, framework, nodes, seen);
+        // Bun.serve fetch-handler recognizer (inline url comparisons / switch).
+        // Only fires on Bun.serve() calls; no-op on other frameworks.
+        detectBunServeRoutes(file, filePath, framework, nodes, seen);
         const callExpressions = file.getDescendantsOfKind(SyntaxKind.CallExpression);
         for (const call of callExpressions) {
             try {
@@ -140,6 +433,12 @@ export function analyzeBackendRoutes(repoPath) {
                     ;
                 }
                 const params = extractParams(urlPath);
+                // Dedup against the route-table + bun.serve recognizers (disjoint shapes,
+                // but defensive — same route won't be emitted twice across recognizers).
+                const _imperativeKey = `${filePath}::${normalizeMethod(methodName)}::${urlPath}`;
+                if (seen.has(_imperativeKey))
+                    continue;
+                seen.add(_imperativeKey);
                 nodes.push({
                     type: "BACKEND_ROUTE",
                     urlPath,

package/dist/filesystem/index.js

@@ -4,9 +4,13 @@ import { analyzePagesRouter } from "./pagesRouter.js";
 import { analyzeBackendRoutes } from "./backendRoutes.js";
 import { analyzeReactRouterRoutes } from "./reactRouterRoutes.js";
 export function analyzeFilesystem(repoPath, fingerprint) {
-    // Handle backend frameworks first
-    if (["express", "fastify", "koa"].includes(fingerprint.framework)) {
-        return analyzeBackendRoutes(repoPath);
+    // Handle backend frameworks first.
+    // Same list as BACKEND_FRAMEWORKS in fingerprint/detectors.ts — kept inline
+    // to avoid a circular import (detectors imports types, not filesystem).
+    // framework is forwarded so analyzeBackendRoutes can pick a scan strategy
+    // (import-gated for express/fastify/koa/hono/elysia, broad for bare bun).
+    if (["express", "fastify", "koa", "hono", "elysia", "bun"].includes(fingerprint.framework)) {
+        return analyzeBackendRoutes(repoPath, fingerprint.framework);
     }
     // Handle React Router projects (framework: "react", router: "react-router").
     // Routes are defined in code, so this runs before the Next.js gate below.

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/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/types.d.ts

@@ -1,7 +1,7 @@
 export type Language = "javascript" | "typescript" | "python" | "unknown";
-export type Framework = "nextjs" | "react" | "express" | "fastify" | "koa" | "unknown";
+export type Framework = "nextjs" | "react" | "express" | "fastify" | "koa" | "hono" | "elysia" | "bun" | "unknown";
 export type FrontendFramework = "nextjs" | "react";
-export type BackendFramework = "express" | "fastify" | "koa";
+export type BackendFramework = "express" | "fastify" | "koa" | "hono" | "elysia" | "bun";
 export type RouterType = "app" | "pages" | "app+pages" | "react-router" | "none";
 export type ProjectType = "frontend" | "backend" | "fullstack" | "unknown";
 export type StateLibrary = "zustand" | "redux" | "recoil" | "jotai" | "context-only";

package/package.json

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