codesight 1.1.1 → 1.3.0

package/dist/index.js

@@ -14,7 +14,7 @@ import { calculateTokenStats } from "./detectors/tokens.js";
 import { writeOutput } from "./formatter.js";
 import { generateAIConfigs } from "./generators/ai-config.js";
 import { generateHtmlReport } from "./generators/html-report.js";
-const VERSION = "1.1.1";
+const VERSION = "1.3.0";
 const BRAND = "codesight";
 function printHelp() {
     console.log(`
@@ -33,6 +33,8 @@ function printHelp() {
     --mcp                Start as MCP server (for Claude Code, Cursor)
     --json               Output JSON instead of markdown
     --benchmark          Show detailed token savings breakdown
+    --profile <tool>     Generate optimized config (claude-code|cursor|codex|copilot|windsurf)
+    --blast <file>       Show blast radius for a file
     -v, --version        Show version
     -h, --help           Show this help
 
@@ -84,7 +86,17 @@ async function scan(root, outputDirName, maxDepth) {
     ]);
     // Step 4: Enrich routes with contract info
     const routes = await enrichRouteContracts(rawRoutes, project);
-    console.log(" done");
+    // Report AST vs regex detection
+    const astRoutes = routes.filter((r) => r.confidence === "ast").length;
+    const astSchemas = schemas.filter((s) => s.confidence === "ast").length;
+    const astComponents = components.filter((c) => c.confidence === "ast").length;
+    const totalAST = astRoutes + astSchemas + astComponents;
+    if (totalAST > 0) {
+        console.log(` done (AST: ${astRoutes} routes, ${astSchemas} models, ${astComponents} components)`);
+    }
+    else {
+        console.log(" done");
+    }
     // Step 5: Write output
     process.stdout.write("  Writing output...");
     // Temporary result without token stats to generate output
@@ -220,6 +232,8 @@ async function main() {
     let doOpen = false;
     let doMcp = false;
     let doBenchmark = false;
+    let doProfile = "";
+    let doBlast = "";
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if ((arg === "-o" || arg === "--output") && args[i + 1]) {
@@ -253,6 +267,12 @@ async function main() {
         else if (arg === "--benchmark") {
             doBenchmark = true;
         }
+        else if (arg === "--profile" && args[i + 1]) {
+            doProfile = args[++i];
+        }
+        else if (arg === "--blast" && args[i + 1]) {
+            doBlast = args[++i];
+        }
         else if (!arg.startsWith("-")) {
             targetDir = resolve(arg);
         }
@@ -329,6 +349,44 @@ async function main() {
   - 1.3x multiplier: AI revisits files during multi-turn exploration
 `);
     }
