devlensio 0.2.0

package/dist/filesystem/index.test.js

@@ -0,0 +1,178 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { analyzeFilesystem } from "./index.js";
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function createFakeRepo(structure) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devlens-fs-test-"));
+    for (const filePath of structure) {
+        const fullPath = path.join(tmpDir, filePath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, "// fake file");
+    }
+    return tmpDir;
+}
+function deleteFakeRepo(repoPath) {
+    fs.rmSync(repoPath, { recursive: true, force: true });
+}
+function makeFingerprint(framework, router) {
+    return {
+        language: "typescript",
+        projectType: "frontend",
+        framework,
+        router,
+        stateManagement: ["context-only"],
+        dataFetching: ["fetch"],
+        databases: [],
+        rawDependencies: {},
+    };
+}
+// ─── Tests ────────────────────────────────────────────────────────────────────
+describe("analyzeFilesystem", () => {
+    // ─── Non Next.js projects ─────────────────────────────────────────────────
+    it("should return empty array for plain React projects", () => {
+        const repoPath = createFakeRepo(["src/App.tsx"]);
+        const fingerprint = makeFingerprint("react", "react-router");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        expect(routes).toHaveLength(0);
+        deleteFakeRepo(repoPath);
+    });
+    it("should return empty array for unknown projects", () => {
+        const repoPath = createFakeRepo(["src/index.ts"]);
+        const fingerprint = makeFingerprint("unknown", "none");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        expect(routes).toHaveLength(0);
+        deleteFakeRepo(repoPath);
+    });
+    // ─── App Router ───────────────────────────────────────────────────────────
+    it("should detect root page in app router", () => {
+        const repoPath = createFakeRepo(["src/app/page.tsx"]);
+        const fingerprint = makeFingerprint("nextjs", "app");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const page = routes.find((r) => r.type === "PAGE");
+        expect(page).toBeDefined();
+        expect(page?.urlPath).toBe("/");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect nested page in app router", () => {
+        const repoPath = createFakeRepo(["src/app/dashboard/page.tsx"]);
+        const fingerprint = makeFingerprint("nextjs", "app");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const page = routes.find((r) => r.type === "PAGE");
+        expect(page?.urlPath).toBe("/dashboard");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect dynamic route in app router", () => {
+        const repoPath = createFakeRepo(["src/app/users/[userId]/page.tsx"]);
+        const fingerprint = makeFingerprint("nextjs", "app");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const page = routes.find((r) => r.type === "PAGE");
+        expect(page?.isDynamic).toBe(true);
+        expect(page?.params).toContain("userId");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect catch all route in app router", () => {
+        const repoPath = createFakeRepo(["src/app/docs/[...slug]/page.tsx"]);
+        const fingerprint = makeFingerprint("nextjs", "app");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const page = routes.find((r) => r.type === "PAGE");
+        expect(page?.isCatchAll).toBe(true);
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect route group and ignore it in url", () => {
+        const repoPath = createFakeRepo(["src/app/(auth)/login/page.tsx"]);
+        const fingerprint = makeFingerprint("nextjs", "app");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const page = routes.find((r) => r.type === "PAGE");
+        expect(page?.urlPath).toBe("/login");
+        expect(page?.isGroupRoute).toBe(true);
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect layout in app router", () => {
+        const repoPath = createFakeRepo(["src/app/layout.tsx", "src/app/page.tsx"]);
+        const fingerprint = makeFingerprint("nextjs", "app");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const layout = routes.find((r) => r.type === "LAYOUT");
+        expect(layout).toBeDefined();
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect api route in app router", () => {
+        const repoPath = createFakeRepo(["src/app/api/users/route.ts"]);
+        const fingerprint = makeFingerprint("nextjs", "app");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const api = routes.find((r) => r.type === "API_ROUTE");
+        expect(api).toBeDefined();
+        expect(api?.urlPath).toBe("/api/users");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect middleware in app router project", () => {
+        const repoPath = createFakeRepo([
+            "src/app/page.tsx",
+            "middleware.ts",
+        ]);
+        const fingerprint = makeFingerprint("nextjs", "app");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const middleware = routes.find((r) => r.type === "MIDDLEWARE");
+        expect(middleware).toBeDefined();
+        expect(middleware?.isCatchAll).toBe(true);
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect layout path for a page", () => {
+        const repoPath = createFakeRepo([
+            "src/app/dashboard/layout.tsx",
+            "src/app/dashboard/page.tsx",
+        ]);
+        const fingerprint = makeFingerprint("nextjs", "app");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const page = routes.find((r) => r.type === "PAGE");
+        expect(page?.layoutPath).toBeDefined();
+        deleteFakeRepo(repoPath);
+    });
+    // ─── Pages Router ─────────────────────────────────────────────────────────
+    it("should detect root page in pages router", () => {
+        const repoPath = createFakeRepo(["src/pages/index.tsx"]);
+        const fingerprint = makeFingerprint("nextjs", "pages");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const page = routes.find((r) => r.type === "PAGE");
+        expect(page?.urlPath).toBe("/");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect nested page in pages router", () => {
+        const repoPath = createFakeRepo(["src/pages/dashboard/index.tsx"]);
+        const fingerprint = makeFingerprint("nextjs", "pages");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const page = routes.find((r) => r.type === "PAGE");
+        expect(page?.urlPath).toBe("/dashboard");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect dynamic route in pages router", () => {
+        const repoPath = createFakeRepo(["src/pages/users/[userId].tsx"]);
+        const fingerprint = makeFingerprint("nextjs", "pages");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const page = routes.find((r) => r.type === "PAGE");
+        expect(page?.isDynamic).toBe(true);
+        expect(page?.params).toContain("userId");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect api route in pages router", () => {
+        const repoPath = createFakeRepo(["src/pages/api/users.ts"]);
+        const fingerprint = makeFingerprint("nextjs", "pages");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        const api = routes.find((r) => r.type === "API_ROUTE");
+        expect(api).toBeDefined();
+        expect(api?.urlPath).toBe("/api/users");
+        deleteFakeRepo(repoPath);
+    });
+    it("should skip special files in pages router", () => {
+        const repoPath = createFakeRepo([
+            "src/pages/_app.tsx",
+            "src/pages/_document.tsx",
+            "src/pages/index.tsx",
+        ]);
+        const fingerprint = makeFingerprint("nextjs", "pages");
+        const routes = analyzeFilesystem(repoPath, fingerprint);
+        // Only index.tsx should be detected, not _app or _document
+        expect(routes).toHaveLength(1);
+        deleteFakeRepo(repoPath);
+    });
+});

