codesight 1.2.0 → 1.3.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. 25+ framework detectors. 8 ORM parsers. 8 MCP tools. Blast radius analysis. One `npx` call.**
+**Zero dependencies. AST precision. 25+ framework detectors. 8 ORM parsers. 8 MCP tools. Blast radius analysis. 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)
@@ -56,12 +56,70 @@ Every AI coding conversation starts the same way. Your assistant reads files, gr
 
 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.
 
+**v1.3.0: AST-level precision.** When TypeScript is available in your project, codesight uses the TypeScript compiler API for structural parsing instead of regex. This gives exact route paths, proper controller prefix combining (NestJS), accurate tRPC procedure nesting, precise Drizzle field types, and React prop extraction from type annotations. Zero new dependencies — borrows TypeScript from your project's node_modules. Falls back to regex when TypeScript is not available.
+
 ```
 Output size:      ~3,200 tokens
 Exploration cost: ~52,000 tokens (without codesight)
 Saved:            ~48,800 tokens per conversation
 ```
 
+## How It Works
+
+```mermaid
+flowchart LR
+    A["Your Codebase"] --> B["codesight"]
+    B --> C["AST Parser"]
+    B --> D["Regex Fallback"]
+    C --> E["Structured Context Map"]
+    D --> E
+    E --> F["CLAUDE.md"]
+    E --> G[".cursorrules"]
+    E --> H["codex.md"]
+    E --> I["MCP Server"]
+    
+    style B fill:#f59e0b,stroke:#d97706,color:#000
+    style C fill:#10b981,stroke:#059669,color:#000
+    style E fill:#3b82f6,stroke:#2563eb,color:#fff
+```
+
+```mermaid
+flowchart TD
+    subgraph Detectors["8 Parallel Detectors"]
+        R["Routes<br/>25+ frameworks"]
+        S["Schema<br/>8 ORMs"]
+        CP["Components<br/>React/Vue/Svelte"]
+        G["Dep Graph<br/>Import analysis"]
+        M["Middleware<br/>Auth/CORS/etc"]
+        CF["Config<br/>Env vars"]
+        L["Libraries<br/>Exports + sigs"]
+        CT["Contracts<br/>Params + types"]
+    end
+    
+    A["File Scanner"] --> Detectors
+    Detectors --> O["~3K-5K tokens<br/>vs ~50K-70K exploration"]
+    
+    style O fill:#10b981,stroke:#059669,color:#000
+```
+
+```mermaid
+flowchart LR
+    subgraph Without["Without codesight"]
+        W1["AI reads files"] --> W2["AI greps patterns"]
+        W2 --> W3["AI opens configs"]
+        W3 --> W4["AI explores deps"]
+        W4 --> W5["50,000+ tokens burned"]
+    end
+    
+    subgraph With["With codesight"]
+        C1["AI reads CODESIGHT.md"] --> C2["Full project context"]
+        C2 --> C3["~3,000 tokens"]
+    end
+    
+    style W5 fill:#ef4444,stroke:#dc2626,color:#fff
+    style C3 fill:#10b981,stroke:#059669,color:#000
+```
+
 ## What It Generates
 
 ```
@@ -77,6 +135,41 @@ Saved:            ~48,800 tokens per conversation
   report.html      Interactive visual dashboard (with --html or --open)
 ```
 
