codesight 1.3.2 → 1.5.0

package/dist/detectors/schema.js

@@ -1,7 +1,9 @@
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { readFileSafe } from "../scanner.js";
 import { loadTypeScript } from "../ast/loader.js";
 import { extractDrizzleSchemaAST, extractTypeORMSchemaAST } from "../ast/extract-schema.js";
+import { extractSQLAlchemyAST } from "../ast/extract-python.js";
+import { extractGORMModelsStructured } from "../ast/extract-go.js";
 const AUDIT_FIELDS = new Set([
     "createdAt",
     "updatedAt",
@@ -26,6 +28,9 @@ export async function detectSchemas(files, project) {
             case "sqlalchemy":
                 models.push(...(await detectSQLAlchemySchemas(files, project)));
                 break;
+            case "gorm":
+                models.push(...(await detectGORMSchemas(files, project)));
+                break;
         }
     }
     return models;
@@ -256,8 +261,15 @@ async function detectSQLAlchemySchemas(files, project) {
             continue;
         if (!content.includes("Base") && !content.includes("DeclarativeBase") && !content.includes("Model"))
             continue;
-        // Match class definitions
-        const classPattern = /class\s+(\w+)\s*\([^)]*(?:Base|Model|DeclarativeBase)[^)]*\)\s*:([\s\S]*?)(?=\nclass\s|\n[^\s]|\Z)/g;
+        const rel = relative(project.root, file);
+        // Try Python AST first
+        const astModels = await extractSQLAlchemyAST(rel, content);
+        if (astModels && astModels.length > 0) {
+            models.push(...astModels);
+            continue;
+        }
+        // Fallback to regex
+        const classPattern = /class\s+(\w+)\s*\([^)]*(?:Base|Model|DeclarativeBase)[^)]*\)\s*:([\s\S]*?)(?=\nclass\s|\n[^\s]|$)/g;
         let match;
         while ((match = classPattern.exec(content)) !== null) {
             const name = match[1];
@@ -301,3 +313,17 @@ async function detectSQLAlchemySchemas(files, project) {
     }
     return models;
 }
+// --- GORM ---
+async function detectGORMSchemas(files, _project) {
+    const goFiles = files.filter((f) => f.endsWith(".go"));
+    const models = [];
+    for (const file of goFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("gorm") && !content.includes("Model") && !content.includes("`json:"))
+            continue;
+        const rel = relative(_project.root, file);
+        const structModels = extractGORMModelsStructured(rel, content);
+        models.push(...structModels);
+    }
+    return models;
+}

package/dist/eval.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Evaluation suite: runs codesight on fixture repos and measures
+ * precision, recall, and F1 against ground truth.
+ */
+export declare function runEval(): Promise<void>;

package/dist/eval.js