package/dist/filesystem/pagesRouter.d.ts

@@ -0,0 +1,2 @@
+import type { RouteNode } from "../types.js";
+export declare function analyzePagesRouter(repoPath: string): RouteNode[];

package/dist/filesystem/pagesRouter.js

@@ -0,0 +1,109 @@
+import fs from "fs";
+import path from "path";
+// Converts a filesystem path to a URL path
+// e.g. users/[userId]/posts → /users/:userId/posts
+function toUrlPath(relativePath) {
+    if (relativePath === "index")
+        return "/";
+    return ("/" +
+        relativePath
+            .split(path.sep)
+            .map((segment) => {
+            // Remove file extension from last segment
+            segment = segment.replace(/\.(tsx|ts|jsx|js)$/, "");
+            if (segment === "index")
+                return null;
+            if (segment.startsWith("[...") && segment.endsWith("]")) {
+                const param = segment.slice(4, -1);
+                return `:${param}*`;
+            }
+            if (segment.startsWith("[") && segment.endsWith("]")) {
+                const param = segment.slice(1, -1);
+                return `:${param}`;
+            }
+            return segment;
+        })
+            .filter(Boolean)
+            .join("/"));
+}
+// Extracts param names from a url path
+function extractParams(urlPath) {
+    const matches = urlPath.match(/:([a-zA-Z]+)\*?/g) || [];
+    return matches.map((m) => m.replace(":", "").replace("*", ""));
+}
+// Checks if a file is a valid page file
+function isPageFile(fileName) {
+    return /\.(tsx|ts|jsx|js)$/.test(fileName);
+}
+// Checks if a file is a special Next.js file to skip
+function isSpecialFile(fileName) {
+    const special = ["_app", "_document", "_error", "_middleware"];
+    const nameWithoutExt = fileName.replace(/\.(tsx|ts|jsx|js)$/, "");
+    return special.includes(nameWithoutExt);
+}
+// Determines node type based on file location
+function getRouteNodeType(relativePath, fileName) {
+    const nameWithoutExt = fileName.replace(/\.(tsx|ts|jsx|js)$/, "");
+    // Files inside pages/api are API routes
+    if (relativePath.startsWith("api" + path.sep) || relativePath === "api") {
+        return "API_ROUTE";
+    }
+    if (nameWithoutExt === "404")
+        return "NOT_FOUND";
+    return "PAGE";
+}
+function walkPagesDir(currentDir, pagesDir, nodes) {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            walkPagesDir(fullPath, pagesDir, nodes);
+            continue;
+        }
+        // Skip non page files
+        if (!isPageFile(entry.name))
+            continue;
+        // Skip special Next.js files like _app.tsx, _document.tsx
+        if (isSpecialFile(entry.name))
+            continue;
+        const relativePath = path.relative(pagesDir, fullPath);
+        const nodeType = getRouteNodeType(path.relative(pagesDir, currentDir), entry.name);
+        const urlPath = toUrlPath(relativePath);
+        const params = extractParams(urlPath);
+        nodes.push({
+            type: nodeType,
+            urlPath,
+            filePath: fullPath,
+            isDynamic: params.length > 0,
+            isCatchAll: urlPath.includes("*"),
+            isGroupRoute: false, // pages router has no route groups
+            params: params.length > 0 ? params : undefined,
+        });
+    }
+}
+export function analyzePagesRouter(repoPath) {
+    let pagesDir = path.join(repoPath, "src/pages");
+    if (!fs.existsSync(pagesDir)) {
+        pagesDir = path.join(repoPath, "pages");
+    }
+    if (!fs.existsSync(pagesDir)) {
+        throw new Error(`No pages directory found at: ${pagesDir}`);
+    }
+    const nodes = [];
+    // Check for middleware at root level
+    const middlewarePath = ["middleware.ts", "middleware.js"]
+        .map((f) => path.join(repoPath, f))
+        .find((f) => fs.existsSync(f));
+    if (middlewarePath) {
+        nodes.push({
+            type: "MIDDLEWARE",
+            urlPath: "*",
+            filePath: middlewarePath,
+            isDynamic: false,
+            isCatchAll: true,
+            isGroupRoute: false,
+        });
+    }
+    walkPagesDir(pagesDir, pagesDir, nodes);
+    return nodes;
+}