+## AST Precision
+
+When TypeScript is installed in the project being scanned, codesight uses the actual TypeScript compiler API to parse your code structurally. No regex guessing.
+
+| What AST enables | Regex alone |
+|---|---|
+| Follows `router.use('/prefix', subRouter)` chains | Misses nested routers |
+| Combines `@Controller('users')` + `@Get(':id')` into `/users/:id` | May miss prefix |
+| Parses `router({ users: userRouter })` tRPC nesting | Line-by-line matching |
+| Extracts exact Drizzle field types from `.primaryKey().notNull()` chains | Pattern matching |
+| Gets React props from TypeScript interfaces and destructuring | Regex on `{ prop }` |
+| Detects middleware in route chains: `app.get('/path', auth, handler)` | Not captured |
+
+```mermaid
+flowchart TD
+    F["Source File"] --> Check{"TypeScript<br/>in node_modules?"}
+    Check -->|Yes| AST["AST Parse<br/>(TypeScript Compiler API)"]
+    Check -->|No| Regex["Regex Parse<br/>(Pattern Matching)"]
+    AST --> Result["Routes / Schema / Components"]
+    AST -->|"Parse failed"| Regex
+    Regex --> Result
+    
+    style AST fill:#10b981,stroke:#059669,color:#000
+    style Regex fill:#f59e0b,stroke:#d97706,color:#000
+    style Result fill:#3b82f6,stroke:#2563eb,color:#fff
+```
+
+AST detection is indicated in the output:
+
+```
+Analyzing... done (AST: 65 routes, 18 models, 16 components)
+```
+
+No configuration needed. If TypeScript is in your `node_modules`, AST kicks in automatically. Works with npm, yarn, and pnpm (including strict mode). Falls back to regex for non-TypeScript projects or frameworks without AST support.
+
 ## 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 25+ frameworks automatically.
@@ -121,6 +214,25 @@ The files imported the most are the ones that break the most things when changed
 
 ## Blast Radius
 
+```mermaid
+graph TD
+    DB["src/lib/db.ts<br/>(you change this)"] --> U["src/routes/users.ts"]
+    DB --> P["src/routes/projects.ts"]
+    DB --> B["src/routes/billing.ts"]
+    DB --> A["src/routes/auth.ts"]
+    U --> MW["src/middleware/auth.ts"]
+    P --> MW
+    B --> S["src/services/stripe.ts"]
+    
+    style DB fill:#ef4444,stroke:#dc2626,color:#fff
+    style U fill:#f59e0b,stroke:#d97706,color:#000
+    style P fill:#f59e0b,stroke:#d97706,color:#000
+    style B fill:#f59e0b,stroke:#d97706,color:#000
+    style A fill:#f59e0b,stroke:#d97706,color:#000
+    style MW fill:#fbbf24,stroke:#f59e0b,color:#000
+    style S fill:#fbbf24,stroke:#f59e0b,color:#000
+```
+
 See exactly what breaks if you change a file. BFS through the import graph finds all transitively affected files, routes, models, and middleware.
 
 ```bash
@@ -234,6 +346,21 @@ Runs as a Model Context Protocol server. Claude Code and Cursor call it directly
 }
 ```
 
+```mermaid
+flowchart LR
+    AI["Claude Code<br/>or Cursor"] <-->|"JSON-RPC 2.0<br/>over stdio"| MCP["codesight<br/>MCP Server"]
+    MCP --> Cache["Session Cache<br/>(scan once)"]
+    MCP --> T1["get_summary"]
+    MCP --> T2["get_routes"]
+    MCP --> T3["get_schema"]
+    MCP --> T4["get_blast_radius"]
+    MCP --> T5["get_env"]
+    MCP --> T6["get_hot_files"]
+    
+    style MCP fill:#f59e0b,stroke:#d97706,color:#000
+    style Cache fill:#10b981,stroke:#059669,color:#000
+```
+
 Exposes 8 specialized tools, each returning only what your AI needs:
 
 | Tool | What it does |
@@ -332,6 +459,7 @@ Most AI context tools dump your entire codebase into one file. codesight takes a
 
 | | codesight | File concatenation tools | AST-based tools |
 |---|---|---|---|
+| **Parsing** | AST when available, regex fallback | None | Tree-sitter / custom |
 | **Output** | Structured routes, schema, components, deps | Raw file contents | Call graphs, class diagrams |
 | **Token cost** | ~3,000-5,000 tokens | 50,000-500,000+ tokens | Varies |
 | **Route detection** | 25+ frameworks auto-detected | None | Limited |
