codesight 1.1.1 → 1.3.0

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[];

package/dist/ast/extract-schema.js

@@ -0,0 +1,302 @@
+import { parseSourceFile, getDecorators, parseDecorator, getText } from "./loader.js";
+const AUDIT_FIELDS = new Set([
+    "createdAt", "updatedAt", "deletedAt",
+    "created_at", "updated_at", "deleted_at",
+]);
+/**
+ * Extract Drizzle schema from a file using AST.
+ */
+export function extractDrizzleSchemaAST(ts, filePath, content) {
+    try {
+        const sf = parseSourceFile(ts, filePath, content);
+        return extractDrizzleTables(ts, sf, content);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Extract TypeORM entities from a file using AST.
+ */
+export function extractTypeORMSchemaAST(ts, filePath, content) {
+    try {
+        const sf = parseSourceFile(ts, filePath, content);
+        return extractTypeORMEntities(ts, sf);
+    }
+    catch {
+        return [];
+    }
+}
+// ─── Drizzle ───
+const DRIZZLE_TABLE_FUNCS = new Set(["pgTable", "mysqlTable", "sqliteTable"]);
+function extractDrizzleTables(ts, sf, _content) {
+    const models = [];
+    const SK = ts.SyntaxKind;
+    function visit(node) {
+        // Look for: const xxx = pgTable("name", { ... })
+        if (node.kind === SK.CallExpression) {
+            const callee = node.expression;
+            const funcName = callee?.kind === SK.Identifier ? getText(sf, callee) : "";
+            if (DRIZZLE_TABLE_FUNCS.has(funcName) && node.arguments?.length >= 2) {
+                const nameArg = node.arguments[0];
+                const fieldsArg = node.arguments[1];
+                // Table name from first argument
+                let tableName = "";
+                if (nameArg.kind === SK.StringLiteral || nameArg.kind === SK.NoSubstitutionTemplateLiteral) {
+                    tableName = nameArg.text;
+                }
+                if (!tableName) {
+                    ts.forEachChild(node, visit);
+                    return;
+                }
+                // Fields from second argument (ObjectLiteralExpression or arrow returning one)
+                let fieldsObj = null;
+                if (fieldsArg.kind === SK.ObjectLiteralExpression) {
+                    fieldsObj = fieldsArg;
+                }
+                else if (fieldsArg.kind === SK.ArrowFunction || fieldsArg.kind === SK.FunctionExpression) {
+                    // (t) => ({ ... }) — body might be ParenthesizedExpression containing ObjectLiteralExpression
+                    const body = fieldsArg.body;
+                    if (body?.kind === SK.ObjectLiteralExpression) {
+                        fieldsObj = body;
+                    }
+                    else if (body?.kind === SK.ParenthesizedExpression && body.expression?.kind === SK.ObjectLiteralExpression) {
+                        fieldsObj = body.expression;
+                    }
+                }
+                if (!fieldsObj) {
+                    ts.forEachChild(node, visit);
+                    return;
+                }
+                const fields = [];
+                const relations = [];
+                for (const prop of fieldsObj.properties || []) {
+                    if (prop.kind !== SK.PropertyAssignment)
+                        continue;
+                    const fieldName = prop.name ? getText(sf, prop.name) : "";
+                    if (!fieldName || AUDIT_FIELDS.has(fieldName))
+                        continue;
+                    // Parse the initializer chain: serial("id").primaryKey()
+                    const { type, flags, refTarget } = parseFieldChain(ts, sf, prop.initializer);
+                    if (refTarget) {
+                        relations.push(`${fieldName} -> ${refTarget}`);
+                    }
+                    if (fieldName.endsWith("Id") || fieldName.endsWith("_id")) {
+                        if (!flags.includes("fk"))
+                            flags.push("fk");
+                    }
+                    fields.push({ name: fieldName, type, flags });
+                }
+                if (fields.length > 0) {
+                    models.push({ name: tableName, fields, relations, orm: "drizzle", confidence: "ast" });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sf);
+    // Also extract Drizzle relations() calls
+    extractDrizzleRelations(ts, sf, models);
+    return models;
+}
+function parseFieldChain(ts, sf, node) {
+    const SK = ts.SyntaxKind;
+    const flags = [];
+    let type = "unknown";
+    let refTarget = null;
+    // Walk the chain from outermost to innermost call
+    // e.g., serial("id").primaryKey().notNull() is:
+    // CallExpression(.notNull)
+    //   expression: PropertyAccessExpression
+    //     expression: CallExpression(.primaryKey)
+    //       expression: PropertyAccessExpression
+    //         expression: CallExpression(serial)
+    function walkChain(n) {
+        if (!n)
+            return;
+        if (n.kind === SK.CallExpression) {
+            const expr = n.expression;
+            if (expr?.kind === SK.PropertyAccessExpression) {
+                const methodName = getText(sf, expr.name);
+                switch (methodName) {
+                    case "primaryKey":
+                        flags.push("pk");
+                        break;
+                    case "notNull":
+                        flags.push("required");
+                        break;
+                    case "unique":
+                        flags.push("unique");
+                        break;
+                    case "default":
+                    case "defaultNow":
+                    case "$default":
+                    case "$defaultFn":
+                        flags.push("default");
+                        break;
+                    case "references":
+                        flags.push("fk");
+                        // Try to extract reference target: .references(() => users.id)
+                        if (n.arguments?.length > 0) {
+                            const refArg = n.arguments[0];
+                            if (refArg.kind === SK.ArrowFunction || refArg.kind === SK.FunctionExpression) {
+                                const refBody = refArg.body;
+                                if (refBody?.kind === SK.PropertyAccessExpression) {
+                                    refTarget = getText(sf, refBody);
+                                }
+                            }
+                        }
+                        break;
+                }
+                // Recurse into the receiver
+                walkChain(expr.expression);
+            }
+            else if (expr?.kind === SK.Identifier) {
+                // Base function call: serial("id"), text("name"), etc.
+                type = getText(sf, expr);
+            }
+            else if (expr?.kind === SK.PropertyAccessExpression) {
+                // Could be t.serial("id") — method on a prefix
+                type = getText(sf, expr.name);
+                // Walk further for nested chains
+            }
+        }
+    }
+    walkChain(node);
+    return { type, flags, refTarget };
+}
+function extractDrizzleRelations(ts, sf, models) {
+    const SK = ts.SyntaxKind;
+    function visit(node) {
+        // relations(tableVar, ({ one, many }) => ({ ... }))
+        if (node.kind === SK.CallExpression) {
+            const callee = node.expression;
+            const funcName = callee?.kind === SK.Identifier ? getText(sf, callee) : "";
+            if (funcName === "relations" && node.arguments?.length >= 2) {
+                const tableArg = node.arguments[0];
+                const tableName = tableArg?.kind === SK.Identifier ? getText(sf, tableArg) : "";
+                // Find matching model by variable name (approximate match)
+                const model = models.find((m) => m.name === tableName ||
+                    m.name === tableName.replace(/s$/, "") ||
+                    tableName.startsWith(m.name));
+                if (!model) {
+                    ts.forEachChild(node, visit);
+                    return;
+                }
+                const relArg = node.arguments[1];
+                // Arrow function body should be an ObjectLiteralExpression
+                let relObj = null;
+                if (relArg?.kind === SK.ArrowFunction) {
+                    const body = relArg.body;
+                    if (body?.kind === SK.ObjectLiteralExpression) {
+                        relObj = body;
+                    }
+                    else if (body?.kind === SK.ParenthesizedExpression && body.expression?.kind === SK.ObjectLiteralExpression) {
+                        relObj = body.expression;
+                    }
+                }
+                if (!relObj) {
+                    ts.forEachChild(node, visit);
+                    return;
+                }
+                for (const prop of relObj.properties || []) {
+                    if (prop.kind !== SK.PropertyAssignment)
+                        continue;
+                    const relName = prop.name ? getText(sf, prop.name) : "";
+                    if (!relName)
+                        continue;
+                    const init = prop.initializer;
+                    if (init?.kind === SK.CallExpression && init.expression?.kind === SK.Identifier) {
+                        const relType = getText(sf, init.expression); // "one" or "many"
+                        const targetArg = init.arguments?.[0];
+                        const target = targetArg?.kind === SK.Identifier ? getText(sf, targetArg) : "?";
+                        const existing = model.relations.find((r) => r.startsWith(`${relName}:`));
+                        if (!existing) {
+                            model.relations.push(`${relName}: ${relType}(${target})`);
+                        }
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sf);
+}
+// ─── TypeORM ───
+function extractTypeORMEntities(ts, sf) {
+    const models = [];
+    const SK = ts.SyntaxKind;
+    function visitNode(node) {
+        if (node.kind === SK.ClassDeclaration) {
+            const decorators = getDecorators(ts, node);
+            let isEntity = false;
+            let entityName = "";
+            for (const dec of decorators) {
+                const parsed = parseDecorator(ts, sf, dec);
+                if (parsed.name === "Entity") {
+                    isEntity = true;
+                    entityName = parsed.arg || "";
+                    break;
+                }
+            }
+            if (!isEntity) {
+                ts.forEachChild(node, visitNode);
+                return;
+            }
+            // Class name as fallback
+            const className = node.name ? getText(sf, node.name) : "Unknown";
+            const name = entityName || className;
+            const fields = [];
+            const relations = [];
+            for (const member of node.members || []) {
+                if (member.kind !== SK.PropertyDeclaration)
+                    continue;
+                const memberDecs = getDecorators(ts, member);
+                const memberName = member.name ? getText(sf, member.name) : "";
+                if (!memberName || AUDIT_FIELDS.has(memberName))
+                    continue;
+                // Get type annotation
+                const memberType = member.type ? getText(sf, member.type) : "unknown";
+                for (const dec of memberDecs) {
+                    const parsed = parseDecorator(ts, sf, dec);
+                    // Column decorators
+                    if (parsed.name === "PrimaryGeneratedColumn" || parsed.name === "PrimaryColumn") {
+                        const flags = ["pk"];
+                        if (parsed.name === "PrimaryGeneratedColumn")
+                            flags.push("default");
+                        fields.push({ name: memberName, type: parsed.arg || memberType, flags });
+                        break;
+                    }
+                    if (parsed.name === "Column" || parsed.name === "CreateDateColumn" || parsed.name === "UpdateDateColumn") {
+                        const flags = [];
+                        // Parse column options from decorator argument
+                        const decExpr = dec.expression;
+                        if (decExpr?.kind === SK.CallExpression && decExpr.arguments?.length > 0) {
+                            const optArg = decExpr.arguments[0];
+                            const optText = getText(sf, optArg);
+                            if (optText.includes("unique: true") || optText.includes("unique:true"))
+                                flags.push("unique");
+                            if (optText.includes("nullable: true") || optText.includes("nullable:true"))
+                                flags.push("nullable");
+                            if (optText.includes("default:"))
+                                flags.push("default");
+                        }
+                        fields.push({ name: memberName, type: parsed.arg || memberType, flags });
+                        break;
+                    }
+                    // Relation decorators
+                    if (["OneToMany", "ManyToOne", "OneToOne", "ManyToMany"].includes(parsed.name)) {
+                        relations.push(`${memberName}: ${parsed.name}(${memberType})`);
+                        break;
+                    }
+                }
+            }
+            if (fields.length > 0) {
+                models.push({ name, fields, relations, orm: "typeorm", confidence: "ast" });
+            }
+        }
+        ts.forEachChild(node, visitNode);
+    }
+    visitNode(sf);
+    return models;
+}

package/dist/ast/loader.d.ts

@@ -0,0 +1,20 @@
+export declare function loadTypeScript(projectRoot: string): any | null;
+export declare function resetCache(): void;
+export declare function parseSourceFile(ts: any, fileName: string, content: string): any;
+/**
+ * Get decorators from a node, handling both TS 4.x (node.decorators)
+ * and TS 5.x (node.modifiers with SyntaxKind.Decorator).
+ */
+export declare function getDecorators(ts: any, node: any): any[];
+/**
+ * Extract the name and first string argument from a decorator.
+ * @returns { name: string, arg: string | null }
+ */
+export declare function parseDecorator(ts: any, sf: any, decorator: any): {
+    name: string;
+    arg: string | null;
+};
+/**
+ * Get text from a node safely.
+ */
+export declare function getText(sf: any, node: any): string;