codesight 1.1.1 → 1.3.0

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/blast-radius.d.ts

@@ -0,0 +1,11 @@
+import type { ScanResult, BlastRadiusResult } from "../types.js";
+/**
+ * Blast radius analysis: given a file, find all transitively affected
+ * files, routes, models, and middleware using BFS through the import graph.
+ */
+export declare function analyzeBlastRadius(filePath: string, result: ScanResult, maxDepth?: number): BlastRadiusResult;
+/**
+ * Multi-file blast radius: given a list of changed files (e.g., from git diff),
+ * find the combined blast radius.
+ */
+export declare function analyzeMultiFileBlastRadius(files: string[], result: ScanResult, maxDepth?: number): BlastRadiusResult;

package/dist/detectors/blast-radius.js

@@ -0,0 +1,102 @@
+/**
+ * Blast radius analysis: given a file, find all transitively affected
+ * files, routes, models, and middleware using BFS through the import graph.
+ */
+export function analyzeBlastRadius(filePath, result, maxDepth = 3) {
+    const { graph, routes, schemas, middleware } = result;
+    // Build reverse adjacency map: file -> files that import it
+    const importedBy = new Map();
+    // Build forward adjacency map: file -> files it imports
+    const imports = new Map();
+    for (const edge of graph.edges) {
+        if (!importedBy.has(edge.to))
+            importedBy.set(edge.to, new Set());
+        importedBy.get(edge.to).add(edge.from);
+        if (!imports.has(edge.from))
+            imports.set(edge.from, new Set());
+        imports.get(edge.from).add(edge.to);
+    }
+    // BFS: find all files affected by changing this file
+    // "affected" = files that directly or transitively import this file
+    const affected = new Set();
+    const queue = [{ file: filePath, depth: 0 }];
+    while (queue.length > 0) {
+        const { file, depth } = queue.shift();
+        if (depth > maxDepth)
+            continue;
+        const dependents = importedBy.get(file);
+        if (!dependents)
+            continue;
+        for (const dep of dependents) {
+            if (!affected.has(dep)) {
+                affected.add(dep);
+                queue.push({ file: dep, depth: depth + 1 });
+            }
+        }
+    }
+    // Also include the file itself
+    affected.add(filePath);
+    // Find affected routes (routes whose handler file is in the affected set)
+    const affectedRoutes = routes.filter((r) => affected.has(r.file));
+    // Find affected models (schemas referenced in affected files)
+    const affectedModels = [];
+    for (const schema of schemas) {
+        for (const file of affected) {
+            // Check if any route/lib in this file touches this model
+            const routesInFile = routes.filter((r) => r.file === file);
+            if (routesInFile.some((r) => r.tags.includes("db"))) {
+                if (!affectedModels.includes(schema.name)) {
+                    affectedModels.push(schema.name);
+                }
+                break;
+            }
+        }
+    }
+    // Find affected middleware
+    const affectedMiddleware = middleware
+        .filter((m) => affected.has(m.file))
+        .map((m) => m.name);
+    return {
+        file: filePath,
+        affectedFiles: Array.from(affected).filter((f) => f !== filePath),
+        affectedRoutes,
+        affectedModels,
+        affectedMiddleware,
+        depth: maxDepth,
+    };
+}
+/**
+ * Multi-file blast radius: given a list of changed files (e.g., from git diff),
+ * find the combined blast radius.
+ */
+export function analyzeMultiFileBlastRadius(files, result, maxDepth = 3) {
+    const combined = new Set();
+    const combinedRoutes = [];
+    const combinedModels = new Set();
+    const combinedMiddleware = new Set();
+    for (const file of files) {
+        const br = analyzeBlastRadius(file, result, maxDepth);
+        for (const f of br.affectedFiles)
+            combined.add(f);
+        for (const r of br.affectedRoutes) {
+            if (!combinedRoutes.some((cr) => cr.path === r.path && cr.method === r.method)) {
+                combinedRoutes.push(r);
+            }
+        }
+        for (const m of br.affectedModels)
+            combinedModels.add(m);
+        for (const mw of br.affectedMiddleware)
+            combinedMiddleware.add(mw);
+    }
+    // Remove the input files from affected
+    for (const file of files)
+        combined.delete(file);
+    return {
+        file: files.join(", "),
+        affectedFiles: Array.from(combined),
+        affectedRoutes: combinedRoutes,
+        affectedModels: Array.from(combinedModels),
+        affectedMiddleware: Array.from(combinedMiddleware),
+        depth: maxDepth,
+    };
+}

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