@@ -340,7 +468,7 @@ Most AI context tools dump your entire codebase into one file. codesight takes a
 | **AI tool profiles** | 5 tools (Claude, Cursor, Codex, Copilot, Windsurf) | None | None |
 | **MCP server** | 8 specialized tools with session caching | None | Some |
 | **Setup** | `npx codesight` (zero deps, zero config) | Copy/paste | Install compilers, runtimes |
-| **Dependencies** | Zero | Varies | Tree-sitter, SQLite, etc. |
+| **Dependencies** | Zero (borrows TS from your project) | Varies | Tree-sitter, SQLite, etc. |
 
 ## Contributing
 

package/dist/ast/extract-components.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AST-based component extraction for React.
+ * Provides higher accuracy than regex for:
+ * - Component name detection from function/arrow function declarations
+ * - Prop extraction from destructured parameters and Props interface/type
+ * - Distinguishes client/server components via directive detection
+ */
+import type { ComponentInfo } from "../types.js";
+/**
+ * Extract React components from a file using AST.
+ */
+export declare function extractReactComponentsAST(ts: any, filePath: string, content: string, relPath: string): ComponentInfo[];

package/dist/ast/extract-components.js

@@ -0,0 +1,180 @@
+import { parseSourceFile, getText } from "./loader.js";
+/**
+ * Extract React components from a file using AST.
+ */
+export function extractReactComponentsAST(ts, filePath, content, relPath) {
+    try {
+        const sf = parseSourceFile(ts, filePath, content);
+        return extractComponents(ts, sf, content, relPath);
+    }
+    catch {
+        return [];
+    }
+}
+function extractComponents(ts, sf, content, relPath) {
+    const components = [];
+    const SK = ts.SyntaxKind;
+    const isClient = content.slice(0, 80).includes("use client");
+    const isServer = content.slice(0, 80).includes("use server");
+    // Collect all Props interfaces/types in the file
+    const propsTypes = new Map(); // type name -> prop names
+    function collectPropsTypes(node) {
+        // interface FooProps { ... } or type FooProps = { ... }
+        if (node.kind === SK.InterfaceDeclaration || node.kind === SK.TypeAliasDeclaration) {
+            const name = node.name ? getText(sf, node.name) : "";
+            if (!name.includes("Props") && !name.includes("props")) {
+                ts.forEachChild(node, collectPropsTypes);
+                return;
+            }
+            const props = [];
+            // For interfaces: node.members
+            if (node.members) {
+                for (const member of node.members) {
+                    if (member.kind === SK.PropertySignature && member.name) {
+                        const propName = getText(sf, member.name);
+                        if (propName !== "children")
+                            props.push(propName);
+                    }
+                }
+            }
+            // For type aliases: node.type might be TypeLiteral
+            if (node.type?.kind === SK.TypeLiteral && node.type.members) {
+                for (const member of node.type.members) {
+                    if (member.kind === SK.PropertySignature && member.name) {
+                        const propName = getText(sf, member.name);
+                        if (propName !== "children")
+                            props.push(propName);
+                    }
+                }
+            }
+            if (props.length > 0)
+                propsTypes.set(name, props);
+        }
+        ts.forEachChild(node, collectPropsTypes);
+    }
+    collectPropsTypes(sf);
+    // Find exported functions/consts that start with uppercase (components)
+    function findComponents(node) {
+        // export function ComponentName(...) or export default function ComponentName(...)
+        if (node.kind === SK.FunctionDeclaration) {
+            const name = node.name ? getText(sf, node.name) : "";
+            if (!name || !/^[A-Z]/.test(name)) {
+                ts.forEachChild(node, findComponents);
+                return;
+            }
+            // Check if exported
+            const isExported = node.modifiers?.some((m) => m.kind === SK.ExportKeyword || m.kind === SK.DefaultKeyword);
+            if (!isExported) {
+                ts.forEachChild(node, findComponents);
+                return;
+            }
+            const props = extractPropsFromParams(ts, sf, node.parameters, propsTypes);
+            components.push({
+                name,
+                file: relPath,
+                props: props.slice(0, 10),
+                isClient,
+                isServer,
+                confidence: "ast",
+            });
+        }
+        // export const ComponentName = (...) => { ... }
+        if (node.kind === SK.VariableStatement) {
+            const isExported = node.modifiers?.some((m) => m.kind === SK.ExportKeyword);
+            if (!isExported) {
+                ts.forEachChild(node, findComponents);
+                return;
+            }
+            for (const decl of node.declarationList?.declarations || []) {
+                if (decl.kind !== SK.VariableDeclaration)
+                    continue;
+                const name = decl.name ? getText(sf, decl.name) : "";
+                if (!name || !/^[A-Z]/.test(name))
+                    continue;
+                // Check if the initializer is an arrow function or function expression
+                const init = decl.initializer;
+                if (!init)
+                    continue;
+                let params = null;
+                if (init.kind === SK.ArrowFunction || init.kind === SK.FunctionExpression) {
+                    params = init.parameters;
+                }
+                // React.forwardRef((...) => { ... })
+                if (init.kind === SK.CallExpression) {
+                    const callee = init.expression;
+                    const calleeName = callee?.kind === SK.PropertyAccessExpression
+                        ? getText(sf, callee.name)
+                        : callee?.kind === SK.Identifier ? getText(sf, callee) : "";
+                    if (calleeName === "forwardRef" || calleeName === "memo") {
+                        const innerFn = init.arguments?.[0];
+                        if (innerFn && (innerFn.kind === SK.ArrowFunction || innerFn.kind === SK.FunctionExpression)) {
+                            params = innerFn.parameters;
+                        }
+                    }
+                }
+                if (params) {
+                    const props = extractPropsFromParams(ts, sf, params, propsTypes);
+                    components.push({
+                        name,
+                        file: relPath,
+                        props: props.slice(0, 10),
+                        isClient,
+                        isServer,
+                        confidence: "ast",
+                    });
+                }
+            }
+        }
+        ts.forEachChild(node, findComponents);
+    }
+    findComponents(sf);
+    return components;
+}
+/**
+ * Extract prop names from function parameters.
+ * Handles: ({ prop1, prop2 }: Props) and (props: Props)
+ */
+function extractPropsFromParams(ts, sf, params, propsTypes) {
+    if (!params || params.length === 0)
+        return [];
+    const SK = ts.SyntaxKind;
+    const firstParam = params[0];
+    // Destructured: ({ prop1, prop2, ...rest }: Props)
+    if (firstParam.name?.kind === SK.ObjectBindingPattern) {
+        const props = [];
+        for (const element of firstParam.name.elements || []) {
+            if (element.dotDotDotToken)
+                continue; // skip ...rest
+            const propName = element.name ? getText(sf, element.name) : "";
+            if (propName && propName !== "children")
+                props.push(propName);
+        }
+        // If we got props from destructuring, great
+        if (props.length > 0)
+            return props;
+        // Fall back to type annotation if destructuring is empty
+    }
+    // Type annotation: (props: FooProps) or ({ ... }: FooProps)
+    if (firstParam.type) {
+        // TypeReference: FooProps
+        if (firstParam.type.kind === SK.TypeReference) {
+            const typeName = firstParam.type.typeName ? getText(sf, firstParam.type.typeName) : "";
+            const typeProps = propsTypes.get(typeName);
+            if (typeProps)
+                return typeProps;
+        }
+        // TypeLiteral: { prop1: string; prop2: number }
+        if (firstParam.type.kind === SK.TypeLiteral) {
+            const props = [];
+            for (const member of firstParam.type.members || []) {
+                if (member.kind === SK.PropertySignature && member.name) {
+                    const propName = getText(sf, member.name);
+                    if (propName !== "children")
+                        props.push(propName);
+                }
+            }
+            return props;
+        }
+    }
+    return [];
+}