+    // Blast radius analysis
+    if (doBlast) {
+        const { analyzeBlastRadius } = await import("./detectors/blast-radius.js");
+        const br = analyzeBlastRadius(doBlast, result);
+        console.log(`\n  Blast Radius: ${doBlast}`);
+        console.log(`  Depth: ${br.depth} hops\n`);
+        if (br.affectedFiles.length > 0) {
+            console.log(`  Affected files (${br.affectedFiles.length}):`);
+            for (const f of br.affectedFiles.slice(0, 20)) {
+                console.log(`    ${f}`);
+            }
+            if (br.affectedFiles.length > 20)
+                console.log(`    ... +${br.affectedFiles.length - 20} more`);
+        }
+        if (br.affectedRoutes.length > 0) {
+            console.log(`\n  Affected routes (${br.affectedRoutes.length}):`);
+            for (const r of br.affectedRoutes) {
+                console.log(`    ${r.method} ${r.path} — ${r.file}`);
+            }
+        }
+        if (br.affectedModels.length > 0) {
+            console.log(`\n  Affected models: ${br.affectedModels.join(", ")}`);
+        }
+        if (br.affectedMiddleware.length > 0) {
+            console.log(`\n  Affected middleware: ${br.affectedMiddleware.join(", ")}`);
+        }
+        if (br.affectedFiles.length === 0) {
+            console.log("  No downstream dependencies. Minimal blast radius.");
+        }
+        console.log("");
+    }
+    // Profile-based AI config generation
+    if (doProfile) {
+        const { generateProfileConfig } = await import("./generators/ai-config.js");
+        process.stdout.write(`  Generating ${doProfile} profile...`);
+        const file = await generateProfileConfig(result, root, doProfile);
+        console.log(` ${file}`);
+    }
     // Watch mode (blocks)
     if (doWatch) {
         await watchMode(root, outputDirName, maxDepth);

package/dist/mcp-server.js

@@ -10,13 +10,20 @@ import { detectDependencyGraph } from "./detectors/graph.js";
 import { enrichRouteContracts } from "./detectors/contracts.js";
 import { calculateTokenStats } from "./detectors/tokens.js";
 import { writeOutput } from "./formatter.js";
+import { analyzeBlastRadius, analyzeMultiFileBlastRadius } from "./detectors/blast-radius.js";
 function send(msg) {
     const json = JSON.stringify(msg);
     const header = `Content-Length: ${Buffer.byteLength(json)}\r\n\r\n`;
     process.stdout.write(header + json);
 }
-async function runScan(directory) {
+// Cache scan results for the session to avoid re-scanning
+let cachedResult = null;
+let cachedRoot = null;
+async function getScanResult(directory) {
     const root = resolve(directory || process.cwd());
+    // Return cached if same directory
+    if (cachedResult && cachedRoot === root)
+        return cachedResult;
     const project = await detectProject(root);
     const files = await collectFiles(root, 10);
     const [rawRoutes, schemas, components, libs, config, middleware, graph] = await Promise.all([
@@ -42,10 +49,277 @@ async function runScan(directory) {
     };
     const outputContent = await writeOutput(tempResult, resolve(root, ".codesight"));
     const tokenStats = calculateTokenStats(tempResult, outputContent, files.length);
-    return outputContent.replace(/Saves ~\d[\d,]* tokens/, `Saves ~${tokenStats.saved.toLocaleString()} tokens`);
+    cachedResult = { ...tempResult, tokenStats };
+    cachedRoot = root;
+    return cachedResult;
 }
+// =================== TOOL IMPLEMENTATIONS ===================
+async function toolScan(args) {
+    const result = await getScanResult(args.directory);
+    const outputContent = await writeOutput(result, resolve(cachedRoot, ".codesight"));
+    return outputContent.replace(/Saves ~\d[\d,]* tokens/, `Saves ~${result.tokenStats.saved.toLocaleString()} tokens`);
+}
+async function toolGetRoutes(args) {
+    const result = await getScanResult(args.directory);
+    let routes = result.routes;
+    // Filter by prefix
+    if (args.prefix) {
+        routes = routes.filter((r) => r.path.startsWith(args.prefix));
+    }
+    // Filter by tag
+    if (args.tag) {
+        routes = routes.filter((r) => r.tags.includes(args.tag));
+    }
+    // Filter by method
+    if (args.method) {
+        routes = routes.filter((r) => r.method === args.method.toUpperCase());
+    }
+    const lines = routes.map((r) => {
+        const tags = r.tags.length > 0 ? ` [${r.tags.join(", ")}]` : "";
+        const params = r.params ? ` params(${r.params.join(", ")})` : "";
+        return `${r.method} ${r.path}${params}${tags} — ${r.file}`;
+    });
+    return lines.length > 0
+        ? `${lines.length} routes:\n${lines.join("\n")}`
+        : "No routes found matching filters.";
+}
+async function toolGetSchema(args) {
+    const result = await getScanResult(args.directory);
+    let models = result.schemas;
+    if (args.model) {
+        models = models.filter((m) => m.name.toLowerCase().includes(args.model.toLowerCase()));
+    }
+    const lines = [];
+    for (const model of models) {
+        lines.push(`### ${model.name} (${model.orm})`);
+        for (const field of model.fields) {
+            const flags = field.flags.length > 0 ? ` (${field.flags.join(", ")})` : "";
+            lines.push(`  ${field.name}: ${field.type}${flags}`);
+        }
+        if (model.relations.length > 0) {
+            lines.push(`  relations: ${model.relations.join(", ")}`);
+        }
+        lines.push("");
+    }
+    return lines.length > 0
+        ? `${models.length} models:\n${lines.join("\n")}`
+        : "No models found.";
+}
+async function toolGetBlastRadius(args) {
+    const result = await getScanResult(args.directory);
+    const maxDepth = args.depth || 3;
+    let br;
+    if (args.files && Array.isArray(args.files)) {
+        br = analyzeMultiFileBlastRadius(args.files, result, maxDepth);
+    }
+    else if (args.file) {
+        br = analyzeBlastRadius(args.file, result, maxDepth);
+    }
+    else {
+        return "Error: provide 'file' (string) or 'files' (array) parameter.";
+    }
+    const lines = [];
+    lines.push(`## Blast Radius for ${br.file}`);
+    lines.push(`Depth: ${br.depth} hops\n`);
+    if (br.affectedFiles.length > 0) {
+        lines.push(`### Affected Files (${br.affectedFiles.length})`);
+        for (const f of br.affectedFiles.slice(0, 30)) {
+            lines.push(`- ${f}`);
+        }
+        if (br.affectedFiles.length > 30) {
+            lines.push(`- ... +${br.affectedFiles.length - 30} more`);
+        }
+        lines.push("");
+    }
+    if (br.affectedRoutes.length > 0) {
+        lines.push(`### Affected Routes (${br.affectedRoutes.length})`);
+        for (const r of br.affectedRoutes) {
+            lines.push(`- ${r.method} ${r.path} — ${r.file}`);
+        }
+        lines.push("");
+    }
+    if (br.affectedModels.length > 0) {
+        lines.push(`### Potentially Affected Models (${br.affectedModels.length})`);
+        for (const m of br.affectedModels) {
+            lines.push(`- ${m}`);
+        }
+        lines.push("");
+    }
+    if (br.affectedMiddleware.length > 0) {
+        lines.push(`### Affected Middleware (${br.affectedMiddleware.length})`);
+        for (const m of br.affectedMiddleware) {
+            lines.push(`- ${m}`);
+        }
+        lines.push("");
+    }
+    if (br.affectedFiles.length === 0 && br.affectedRoutes.length === 0) {
+        lines.push("No downstream dependencies found. This file change has minimal blast radius.");
+    }
+    return lines.join("\n");
+}
+async function toolGetEnv(args) {
+    const result = await getScanResult(args.directory);
+    const envVars = result.config.envVars;
+    if (args.required_only) {
+        const required = envVars.filter((e) => !e.hasDefault);
+        const lines = required.map((e) => `${e.name} **required** — ${e.source}`);
+        return `${required.length} required env vars (no defaults):\n${lines.join("\n")}`;
+    }
+    const lines = envVars.map((e) => {
+        const status = e.hasDefault ? "(has default)" : "**required**";
+        return `${e.name} ${status} — ${e.source}`;
+    });
+    return `${envVars.length} env vars:\n${lines.join("\n")}`;
+}
+async function toolGetHotFiles(args) {
+    const result = await getScanResult(args.directory);
+    const limit = args.limit || 15;
+    const hotFiles = result.graph.hotFiles.slice(0, limit);
+    if (hotFiles.length === 0)
+        return "No import graph data. Run a full scan first.";
+    const lines = hotFiles.map((h) => `${h.file} — imported by ${h.importedBy} files`);
+    return `Top ${hotFiles.length} most-imported files (change carefully):\n${lines.join("\n")}`;
+}
+async function toolGetSummary(args) {
+    const result = await getScanResult(args.directory);
+    const { project, routes, schemas, components, config, middleware, graph, tokenStats } = result;
+    const fw = project.frameworks.join(", ") || "generic";
+    const orm = project.orms.join(", ") || "none";
+    const lines = [];
+    lines.push(`# ${project.name}`);
+    lines.push(`Stack: ${fw} | ${orm} | ${project.componentFramework} | ${project.language}`);
+    if (project.isMonorepo) {
+        lines.push(`Monorepo: ${project.workspaces.map((w) => w.name).join(", ")}`);
+    }
+    lines.push("");
+    lines.push(`${routes.length} routes | ${schemas.length} models | ${components.length} components | ${config.envVars.length} env vars | ${middleware.length} middleware | ${graph.edges.length} import links`);
+    lines.push(`Token savings: ~${tokenStats.saved.toLocaleString()} per conversation`);
+    lines.push("");
+    // Top routes summary
+    if (routes.length > 0) {
+        lines.push(`Key API areas: ${[...new Set(routes.map((r) => r.path.split("/").slice(0, 3).join("/")))].slice(0, 8).join(", ")}`);
+    }
+    // Hot files
+    if (graph.hotFiles.length > 0) {
+        lines.push(`High-impact files: ${graph.hotFiles.slice(0, 5).map((h) => h.file).join(", ")}`);
+    }
+    // Required env
+    const required = config.envVars.filter((e) => !e.hasDefault);
+    if (required.length > 0) {
+        lines.push(`Required env: ${required.slice(0, 8).map((e) => e.name).join(", ")}${required.length > 8 ? ` +${required.length - 8} more` : ""}`);
+    }
+    lines.push("");
+    lines.push("Use codesight_get_routes, codesight_get_schema, codesight_get_blast_radius for details.");
+    return lines.join("\n");
+}
+async function toolRefresh(args) {
+    cachedResult = null;
+    cachedRoot = null;
+    const result = await getScanResult(args.directory);
+    return `Refreshed. ${result.routes.length} routes, ${result.schemas.length} models, ${result.graph.edges.length} import links, ${result.config.envVars.length} env vars.`;
+}
+// =================== TOOL DEFINITIONS ===================
+const TOOLS = [
+    {
+        name: "codesight_scan",
+        description: "Full codebase scan. Returns complete AI context map with routes, schema, components, libraries, config, middleware, and dependency graph. Use this for initial project understanding.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: { type: "string", description: "Directory to scan (defaults to cwd)" },
+            },
+        },
+        handler: toolScan,
+    },
+    {
+        name: "codesight_get_summary",
+        description: "Compact project summary (~500 tokens). Stack, key stats, high-impact files, required env vars. Use this first before diving deeper.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: { type: "string", description: "Directory (defaults to cwd)" },
+            },
+        },
+        handler: toolGetSummary,
+    },
+    {
+        name: "codesight_get_routes",
+        description: "Get API routes with methods, paths, params, tags, and handler files. Supports filtering by prefix, tag, or HTTP method.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: { type: "string", description: "Directory (defaults to cwd)" },
+                prefix: { type: "string", description: "Filter routes by path prefix (e.g., '/api/users')" },
+                tag: { type: "string", description: "Filter routes by tag (e.g., 'auth', 'db', 'payment', 'ai')" },
+                method: { type: "string", description: "Filter by HTTP method (e.g., 'GET', 'POST')" },
+            },
+        },
+        handler: toolGetRoutes,
+    },
+    {
+        name: "codesight_get_schema",
+        description: "Get database models with fields, types, constraints, and relations. Optionally filter by model name.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: { type: "string", description: "Directory (defaults to cwd)" },
+                model: { type: "string", description: "Filter by model name (partial match)" },
+            },
+        },
+        handler: toolGetSchema,
+    },
+    {
+        name: "codesight_get_blast_radius",
+        description: "Blast radius analysis. Given a file (or list of files), returns all transitively affected files, routes, models, and middleware. Use before making changes to understand impact.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: { type: "string", description: "Directory (defaults to cwd)" },
+                file: { type: "string", description: "Single file path (relative to project root)" },
+                files: { type: "array", items: { type: "string" }, description: "Multiple file paths for combined blast radius" },
+                depth: { type: "number", description: "Max traversal depth (default: 3)" },
+            },
+        },
+        handler: toolGetBlastRadius,
+    },
+    {
+        name: "codesight_get_env",
+        description: "Get environment variables across the codebase with required/default status and source file.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: { type: "string", description: "Directory (defaults to cwd)" },
+                required_only: { type: "boolean", description: "Only show required vars (no defaults)" },
+            },
+        },
+        handler: toolGetEnv,
+    },
+    {
+        name: "codesight_get_hot_files",
+        description: "Get the most-imported files in the project. These have the highest blast radius — changes here affect the most other files.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: { type: "string", description: "Directory (defaults to cwd)" },
+                limit: { type: "number", description: "Number of files to return (default: 15)" },
+            },
+        },
+        handler: toolGetHotFiles,
+    },
+    {
+        name: "codesight_refresh",
+        description: "Force re-scan the project. Use after making significant changes to get updated context.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: { type: "string", description: "Directory (defaults to cwd)" },
+            },
+        },
+        handler: toolRefresh,
+    },
+];
+// =================== MCP PROTOCOL ===================
 async function handleRequest(req) {
-    // MCP initialize
     if (req.method === "initialize") {
         send({
             jsonrpc: "2.0",
@@ -53,47 +327,35 @@ async function handleRequest(req) {
             result: {
                 protocolVersion: "2024-11-05",
                 capabilities: { tools: {} },
-                serverInfo: { name: "codesight", version: "1.0.0" },
+                serverInfo: { name: "codesight", version: "1.2.0" },
             },
         });
         return;
     }
-    // MCP initialized notification
     if (req.method === "notifications/initialized") {
-        return; // no response for notifications
+        return;
     }
-    // List tools
     if (req.method === "tools/list") {
         send({
             jsonrpc: "2.0",
             id: req.id ?? null,
             result: {
-                tools: [
-                    {
-                        name: "codesight_scan",
-                        description: "Scans a codebase and returns a complete AI context map including routes, database schema, components, libraries, config, middleware, and dependency graph. Saves thousands of tokens vs manual exploration.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                directory: {
-                                    type: "string",
-                                    description: "Directory to scan (defaults to current working directory)",
-                                },
-                            },
-                        },
-                    },
-                ],
+                tools: TOOLS.map(({ name, description, inputSchema }) => ({
+                    name,
+                    description,
+                    inputSchema,
+                })),
             },
         });
         return;
     }