@@ -0,0 +1,184 @@
+/**
+ * Evaluation suite: runs codesight on fixture repos and measures
+ * precision, recall, and F1 against ground truth.
+ */
+import { readFile, writeFile, mkdir, rm } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { collectFiles, detectProject } from "./scanner.js";
+import { detectRoutes } from "./detectors/routes.js";
+import { detectSchemas } from "./detectors/schema.js";
+import { detectComponents } from "./detectors/components.js";
+import { detectConfig } from "./detectors/config.js";
+import { detectMiddleware } from "./detectors/middleware.js";
+function calcMetrics(detected, expected) {
+    let tp = 0;
+    let fp = 0;
+    let fn = 0;
+    for (const item of detected) {
+        if (expected.has(item))
+            tp++;
+        else
+            fp++;
+    }
+    for (const item of expected) {
+        if (!detected.has(item))
+            fn++;
+    }
+    const precision = tp + fp > 0 ? tp / (tp + fp) : 1;
+    const recall = tp + fn > 0 ? tp / (tp + fn) : 1;
+    const f1 = precision + recall > 0 ? (2 * precision * recall) / (precision + recall) : 0;
+    return {
+        precision: Math.round(precision * 1000) / 1000,
+        recall: Math.round(recall * 1000) / 1000,
+        f1: Math.round(f1 * 1000) / 1000,
+        truePositives: tp,
+        falsePositives: fp,
+        falseNegatives: fn,
+    };
+}
+async function createTempRepo(fixture) {
+    const tmpDir = join((await import("node:os")).tmpdir(), `codesight-eval-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+    for (const [filePath, content] of Object.entries(fixture.files)) {
+        const fullPath = join(tmpDir, filePath);
+        await mkdir(dirname(fullPath), { recursive: true });
+        await writeFile(fullPath, content);
+    }
+    return tmpDir;
+}
+async function evalFixture(fixturePath) {
+    const repoJson = JSON.parse(await readFile(join(fixturePath, "repo.json"), "utf-8"));
+    const groundTruth = JSON.parse(await readFile(join(fixturePath, "ground-truth.json"), "utf-8"));
+    // Create temp repo from fixture
+    const tmpDir = await createTempRepo(repoJson);
+    const startTime = Date.now();
+    try {
+        // Run codesight detectors
+        const project = await detectProject(tmpDir);
+        const files = await collectFiles(tmpDir, 10);
+        const [routes, schemas, components, config, middleware] = await Promise.all([
+            detectRoutes(files, project),
+            detectSchemas(files, project),
+            detectComponents(files, project),
+            detectConfig(files, project),
+            detectMiddleware(files, project),
+        ]);
+        const runtime = Date.now() - startTime;
+        // Compare routes: method:path
+        const detectedRoutes = new Set(routes.map((r) => `${r.method}:${r.path}`));
+        const expectedRoutes = new Set((groundTruth.routes || []).map((r) => `${r.method}:${r.path}`));
+        // Compare models: name
+        const detectedModels = new Set(schemas.map((s) => s.name.toLowerCase()));
+        const expectedModels = new Set((groundTruth.models || []).map((m) => m.name.toLowerCase()));
+        // Compare env vars
+        const detectedEnvVars = new Set(config.envVars.map((e) => e.name));
+        const expectedEnvVars = new Set(groundTruth.envVars || []);
+        const result = {
+            name: repoJson.name,
+            routes: calcMetrics(detectedRoutes, expectedRoutes),
+            models: calcMetrics(detectedModels, expectedModels),
+            envVars: calcMetrics(detectedEnvVars, expectedEnvVars),
+            runtime,
+        };
+        // Components (if ground truth has them)
+        if (groundTruth.components && groundTruth.components.length > 0) {
+            const detectedComps = new Set(components.map((c) => c.name));
+            const expectedComps = new Set(groundTruth.components.map((c) => c.name));
+            result.components = calcMetrics(detectedComps, expectedComps);
+        }
+        // Middleware
+        if (groundTruth.middleware && groundTruth.middleware.length > 0) {
+            const detectedMw = new Set(middleware.map((m) => m.name));
+            const expectedMw = new Set(groundTruth.middleware);
+            result.middleware = calcMetrics(detectedMw, expectedMw);
+        }
+        return result;
+    }
+    finally {
+        // Cleanup temp dir
+        await rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+function formatPercent(n) {
+    return `${(n * 100).toFixed(1)}%`;
+}
+function printMetrics(label, m) {
+    console.log(`    ${label.padEnd(14)} P: ${formatPercent(m.precision).padStart(6)}  R: ${formatPercent(m.recall).padStart(6)}  F1: ${formatPercent(m.f1).padStart(6)}  (TP:${m.truePositives} FP:${m.falsePositives} FN:${m.falseNegatives})`);
+}
+export async function runEval() {
+    // Find eval fixtures
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const evalDir = join(__dirname, "..", "eval", "fixtures");
+    let fixtureNames;
+    try {
+        const { readdir } = await import("node:fs/promises");
+        fixtureNames = await readdir(evalDir);
+    }
+    catch {
+        // Try from dist path
+        const altDir = join(__dirname, "..", "..", "eval", "fixtures");
+        const { readdir } = await import("node:fs/promises");
+        fixtureNames = await readdir(altDir);
+        // Override evalDir for the loop below
+        return runEvalFromDir(altDir, fixtureNames);
+    }
+    return runEvalFromDir(evalDir, fixtureNames);
+}
+async function runEvalFromDir(evalDir, fixtureNames) {
+    console.log(`\n  codesight eval — precision/recall benchmarks\n`);
+    const results = [];
+    let totalPrecision = 0;
+    let totalRecall = 0;
+    let totalF1 = 0;
+    let metricCount = 0;
+    for (const name of fixtureNames) {
+        const fixturePath = join(evalDir, name);
+        // Check if it has repo.json
+        try {
+            await import("node:fs/promises").then((fs) => fs.stat(join(fixturePath, "repo.json")));
+        }
+        catch {
+            continue;
+        }
+        process.stdout.write(`  ${name}...`);
+        const result = await evalFixture(fixturePath);
+        results.push(result);
+        console.log(` ${result.runtime}ms`);
+        printMetrics("Routes", result.routes);
+        printMetrics("Models", result.models);
+        printMetrics("Env vars", result.envVars);
+        if (result.components)
+            printMetrics("Components", result.components);
+        if (result.middleware)
+            printMetrics("Middleware", result.middleware);
+        console.log("");
+        // Accumulate for averages
+        const metrics = [result.routes, result.models, result.envVars];
+        if (result.components)
+            metrics.push(result.components);
+        if (result.middleware)
+            metrics.push(result.middleware);
+        for (const m of metrics) {
+            totalPrecision += m.precision;
+            totalRecall += m.recall;
+            totalF1 += m.f1;
+            metricCount++;
+        }
+    }
+    if (results.length === 0) {
+        console.log("  No fixtures found. Add fixtures to eval/fixtures/");
+        return;
+    }
+    // Summary
+    const avgP = totalPrecision / metricCount;
+    const avgR = totalRecall / metricCount;
+    const avgF1 = totalF1 / metricCount;
+    const totalRuntime = results.reduce((s, r) => s + r.runtime, 0);
+    console.log("  ──────────────────────────────────────────");
+    console.log(`  Fixtures:           ${results.length}`);
+    console.log(`  Avg precision:      ${formatPercent(avgP)}`);
+    console.log(`  Avg recall:         ${formatPercent(avgR)}`);
+    console.log(`  Avg F1:             ${formatPercent(avgF1)}`);
+    console.log(`  Total runtime:      ${totalRuntime}ms`);
+    console.log("");
+}

package/dist/index.js

@@ -14,7 +14,8 @@ 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.3.2";
+import { loadConfig, mergeCliConfig } from "./config.js";
+const VERSION = "1.5.0";
 const BRAND = "codesight";
 function printHelp() {
     console.log(`
@@ -35,9 +36,15 @@ function printHelp() {
     --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
+    --telemetry          Run token telemetry (real before/after measurement)
+    --eval               Run precision/recall benchmarks on eval fixtures
     -v, --version        Show version
     -h, --help           Show this help
 
+  Config:
+    Reads codesight.config.(ts|js|json) or package.json "codesight" field.
+    See docs for disableDetectors, customRoutePatterns, plugins, and more.
+
   Examples:
     npx ${BRAND}                    # Scan current directory
     npx ${BRAND} --init             # Scan + generate AI config files
@@ -45,6 +52,8 @@ function printHelp() {
     npx ${BRAND} --watch            # Watch mode, re-scan on changes
     npx ${BRAND} --mcp              # Start MCP server
     npx ${BRAND} --hook             # Install git pre-commit hook
+    npx ${BRAND} --telemetry        # Measure real token savings
+    npx ${BRAND} --eval             # Run accuracy benchmarks
     npx ${BRAND} ./my-project       # Scan specific directory
 `);
 }
@@ -57,7 +66,7 @@ async function fileExists(path) {
         return false;
     }
 }
-async function scan(root, outputDirName, maxDepth) {
+async function scan(root, outputDirName, maxDepth, userConfig = {}) {
     const outputDir = join(root, outputDirName);
     console.log(`\n  ${BRAND} v${VERSION}`);
     console.log(`  Scanning: ${root}\n`);
@@ -73,17 +82,39 @@ async function scan(root, outputDirName, maxDepth) {
     process.stdout.write("  Collecting files...");
     const files = await collectFiles(root, maxDepth);
     console.log(` ${files.length} files`);
-    // Step 3: Run all detectors in parallel
+    // Step 3: Run all detectors in parallel (respecting disableDetectors config)
     process.stdout.write("  Analyzing...");
-    const [rawRoutes, schemas, components, libs, config, middleware, graph] = await Promise.all([
-        detectRoutes(files, project),
-        detectSchemas(files, project),
-        detectComponents(files, project),
-        detectLibs(files, project),
-        detectConfig(files, project),
-        detectMiddleware(files, project),
-        detectDependencyGraph(files, project),
+    const disabled = new Set(userConfig.disableDetectors || []);
+    const [rawRoutes, schemas, components, libs, configResult, middleware, graph] = await Promise.all([
+        disabled.has("routes") ? Promise.resolve([]) : detectRoutes(files, project),
+        disabled.has("schema") ? Promise.resolve([]) : detectSchemas(files, project),
+        disabled.has("components") ? Promise.resolve([]) : detectComponents(files, project),
+        disabled.has("libs") ? Promise.resolve([]) : detectLibs(files, project),
+        disabled.has("config") ? Promise.resolve({ envVars: [], configFiles: [], dependencies: {}, devDependencies: {} }) : detectConfig(files, project),
+        disabled.has("middleware") ? Promise.resolve([]) : detectMiddleware(files, project),
+        disabled.has("graph") ? Promise.resolve({ edges: [], hotFiles: [] }) : detectDependencyGraph(files, project),
     ]);
+    // Step 3b: Run plugin detectors
+    if (userConfig.plugins) {
+        for (const plugin of userConfig.plugins) {
+            if (plugin.detector) {
+                try {
+                    const pluginResult = await plugin.detector(files, project);
+                    if (pluginResult.routes)
+                        rawRoutes.push(...pluginResult.routes);
+                    if (pluginResult.schemas)
+                        schemas.push(...pluginResult.schemas);
+                    if (pluginResult.components)
+                        components.push(...pluginResult.components);
+                    if (pluginResult.middleware)
+                        middleware.push(...pluginResult.middleware);
+                }
+                catch (err) {
+                    console.warn(`\n  Warning: plugin "${plugin.name}" failed: ${err.message}`);
+                }
+            }
+        }
+    }
     // Step 4: Enrich routes with contract info
     const routes = await enrichRouteContracts(rawRoutes, project);
     // Report AST vs regex detection
@@ -106,7 +137,7 @@ async function scan(root, outputDirName, maxDepth) {
         schemas,
         components,
         libs,
-        config,
+        config: configResult,
         middleware,
         graph,
         tokenStats: { outputTokens: 0, estimatedExplorationTokens: 0, saved: 0, fileCount: files.length },
@@ -126,7 +157,7 @@ async function scan(root, outputDirName, maxDepth) {
     Models:       ${schemas.length}
     Components:   ${components.length}
     Libraries:    ${libs.length}
-    Env vars:     ${config.envVars.length}
+    Env vars:     ${configResult.envVars.length}
     Middleware:    ${middleware.length}
     Import links: ${graph.edges.length}
     Hot files:    ${graph.hotFiles.length}
@@ -234,6 +265,8 @@ async function main() {
     let doBenchmark = false;
     let doProfile = "";
     let doBlast = "";
+    let doTelemetry = false;
+    let doEval = false;
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if ((arg === "-o" || arg === "--output") && args[i + 1]) {
@@ -273,6 +306,12 @@ async function main() {
         else if (arg === "--blast" && args[i + 1]) {
             doBlast = args[++i];
         }
+        else if (arg === "--telemetry") {
+            doTelemetry = true;
+        }
+        else if (arg === "--eval") {
+            doEval = true;
+        }
         else if (!arg.startsWith("-")) {
             targetDir = resolve(arg);
         }
@@ -283,13 +322,58 @@ async function main() {
         await startMCPServer();
         return;
     }
+    // Eval mode (standalone, no scan needed)
+    if (doEval) {
+        const { runEval } = await import("./eval.js");
+        await runEval();
+        return;
+    }
     const root = resolve(targetDir);
+    // Load config file
+    const fileConfig = await loadConfig(root);
+    const config = mergeCliConfig(fileConfig, {
+        maxDepth: maxDepth !== 10 ? maxDepth : undefined,
+        outputDir: outputDirName !== ".codesight" ? outputDirName : undefined,
+        profile: doProfile || undefined,
+    });
+    // Apply config overrides
+    if (config.maxDepth)
+        maxDepth = config.maxDepth;
+    if (config.outputDir)
+        outputDirName = config.outputDir;
     // Install git hook
     if (doHook) {
         await installGitHook(root, outputDirName);
     }
-    // Run scan
-    const result = await scan(root, outputDirName, maxDepth);
+    // Run scan (passes config for disabled detectors + plugins)
+    let result = await scan(root, outputDirName, maxDepth, config);
+    // Run plugin post-processors
+    if (config.plugins) {
+        for (const plugin of config.plugins) {
+            if (plugin.postProcessor) {
+                try {
+                    result = await plugin.postProcessor(result);
+                }
+                catch (err) {
+                    console.warn(`  Warning: plugin "${plugin.name}" post-processor failed: ${err.message}`);
+                }
+            }
+        }
+    }
+    // Token telemetry
+    if (doTelemetry) {
+        const { runTelemetry } = await import("./telemetry.js");
+        const outputDir = join(root, outputDirName);
+        process.stdout.write("  Running telemetry...");
+        const report = await runTelemetry(root, result, outputDir);
+        console.log(` ${outputDirName}/telemetry.md`);
+        console.log(`\n  Telemetry Results:`);
+        for (const task of report.tasks) {
+            console.log(`    ${task.name}: ${task.reduction}x reduction (${task.tokensWithout.toLocaleString()} → ${task.tokensWith.toLocaleString()} tokens)`);
+        }
+        console.log(`    Average: ${report.summary.averageReduction}x | Tool calls saved: ${report.summary.totalToolCallsSaved}`);
+        console.log("");
+    }
     // JSON output
     if (jsonOutput) {
         console.log(JSON.stringify(result, null, 2));

package/dist/scanner.js

@@ -212,11 +212,11 @@ async function detectFrameworks(root, pkg) {
         frameworks.push("django");
     // Go frameworks - check go.mod
     const goDeps = await getGoDeps(root);
-    if (goDeps.includes("net/http"))
+    if (goDeps.some((d) => d.includes("net/http")))
         frameworks.push("go-net-http");
-    if (goDeps.includes("gin-gonic/gin"))
+    if (goDeps.some((d) => d.includes("gin-gonic/gin")))
         frameworks.push("gin");
-    if (goDeps.includes("gofiber/fiber"))
+    if (goDeps.some((d) => d.includes("gofiber/fiber")))
         frameworks.push("fiber");
     if (goDeps.some((d) => d.includes("labstack/echo")))
         frameworks.push("echo");

package/dist/telemetry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Token telemetry: measures real before/after token usage by simulating
+ * what an AI agent would do with and without codesight context.
+ *
+ * Approach: for each standard task (explain architecture, add route, review diff),
+ * measure the actual bytes of context that would be consumed.
+ *
+ * "Without codesight": count tokens from the files an AI would need to read
+ * to discover routes, schema, components, config, etc.
+ *
+ * "With codesight": count tokens from the CODESIGHT.md output.
+ */
+import type { ScanResult } from "./types.js";
+export interface TelemetryTask {
+    name: string;
+    description: string;
+    /** Files the AI would need to read without codesight */
+    filesRead: string[];
+    /** Tool calls the AI would make (glob, grep, read) */
+    toolCalls: number;
+    /** Tokens consumed reading those files */
+    tokensWithout: number;
+    /** Tokens consumed from codesight output */
+    tokensWith: number;
+    /** Reduction factor */
+    reduction: number;
+}
+export interface TelemetryReport {
+    project: string;
+    tasks: TelemetryTask[];
+    summary: {
+        totalTokensWithout: number;
+        totalTokensWith: number;
+        averageReduction: number;
+        totalToolCallsSaved: number;
+    };
+}
+export declare function runTelemetry(root: string, result: ScanResult, outputDir: string): Promise<TelemetryReport>;