package/dist/ast/extract-routes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AST-based route extraction for TypeScript/JavaScript frameworks.
+ * Provides higher accuracy than regex for:
+ * - Express/Hono/Fastify/Koa/Elysia: method calls with path strings
+ * - NestJS: decorator-based routes with controller prefix combining
+ * - tRPC: router object with procedure chains and nesting
+ */
+import type { RouteInfo, Framework } from "../types.js";
+/**
+ * Try AST-based route extraction for a single file.
+ * Returns routes with confidence: 'ast', or empty array if AST cannot handle this file.
+ */
+export declare function extractRoutesAST(ts: any, filePath: string, content: string, framework: Framework, tags: string[]): RouteInfo[];

package/dist/ast/extract-routes.js

@@ -0,0 +1,271 @@
+import { parseSourceFile, getDecorators, parseDecorator, getText } from "./loader.js";
+const HTTP_METHODS = new Set(["get", "post", "put", "patch", "delete", "options", "head", "all"]);
+function extractPathParams(path) {
+    const params = [];
+    const regex = /[:{}](\w+)/g;
+    let m;
+    while ((m = regex.exec(path)) !== null)
+        params.push(m[1]);
+    return params;
+}
+/**
+ * Try AST-based route extraction for a single file.
+ * Returns routes with confidence: 'ast', or empty array if AST cannot handle this file.
+ */
+export function extractRoutesAST(ts, filePath, content, framework, tags) {
+    try {
+        const sf = parseSourceFile(ts, filePath, content);
+        switch (framework) {
+            case "express":
+            case "hono":
+            case "fastify":
+            case "koa":
+            case "elysia":
+                return extractHttpFrameworkRoutes(ts, sf, filePath, content, framework, tags);
+            case "nestjs":
+                return extractNestJSRoutes(ts, sf, filePath, content, tags);
+            case "trpc":
+                return extractTRPCRoutes(ts, sf, filePath, content, tags);
+            default:
+                return [];
+        }
+    }
+    catch {
+        return []; // AST parsing failed — caller falls back to regex
+    }
+}
+// ─── Express / Hono / Fastify / Koa / Elysia ───
+function extractHttpFrameworkRoutes(ts, sf, filePath, _content, framework, tags) {
+    const routes = [];
+    const SK = ts.SyntaxKind;
+    // Track router.use('/prefix', subRouter) for prefix resolution
+    const prefixMap = new Map(); // variable name -> prefix
+    function visit(node) {
+        if (node.kind === SK.CallExpression) {
+            const expr = node.expression;
+            if (expr?.kind === SK.PropertyAccessExpression) {
+                const methodName = getText(sf, expr.name).toLowerCase();
+                const receiverName = expr.expression?.kind === SK.Identifier
+                    ? getText(sf, expr.expression)
+                    : "";
+                // Track .use('/prefix', variable) for prefix chains
+                if (methodName === "use" && node.arguments?.length >= 2) {
+                    const first = node.arguments[0];
+                    const second = node.arguments[1];
+                    if ((first.kind === SK.StringLiteral || first.kind === SK.NoSubstitutionTemplateLiteral) &&
+                        second.kind === SK.Identifier) {
+                        const prefix = first.text;
+                        const routerVar = getText(sf, second);
+                        prefixMap.set(routerVar, prefix);
+                    }
+                }
+                // Route registration: .get('/path', ...) .post('/path', ...) etc.
+                if (HTTP_METHODS.has(methodName) && node.arguments?.length > 0) {
+                    const pathArg = node.arguments[0];
+                    let path = null;
+                    if (pathArg.kind === SK.StringLiteral || pathArg.kind === SK.NoSubstitutionTemplateLiteral) {
+                        path = pathArg.text;
+                    }
+                    if (path !== null) {
+                        // Filter: route paths must start with / or : — skip context.get("key") calls
+                        if (!path.startsWith("/") && !path.startsWith(":")) {
+                            ts.forEachChild(node, visit);
+                            return;
+                        }
+                        // Apply prefix if this receiver has one registered
+                        const prefix = prefixMap.get(receiverName) || "";
+                        const fullPath = prefix ? (prefix + path).replace(/\/\//g, "/") : path;
+                        // Extract middleware names from intermediate arguments
+                        const middleware = [];
+                        for (let i = 1; i < node.arguments.length; i++) {
+                            const arg = node.arguments[i];
+                            if (arg.kind === SK.Identifier) {
+                                middleware.push(getText(sf, arg));
+                            }
+                        }
+                        routes.push({
+                            method: methodName.toUpperCase() === "ALL" ? "ALL" : methodName.toUpperCase(),
+                            path: fullPath,
+                            file: filePath,
+                            tags,
+                            framework,
+                            params: extractPathParams(fullPath),
+                            confidence: "ast",
+                            middleware,
+                        });
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sf);
+    return routes;
+}
+// ─── NestJS ───
+const NEST_METHOD_MAP = {
+    Get: "GET",
+    Post: "POST",
+    Put: "PUT",
+    Patch: "PATCH",
+    Delete: "DELETE",
+    Options: "OPTIONS",
+    Head: "HEAD",
+    All: "ALL",
+};
+function extractNestJSRoutes(ts, sf, filePath, _content, tags) {
+    const routes = [];
+    const SK = ts.SyntaxKind;
+    function visitNode(node) {
+        if (node.kind === SK.ClassDeclaration) {
+            const decorators = getDecorators(ts, node);
+            // Find @Controller decorator and extract prefix
+            let controllerPrefix = "";
+            let isController = false;
+            for (const dec of decorators) {
+                const parsed = parseDecorator(ts, sf, dec);
+                if (parsed.name === "Controller") {
+                    isController = true;
+                    controllerPrefix = parsed.arg || "";
+                    break;
+                }
+            }
+            if (!isController) {
+                ts.forEachChild(node, visitNode);
+                return;
+            }
+            // Extract guards at class level
+            const classGuards = [];
+            for (const dec of decorators) {
+                const parsed = parseDecorator(ts, sf, dec);
+                if (parsed.name === "UseGuards" && parsed.arg) {
+                    classGuards.push(parsed.arg);
+                }
+            }
+            // Visit methods
+            for (const member of node.members || []) {
+                if (member.kind !== SK.MethodDeclaration)
+                    continue;
+                const methodDecorators = getDecorators(ts, member);
+                for (const dec of methodDecorators) {
+                    const parsed = parseDecorator(ts, sf, dec);
+                    if (!parsed.name || !NEST_METHOD_MAP[parsed.name])
+                        continue;
+                    const methodPath = parsed.arg || "";
+                    const combined = [controllerPrefix, methodPath].filter(Boolean).join("/");
+                    const fullPath = "/" + combined.replace(/^\/+/, "").replace(/\/+/g, "/");
+                    const normalizedPath = fullPath.replace(/\/$/, "") || "/";
+                    // Extract @Param, @Body, @Query from method parameters
+                    const params = [];
+                    const middleware = [...classGuards];
+                    for (const param of member.parameters || []) {
+                        const paramDecs = getDecorators(ts, param);
+                        for (const pd of paramDecs) {
+                            const pp = parseDecorator(ts, sf, pd);
+                            if (pp.name === "Param" && pp.arg)
+                                params.push(pp.arg);
+                        }
+                    }
+                    // Method-level guards
+                    for (const mdec of methodDecorators) {
+                        const mp = parseDecorator(ts, sf, mdec);
+                        if (mp.name === "UseGuards" && mp.arg)
+                            middleware.push(mp.arg);
+                    }
+                    routes.push({
+                        method: NEST_METHOD_MAP[parsed.name],
+                        path: normalizedPath,
+                        file: filePath,
+                        tags,
+                        framework: "nestjs",
+                        params: params.length > 0 ? params : extractPathParams(normalizedPath),
+                        confidence: "ast",
+                        middleware: middleware.length > 0 ? middleware : undefined,
+                    });
+                }
+            }
+        }
+        ts.forEachChild(node, visitNode);
+    }
+    visitNode(sf);
+    return routes;
+}
+// ─── tRPC ───
+function extractTRPCRoutes(ts, sf, filePath, _content, tags) {
+    const routes = [];
+    const SK = ts.SyntaxKind;
+    function isRouterCall(node) {
+        if (node.kind !== SK.CallExpression)
+            return false;
+        const callee = node.expression;
+        if (callee.kind === SK.Identifier) {
+            const name = getText(sf, callee);
+            return name === "router" || name === "createTRPCRouter";
+        }
+        if (callee.kind === SK.PropertyAccessExpression) {
+            return getText(sf, callee.name) === "router";
+        }
+        return false;
+    }
+    function findProcedureMethod(node) {
+        if (!node || node.kind !== SK.CallExpression)
+            return null;
+        const expr = node.expression;
+        if (expr?.kind === SK.PropertyAccessExpression) {
+            const name = getText(sf, expr.name);
+            if (name === "query")
+                return "QUERY";
+            if (name === "mutation")
+                return "MUTATION";
+            if (name === "subscription")
+                return "SUBSCRIPTION";
+        }
+        return null;
+    }
+    function extractFromRouter(node, prefix) {
+        if (!isRouterCall(node) || !node.arguments?.length)
+            return;
+        const arg = node.arguments[0];
+        if (arg.kind !== SK.ObjectLiteralExpression)
+            return;
+        for (const prop of arg.properties || []) {
+            if (prop.kind === SK.PropertyAssignment) {
+                const name = prop.name ? getText(sf, prop.name) : "";
+                if (!name)
+                    continue;
+                const init = prop.initializer;
+                // Nested router
+                if (isRouterCall(init)) {
+                    extractFromRouter(init, prefix ? `${prefix}.${name}` : name);
+                    continue;
+                }
+                // Procedure: look for .query() / .mutation() / .subscription()
+                const method = findProcedureMethod(init);
+                if (method) {
+                    routes.push({
+                        method,
+                        path: prefix ? `${prefix}.${name}` : name,
+                        file: filePath,
+                        tags,
+                        framework: "trpc",
+                        confidence: "ast",
+                    });
+                    continue;
+                }
+                // Could be a reference to another router variable — can't resolve without types
+            }
+            if (prop.kind === SK.SpreadAssignment) {
+                // ...otherRoutes — can't resolve statically
+            }
+        }
+    }
+    // Find all router() calls in the file
+    function visit(node) {
+        if (isRouterCall(node)) {
+            extractFromRouter(node, "");
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sf);
+    return routes;
+}

package/dist/ast/extract-schema.d.ts

@@ -0,0 +1,15 @@
+/**
+ * AST-based schema extraction for TypeScript/JavaScript ORMs.
+ * Provides higher accuracy than regex for:
+ * - Drizzle: pgTable/mysqlTable/sqliteTable with field types and chained modifiers
+ * - TypeORM: @Entity + @Column/@PrimaryGeneratedColumn decorators
+ */
+import type { SchemaModel } from "../types.js";
+/**
+ * Extract Drizzle schema from a file using AST.
+ */
+export declare function extractDrizzleSchemaAST(ts: any, filePath: string, content: string): SchemaModel[];
+/**
+ * Extract TypeORM entities from a file using AST.
+ */
+export declare function extractTypeORMSchemaAST(ts: any, filePath: string, content: string): SchemaModel[];