codesight 1.0.1 → 1.1.1

package/README.md

@@ -2,7 +2,7 @@
 
 ### Your AI assistant wastes thousands of tokens every conversation just figuring out your project. codesight fixes that in one command.
 
-**Zero dependencies. 11 framework detectors. 4 ORM parsers. MCP server. One `npx` call.**
+**Zero dependencies. 25+ framework detectors. 4 ORM parsers. MCP server. One `npx` call.**
 
 [![npm version](https://img.shields.io/npm/v/codesight?style=for-the-badge&logo=npm&color=CB3837)](https://www.npmjs.com/package/codesight)
 [![npm downloads](https://img.shields.io/npm/dm/codesight?style=for-the-badge&logo=npm&color=blue&label=Monthly%20Downloads)](https://www.npmjs.com/package/codesight)
@@ -26,9 +26,13 @@
 ---
 
 ```
-0 dependencies · Node.js >= 18 · MIT
+0 dependencies · Node.js >= 18 · 27 tests · MIT
 ```
 
+## Works With
+
+**Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Windsurf, Cline, Aider**, and anything that reads markdown.
+
 ## Install
 
 ```bash
@@ -41,6 +45,7 @@ That's it. Run it in any project root. No config, no setup, no API keys.
 npx codesight --init       # Also generate CLAUDE.md, .cursorrules, codex.md, AGENTS.md
 npx codesight --open       # Also open interactive HTML report in browser
 npx codesight --mcp        # Start as MCP server for Claude Code / Cursor
+npx codesight --benchmark  # Show detailed token savings breakdown
 ```
 
 ## What It Does
@@ -55,8 +60,6 @@ Exploration cost: ~52,000 tokens (without codesight)
 Saved:            ~48,800 tokens per conversation
 ```
 
-Works with **Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Windsurf, Cline**, and anything that reads markdown.
-
 ## What It Generates
 
 ```
@@ -74,13 +77,14 @@ Works with **Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Windsurf, Cline*
 
 ## Routes
 
-Not just paths. Methods, URL parameters, what each route touches (auth, database, cache, payments, AI, email, queues), and where the handler lives. Detects routes across 11 frameworks automatically.
+Not just paths. Methods, URL parameters, what each route touches (auth, database, cache, payments, AI, email, queues), and where the handler lives. Detects routes across 25+ frameworks automatically.
 
 ```markdown
 - `POST` `/auth/login` [auth, db, email]
 - `GET` `/api/projects/:id/analytics` params(id) [auth, db, cache]
 - `POST` `/api/billing/checkout` [auth, db, payment]
-- `POST` `/api/webhooks/stripe` [payment]
+- `QUERY` `getUsers` [db]             # tRPC procedures
+- `MUTATION` `createProject` [db, ai]  # tRPC mutations
 ```
 
 ## Schema
@@ -123,18 +127,44 @@ Every env var across your codebase, flagged as required or has default, with the
 - `PORT` (has default) — apps/api/src/index.ts
 ```
 
+## Token Benchmark
+
+See exactly where your token savings come from:
+
+```bash
+npx codesight --benchmark
+```
+
+```
+  Token Savings Breakdown:
+  ┌──────────────────────────────────────────────────┐
+  │ What codesight found         │ Exploration cost   │
+  ├──────────────────────────────┼────────────────────┤
+  │  65 routes                   │ ~26,000 tokens     │
+  │  18 schema models            │ ~ 5,400 tokens     │
+  │  16 components               │ ~ 4,000 tokens     │
+  │  36 library files            │ ~ 7,200 tokens     │
+  │  22 env vars                 │ ~ 2,200 tokens     │
+  │  92 files (search overhead)  │ ~ 4,000 tokens     │
+  ├──────────────────────────────┼────────────────────┤
+  │ codesight output             │ ~ 4,041 tokens     │
+  │ SAVED PER CONVERSATION       │ ~64,599 tokens     │
+  └──────────────────────────────┴────────────────────┘
+```
+
 ## Supported Stacks
 
 | Category | Supported |
 |---|---|
-| **Routes** | Hono, Express, Fastify, Next.js (App + Pages), Koa, FastAPI, Flask, Django, Go (net/http, Gin, Fiber) |
-| **Schema** | Drizzle, Prisma, TypeORM, SQLAlchemy |
+| **Routes** | Hono, Express, Fastify, Next.js (App + Pages), Koa, NestJS, tRPC, Elysia, AdonisJS, SvelteKit, Remix, Nuxt, FastAPI, Flask, Django, Go (net/http, Gin, Fiber, Echo, Chi), Rails, Phoenix, Spring Boot, Actix, Axum, raw http.createServer |
+| **Schema** | Drizzle, Prisma, TypeORM, Mongoose, Sequelize, SQLAlchemy, ActiveRecord, Ecto |
 | **Components** | React, Vue, Svelte (auto-filters shadcn/ui and Radix primitives) |
-| **Libraries** | TypeScript, JavaScript, Python, Go (exports with function signatures) |
+| **Libraries** | TypeScript, JavaScript, Python, Go, Ruby, Elixir, Java, Kotlin, Rust (exports with function signatures) |
 | **Middleware** | Auth, rate limiting, CORS, validation, logging, error handlers |
 | **Dependencies** | Import graph with hot file detection (most imported = highest blast radius) |
 | **Contracts** | URL params, request types, response types from route handlers |
 | **Monorepos** | pnpm, npm, yarn workspaces (cross-workspace detection) |
+| **Languages** | TypeScript, JavaScript, Python, Go, Ruby, Elixir, Java, Kotlin, Rust, PHP |
 
 ## AI Config Generation
 
@@ -183,6 +213,28 @@ npx codesight --open
 
 Opens an interactive HTML dashboard in your browser. Routes table with method badges and tags. Schema cards with fields and relations. Dependency hot files with impact bars. Env var audit. Token savings breakdown. Useful for onboarding or just seeing your project from above.
 
+## GitHub Action
+
+Add to your CI pipeline to keep context fresh on every push:
+
+```yaml
+name: codesight
+on: [push]
+jobs:
+  scan:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm install -g codesight && codesight
+      - uses: actions/upload-artifact@v4
+        with:
+          name: codesight
+          path: .codesight/
+```
+
 ## Watch Mode and Git Hook
 
 **Watch mode** re-scans when files change:
@@ -210,11 +262,27 @@ npx codesight --html                # Generate HTML report without opening
 npx codesight --mcp                 # Start MCP server
 npx codesight --watch               # Watch mode
 npx codesight --hook                # Install git pre-commit hook
+npx codesight --benchmark           # Detailed token savings breakdown
 npx codesight --json                # Output as JSON
 npx codesight -o .ai-context        # Custom output directory
 npx codesight -d 5                  # Limit directory depth
 ```
 
+## How It Compares
+
+Most AI context tools dump your entire codebase into one file. codesight takes a different approach: it **parses** your code to extract structured information.
+
+| | codesight | File concatenation tools |
+|---|---|---|
+| **Output** | Structured routes, schema, components, deps | Raw file contents |
+| **Token cost** | ~3,000-5,000 tokens | 50,000-500,000+ tokens |
+| **Route detection** | 25+ frameworks auto-detected | None |
+| **Schema parsing** | ORM-aware with relations | None |
+| **Dependency graph** | Hot file detection | None |
+| **AI config generation** | CLAUDE.md, .cursorrules, etc. | None |
+| **MCP server** | Built-in | Varies |
+| **Dependencies** | Zero | Varies |
+
 ## Contributing
 
 ```bash
@@ -223,6 +291,7 @@ cd codesight
 pnpm install
 pnpm dev              # Run locally
 pnpm build            # Compile TypeScript
+pnpm test             # Run 27 tests
 ```
 
 PRs welcome. Open an issue first for large changes.

package/dist/detectors/contracts.js

@@ -36,9 +36,16 @@ export async function enrichRouteContracts(routes, project) {
             case "express":
             case "fastify":
             case "koa":
+            case "nestjs":
+            case "elysia":
+            case "adonis":
+            case "raw-http":
                 enrichTSRoute(route, content);
                 break;
             case "next-app":
+            case "sveltekit":
+            case "remix":
+            case "nuxt":
                 enrichNextRoute(route, content);
                 break;
             case "fastapi":

package/dist/detectors/graph.js

@@ -3,7 +3,15 @@ import { readFileSafe } from "../scanner.js";
 export async function detectDependencyGraph(files, project) {
     const edges = [];
     const importCount = new Map();
-    const codeFiles = files.filter((f) => f.match(/\.(ts|tsx|js|jsx|mjs|py|go)$/));
+    const codeFiles = files.filter((f) => f.match(/\.(ts|tsx|js|jsx|mjs|py|go|rb|ex|exs|java|kt|rs|php)$/));
+    // Build a lookup map for faster resolution: relative path -> true
+    const relPathSet = new Set();
+    const relPaths = [];
+    for (const file of files) {
+        const rel = relative(project.root, file);
+        relPathSet.add(rel);
+        relPaths.push(rel);
+    }
     for (const file of codeFiles) {
         const content = await readFileSafe(file);
         if (!content)
@@ -16,8 +24,20 @@ export async function detectDependencyGraph(files, project) {
         else if (ext === ".go") {
             extractGoImports(content, rel, edges, importCount);
         }
+        else if (ext === ".rb") {
+            extractRubyImports(content, rel, edges, importCount);
+        }
+        else if (ext === ".ex" || ext === ".exs") {
+            extractElixirImports(content, rel, edges, importCount);
+        }
+        else if (ext === ".java" || ext === ".kt") {
+            extractJavaImports(content, rel, edges, importCount, relPaths);
+        }
+        else if (ext === ".rs") {
+            extractRustImports(content, rel, edges, importCount);
+        }
         else {
-            extractTSImports(content, rel, file, project, files, edges, importCount);
+            extractTSImports(content, rel, file, project, relPathSet, edges, importCount);
         }
     }
     // Sort by most imported
@@ -27,7 +47,7 @@ export async function detectDependencyGraph(files, project) {
         .slice(0, 20);
     return { edges, hotFiles };
 }
-function extractTSImports(content, rel, absPath, project, allFiles, edges, importCount) {
+function extractTSImports(content, rel, absPath, project, relPathSet, edges, importCount) {
     // Match: import ... from "./path" or import("./path") or require("./path")
     const patterns = [
         /(?:import|export)\s+.*?from\s+['"]([^'"]+)['"]/g,
@@ -50,8 +70,10 @@ function extractTSImports(content, rel, absPath, project, allFiles, edges, impor
                 const dir = dirname(absPath);
                 resolvedPath = relative(project.root, resolve(dir, importPath));
             }
-            // Strip extension and try to find the actual file
-            const normalized = normalizeImportPath(resolvedPath, allFiles, project.root);
+            // Strip .js/.mjs extension that TypeScript adds for ESM compatibility
+            // e.g., import { foo } from "./bar.js" actually refers to ./bar.ts
+            const stripped = resolvedPath.replace(/\.(js|mjs|cjs)$/, "");
+            const normalized = normalizeImportPath(stripped, relPathSet);
             if (normalized && normalized !== rel) {
                 edges.push({ from: rel, to: normalized });
                 importCount.set(normalized, (importCount.get(normalized) || 0) + 1);
@@ -70,11 +92,9 @@ function extractPythonImports(content, rel, edges, importCount) {
     }
 }
 function extractGoImports(content, rel, edges, importCount) {
-    // Go doesn't have relative imports in the same way, but we can track internal package imports
     const importBlock = content.match(/import\s*\(([\s\S]*?)\)/);
     if (!importBlock)
         return;
-    // Look for internal package paths (not standard library)
     const lines = importBlock[1].split("\n");
     for (const line of lines) {
         const pathMatch = line.match(/["']([^"']+)["']/);
@@ -85,29 +105,73 @@ function extractGoImports(content, rel, edges, importCount) {
         }
     }
 }
-function normalizeImportPath(importPath, allFiles, root) {
-    // Try exact match first
-    for (const file of allFiles) {
-        const rel = relative(root, file);
-        if (rel === importPath)
-            return rel;
+function extractRubyImports(content, rel, edges, importCount) {
+    // require_relative "./path"
+    const pattern = /require_relative\s+['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+        const target = match[1].replace(/^\.\//, "") + ".rb";
+        edges.push({ from: rel, to: target });
+        importCount.set(target, (importCount.get(target) || 0) + 1);
+    }
+}
+function extractElixirImports(content, rel, edges, importCount) {
+    // alias MyApp.Accounts.User
+    const pattern = /(?:alias|import|use)\s+([\w.]+)/g;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+        const mod = match[1];
+        // Convert module path to potential file: MyApp.Accounts.User -> lib/my_app/accounts/user.ex
+        if (mod.includes(".") && !mod.startsWith("Ecto") && !mod.startsWith("Phoenix") && !mod.startsWith("Plug")) {
+            const target = "lib/" + mod.split(".").map(s => s.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "")).join("/") + ".ex";
+            edges.push({ from: rel, to: target });
+            importCount.set(target, (importCount.get(target) || 0) + 1);
+        }
+    }
+}
+function extractJavaImports(content, rel, edges, importCount, relPaths) {
+    // import com.myapp.service.UserService;
+    const pattern = /^import\s+([\w.]+);/gm;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+        const imp = match[1];
+        // Skip standard library and common third-party
+        if (imp.startsWith("java.") || imp.startsWith("javax.") || imp.startsWith("org.springframework") || imp.startsWith("org.apache"))
+            continue;
+        // Convert to path pattern: com.myapp.service.UserService -> UserService
+        const className = imp.split(".").pop();
+        const found = relPaths.find(p => p.endsWith(`/${className}.java`) || p.endsWith(`/${className}.kt`));
+        if (found && found !== rel) {
+            edges.push({ from: rel, to: found });
+            importCount.set(found, (importCount.get(found) || 0) + 1);
+        }
     }
+}
+function extractRustImports(content, rel, edges, importCount) {
+    // mod my_module; or use crate::my_module::something;
+    const modPattern = /^mod\s+(\w+)\s*;/gm;
+    let match;
+    while ((match = modPattern.exec(content)) !== null) {
+        const dir = dirname(rel);
+        const target = dir === "." ? `${match[1]}.rs` : `${dir}/${match[1]}.rs`;
+        edges.push({ from: rel, to: target });
+        importCount.set(target, (importCount.get(target) || 0) + 1);
+    }
+}
+function normalizeImportPath(importPath, relPathSet) {
+    // Try exact match first
+    if (relPathSet.has(importPath))
+        return importPath;
     // Try with extensions
     const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
     for (const ext of extensions) {
-        for (const file of allFiles) {
-            const rel = relative(root, file);
-            if (rel === importPath + ext)
-                return rel;
-        }
+        if (relPathSet.has(importPath + ext))
+            return importPath + ext;
     }
     // Try index files
     for (const ext of extensions) {
-        for (const file of allFiles) {
-            const rel = relative(root, file);
-            if (rel === importPath + "/index" + ext)
-                return rel;
-        }
+        if (relPathSet.has(importPath + "/index" + ext))
+            return importPath + "/index" + ext;
     }
     return null;
 }

package/dist/detectors/routes.js

@@ -42,6 +42,27 @@ export async function detectRoutes(files, project) {
             case "koa":
                 routes.push(...(await detectKoaRoutes(files, project)));
                 break;
+            case "nestjs":
+                routes.push(...(await detectNestJSRoutes(files, project)));
+                break;
+            case "elysia":
+                routes.push(...(await detectElysiaRoutes(files, project)));
+                break;
+            case "adonis":
+                routes.push(...(await detectAdonisRoutes(files, project)));
+                break;
+            case "trpc":
+                routes.push(...(await detectTRPCRoutes(files, project)));
+                break;
+            case "sveltekit":
+                routes.push(...(await detectSvelteKitRoutes(files, project)));
+                break;
+            case "remix":
+                routes.push(...(await detectRemixRoutes(files, project)));
+                break;
+            case "nuxt":
+                routes.push(...(await detectNuxtRoutes(files, project)));
+                break;
             case "fastapi":
                 routes.push(...(await detectFastAPIRoutes(files, project)));
                 break;
@@ -54,8 +75,26 @@ export async function detectRoutes(files, project) {
             case "gin":
             case "go-net-http":
             case "fiber":
+            case "echo":
+            case "chi":
                 routes.push(...(await detectGoRoutes(files, project, fw)));
                 break;
+            case "rails":
+                routes.push(...(await detectRailsRoutes(files, project)));
+                break;
+            case "phoenix":
+                routes.push(...(await detectPhoenixRoutes(files, project)));
+                break;
+            case "spring":
+                routes.push(...(await detectSpringRoutes(files, project)));
+                break;
+            case "actix":
+            case "axum":
+                routes.push(...(await detectRustRoutes(files, project, fw)));
+                break;
+            case "raw-http":
+                routes.push(...(await detectRawHttpRoutes(files, project)));
+                break;
         }
     }
     return routes;
@@ -67,7 +106,6 @@ async function detectNextAppRoutes(files, project) {
     for (const file of routeFiles) {
         const content = await readFileSafe(file);
         const rel = relative(project.root, file);
-        // Extract API path from file path
         const pathMatch = rel.match(/(?:src\/)?app(.*)\/route\./);
         const apiPath = pathMatch ? pathMatch[1] || "/" : "/";
         for (const method of HTTP_METHODS) {
@@ -95,7 +133,6 @@ async function detectNextPagesApi(files, project) {
         const pathMatch = rel.match(/(?:src\/)?pages(\/api\/.*)\.(?:ts|js|tsx|jsx)$/);
         let apiPath = pathMatch ? pathMatch[1] : "/api";
         apiPath = apiPath.replace(/\/index$/, "").replace(/\[([^\]]+)\]/g, ":$1");
-        // Detect methods from handler
         const methods = [];
         for (const method of HTTP_METHODS) {
             if (content.includes(`req.method === '${method}'`) || content.includes(`req.method === "${method}"`)) {
@@ -125,12 +162,10 @@ async function detectHonoRoutes(files, project) {
         if (!content.includes("hono") && !content.includes("Hono"))
             continue;
         const rel = relative(project.root, file);
-        // Match: app.get("/path", ...), router.post("/path", ...), .route("/base", ...)
         const routePattern = /\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
         let match;
         while ((match = routePattern.exec(content)) !== null) {
             const path = match[2];
-            // Skip non-path strings (middleware keys like "user", "userId", etc.)
             if (!path.startsWith("/") && !path.startsWith(":"))
                 continue;
             routes.push({
@@ -153,7 +188,6 @@ async function detectExpressRoutes(files, project) {
         if (!content.includes("express") && !content.includes("Router"))
             continue;
         const rel = relative(project.root, file);
-        // Match: app.get("/path", ...), router.post("/path", ...)
         const routePattern = /(?:app|router|server)\s*\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
         let match;
         while ((match = routePattern.exec(content)) !== null) {
@@ -177,7 +211,6 @@ async function detectFastifyRoutes(files, project) {
         if (!content.includes("fastify"))
             continue;
         const rel = relative(project.root, file);
-        // Match: fastify.get("/path", ...) or server.route({ method: 'GET', url: '/path' })
         const routePattern = /(?:fastify|server|app)\s*\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
         let match;
         while ((match = routePattern.exec(content)) !== null) {
@@ -226,6 +259,233 @@ async function detectKoaRoutes(files, project) {
     }
     return routes;
 }
+// --- NestJS ---
+async function detectNestJSRoutes(files, project) {
+    const tsFiles = files.filter((f) => f.match(/\.(ts|js)$/));
+    const routes = [];
+    for (const file of tsFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("@Controller") && !content.includes("@Get") && !content.includes("@Post"))
+            continue;
+        const rel = relative(project.root, file);
+        // Extract controller base path: @Controller('users') or @Controller('/users')
+        const controllerMatch = content.match(/@Controller\s*\(\s*['"`]([^'"`]*)['"`]\s*\)/);
+        const basePath = controllerMatch ? "/" + controllerMatch[1].replace(/^\//, "") : "";
+        // Match method decorators: @Get(), @Post('/create'), @Put(':id'), etc.
+        const decoratorPattern = /@(Get|Post|Put|Patch|Delete|Options|Head|All)\s*\(\s*(?:['"`]([^'"`]*)['"`])?\s*\)/gi;
+        let match;
+        while ((match = decoratorPattern.exec(content)) !== null) {
+            const method = match[1].toUpperCase();
+            const subPath = match[2] || "";
+            const fullPath = basePath + (subPath ? "/" + subPath.replace(/^\//, "") : "") || "/";
+            routes.push({
+                method,
+                path: fullPath,
+                file: rel,
+                tags: detectTags(content),
+                framework: "nestjs",
+            });
+        }
+    }
+    return routes;
+}
+// --- Elysia (Bun) ---
+async function detectElysiaRoutes(files, project) {
+    const tsFiles = files.filter((f) => f.match(/\.(ts|js|mjs)$/));
+    const routes = [];
+    for (const file of tsFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("elysia") && !content.includes("Elysia"))
+            continue;
+        const rel = relative(project.root, file);
+        const routePattern = /\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+        let match;
+        while ((match = routePattern.exec(content)) !== null) {
+            const path = match[2];
+            if (!path.startsWith("/") && !path.startsWith(":"))
+                continue;
+            routes.push({
+                method: match[1].toUpperCase(),
+                path,
+                file: rel,
+                tags: detectTags(content),
+                framework: "elysia",
+            });
+        }
+    }
+    return routes;
+}
+// --- AdonisJS ---
+async function detectAdonisRoutes(files, project) {
+    // AdonisJS uses start/routes.ts with Route.get(), Route.post(), router.get(), etc.
+    const routeFiles = files.filter((f) => f.match(/routes\.(ts|js)$/) || f.match(/\/routes\/.*\.(ts|js)$/));
+    const routes = [];
+    for (const file of routeFiles) {
+        const content = await readFileSafe(file);
+        const rel = relative(project.root, file);
+        const routePattern = /(?:Route|router)\s*\.\s*(get|post|put|patch|delete|any)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+        let match;
+        while ((match = routePattern.exec(content)) !== null) {
+            routes.push({
+                method: match[1].toUpperCase() === "ANY" ? "ALL" : match[1].toUpperCase(),
+                path: match[2],
+                file: rel,
+                tags: detectTags(content),
+                framework: "adonis",
+            });
+        }
+    }
+    return routes;
+}
+// --- tRPC ---
+async function detectTRPCRoutes(files, project) {
+    const tsFiles = files.filter((f) => f.match(/\.(ts|js)$/));
+    const routes = [];
+    for (const file of tsFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("Procedure") && !content.includes("procedure") && !content.includes("router"))
+            continue;
+        if (!content.includes("trpc") && !content.includes("TRPC") && !content.includes("createTRPCRouter") && !content.includes("publicProcedure") && !content.includes("protectedProcedure"))
+            continue;
+        const rel = relative(project.root, file);
+        // Match tRPC procedure definitions like:
+        //   list: publicProcedure.query(...)
+        //   create: publicProcedure.input(schema).mutation(...)
+        //   getById: t.procedure.input(z.object({...})).query(...)
+        // Strategy: find lines with "query(" or "mutation(" and extract the procedure name
+        const lines = content.split("\n");
+        for (const line of lines) {
+            const queryMatch = line.match(/^\s*(\w+)\s*:\s*.*\.(query)\s*\(/);
+            const mutationMatch = line.match(/^\s*(\w+)\s*:\s*.*\.(mutation)\s*\(/);
+            const m = queryMatch || mutationMatch;
+            if (m) {
+                const procName = m[1];
+                const isQuery = m[2] === "query";
+                if (!routes.some((r) => r.path === procName && r.file === rel)) {
+                    routes.push({
+                        method: isQuery ? "QUERY" : "MUTATION",
+                        path: procName,
+                        file: rel,
+                        tags: detectTags(content),
+                        framework: "trpc",
+                    });
+                }
+            }
+        }
+    }
+    return routes;
+}
+// --- SvelteKit ---
+async function detectSvelteKitRoutes(files, project) {
+    // SvelteKit API routes: src/routes/**/+server.ts
+    const routeFiles = files.filter((f) => f.match(/\/routes\/.*\+server\.(ts|js)$/));
+    const routes = [];
+    for (const file of routeFiles) {
+        const content = await readFileSafe(file);
+        const rel = relative(project.root, file);
+        // Extract path from file structure: src/routes/api/users/+server.ts -> /api/users
+        const pathMatch = rel.match(/(?:src\/)?routes(.*)\/\+server\./);
+        let apiPath = pathMatch ? pathMatch[1] || "/" : "/";
+        // Convert [param] to :param
+        apiPath = apiPath.replace(/\[([^\]]+)\]/g, ":$1");
+        for (const method of HTTP_METHODS) {
+            const pattern = new RegExp(`export\\s+(?:async\\s+)?function\\s+${method}\\b`);
+            if (pattern.test(content)) {
+                routes.push({
+                    method,
+                    path: apiPath,
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: "sveltekit",
+                });
+            }
+        }
+        // Also detect: export const GET = ...
+        for (const method of HTTP_METHODS) {
+            const constPattern = new RegExp(`export\\s+const\\s+${method}\\s*[=:]`);
+            if (constPattern.test(content) && !routes.some((r) => r.method === method && r.path === apiPath)) {
+                routes.push({
+                    method,
+                    path: apiPath,
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: "sveltekit",
+                });
+            }
+        }
+    }
+    return routes;
+}
+// --- Remix ---
+async function detectRemixRoutes(files, project) {
+    // Remix routes: app/routes/*.tsx with loader/action exports
+    const routeFiles = files.filter((f) => f.match(/\/routes\/.*\.(ts|tsx|js|jsx)$/));
+    const routes = [];
+    for (const file of routeFiles) {
+        const content = await readFileSafe(file);
+        const rel = relative(project.root, file);
+        // Convert filename to route path
+        const pathMatch = rel.match(/(?:app\/)?routes\/(.+)\.(ts|tsx|js|jsx)$/);
+        if (!pathMatch)
+            continue;
+        let routePath = "/" + pathMatch[1]
+            .replace(/\./g, "/") // dots become path segments
+            .replace(/_index$/, "") // _index -> root of parent
+            .replace(/\$/g, ":") // $param -> :param
+            .replace(/\[([^\]]+)\]/g, ":$1");
+        if (content.match(/export\s+(?:async\s+)?function\s+loader\b/) || content.match(/export\s+const\s+loader\b/)) {
+            routes.push({
+                method: "GET",
+                path: routePath,
+                file: rel,
+                tags: detectTags(content),
+                framework: "remix",
+            });
+        }
+        if (content.match(/export\s+(?:async\s+)?function\s+action\b/) || content.match(/export\s+const\s+action\b/)) {
+            routes.push({
+                method: "POST",
+                path: routePath,
+                file: rel,
+                tags: detectTags(content),
+                framework: "remix",
+            });
+        }
+    }
+    return routes;
+}
+// --- Nuxt ---
+async function detectNuxtRoutes(files, project) {
+    // Nuxt server routes: server/api/**/*.ts
+    const routeFiles = files.filter((f) => f.match(/\/server\/(?:api|routes)\/.*\.(ts|js|mjs)$/));
+    const routes = [];
+    for (const file of routeFiles) {
+        const content = await readFileSafe(file);
+        const rel = relative(project.root, file);
+        // Extract path from file structure
+        const pathMatch = rel.match(/server\/((?:api|routes)\/.+)\.(ts|js|mjs)$/);
+        if (!pathMatch)
+            continue;
+        let routePath = "/" + pathMatch[1]
+            .replace(/\/index$/, "")
+            .replace(/\[([^\]]+)\]/g, ":$1");
+        // Detect method from filename (e.g., users.get.ts, users.post.ts)
+        const methodFromFile = basename(file).match(/\.(get|post|put|patch|delete)\.(ts|js|mjs)$/);
+        const method = methodFromFile ? methodFromFile[1].toUpperCase() : "ALL";
+        // Clean path: remove method suffix from path
+        if (methodFromFile) {
+            routePath = routePath.replace(new RegExp(`\\.${methodFromFile[1]}$`), "");
+        }
+        routes.push({
+            method,
+            path: routePath,
+            file: rel,
+            tags: detectTags(content),
+            framework: "nuxt",
+        });
+    }
+    return routes;
+}
 // --- FastAPI ---
 async function detectFastAPIRoutes(files, project) {
     const pyFiles = files.filter((f) => f.endsWith(".py"));
@@ -235,7 +495,6 @@ async function detectFastAPIRoutes(files, project) {
         if (!content.includes("fastapi") && !content.includes("FastAPI") && !content.includes("APIRouter"))
             continue;
         const rel = relative(project.root, file);
-        // Match: @app.get("/path") or @router.post("/path") or @api_router.get("/path")
         const routePattern = /@\w+\s*\.\s*(get|post|put|patch|delete|options)\s*\(\s*['"]([^'"]+)['"]/gi;
         let match;
         while ((match = routePattern.exec(content)) !== null) {
@@ -259,8 +518,7 @@ async function detectFlaskRoutes(files, project) {
         if (!content.includes("flask") && !content.includes("Flask") && !content.includes("Blueprint"))
             continue;
         const rel = relative(project.root, file);
-        // Match: @app.route("/path", methods=["GET", "POST"])
-        const routePattern = /@(?:app|bp|blueprint)\s*\.\s*route\s*\(\s*['"]([^'"]+)['"](?:\s*,\s*methods\s*=\s*\[([^\]]+)\])?\s*\)/gi;
+        const routePattern = /@(?:app|bp|blueprint|\w+)\s*\.\s*route\s*\(\s*['"]([^'"]+)['"](?:\s*,\s*methods\s*=\s*\[([^\]]+)\])?\s*\)/gi;
         let match;
         while ((match = routePattern.exec(content)) !== null) {
             const path = match[1];
@@ -287,7 +545,7 @@ async function detectDjangoRoutes(files, project) {
     for (const file of pyFiles) {
         const content = await readFileSafe(file);
         const rel = relative(project.root, file);
-        // Match: path("api/v1/users/", views.UserView.as_view())
+        // path("api/v1/users/", views.UserView.as_view())
         const pathPattern = /path\s*\(\s*['"]([^'"]*)['"]\s*,/g;
         let match;
         while ((match = pathPattern.exec(content)) !== null) {
@@ -302,7 +560,7 @@ async function detectDjangoRoutes(files, project) {
     }
     return routes;
 }
-// --- Go ---
+// --- Go (net/http, Gin, Fiber, Echo, Chi) ---
 async function detectGoRoutes(files, project, fw) {
     const goFiles = files.filter((f) => f.endsWith(".go"));
     const routes = [];
@@ -310,7 +568,6 @@ async function detectGoRoutes(files, project, fw) {
         const content = await readFileSafe(file);
         const rel = relative(project.root, file);
         if (fw === "gin") {
-            // Match: r.GET("/path", handler)
             const pattern = /\.\s*(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\s*\(\s*["']([^"']+)["']/g;
             let match;
             while ((match = pattern.exec(content)) !== null) {
@@ -324,7 +581,34 @@ async function detectGoRoutes(files, project, fw) {
             }
         }
         else if (fw === "fiber") {
-            // Match: app.Get("/path", handler)
+            const pattern = /\.\s*(Get|Post|Put|Patch|Delete|Options|Head)\s*\(\s*["']([^"']+)["']/g;
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                routes.push({
+                    method: match[1].toUpperCase(),
+                    path: match[2],
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: fw,
+                });
+            }
+        }
+        else if (fw === "echo") {
+            // e.GET("/path", handler) or g.POST("/path", handler)
+            const pattern = /\.\s*(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\s*\(\s*["']([^"']+)["']/g;
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                routes.push({
+                    method: match[1],
+                    path: match[2],
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: fw,
+                });
+            }
+        }
+        else if (fw === "chi") {
+            // r.Get("/path", handler), r.Post("/path", handler)
             const pattern = /\.\s*(Get|Post|Put|Patch|Delete|Options|Head)\s*\(\s*["']([^"']+)["']/g;
             let match;
             while ((match = pattern.exec(content)) !== null) {
@@ -354,3 +638,225 @@ async function detectGoRoutes(files, project, fw) {
     }
     return routes;
 }
+// --- Rails ---
+async function detectRailsRoutes(files, project) {
+    const routeFiles = files.filter((f) => f.match(/routes\.rb$/));
+    const routes = [];
+    for (const file of routeFiles) {
+        const content = await readFileSafe(file);
+        const rel = relative(project.root, file);
+        // get '/users', to: 'users#index'
+        const routePattern = /\b(get|post|put|patch|delete)\s+['"]([^'"]+)['"]/gi;
+        let match;
+        while ((match = routePattern.exec(content)) !== null) {
+            routes.push({
+                method: match[1].toUpperCase(),
+                path: match[2],
+                file: rel,
+                tags: detectTags(content),
+                framework: "rails",
+            });
+        }
+        // resources :users (generates RESTful routes)
+        const resourcePattern = /resources?\s+:(\w+)/g;
+        while ((match = resourcePattern.exec(content)) !== null) {
+            const name = match[1];
+            for (const [method, suffix] of [
+                ["GET", ""], ["GET", "/:id"], ["POST", ""],
+                ["PUT", "/:id"], ["PATCH", "/:id"], ["DELETE", "/:id"],
+            ]) {
+                routes.push({
+                    method,
+                    path: `/${name}${suffix}`,
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: "rails",
+                });
+            }
+        }
+    }
+    return routes;
+}
+// --- Phoenix (Elixir) ---
+async function detectPhoenixRoutes(files, project) {
+    const routeFiles = files.filter((f) => f.match(/router\.ex$/));
+    const routes = [];
+    for (const file of routeFiles) {
+        const content = await readFileSafe(file);
+        const rel = relative(project.root, file);
+        // get "/users", UserController, :index
+        const routePattern = /\b(get|post|put|patch|delete)\s+["']([^"']+)["']/gi;
+        let match;
+        while ((match = routePattern.exec(content)) !== null) {
+            routes.push({
+                method: match[1].toUpperCase(),
+                path: match[2],
+                file: rel,
+                tags: detectTags(content),
+                framework: "phoenix",
+            });
+        }
+        // resources "/users", UserController
+        const resourcePattern = /resources\s+["']([^"']+)["']/g;
+        while ((match = resourcePattern.exec(content)) !== null) {
+            const basePath = match[1];
+            for (const [method, suffix] of [
+                ["GET", ""], ["GET", "/:id"], ["POST", ""],
+                ["PUT", "/:id"], ["PATCH", "/:id"], ["DELETE", "/:id"],
+            ]) {
+                routes.push({
+                    method,
+                    path: `${basePath}${suffix}`,
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: "phoenix",
+                });
+            }
+        }
+    }
+    return routes;
+}
+// --- Spring Boot (Java/Kotlin) ---
+async function detectSpringRoutes(files, project) {
+    const javaFiles = files.filter((f) => f.match(/\.(java|kt)$/));
+    const routes = [];
+    for (const file of javaFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("@RestController") && !content.includes("@Controller") && !content.includes("@RequestMapping"))
+            continue;
+        const rel = relative(project.root, file);
+        // Extract class-level @RequestMapping
+        const classMapping = content.match(/@RequestMapping\s*\(\s*(?:value\s*=\s*)?["']([^"']+)["']/);
+        const basePath = classMapping ? classMapping[1] : "";
+        // @GetMapping("/path"), @PostMapping("/path"), etc.
+        const mappingPattern = /@(Get|Post|Put|Patch|Delete)Mapping\s*\(\s*(?:value\s*=\s*)?(?:["']([^"']*)["'])?\s*\)/gi;
+        let match;
+        while ((match = mappingPattern.exec(content)) !== null) {
+            const method = match[1].toUpperCase();
+            const subPath = match[2] || "";
+            routes.push({
+                method,
+                path: basePath + subPath || "/",
+                file: rel,
+                tags: detectTags(content),
+                framework: "spring",
+            });
+        }
+        // @RequestMapping(method = RequestMethod.GET, value = "/path")
+        const reqMappingPattern = /@RequestMapping\s*\([^)]*method\s*=\s*RequestMethod\.(\w+)[^)]*value\s*=\s*["']([^"']+)["']/gi;
+        while ((match = reqMappingPattern.exec(content)) !== null) {
+            routes.push({
+                method: match[1].toUpperCase(),
+                path: basePath + match[2],
+                file: rel,
+                tags: detectTags(content),
+                framework: "spring",
+            });
+        }
+    }
+    return routes;
+}
+// --- Rust (Actix-web, Axum) ---
+async function detectRustRoutes(files, project, fw) {
+    const rsFiles = files.filter((f) => f.endsWith(".rs"));
+    const routes = [];
+    for (const file of rsFiles) {
+        const content = await readFileSafe(file);
+        const rel = relative(project.root, file);
+        if (fw === "actix") {
+            // #[get("/path")], #[post("/path")], etc.
+            const attrPattern = /#\[(get|post|put|patch|delete)\s*\(\s*"([^"]+)"\s*\)\s*\]/gi;
+            let match;
+            while ((match = attrPattern.exec(content)) !== null) {
+                routes.push({
+                    method: match[1].toUpperCase(),
+                    path: match[2],
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: "actix",
+                });
+            }
+            // .route("/path", web::get().to(handler))
+            const routePattern = /\.route\s*\(\s*"([^"]+)"\s*,\s*web::(get|post|put|patch|delete)\s*\(\s*\)/gi;
+            while ((match = routePattern.exec(content)) !== null) {
+                routes.push({
+                    method: match[2].toUpperCase(),
+                    path: match[1],
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: "actix",
+                });
+            }
+        }
+        else if (fw === "axum") {
+            // .route("/path", get(handler)) or .route("/path", post(handler).get(handler))
+            const routePattern = /\.route\s*\(\s*"([^"]+)"\s*,\s*(get|post|put|patch|delete)\s*\(/gi;
+            let match;
+            while ((match = routePattern.exec(content)) !== null) {
+                routes.push({
+                    method: match[2].toUpperCase(),
+                    path: match[1],
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: "axum",
+                });
+            }
+        }
+    }
+    return routes;
+}
+// --- Raw HTTP (Node.js http.createServer, Deno, Bun.serve) ---
+async function detectRawHttpRoutes(files, project) {
+    const tsFiles = files.filter((f) => f.match(/\.(ts|js|mjs|cjs)$/));
+    const routes = [];
+    const globalSeen = new Set();
+    for (const file of tsFiles) {
+        const content = await readFileSafe(file);
+        // Only scan files that handle HTTP requests
+        if (!content.match(/(?:createServer|http\.|req\.|request\.|url|pathname|Bun\.serve|Deno\.serve)/))
+            continue;
+        const rel = relative(project.root, file);
+        const patterns = [
+            // Direct comparison: url === "/path" or pathname === "/path"
+            /(?:url|pathname|parsedUrl\.pathname)\s*===?\s*['"`](\/[a-zA-Z0-9/_:.\-]+)['"`]/g,
+            // startsWith: url.startsWith("/api")
+            /(?:url|pathname)\s*\.startsWith\s*\(\s*['"`](\/[a-zA-Z0-9/_:.\-]+)['"`]\s*\)/g,
+            // Switch case: case "/path":
+            /case\s+['"`](\/[a-zA-Z0-9/_:.\-]+)['"`]\s*:/g,
+        ];
+        const fileTags = detectTags(content);
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                const path = match[1];
+                // Skip paths that are clearly not routes
+                if (path.includes("\\") || path.length > 100 || path.includes(".."))
+                    continue;
+                // Skip file extensions
+                if (path.match(/\.\w{2,4}$/))
+                    continue;
+                const key = `${rel}:${path}`;
+                if (globalSeen.has(key))
+                    continue;
+                globalSeen.add(key);
+                // Try to detect method from surrounding context (within 300 chars)
+                const surroundingStart = Math.max(0, match.index - 300);
+                const surroundingEnd = Math.min(content.length, match.index + 300);
+                const surrounding = content.substring(surroundingStart, surroundingEnd);
+                let method = "ALL";
+                const methodMatch = surrounding.match(/method\s*===?\s*['"`](GET|POST|PUT|PATCH|DELETE)['"`]/i);
+                if (methodMatch) {
+                    method = methodMatch[1].toUpperCase();
+                }
+                routes.push({
+                    method,
+                    path,
+                    file: rel,
+                    tags: fileTags,
+                    framework: "raw-http",
+                });
+            }
+        }
+    }
+    return routes;
+}

package/dist/formatter.js

@@ -253,14 +253,27 @@ function formatCombined(result, sections) {
 }
 function filterNotableDeps(deps) {
     const notable = new Set([
+        // Frameworks
         "next", "react", "vue", "svelte", "hono", "express", "fastify", "koa",
-        "drizzle-orm", "prisma", "@prisma/client", "typeorm", "tailwindcss",
-        "stripe", "@polar-sh/sdk", "resend", "bullmq", "redis", "ioredis",
-        "zod", "trpc", "@trpc/server", "better-auth", "@clerk/nextjs",
-        "next-auth", "lucia", "passport", "@anthropic-ai/sdk", "openai",
-        "ai", "langchain", "supabase", "@supabase/supabase-js", "mongoose",
-        "pg", "mysql2", "better-sqlite3", "playwright", "puppeteer",
-        "socket.io", "graphql", "@apollo/server",
+        "@nestjs/core", "@nestjs/common", "elysia", "@adonisjs/core",
+        "@sveltejs/kit", "@remix-run/node", "@remix-run/react", "nuxt",
+        // ORMs & DB
+        "drizzle-orm", "prisma", "@prisma/client", "typeorm", "mongoose", "sequelize",
+        "pg", "mysql2", "better-sqlite3", "knex",
+        // Auth
+        "better-auth", "@clerk/nextjs", "next-auth", "lucia", "passport", "@auth/core",
+        // Payments
+        "stripe", "@polar-sh/sdk", "resend", "@lemonsqueezy/lemonsqueezy.js",
+        // Infrastructure
+        "bullmq", "redis", "ioredis", "tailwindcss",
+        // API
+        "zod", "@trpc/server", "graphql", "@apollo/server",
+        // AI
+        "@anthropic-ai/sdk", "openai", "ai", "langchain", "@google/generative-ai",
+        // Services
+        "supabase", "@supabase/supabase-js", "firebase", "@firebase/app",
+        // Testing/tools
+        "playwright", "puppeteer", "socket.io",
     ]);
     return Object.entries(deps)
         .filter(([name]) => notable.has(name))

package/dist/index.js

@@ -14,7 +14,7 @@ import { calculateTokenStats } from "./detectors/tokens.js";
 import { writeOutput } from "./formatter.js";
 import { generateAIConfigs } from "./generators/ai-config.js";
 import { generateHtmlReport } from "./generators/html-report.js";
-const VERSION = "1.0.1";
+const VERSION = "1.1.1";
 const BRAND = "codesight";
 function printHelp() {
     console.log(`
@@ -32,6 +32,7 @@ function printHelp() {
     --open               Generate HTML report and open in browser
     --mcp                Start as MCP server (for Claude Code, Cursor)
     --json               Output JSON instead of markdown
+    --benchmark          Show detailed token savings breakdown
     -v, --version        Show version
     -h, --help           Show this help
 
@@ -218,6 +219,7 @@ async function main() {
     let doHtml = false;
     let doOpen = false;
     let doMcp = false;
+    let doBenchmark = false;
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if ((arg === "-o" || arg === "--output") && args[i + 1]) {
@@ -248,6 +250,9 @@ async function main() {
         else if (arg === "--mcp") {
             doMcp = true;
         }
+        else if (arg === "--benchmark") {
+            doBenchmark = true;
+        }
         else if (!arg.startsWith("-")) {
             targetDir = resolve(arg);
         }
@@ -293,6 +298,37 @@ async function main() {
             console.log("  Opening in browser...");
         }
     }
+    // Benchmark output
+    if (doBenchmark) {
+        const ts = result.tokenStats;
+        const r = result;
+        console.log(`
+  Token Savings Breakdown:
+  ┌──────────────────────────────────────────────────┐
+  │ What codesight found         │ Exploration cost   │
+  ├──────────────────────────────┼────────────────────┤
+  │ ${String(r.routes.length).padStart(3)} routes                   │ ~${(r.routes.length * 400).toLocaleString().padStart(6)} tokens     │
+  │ ${String(r.schemas.length).padStart(3)} schema models            │ ~${(r.schemas.length * 300).toLocaleString().padStart(6)} tokens     │
+  │ ${String(r.components.length).padStart(3)} components              │ ~${(r.components.length * 250).toLocaleString().padStart(6)} tokens     │
+  │ ${String(r.libs.length).padStart(3)} library files            │ ~${(r.libs.length * 200).toLocaleString().padStart(6)} tokens     │
+  │ ${String(r.config.envVars.length).padStart(3)} env vars                │ ~${(r.config.envVars.length * 100).toLocaleString().padStart(6)} tokens     │
+  │ ${String(r.middleware.length).padStart(3)} middleware              │ ~${(r.middleware.length * 200).toLocaleString().padStart(6)} tokens     │
+  │ ${String(r.graph.hotFiles.length).padStart(3)} hot files               │ ~${(r.graph.hotFiles.length * 150).toLocaleString().padStart(6)} tokens     │
+  │ ${String(ts.fileCount).padStart(3)} files (search overhead) │ ~${(Math.min(ts.fileCount, 50) * 80).toLocaleString().padStart(6)} tokens     │
+  ├──────────────────────────────┼────────────────────┤
+  │ codesight output             │ ~${ts.outputTokens.toLocaleString().padStart(6)} tokens     │
+  │ Manual exploration (1.3x)    │ ~${ts.estimatedExplorationTokens.toLocaleString().padStart(6)} tokens     │
+  │ SAVED PER CONVERSATION       │ ~${ts.saved.toLocaleString().padStart(6)} tokens     │
+  └──────────────────────────────┴────────────────────┘
+
+  How this is calculated:
+  - Each route found saves ~400 tokens of file reading + grep exploration
+  - Each schema model saves ~300 tokens of migration/ORM file parsing
+  - Each component saves ~250 tokens of prop discovery
+  - Search overhead: AI typically runs ${Math.min(ts.fileCount, 50)} glob/grep operations
+  - 1.3x multiplier: AI revisits files during multi-turn exploration
+`);
+    }
     // Watch mode (blocks)
     if (doWatch) {
         await watchMode(root, outputDirName, maxDepth);

package/dist/scanner.js

@@ -35,6 +35,13 @@ const CODE_EXTENSIONS = new Set([
     ".go",
     ".vue",
     ".svelte",
+    ".rb",
+    ".ex",
+    ".exs",
+    ".java",
+    ".kt",
+    ".rs",
+    ".php",
 ]);
 export async function collectFiles(root, maxDepth = 10) {
     const files = [];
@@ -174,6 +181,27 @@ async function detectFrameworks(root, pkg) {
     // Koa
     if (deps["koa"])
         frameworks.push("koa");
+    // NestJS
+    if (deps["@nestjs/core"] || deps["@nestjs/common"])
+        frameworks.push("nestjs");
+    // Elysia (Bun)
+    if (deps["elysia"])
+        frameworks.push("elysia");
+    // AdonisJS
+    if (deps["@adonisjs/core"])
+        frameworks.push("adonis");
+    // tRPC
+    if (deps["@trpc/server"])
+        frameworks.push("trpc");
+    // SvelteKit
+    if (deps["@sveltejs/kit"])
+        frameworks.push("sveltekit");
+    // Remix
+    if (deps["@remix-run/node"] || deps["@remix-run/react"])
+        frameworks.push("remix");
+    // Nuxt
+    if (deps["nuxt"])
+        frameworks.push("nuxt");
     // Python frameworks - check for requirements.txt or pyproject.toml
     const pyDeps = await getPythonDeps(root);
     if (pyDeps.includes("flask"))
@@ -190,6 +218,59 @@ async function detectFrameworks(root, pkg) {
         frameworks.push("gin");
     if (goDeps.includes("gofiber/fiber"))
         frameworks.push("fiber");
+    if (goDeps.some((d) => d.includes("labstack/echo")))
+        frameworks.push("echo");
+    if (goDeps.some((d) => d.includes("go-chi/chi")))
+        frameworks.push("chi");
+    // Ruby on Rails
+    const hasGemfile = await fileExists(join(root, "Gemfile"));
+    if (hasGemfile) {
+        try {
+            const gemfile = await readFile(join(root, "Gemfile"), "utf-8");
+            if (gemfile.includes("rails"))
+                frameworks.push("rails");
+        }
+        catch { }
+    }
+    // Phoenix (Elixir)
+    const hasMixFile = await fileExists(join(root, "mix.exs"));
+    if (hasMixFile) {
+        try {
+            const mix = await readFile(join(root, "mix.exs"), "utf-8");
+            if (mix.includes("phoenix"))
+                frameworks.push("phoenix");
+        }
+        catch { }
+    }
+    // Spring Boot (Java/Kotlin)
+    const hasPomXml = await fileExists(join(root, "pom.xml"));
+    const hasBuildGradle = await fileExists(join(root, "build.gradle")) || await fileExists(join(root, "build.gradle.kts"));
+    if (hasPomXml || hasBuildGradle) {
+        try {
+            const buildFile = hasPomXml
+                ? await readFile(join(root, "pom.xml"), "utf-8")
+                : await readFile(join(root, hasBuildGradle ? "build.gradle.kts" : "build.gradle"), "utf-8");
+            if (buildFile.includes("spring"))
+                frameworks.push("spring");
+        }
+        catch { }
+    }
+    // Rust web frameworks
+    const hasCargoToml = await fileExists(join(root, "Cargo.toml"));
+    if (hasCargoToml) {
+        try {
+            const cargo = await readFile(join(root, "Cargo.toml"), "utf-8");
+            if (cargo.includes("actix-web"))
+                frameworks.push("actix");
+            else if (cargo.includes("axum"))
+                frameworks.push("axum");
+        }
+        catch { }
+    }
+    // Fallback: detect raw http.createServer if no other frameworks found
+    if (frameworks.length === 0) {
+        frameworks.push("raw-http");
+    }
     return frameworks;
 }
 async function detectORMs(root, pkg) {
@@ -201,12 +282,36 @@ async function detectORMs(root, pkg) {
         orms.push("prisma");
     if (deps["typeorm"])
         orms.push("typeorm");
+    if (deps["mongoose"])
+        orms.push("mongoose");
+    if (deps["sequelize"])
+        orms.push("sequelize");
     const pyDeps = await getPythonDeps(root);
     if (pyDeps.includes("sqlalchemy"))
         orms.push("sqlalchemy");
     const goDeps = await getGoDeps(root);
     if (goDeps.some((d) => d.includes("gorm")))
         orms.push("gorm");
+    // Rails ActiveRecord
+    const hasGemfile = await fileExists(join(root, "Gemfile"));
+    if (hasGemfile) {
+        try {
+            const gemfile = await readFile(join(root, "Gemfile"), "utf-8");
+            if (gemfile.includes("activerecord") || gemfile.includes("rails"))
+                orms.push("activerecord");
+        }
+        catch { }
+    }
+    // Phoenix Ecto
+    const hasMixFile = await fileExists(join(root, "mix.exs"));
+    if (hasMixFile) {
+        try {
+            const mix = await readFile(join(root, "mix.exs"), "utf-8");
+            if (mix.includes("ecto"))
+                orms.push("ecto");
+        }
+        catch { }
+    }
     return orms;
 }
 function detectComponentFramework(deps) {
@@ -223,6 +328,12 @@ async function detectLanguage(root, deps) {
     const hasPyProject = await fileExists(join(root, "pyproject.toml")) || await fileExists(join(root, "backend/pyproject.toml"));
     const hasGoMod = await fileExists(join(root, "go.mod"));
     const hasRequirements = await fileExists(join(root, "requirements.txt")) || await fileExists(join(root, "backend/requirements.txt"));
+    const hasGemfile = await fileExists(join(root, "Gemfile"));
+    const hasMixExs = await fileExists(join(root, "mix.exs"));
+    const hasPomXml = await fileExists(join(root, "pom.xml"));
+    const hasBuildGradle = await fileExists(join(root, "build.gradle")) || await fileExists(join(root, "build.gradle.kts"));
+    const hasCargoToml = await fileExists(join(root, "Cargo.toml"));
+    const hasComposerJson = await fileExists(join(root, "composer.json"));
     const langs = [];
     if (hasTsConfig || deps["typescript"])
         langs.push("typescript");
@@ -230,14 +341,22 @@ async function detectLanguage(root, deps) {
         langs.push("python");
     if (hasGoMod)
         langs.push("go");
+    if (hasGemfile)
+        langs.push("ruby");
+    if (hasMixExs)
+        langs.push("elixir");
+    if (hasBuildGradle)
+        langs.push("kotlin");
+    else if (hasPomXml)
+        langs.push("java");
+    if (hasCargoToml)
+        langs.push("rust");
+    if (hasComposerJson)
+        langs.push("php");
     if (langs.length > 1)
         return "mixed";
-    if (langs[0] === "typescript")
-        return "typescript";
-    if (langs[0] === "python")
-        return "python";
-    if (langs[0] === "go")
-        return "go";
+    if (langs.length === 1)
+        return langs[0];
     return "javascript";
 }
 async function getWorkspacePatterns(root, pkg) {

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-export type Framework = "next-app" | "next-pages" | "hono" | "express" | "fastify" | "koa" | "flask" | "fastapi" | "django" | "go-net-http" | "gin" | "fiber" | "unknown";
-export type ORM = "drizzle" | "prisma" | "typeorm" | "sqlalchemy" | "gorm" | "unknown";
+export type Framework = "next-app" | "next-pages" | "hono" | "express" | "fastify" | "koa" | "nestjs" | "elysia" | "adonis" | "trpc" | "sveltekit" | "remix" | "nuxt" | "flask" | "fastapi" | "django" | "go-net-http" | "gin" | "fiber" | "echo" | "chi" | "rails" | "phoenix" | "spring" | "actix" | "axum" | "raw-http" | "unknown";
+export type ORM = "drizzle" | "prisma" | "typeorm" | "sqlalchemy" | "gorm" | "mongoose" | "sequelize" | "activerecord" | "ecto" | "unknown";
 export type ComponentFramework = "react" | "vue" | "svelte" | "unknown";
 export interface ProjectInfo {
     root: string;
@@ -9,7 +9,7 @@ export interface ProjectInfo {
     componentFramework: ComponentFramework;
     isMonorepo: boolean;
     workspaces: WorkspaceInfo[];
-    language: "typescript" | "javascript" | "python" | "go" | "mixed";
+    language: "typescript" | "javascript" | "python" | "go" | "ruby" | "elixir" | "java" | "kotlin" | "rust" | "php" | "mixed";
 }
 export interface WorkspaceInfo {
     name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codesight",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "See your codebase clearly. Universal AI context generator that maps routes, schema, components, dependencies, and more for Claude Code, Cursor, Copilot, Codex, and any AI coding tool.",
   "main": "dist/index.js",
   "bin": {
@@ -10,6 +10,7 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsx src/index.ts",
+    "test": "pnpm build && node --test tests/detectors.test.ts",
     "prepublishOnly": "pnpm build"
   },
   "keywords": [