-    // Call tool
     if (req.method === "tools/call") {
         const toolName = req.params?.name;
         const args = req.params?.arguments || {};
-        if (toolName === "codesight_scan") {
+        const tool = TOOLS.find((t) => t.name === toolName);
+        if (tool) {
             try {
-                const result = await runScan(args.directory || process.cwd());
+                const result = await tool.handler(args);
                 send({
                     jsonrpc: "2.0",
                     id: req.id ?? null,
@@ -107,7 +369,7 @@ async function handleRequest(req) {
                     jsonrpc: "2.0",
                     id: req.id ?? null,
                     result: {
-                        content: [{ type: "text", text: `Error scanning: ${err.message}` }],
+                        content: [{ type: "text", text: `Error: ${err.message}` }],
                         isError: true,
                     },
                 });
@@ -121,7 +383,6 @@ async function handleRequest(req) {
         });
         return;
     }
-    // Unknown method
     if (req.id !== undefined) {
         send({
             jsonrpc: "2.0",
@@ -131,13 +392,11 @@ async function handleRequest(req) {
     }
 }
 export async function startMCPServer() {
-    // Read Content-Length delimited JSON-RPC messages from stdin
     let buffer = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", async (chunk) => {
         buffer += chunk;
         while (true) {
-            // Parse Content-Length header
             const headerEnd = buffer.indexOf("\r\n\r\n");
             if (headerEnd === -1)
                 break;
@@ -166,6 +425,5 @@ export async function startMCPServer() {
             }
         }
     });
-    // Keep alive
     await new Promise(() => { });
 }

package/dist/types.d.ts

@@ -17,6 +17,7 @@ export interface WorkspaceInfo {
     frameworks: Framework[];
     orms: ORM[];
 }
+export type DetectionMethod = "ast" | "regex";
 export interface RouteInfo {
     method: string;
     path: string;
@@ -26,12 +27,15 @@ export interface RouteInfo {
     requestType?: string;
     responseType?: string;
     params?: string[];
+    confidence?: DetectionMethod;
+    middleware?: string[];
 }
 export interface SchemaModel {
     name: string;
     fields: SchemaField[];
     relations: string[];
     orm: ORM;
+    confidence?: DetectionMethod;
 }
 export interface SchemaField {
     name: string;
@@ -41,6 +45,7 @@ export interface SchemaField {
 export interface ComponentInfo {
     name: string;
     file: string;
+    confidence?: DetectionMethod;
     props: string[];
     isClient: boolean;
     isServer: boolean;
@@ -81,6 +86,22 @@ export interface DependencyGraph {
         importedBy: number;
     }[];
 }
+export interface BlastRadiusResult {
+    file: string;
+    affectedFiles: string[];
+    affectedRoutes: RouteInfo[];
+    affectedModels: string[];
+    affectedMiddleware: string[];
+    depth: number;
+}
+export interface CodesightConfig {
+    disableDetectors?: string[];
+    customTags?: Record<string, string[]>;
+    maxDepth?: number;
+    outputDir?: string;
+    profile?: "claude-code" | "cursor" | "codex" | "copilot" | "windsurf" | "generic";
+    ignorePatterns?: string[];
+}
 export interface ScanResult {
     project: ProjectInfo;
     routes: RouteInfo[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codesight",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "See your codebase clearly. Universal AI context generator that maps routes, schema, components, dependencies, and more for Claude Code, Cursor, Copilot, Codex, and any AI coding tool.",
   "main": "dist/index.js",
   "bin": {