codesight 1.0.0 → 1.1.0

package/README.md

@@ -1,113 +1,178 @@
-# codesight
+<div align="center">
 
-See your codebase clearly. One command gives your AI assistant complete project understanding.
+### Your AI assistant wastes thousands of tokens every conversation just figuring out your project. codesight fixes that in one command.
+
+**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)
+[![npm total](https://img.shields.io/npm/dt/codesight?style=for-the-badge&logo=npm&color=cyan&label=Total%20Downloads)](https://www.npmjs.com/package/codesight)
+[![GitHub stars](https://img.shields.io/github/stars/Houseofmvps/codesight?style=for-the-badge&logo=github&color=gold)](https://github.com/Houseofmvps/codesight/stargazers)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow?style=for-the-badge&logo=opensourceinitiative)](LICENSE)
+[![Sponsor](https://img.shields.io/badge/Sponsor-EA4AAA?style=for-the-badge&logo=githubsponsors&logoColor=white)](https://github.com/sponsors/Houseofmvps)
+
+---
+
+[![Follow @kaileskkhumar](https://img.shields.io/badge/Follow%20%40kaileskkhumar-000000?style=for-the-badge&logo=x&logoColor=white)](https://x.com/kaileskkhumar)
+[![LinkedIn](https://img.shields.io/badge/LinkedIn-Connect-0A66C2?style=for-the-badge&logo=linkedin)](https://www.linkedin.com/in/kailesk-khumar)
+[![houseofmvps.com](https://img.shields.io/badge/houseofmvps.com-Website-green?style=for-the-badge&logo=google-chrome&logoColor=white)](https://houseofmvps.com)
+
+**Built by [Kailesk Khumar](https://www.linkedin.com/in/kailesk-khumar), solo founder of [houseofmvps.com](https://houseofmvps.com)**
+
+*Also: [ultraship](https://github.com/Houseofmvps/ultraship) (39 expert skills for Claude Code) · [claude-rank](https://github.com/Houseofmvps/claude-rank) (SEO/GEO/AEO plugin for Claude Code)*
+
+</div>
+
+---
 
-```bash
-npx codesight
+```
+0 dependencies · Node.js >= 18 · 27 tests · MIT
 ```
 
-**Works with Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Windsurf, Cline, and any AI coding tool.**
+## Works With
 
-## The Problem
+**Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Windsurf, Cline, Aider**, and anything that reads markdown.
 
-Every AI coding conversation starts the same way: your assistant burns thousands of tokens exploring files, grepping for patterns, and reading configs just to understand your project. On a 65-route Hono API with 18 Drizzle models, that costs **~68,000 tokens per conversation** in exploration alone.
+## Install
 
-codesight pre-generates that understanding into ~4,000 tokens of structured context. **Your AI starts every conversation already knowing your routes, schema, components, dependencies, and architecture.**
+```bash
+npx codesight
+```
 
-## Quick Start
+That's it. Run it in any project root. No config, no setup, no API keys.
 
 ```bash
-npx codesight              # Scan and generate context
 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
+
+Every AI coding conversation starts the same way. Your assistant reads files, greps for patterns, opens configs, just to understand the project. That exploration costs tens of thousands of tokens before it writes a single line of code.
+
+codesight scans your codebase once and generates a structured context map. Routes, database schema, components, dependencies, environment variables, middleware, all condensed into ~3,000 to 5,000 tokens of structured markdown. Your AI reads one file and knows the entire project.
+
+```
+Output size:      ~3,200 tokens
+Exploration cost: ~52,000 tokens (without codesight)
+Saved:            ~48,800 tokens per conversation
 ```
 
 ## What It Generates
 
 ```
 .codesight/
-  CODESIGHT.md     # Combined AI context map (point your assistant here)
-  routes.md        # API routes with methods, params, request/response types, tags
-  schema.md        # Database models with fields, types, PKs, FKs, relations
-  components.md    # UI components with props (shadcn/radix filtered out)
-  libs.md          # Library exports with function signatures
-  config.md        # Env vars (required vs default), config files, key deps
-  middleware.md    # Auth, rate limiting, CORS, validation, logging
-  graph.md         # Dependency graph: most-imported files + import map
-  report.html      # Interactive visual report (with --html or --open)
+  CODESIGHT.md     Combined context map (one file, full project understanding)
+  routes.md        Every API route with method, path, params, and what it touches
+  schema.md        Every database model with fields, types, keys, and relations
+  components.md    Every UI component with its props
+  libs.md          Every library export with function signatures
+  config.md        Every env var (required vs default), config files, key deps
+  middleware.md    Auth, rate limiting, CORS, validation, logging, error handlers
+  graph.md         Which files import what and which break the most things if changed
+  report.html      Interactive visual dashboard (with --html or --open)
 ```
 
-## Real Output Example
+## Routes
 
-From a production SaaS monorepo (Hono + Drizzle + React):
+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
-# savemrr — AI Context Map
-
-> **Stack:** hono | drizzle | react | typescript
-> **Monorepo:** @savemrr/api, @savemrr/dashboard, @savemrr/widget, @savemrr/shared
-
-> 65 routes | 18 models | 16 components | 36 lib files | 22 env vars | 5 middleware | 53 import links
-> **Token savings:** this file is ~4,041 tokens. Without it, AI exploration would cost ~68,640 tokens.
-> **Saves ~64,599 tokens per conversation.**
-
----
-
-# Routes
+- `POST` `/auth/login` [auth, db, email]
+- `GET` `/api/projects/:id/analytics` params(id) [auth, db, cache]
+- `POST` `/api/billing/checkout` [auth, db, payment]
+- `QUERY` `getUsers` [db]             # tRPC procedures
+- `MUTATION` `createProject` [db, ai]  # tRPC mutations
+```
 
-- `POST` `/magic-link` [auth, db, cache, email]
-- `POST` `/verify` [auth, db, cache, email]
-- `GET` `/me` [auth, db, cache, email]
-- `GET` `/overview` [auth, db, queue, payment, ai]
-- `GET` `/shield` [auth, db, queue, payment, ai]
-- `GET` `/rescue` [auth, db, queue, payment, ai]
-- `POST` `/rescue/:id/send-now` params(id) [auth, db, queue, payment, ai]
-...
+## Schema
 
-# Schema
+Models, fields, types, primary keys, foreign keys, unique constraints, relations. Parsed directly from your ORM definitions. No need to open migration files.
 
+```markdown
 ### users
 - id: uuid (pk, default)
 - email: text (unique, required)
-- tier: text (required, default)
-- polarSubId: text (fk)
-- settings: jsonb (required, default)
+- plan: text (required, default)
+- stripeCustomerId: text (fk)
 
-### stripe_connections
+### projects
 - id: uuid (pk, default)
 - userId: uuid (fk)
-...
+- name: text (required)
+- domain: text (unique)
+- _relations_: userId -> users.id
+```
+
+## Dependency Graph
 
-# Dependency Graph
+The files imported the most are the ones that break the most things when changed. codesight finds them and tells your AI to be careful.
 
+```markdown
 ## Most Imported Files (change these carefully)
-- `packages/shared/src/index.ts` — imported by **12** files
-- `apps/api/src/lib/db.ts` — imported by **8** files
-- `apps/api/src/lib/auth.ts` — imported by **6** files
+- `packages/shared/src/index.ts` — imported by **14** files
+- `apps/api/src/lib/db.ts` — imported by **9** files
+- `apps/api/src/lib/auth.ts` — imported by **7** files
+```
+
+## Environment Audit
+
+Every env var across your codebase, flagged as required or has default, with the exact file where it is referenced.
+
+```markdown
+- `DATABASE_URL` **required** — apps/api/src/lib/db.ts
+- `JWT_SECRET` **required** — apps/api/src/lib/auth.ts
+- `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     │
+  └──────────────────────────────┴────────────────────┘
 ```
 
-## What It Detects
+## 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 |
-| **Components** | React, Vue, Svelte (filters out shadcn/radix primitives) |
-| **Libraries** | TypeScript/JavaScript, Python, Go exports with function signatures |
-| **Config** | Environment variables (required vs defaults), config files, notable dependencies |
+| **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, 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 extracted from route handlers |
-| **Monorepos** | pnpm, npm, yarn workspaces with cross-workspace detection |
-| **Languages** | TypeScript, JavaScript, Python, Go |
+| **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 |
 
-## Auto-Generate AI Config Files
+## AI Config Generation
 
 ```bash
 npx codesight --init
 ```
 
-Generates instruction files for every major AI coding tool:
+Generates ready-to-use instruction files for every major AI coding tool at once:
 
 | File | Tool |
 |---|---|
@@ -115,25 +180,9 @@ Generates instruction files for every major AI coding tool:
 | `.cursorrules` | Cursor |
 | `.github/copilot-instructions.md` | GitHub Copilot |
 | `codex.md` | OpenAI Codex CLI |
-| `AGENTS.md` | OpenAI Codex |
-
-Each file includes your project's stack, key architecture facts, hot files, and required env vars so your AI assistant knows the project from the first message.
+| `AGENTS.md` | OpenAI Codex agents |
 
-## Interactive HTML Report
-
-```bash
-npx codesight --open
-```
-
-Generates a visual dashboard with:
-- Token savings hero metric
-- Route table with methods, contracts, and tags
-- Schema cards with fields and relations
-- Dependency hot files with impact bars
-- Environment variables (required vs defaults)
-- Full middleware map
-
-Screenshots of this report are what go viral on Twitter.
+Each file is pre-filled with your project's stack, architecture, high-impact files, and required env vars. Your AI reads it on startup and starts with full context from the first message.
 
 ## MCP Server
 
@@ -141,7 +190,7 @@ Screenshots of this report are what go viral on Twitter.
 npx codesight --mcp
 ```
 
-Runs as a Model Context Protocol server that Claude Code and Cursor can connect to. Add to your MCP config:
+Runs as a Model Context Protocol server. Claude Code and Cursor call it directly to get project context on demand.
 
 ```json
 {
@@ -154,23 +203,50 @@ Runs as a Model Context Protocol server that Claude Code and Cursor can connect
 }
 ```
 
-Your AI assistant can then call the `codesight_scan` tool to get full project context on demand.
+Exposes one tool: `codesight_scan`. Your AI calls it whenever it needs to understand the project.
 
-## Watch Mode
+## Visual Report
 
 ```bash
-npx codesight --watch
+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
+      - run: npx codesight
+      - uses: actions/upload-artifact@v4
+        with:
+          name: codesight
+          path: .codesight/
 ```
 
-Re-scans automatically when files change. Keeps context fresh during development.
+## Watch Mode and Git Hook
 
-## Git Pre-Commit Hook
+**Watch mode** re-scans when files change:
+
+```bash
+npx codesight --watch
+```
+
+**Git hook** regenerates context on every commit:
 
 ```bash
 npx codesight --hook
 ```
 
-Installs a git pre-commit hook that regenerates context on every commit. Context stays up to date automatically.
+Context stays fresh without thinking about it.
 
 ## All Options
 
@@ -178,36 +254,56 @@ Installs a git pre-commit hook that regenerates context on every commit. Context
 npx codesight                       # Scan current directory
 npx codesight ./my-project          # Scan specific directory
 npx codesight --init                # Generate AI config files
-npx codesight --open                # Open interactive HTML report
-npx codesight --html                # Generate HTML report (no open)
+npx codesight --open                # Open visual HTML report
+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 --json                # Output JSON
+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
 ```
 
-## Why Not Repomix?
+## How It Compares
 
-Repomix dumps your entire codebase into one file. codesight maps your architecture.
+Most AI context tools dump your entire codebase into one file. codesight takes a different approach: it **parses** your code to extract structured information.
 
-| | Repomix | codesight |
+| | codesight | File concatenation tools |
 |---|---|---|
-| **Approach** | Raw code dump | Structured intelligence |
-| **Output** | One giant text blob | Semantic context files |
-| **AI gets** | "Here is all the code" | "Here is the architecture" |
-| **Token cost** | Huge (entire codebase) | Tiny (~4K tokens for full map) |
-| **Route discovery** | Read every file | Instant from routes.md |
-| **Schema understanding** | Read every migration | Instant from schema.md |
-| **Change blast radius** | Unknown | Visible in dependency graph |
-| **AI config generation** | No | CLAUDE.md, .cursorrules, codex.md, AGENTS.md |
-| **Runtime deps** | 26 | **Zero** |
+| **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 |
 
-## Zero Dependencies
+## Contributing
 
-codesight has zero runtime dependencies. Just Node.js built-ins. Fast, portable, no supply chain risk.
+```bash
+git clone https://github.com/Houseofmvps/codesight.git
+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.
 
 ## License
 
 MIT
+
+---
+
+<div align="center">
+
+If codesight saves you tokens, [star it on GitHub](https://github.com/Houseofmvps/codesight) so others find it too.
+
+[![GitHub stars](https://img.shields.io/github/stars/Houseofmvps/codesight?style=for-the-badge&logo=github&color=gold)](https://github.com/Houseofmvps/codesight/stargazers)
+[![Sponsor](https://img.shields.io/badge/Sponsor-EA4AAA?style=for-the-badge&logo=githubsponsors&logoColor=white)](https://github.com/sponsors/Houseofmvps)
+
+</div>

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;
 }