package/dist/fingerprint/detectors.d.ts

@@ -0,0 +1,8 @@
+import type { Language, Framework, RouterType, StateLibrary, DataFetchingLibrary, DatabaseLibrary, ProjectType } from "../types.js";
+export declare function detectLanguage(repoPath: string): Language;
+export declare function detectFramework(deps: Record<string, string>): Framework;
+export declare function detectRouter(deps: Record<string, string>, framework: Framework, repoPath: string): RouterType;
+export declare function detectStateManagement(deps: Record<string, string>): StateLibrary[];
+export declare function detectDataFetching(deps: Record<string, string>): DataFetchingLibrary[];
+export declare function detectDatabases(deps: Record<string, string>): DatabaseLibrary[];
+export declare function detectProjectType(framework: Framework, deps: Record<string, string>, repoPath: string): ProjectType;

package/dist/fingerprint/detectors.js

@@ -0,0 +1,174 @@
+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"];
+export function detectLanguage(repoPath) {
+    if (fs.existsSync(path.join(repoPath, "tsconfig.json")))
+        return "typescript";
+    return "javascript";
+}
+export function detectFramework(deps) {
+    if ("next" in deps)
+        return "nextjs";
+    if ("react" in deps)
+        return "react";
+    if ("express" in deps)
+        return "express";
+    if ("fastify" in deps)
+        return "fastify";
+    if ("koa" in deps)
+        return "koa";
+    return "unknown";
+}
+export function detectRouter(deps, framework, repoPath) {
+    // Router detection only applies to Next.js and React
+    // Backend frameworks handle routing via code not filesystem
+    if (framework === "nextjs") {
+        const hasAppDir = fs.existsSync(path.join(repoPath, "src/app")) || fs.existsSync(path.join(repoPath, "app"));
+        const hasPagesDir = fs.existsSync(path.join(repoPath, "src/pages")) || fs.existsSync(path.join(repoPath, "pages"));
+        if (hasAppDir && hasPagesDir)
+            return "app+pages";
+        if (hasAppDir)
+            return "app";
+        if (hasPagesDir)
+            return "pages";
+    }
+    if (framework === "react") {
+        if ("react-router-dom" in deps)
+            return "react-router";
+    }
+    return "none";
+}
+export function detectStateManagement(deps) {
+    const found = [];
+    if ("zustand" in deps)
+        found.push("zustand");
+    if ("redux" in deps || "@reduxjs/toolkit" in deps)
+        found.push("redux");
+    if ("recoil" in deps)
+        found.push("recoil");
+    if ("jotai" in deps)
+        found.push("jotai");
+    if (found.length === 0)
+        found.push("context-only");
+    return found;
+}
+export function detectDataFetching(deps) {
+    const found = [];
+    if ("@tanstack/react-query" in deps || "react-query" in deps)
+        found.push("react-query");
+    if ("swr" in deps)
+        found.push("swr");
+    if ("axios" in deps)
+        found.push("axios");
+    if (found.length === 0)
+        found.push("fetch");
+    return found;
+}
+export function detectDatabases(deps) {
+    const found = [];
+    if ("prisma" in deps || "@prisma/client" in deps)
+        found.push("prisma");
+    if ("drizzle-orm" in deps)
+        found.push("drizzle");
+    if ("mongoose" in deps || "mongodb" in deps)
+        found.push("mongodb");
+    if ("firebase" in deps || "firebase-admin" in deps)
+        found.push("firebase");
+    if ("@supabase/supabase-js" in deps)
+        found.push("supabase");
+    if ("@planetscale/database" in deps)
+        found.push("planetscale");
+    if ("pg" in deps || "postgres" in deps)
+        found.push("postgres");
+    if ("mysql2" in deps)
+        found.push("mysql");
+    if ("better-sqlite3" in deps)
+        found.push("sqlite");
+    return found;
+}
+export function detectProjectType(framework, deps, repoPath) {
+    const frontendDeps = [
+        "next", "react", "react-dom",
+        "@tanstack/react-query", "swr",
+    ];
+    const backendDeps = [
+        "express", "fastify", "koa",
+        "koa-router", "@fastify/router",
+    ];
+    const databaseDeps = [
+        "prisma", "@prisma/client", "drizzle-orm",
+        "mongoose", "mongodb", "pg", "mysql2",
+        "better-sqlite3", "firebase", "@supabase/supabase-js",
+    ];
+    const hasFrontendDeps = Object.keys(deps).some((d) => frontendDeps.includes(d));
+    const hasBackendDeps = Object.keys(deps).some((d) => backendDeps.includes(d));
+    const hasDatabaseDeps = Object.keys(deps).some((d) => databaseDeps.includes(d));
+    // Check directory structures
+    const hasFrontendStructure = fs.existsSync(path.join(repoPath, "src", "app")) ||
+        fs.existsSync(path.join(repoPath, "src", "pages")) ||
+        (fs.existsSync(path.join(repoPath, "src")) &&
+            fs.existsSync(path.join(repoPath, "src", "components")));
+    const hasBackendStructure = fs.existsSync(path.join(repoPath, "routes")) ||
+        fs.existsSync(path.join(repoPath, "server")) ||
+        fs.existsSync(path.join(repoPath, "controllers")) ||
+        fs.existsSync(path.join(repoPath, "services")) ||
+        fs.existsSync(path.join(repoPath, "middleware"));
+    fs.existsSync(path.join(repoPath, "src/routes")) ||
+        fs.existsSync(path.join(repoPath, "src/server")) ||
+        fs.existsSync(path.join(repoPath, "src/controllers")) ||
+        fs.existsSync(path.join(repoPath, "src/services")) ||
+        fs.existsSync(path.join(repoPath, "src/middleware"));
+    // Framework-based detection first — most reliable signal
+    if (FRONTEND_FRAMEWORKS.includes(framework)) {
+        if (framework === "nextjs") {
+            const hasApiRoutes = fs.existsSync(path.join(repoPath, "app", "api")) ||
+                fs.existsSync(path.join(repoPath, "pages", "api"));
+            if (hasApiRoutes || hasBackendDeps || hasDatabaseDeps) {
+                return "fullstack";
+            }
+            return "frontend";
+        }
+        // Plain React
+        if (hasBackendDeps || hasDatabaseDeps || hasBackendStructure) {
+            return "fullstack";
+        }
+        return "frontend";
+    }
+    if (BACKEND_FRAMEWORKS.includes(framework)) {
+        if (hasFrontendDeps || hasFrontendStructure) {
+            return "fullstack";
+        }
+        return "backend";
+    }
+    // Framework unknown — score based on signals
+    if (framework === "unknown") {
+        let frontendScore = 0;
+        let backendScore = 0;
+        if (hasFrontendDeps)
+            frontendScore += 2;
+        if (hasFrontendStructure)
+            frontendScore += 2;
+        if (fs.existsSync(path.join(repoPath, "public")))
+            frontendScore += 1;
+        if (fs.existsSync(path.join(repoPath, "index.html")))
+            frontendScore += 1;
+        if (hasBackendDeps)
+            backendScore += 2;
+        if (hasDatabaseDeps)
+            backendScore += 2;
+        if (hasBackendStructure)
+            backendScore += 2;
+        if (fs.existsSync(path.join(repoPath, "server.ts")) ||
+            fs.existsSync(path.join(repoPath, "server.js")))
+            backendScore += 1;
+        if (frontendScore > 0 && backendScore > 0)
+            return "fullstack";
+        if (frontendScore > backendScore)
+            return "frontend";
+        if (backendScore > frontendScore)
+            return "backend";
+    }
+    return "unknown";
+}

