codesight 1.2.0 → 1.3.1

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;

package/dist/ast/loader.js

@@ -0,0 +1,105 @@
+/**
+ * Dynamic TypeScript compiler loader.
+ * Loads the TypeScript compiler from the scanned project's node_modules.
+ * Zero new dependencies — borrows TS from the project being analyzed.
+ * Falls back gracefully when TypeScript is not available.
+ */
+import { createRequire } from "node:module";
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+let cached = undefined; // undefined = not tried, null = tried and failed
+let cachedRoot = "";
+export function loadTypeScript(projectRoot) {
+    if (cached !== undefined && cachedRoot === projectRoot)
+        return cached;
+    cachedRoot = projectRoot;
+    // Strategy 1: createRequire from project root (works for npm/yarn)
+    try {
+        const req = createRequire(join(projectRoot, "package.json"));
+        cached = req("typescript");
+        return cached;
+    }
+    catch { }
+    // Strategy 2: Direct path (works for pnpm with public-hoist-pattern)
+    try {
+        const directPath = join(projectRoot, "node_modules", "typescript");
+        const req = createRequire(join(directPath, "package.json"));
+        cached = req(directPath);
+        return cached;
+    }
+    catch { }
+    // Strategy 3: Find in pnpm .pnpm store (strict mode fallback)
+    try {
+        const pnpmDir = join(projectRoot, "node_modules", ".pnpm");
+        const entries = readdirSync(pnpmDir);
+        const tsDir = entries.find((e) => e.startsWith("typescript@"));
+        if (tsDir) {
+            const tsPath = join(pnpmDir, tsDir, "node_modules", "typescript");
+            const req = createRequire(join(tsPath, "package.json"));
+            cached = req(tsPath);
+            return cached;
+        }
+    }
+    catch { }
+    // TypeScript not available — fall back to regex
+    cached = null;
+    return null;
+}
+export function resetCache() {
+    cached = undefined;
+}
+export function parseSourceFile(ts, fileName, content) {
+    return ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true // setParentNodes — needed for walking up the tree
+    );
+}
+/**
+ * Get decorators from a node, handling both TS 4.x (node.decorators)
+ * and TS 5.x (node.modifiers with SyntaxKind.Decorator).
+ */
+export function getDecorators(ts, node) {
+    if (node.decorators)
+        return Array.from(node.decorators);
+    if (node.modifiers) {
+        return node.modifiers.filter((m) => m.kind === ts.SyntaxKind.Decorator);
+    }
+    return [];
+}
+/**
+ * Extract the name and first string argument from a decorator.
+ * @returns { name: string, arg: string | null }
+ */
+export function parseDecorator(ts, sf, decorator) {
+    const SK = ts.SyntaxKind;
+    const expr = decorator.expression;
+    if (!expr)
+        return { name: "", arg: null };
+    // @Get() or @Get('path') — CallExpression
+    if (expr.kind === SK.CallExpression) {
+        const callee = expr.expression;
+        const name = callee.kind === SK.Identifier ? callee.getText(sf) : "";
+        let arg = null;
+        if (expr.arguments?.length > 0) {
+            const first = expr.arguments[0];
+            if (first.kind === SK.StringLiteral || first.kind === SK.NoSubstitutionTemplateLiteral) {
+                arg = first.text;
+            }
+        }
+        return { name, arg };
+    }
+    // @Controller (without parens) — Identifier
+    if (expr.kind === SK.Identifier) {
+        return { name: expr.getText(sf), arg: null };
+    }
+    return { name: "", arg: null };
+}
+/**
+ * Get text from a node safely.
+ */
+export function getText(sf, node) {
+    try {
+        return node.getText(sf);
+    }
+    catch {
+        return node.escapedText || node.text || "";
+    }
+}

package/dist/detectors/components.js

@@ -1,5 +1,7 @@
 import { relative, basename, extname } from "node:path";
 import { readFileSafe } from "../scanner.js";
+import { loadTypeScript } from "../ast/loader.js";
+import { extractReactComponentsAST } from "../ast/extract-components.js";
 // shadcn/ui + radix primitives to filter out
 const UI_PRIMITIVES = new Set([
     "accordion",
@@ -84,6 +86,7 @@ async function detectReactComponents(files, project) {
         !f.endsWith(".stories.tsx") &&
         !f.endsWith(".stories.jsx"));
     const components = [];
+    const ts = loadTypeScript(project.root);
     for (const file of componentFiles) {
         if (isUIPrimitive(file))
             continue;
@@ -91,6 +94,14 @@ async function detectReactComponents(files, project) {
         if (!content)
             continue;
         const rel = relative(project.root, file);
+        // Try AST first — extracts prop types, handles forwardRef/memo
+        if (ts) {
+            const astComponents = extractReactComponentsAST(ts, file, content, rel);
+            if (astComponents.length > 0) {
+                components.push(...astComponents);
+                continue;
+            }
+        }
         // Detect component name from export
         let name = "";
         // export default function ComponentName