package/dist/detectors/routes.js

@@ -1,5 +1,7 @@
 import { relative, basename } from "node:path";
 import { readFileSafe } from "../scanner.js";
+import { loadTypeScript } from "../ast/loader.js";
+import { extractRoutesAST } from "../ast/extract-routes.js";
 const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
 const TAG_PATTERNS = [
     ["auth", [/auth/i, /jwt/i, /token/i, /session/i, /bearer/i, /passport/i, /clerk/i, /betterAuth/i, /better-auth/i]],
@@ -157,11 +159,22 @@ async function detectNextPagesApi(files, project) {
 async function detectHonoRoutes(files, project) {
     const tsFiles = files.filter((f) => f.match(/\.(ts|js|tsx|jsx|mjs)$/));
     const routes = [];
+    const ts = loadTypeScript(project.root);
     for (const file of tsFiles) {
         const content = await readFileSafe(file);
         if (!content.includes("hono") && !content.includes("Hono"))
             continue;
         const rel = relative(project.root, file);
+        const tags = detectTags(content);
+        // Try AST first
+        if (ts) {
+            const astRoutes = extractRoutesAST(ts, rel, content, "hono", tags);
+            if (astRoutes.length > 0) {
+                routes.push(...astRoutes);
+                continue;
+            }
+        }
+        // Regex fallback
         const routePattern = /\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
         let match;
         while ((match = routePattern.exec(content)) !== null) {
@@ -172,8 +185,9 @@ async function detectHonoRoutes(files, project) {
                 method: match[1].toUpperCase(),
                 path,
                 file: rel,
-                tags: detectTags(content),
+                tags,
                 framework: "hono",
+                confidence: "regex",
             });
         }
     }
@@ -183,11 +197,22 @@ async function detectHonoRoutes(files, project) {
 async function detectExpressRoutes(files, project) {
     const tsFiles = files.filter((f) => f.match(/\.(ts|js|mjs|cjs)$/));
     const routes = [];
+    const ts = loadTypeScript(project.root);
     for (const file of tsFiles) {
         const content = await readFileSafe(file);
         if (!content.includes("express") && !content.includes("Router"))
             continue;
         const rel = relative(project.root, file);
+        const tags = detectTags(content);
+        // Try AST first
+        if (ts) {
+            const astRoutes = extractRoutesAST(ts, rel, content, "express", tags);
+            if (astRoutes.length > 0) {
+                routes.push(...astRoutes);
+                continue;
+            }
+        }
+        // Regex fallback
         const routePattern = /(?:app|router|server)\s*\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
         let match;
         while ((match = routePattern.exec(content)) !== null) {
@@ -195,8 +220,9 @@ async function detectExpressRoutes(files, project) {
                 method: match[1].toUpperCase(),
                 path: match[2],
                 file: rel,
-                tags: detectTags(content),
+                tags,
                 framework: "express",
+                confidence: "regex",
             });
         }
     }
@@ -206,11 +232,22 @@ async function detectExpressRoutes(files, project) {
 async function detectFastifyRoutes(files, project) {
     const tsFiles = files.filter((f) => f.match(/\.(ts|js|mjs|cjs)$/));
     const routes = [];
+    const ts = loadTypeScript(project.root);
     for (const file of tsFiles) {
         const content = await readFileSafe(file);
         if (!content.includes("fastify"))
             continue;
         const rel = relative(project.root, file);
+        const tags = detectTags(content);
+        // Try AST first
+        if (ts) {
+            const astRoutes = extractRoutesAST(ts, rel, content, "fastify", tags);
+            if (astRoutes.length > 0) {
+                routes.push(...astRoutes);
+                continue;
+            }
+        }
+        // Regex fallback
         const routePattern = /(?:fastify|server|app)\s*\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
         let match;
         while ((match = routePattern.exec(content)) !== null) {
@@ -218,8 +255,9 @@ async function detectFastifyRoutes(files, project) {
                 method: match[1].toUpperCase(),
                 path: match[2],
                 file: rel,
-                tags: detectTags(content),
+                tags,
                 framework: "fastify",
+                confidence: "regex",
             });
         }
         // Object-style route registration
@@ -229,8 +267,9 @@ async function detectFastifyRoutes(files, project) {
                 method: match[1].toUpperCase(),
                 path: match[2],
                 file: rel,
-                tags: detectTags(content),
+                tags,
                 framework: "fastify",
+                confidence: "regex",
             });
         }
     }
@@ -240,11 +279,20 @@ async function detectFastifyRoutes(files, project) {
 async function detectKoaRoutes(files, project) {
     const tsFiles = files.filter((f) => f.match(/\.(ts|js|mjs|cjs)$/));
     const routes = [];
+    const ts = loadTypeScript(project.root);
     for (const file of tsFiles) {
         const content = await readFileSafe(file);
         if (!content.includes("koa") && !content.includes("Router"))
             continue;
         const rel = relative(project.root, file);
+        const tags = detectTags(content);
+        if (ts) {
+            const astRoutes = extractRoutesAST(ts, rel, content, "koa", tags);
+            if (astRoutes.length > 0) {
+                routes.push(...astRoutes);
+                continue;
+            }
+        }
         const routePattern = /router\s*\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
         let match;
         while ((match = routePattern.exec(content)) !== null) {
@@ -252,8 +300,9 @@ async function detectKoaRoutes(files, project) {
                 method: match[1].toUpperCase(),
                 path: match[2],
                 file: rel,
-                tags: detectTags(content),
+                tags,
                 framework: "koa",
+                confidence: "regex",
             });
         }
     }
@@ -263,15 +312,24 @@ async function detectKoaRoutes(files, project) {
 async function detectNestJSRoutes(files, project) {
     const tsFiles = files.filter((f) => f.match(/\.(ts|js)$/));
     const routes = [];
+    const ts = loadTypeScript(project.root);
     for (const file of tsFiles) {
         const content = await readFileSafe(file);
         if (!content.includes("@Controller") && !content.includes("@Get") && !content.includes("@Post"))
             continue;
         const rel = relative(project.root, file);
-        // Extract controller base path: @Controller('users') or @Controller('/users')
+        const tags = detectTags(content);
+        // Try AST — NestJS benefits most from AST (decorator + controller prefix combining)
+        if (ts) {
+            const astRoutes = extractRoutesAST(ts, rel, content, "nestjs", tags);
+            if (astRoutes.length > 0) {
+                routes.push(...astRoutes);
+                continue;
+            }
+        }
+        // Regex fallback
         const controllerMatch = content.match(/@Controller\s*\(\s*['"`]([^'"`]*)['"`]\s*\)/);
         const basePath = controllerMatch ? "/" + controllerMatch[1].replace(/^\//, "") : "";
-        // Match method decorators: @Get(), @Post('/create'), @Put(':id'), etc.
         const decoratorPattern = /@(Get|Post|Put|Patch|Delete|Options|Head|All)\s*\(\s*(?:['"`]([^'"`]*)['"`])?\s*\)/gi;
         let match;
         while ((match = decoratorPattern.exec(content)) !== null) {
@@ -282,8 +340,9 @@ async function detectNestJSRoutes(files, project) {
                 method,
                 path: fullPath,
                 file: rel,
-                tags: detectTags(content),
+                tags,
                 framework: "nestjs",
+                confidence: "regex",
             });
         }
     }
@@ -293,11 +352,20 @@ async function detectNestJSRoutes(files, project) {
 async function detectElysiaRoutes(files, project) {
     const tsFiles = files.filter((f) => f.match(/\.(ts|js|mjs)$/));
     const routes = [];
+    const ts = loadTypeScript(project.root);
     for (const file of tsFiles) {
         const content = await readFileSafe(file);
         if (!content.includes("elysia") && !content.includes("Elysia"))
             continue;
         const rel = relative(project.root, file);
+        const tags = detectTags(content);
+        if (ts) {
+            const astRoutes = extractRoutesAST(ts, rel, content, "elysia", tags);
+            if (astRoutes.length > 0) {
+                routes.push(...astRoutes);
+                continue;
+            }
+        }
         const routePattern = /\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
         let match;
         while ((match = routePattern.exec(content)) !== null) {
@@ -308,8 +376,9 @@ async function detectElysiaRoutes(files, project) {
                 method: match[1].toUpperCase(),
                 path,
                 file: rel,
-                tags: detectTags(content),
+                tags,
                 framework: "elysia",
+                confidence: "regex",
             });
         }
     }
@@ -341,6 +410,7 @@ async function detectAdonisRoutes(files, project) {
 async function detectTRPCRoutes(files, project) {
     const tsFiles = files.filter((f) => f.match(/\.(ts|js)$/));
     const routes = [];
+    const ts = loadTypeScript(project.root);
     for (const file of tsFiles) {
         const content = await readFileSafe(file);
         if (!content.includes("Procedure") && !content.includes("procedure") && !content.includes("router"))
@@ -348,11 +418,16 @@ async function detectTRPCRoutes(files, project) {
         if (!content.includes("trpc") && !content.includes("TRPC") && !content.includes("createTRPCRouter") && !content.includes("publicProcedure") && !content.includes("protectedProcedure"))
             continue;
         const rel = relative(project.root, file);
-        // Match tRPC procedure definitions like:
-        //   list: publicProcedure.query(...)
-        //   create: publicProcedure.input(schema).mutation(...)
-        //   getById: t.procedure.input(z.object({...})).query(...)
-        // Strategy: find lines with "query(" or "mutation(" and extract the procedure name
+        const tags = detectTags(content);
+        // AST handles tRPC much better — properly parses router nesting and procedure chains
+        if (ts) {
+            const astRoutes = extractRoutesAST(ts, rel, content, "trpc", tags);
+            if (astRoutes.length > 0) {
+                routes.push(...astRoutes);
+                continue;
+            }
+        }
+        // Regex fallback
         const lines = content.split("\n");
         for (const line of lines) {
             const queryMatch = line.match(/^\s*(\w+)\s*:\s*.*\.(query)\s*\(/);
@@ -366,8 +441,9 @@ async function detectTRPCRoutes(files, project) {
                         method: isQuery ? "QUERY" : "MUTATION",
                         path: procName,
                         file: rel,
-                        tags: detectTags(content),
+                        tags,
                         framework: "trpc",
+                        confidence: "regex",
                     });
                 }
             }

package/dist/detectors/schema.js

@@ -1,5 +1,7 @@
 import { join } from "node:path";
 import { readFileSafe } from "../scanner.js";
+import { loadTypeScript } from "../ast/loader.js";
+import { extractDrizzleSchemaAST, extractTypeORMSchemaAST } from "../ast/extract-schema.js";
 const AUDIT_FIELDS = new Set([
     "createdAt",
     "updatedAt",
@@ -35,10 +37,19 @@ async function detectDrizzleSchemas(files, project) {
         f.match(/\.schema\.(ts|js)$/) ||
         f.match(/\/db\/.*\.(ts|js)$/));
     const models = [];
+    const ts = loadTypeScript(project.root);
     for (const file of schemaFiles) {
         const content = await readFileSafe(file);
         if (!content.includes("pgTable") && !content.includes("mysqlTable") && !content.includes("sqliteTable"))
             continue;
+        // Try AST first — much more accurate for Drizzle field chains
+        if (ts) {
+            const astModels = extractDrizzleSchemaAST(ts, file, content);
+            if (astModels.length > 0) {
+                models.push(...astModels);
+                continue;
+            }
+        }
         // Match: export const users = pgTable("users", { ... })
         const tablePattern = /(?:export\s+)?const\s+(\w+)\s*=\s*(?:pgTable|mysqlTable|sqliteTable)\s*\(\s*['"`](\w+)['"`]\s*,\s*(?:\(\s*\)\s*=>\s*\(?\s*)?\{([\s\S]*?)\}\s*\)?\s*(?:,|\))/g;
         let match;
@@ -185,10 +196,19 @@ async function detectPrismaSchemas(project) {
 async function detectTypeORMSchemas(files, project) {
     const entityFiles = files.filter((f) => f.match(/\.entity\.(ts|js)$/) || f.match(/entities\/.*\.(ts|js)$/));
     const models = [];
+    const ts = loadTypeScript(project.root);
     for (const file of entityFiles) {
         const content = await readFileSafe(file);
         if (!content.includes("@Entity") && !content.includes("@Column"))
             continue;
+        // Try AST first — handles TypeORM decorators accurately
+        if (ts) {
+            const astModels = extractTypeORMSchemaAST(ts, file, content);
+            if (astModels.length > 0) {
+                models.push(...astModels);
+                continue;
+            }
+        }
         // Extract entity name
         const entityMatch = content.match(/@Entity\s*\(\s*(?:['"`](\w+)['"`])?\s*\)/);
         const classMatch = content.match(/class\s+(\w+)/);

package/dist/generators/ai-config.d.ts

@@ -1,2 +1,7 @@
 import type { ScanResult } from "../types.js";
 export declare function generateAIConfigs(result: ScanResult, root: string): Promise<string[]>;
+/**
+ * Generate a profile-specific config file optimized for a particular AI tool.
+ * Includes tool-specific instructions on how to use codesight outputs.
+ */
+export declare function generateProfileConfig(result: ScanResult, root: string, profile: string): Promise<string>;

package/dist/generators/ai-config.js

@@ -135,3 +135,100 @@ ${context}
     }
     return generated;
 }
+/**
+ * Generate a profile-specific config file optimized for a particular AI tool.
+ * Includes tool-specific instructions on how to use codesight outputs.
+ */
+export async function generateProfileConfig(result, root, profile) {
+    const { project, routes, schemas, graph, config } = result;
+    // Build a compact always-load summary (~1-2k tokens)
+    const summaryLines = [];
+    summaryLines.push(`# ${project.name} — Project Context\n`);
+    summaryLines.push(`**Stack:** ${project.frameworks.join(", ") || "generic"} | ${project.orms.join(", ") || "none"} | ${project.language}`);
+    if (project.isMonorepo) {
+        summaryLines.push(`**Monorepo:** ${project.workspaces.map((w) => w.name).join(", ")}`);
+    }
+    summaryLines.push(`\n${routes.length} routes | ${schemas.length} models | ${config.envVars.length} env vars | ${graph.edges.length} import links\n`);
+    // Top entry points
+    if (routes.length > 0) {
+        const areas = [...new Set(routes.map((r) => r.path.split("/").slice(0, 3).join("/")))].slice(0, 10);
+        summaryLines.push(`**API areas:** ${areas.join(", ")}`);
+    }
+    // High-impact files
+    if (graph.hotFiles.length > 0) {
+        summaryLines.push(`\n**High-impact files** (change carefully):`);
+        for (const hf of graph.hotFiles.slice(0, 5)) {
+            summaryLines.push(`- ${hf.file} (imported by ${hf.importedBy} files)`);
+        }
+    }
+    // Required env
+    const required = config.envVars.filter((e) => !e.hasDefault);
+    if (required.length > 0) {
+        summaryLines.push(`\n**Required env vars:** ${required.map((e) => e.name).join(", ")}`);
+    }
+    summaryLines.push(`\n---\n`);
+    // Profile-specific instructions
+    switch (profile) {
+        case "claude-code": {
+            summaryLines.push(`## Instructions for Claude Code\n`);
+            summaryLines.push(`Before exploring the repo, read these files in order:`);
+            summaryLines.push(`1. \`.codesight/CODESIGHT.md\` — full context map (routes, schema, components, deps)`);
+            summaryLines.push(`2. Use the codesight MCP server for targeted queries:\n`);
+            summaryLines.push(`   - \`codesight_get_summary\` — quick project overview`);
+            summaryLines.push(`   - \`codesight_get_routes --prefix /api/users\` — filtered routes`);
+            summaryLines.push(`   - \`codesight_get_blast_radius --file src/lib/db.ts\` — impact analysis before changes`);
+            summaryLines.push(`   - \`codesight_get_schema --model users\` — specific model details`);
+            summaryLines.push(`\nOnly open specific files after consulting codesight context. This saves ~${result.tokenStats.saved.toLocaleString()} tokens per conversation.`);
+            const outPath = join(root, "CLAUDE.md");
+            const existing = await fileExists(outPath) ? await readFile(outPath, "utf-8") : "";
+            if (existing && existing.includes("codesight")) {
+                await writeFile(outPath, existing.replace(/# AI Context.*?(?=\n#|\n$|$)/s, summaryLines.join("\n")));
+            }
+            else if (existing) {
+                await writeFile(outPath, existing + "\n\n" + summaryLines.join("\n"));
+            }
+            else {
+                await writeFile(outPath, summaryLines.join("\n"));
+            }
+            return "CLAUDE.md";
+        }
+        case "cursor": {
+            summaryLines.push(`## Instructions for Cursor\n`);
+            summaryLines.push(`When answering questions about this project:`);
+            summaryLines.push(`1. Read \`.codesight/CODESIGHT.md\` first for full project structure`);
+            summaryLines.push(`2. Use \`.codesight/routes.md\` to find relevant API handlers`);
+            summaryLines.push(`3. Use \`.codesight/schema.md\` to understand data models`);
+            summaryLines.push(`4. Use \`.codesight/graph.md\` to check blast radius before changes`);
+            summaryLines.push(`\nDo not crawl the file tree — the codesight context map already contains the full project structure.`);
+            await writeFile(join(root, ".cursorrules"), summaryLines.join("\n"));
+            return ".cursorrules";
+        }
+        case "codex": {
+            summaryLines.push(`## Instructions for OpenAI Codex\n`);
+            summaryLines.push(`This project uses codesight for structured context. Read .codesight/CODESIGHT.md before exploring files.`);
+            summaryLines.push(`Routes: .codesight/routes.md | Schema: .codesight/schema.md | Dependencies: .codesight/graph.md`);
+            await writeFile(join(root, "codex.md"), summaryLines.join("\n"));
+            return "codex.md";
+        }
+        case "copilot": {
+            summaryLines.push(`## Instructions for GitHub Copilot\n`);
+            summaryLines.push(`Project context is pre-generated in .codesight/. Consult CODESIGHT.md for full architecture.`);
+            const ghDir = join(root, ".github");
+            await fileExists(ghDir) || await (await import("node:fs/promises")).mkdir(ghDir, { recursive: true });
+            await writeFile(join(ghDir, "copilot-instructions.md"), summaryLines.join("\n"));
+            return ".github/copilot-instructions.md";
+        }
+        case "windsurf": {
+            summaryLines.push(`## Instructions for Windsurf\n`);
+            summaryLines.push(`Read .codesight/CODESIGHT.md for full project map before exploring files.`);
+            summaryLines.push(`Use .codesight/routes.md for API structure and .codesight/graph.md for dependency analysis.`);
+            await writeFile(join(root, ".windsurfrules"), summaryLines.join("\n"));
+            return ".windsurfrules";
+        }
+        default: {
+            // Generic profile — write all configs
+            const generated = await generateAIConfigs(result, root);
+            return generated.join(", ") || "all configs already exist";
+        }
+    }
+}