package/dist/fingerprint/index.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectFingerprint } from "../types.js";
+export declare function analyzeFingerprint(repoPath: string): ProjectFingerprint;

package/dist/fingerprint/index.js

@@ -0,0 +1,41 @@
+import fs from "fs";
+import path from "path";
+import { detectLanguage, detectFramework, detectRouter, detectStateManagement, detectDataFetching, detectDatabases, detectProjectType, } from "./detectors.js";
+export function analyzeFingerprint(repoPath) {
+    if (!fs.existsSync(repoPath)) {
+        throw new Error(`Repo path does not exist: ${repoPath}`);
+    }
+    const packageJsonPath = path.join(repoPath, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        throw new Error(`No package.json found at: ${packageJsonPath}`);
+    }
+    const raw = fs.readFileSync(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(raw);
+    const deps = {
+        ...(packageJson.dependencies || {}),
+        ...(packageJson.devDependencies || {}),
+    };
+    const language = detectLanguage(repoPath);
+    const framework = detectFramework(deps);
+    const router = detectRouter(deps, framework, repoPath);
+    const projectType = detectProjectType(framework, deps, repoPath);
+    const databases = detectDatabases(deps);
+    // Backend projects have no React state or frontend data fetching
+    const isFrontendRelevant = projectType === "frontend" || projectType === "fullstack";
+    const stateManagement = isFrontendRelevant
+        ? detectStateManagement(deps)
+        : [];
+    const dataFetching = isFrontendRelevant
+        ? detectDataFetching(deps)
+        : [];
+    return {
+        language,
+        projectType,
+        framework,
+        router,
+        stateManagement,
+        dataFetching,
+        databases,
+        rawDependencies: deps,
+    };
+}

package/dist/fingerprint/index.test.d.ts

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

package/dist/fingerprint/index.test.js

@@ -0,0 +1,148 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { analyzeFingerprint } from "./index.js";
+function createFakeRepo(deps, extraFiles = []) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devlens-test-"));
+    const packageJson = {
+        name: "test-project",
+        version: "1.0.0",
+        dependencies: deps,
+    };
+    fs.writeFileSync(path.join(tmpDir, "package.json"), JSON.stringify(packageJson));
+    // Create any extra files/folders the test needs
+    for (const file of extraFiles) {
+        const fullPath = path.join(tmpDir, file);
+        fs.mkdirSync(fullPath, { recursive: true });
+    }
+    return tmpDir;
+}
+function deleteFakeRepo(repoPath) {
+    fs.rmSync(repoPath, { recursive: true, force: true });
+}
+describe("analyzeFingerprint", () => {
+    // ─── Framework Detection ───────────────────────────────────────────────────
+    it("should detect a Next.js project", () => {
+        const repoPath = createFakeRepo({ next: "14.0.0", react: "18.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.framework).toBe("nextjs");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect a plain React project", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.framework).toBe("react");
+        deleteFakeRepo(repoPath);
+    });
+    it("should return unknown for unrecognized project", () => {
+        const repoPath = createFakeRepo({ lodash: "4.17.21" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.framework).toBe("unknown");
+        deleteFakeRepo(repoPath);
+    });
+    // ─── Router Detection ──────────────────────────────────────────────────────
+    it("should detect Next.js app router", () => {
+        const repoPath = createFakeRepo({ next: "14.0.0" }, ["src/app"]);
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.router).toBe("app");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect Next.js pages router", () => {
+        const repoPath = createFakeRepo({ next: "14.0.0" }, ["src/pages"]);
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.router).toBe("pages");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect React Router in plain React project", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0", "react-router-dom": "6.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.router).toBe("react-router");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect both routers during migration", () => {
+        const repoPath = createFakeRepo({ next: "14.0.0" }, ["src/app", "src/pages"]);
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.router).toBe("app+pages");
+        deleteFakeRepo(repoPath);
+    });
+    // ─── State Management Detection ───────────────────────────────────────────
+    it("should detect zustand", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0", zustand: "4.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.stateManagement).toContain("zustand");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect redux", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0", "@reduxjs/toolkit": "2.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.stateManagement).toContain("redux");
+        deleteFakeRepo(repoPath);
+    });
+    it("should fall back to context-only when no state library found", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.stateManagement).toContain("context-only");
+        deleteFakeRepo(repoPath);
+    });
+    // ─── Data Fetching Detection ───────────────────────────────────────────────
+    it("should detect axios", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0", axios: "1.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.dataFetching).toContain("axios");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect react-query", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0", "@tanstack/react-query": "5.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.dataFetching).toContain("react-query");
+        deleteFakeRepo(repoPath);
+    });
+    it("should fall back to fetch when no data fetching library found", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.dataFetching).toContain("fetch");
+        deleteFakeRepo(repoPath);
+    });
+    // ─── Database Detection ────────────────────────────────────────────────────
+    it("should detect prisma", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0", prisma: "5.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.databases).toContain("prisma");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect supabase", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0", "@supabase/supabase-js": "2.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.databases).toContain("supabase");
+        deleteFakeRepo(repoPath);
+    });
+    it("should return empty array when no database found", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.databases).toHaveLength(0);
+        deleteFakeRepo(repoPath);
+    });
+    // ─── Language Detection ────────────────────────────────────────────────────
+    it("should detect typescript when tsconfig.json exists", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0" });
+        fs.writeFileSync(path.join(repoPath, "tsconfig.json"), "{}");
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.language).toBe("typescript");
+        deleteFakeRepo(repoPath);
+    });
+    it("should detect javascript when no tsconfig.json exists", () => {
+        const repoPath = createFakeRepo({ react: "18.0.0" });
+        const fingerprint = analyzeFingerprint(repoPath);
+        expect(fingerprint.language).toBe("javascript");
+        deleteFakeRepo(repoPath);
+    });
+    // ─── Error Handling ────────────────────────────────────────────────────────
+    it("should throw if repo path does not exist", () => {
+        expect(() => analyzeFingerprint("/fake/path/that/does/not/exist")).toThrow();
+    });
+    it("should throw if no package.json found", () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devlens-test-"));
+        expect(() => analyzeFingerprint(tmpDir)).toThrow();
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+});