glirastes 0.3.0 → 0.3.1

package/dist/cjs/codegen/coverage.js

@@ -0,0 +1,408 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAiCoverage = checkAiCoverage;
+exports.formatCoverageReport = formatCoverageReport;
+const node_path_1 = require("node:path");
+const promises_1 = require("node:fs/promises");
+const fs_utils_js_1 = require("./fs-utils.js");
+const endpoint_scanner_js_1 = require("./endpoint-scanner.js");
+const ui_scanner_js_1 = require("./ui-scanner.js");
+const types_js_1 = require("./types.js");
+const format_js_1 = require("./format.js");
+/**
+ * Check AI tool coverage across the project.
+ * Reports on endpoint tools, UI tools, route coverage,
+ * component coverage, and sharedWith configurations.
+ */
+async function checkAiCoverage(options) {
+    const opts = (0, types_js_1.resolveDefaults)(options);
+    // Scan tools
+    const endpointScan = await (0, endpoint_scanner_js_1.scanEndpointTools)(options);
+    const uiScan = await (0, ui_scanner_js_1.scanUiTools)(options);
+    const actionIds = await (0, ui_scanner_js_1.extractActionIds)(options);
+    // NestJS controller coverage
+    let nestControllerTotal = 0;
+    let nestControllerCovered = 0;
+    let nestControllerIgnored = 0;
+    let nestToolCount = 0;
+    const uncoveredNestControllers = [];
+    if (opts.nestjsDirs.length > 0) {
+        const { scanNestControllers } = await Promise.resolve().then(() => __importStar(require('./nestjs-scanner.js')));
+        const nestResult = await scanNestControllers(opts.nestjsDirs, opts.nestjsApiPrefix);
+        // Count unique controller files that have tools
+        const coveredFiles = new Set(nestResult.tools.map(t => t.controllerFile));
+        nestControllerCovered = coveredFiles.size;
+        nestToolCount = nestResult.tools.length;
+        uncoveredNestControllers.push(...nestResult.uncoveredControllers);
+        nestControllerTotal = nestControllerCovered + uncoveredNestControllers.length;
+    }
+    // Route coverage
+    const apiDir = (0, node_path_1.join)(opts.rootDir, opts.apiDir);
+    const routeFiles = await (0, fs_utils_js_1.findRouteFiles)(apiDir);
+    const toolFiles = new Set((await (0, fs_utils_js_1.findFiles)(apiDir, opts.endpointToolFileName)).map((f) => f.replace(`/${opts.endpointToolFileName}`, '')));
+    let routeCovered = 0;
+    let routeIgnored = 0;
+    const uncoveredRoutes = [];
+    for (const routeFile of routeFiles) {
+        const routeDir = routeFile.replace('/route.ts', '');
+        const routeContent = await (0, fs_utils_js_1.readFileSafe)(routeFile);
+        if (routeContent.includes('@ai-ignore') || await (0, fs_utils_js_1.isDirAiIgnored)(routeDir)) {
+            routeIgnored++;
+            continue;
+        }
+        if (toolFiles.has(routeDir) || routeContent.includes('withAiTool(')) {
+            routeCovered++;
+        }
+        else {
+            uncoveredRoutes.push(routeFile.replace(opts.rootDir + '/', ''));
+        }
+    }
+    const routeTotal = routeFiles.length - routeIgnored;
+    // Component coverage
+    const componentsDir = (0, node_path_1.join)(opts.rootDir, opts.componentsDir);
+    const componentDirs = await (0, fs_utils_js_1.getSubdirectories)(componentsDir);
+    const uiToolDirs = new Set((await (0, fs_utils_js_1.findFiles)(componentsDir, opts.uiToolFileName)).map((f) => f.replace(`/${opts.uiToolFileName}`, '')));
+    let componentDirCovered = 0;
+    let componentDirIgnored = 0;
+    const uncoveredComponents = [];
+    for (const dir of componentDirs) {
+        if (await (0, fs_utils_js_1.isDirAiIgnored)(dir)) {
+            componentDirIgnored++;
+            continue;
+        }
+        if (uiToolDirs.has(dir)) {
+            componentDirCovered++;
+        }
+        else {
+            uncoveredComponents.push(dir.replace(opts.rootDir + '/', ''));
+        }
+    }
+    const componentDirTotal = componentDirs.length - componentDirIgnored;
+    // SharedWith analysis
+    const sharedWithConfigs = [];
+    for (const file of endpointScan.files) {
+        const content = await (0, fs_utils_js_1.readFileSafe)(file.absolutePath);
+        const toolBlocksArr = (0, fs_utils_js_1.extractBalancedBlocks)(content, /define(?:Ai)?EndpointTool\(\s*/);
+        for (const block of toolBlocksArr) {
+            const sharedMatch = block.match(/sharedWith\s*:\s*\[([^\]]*)\]/);
+            if (!sharedMatch)
+                continue;
+            const toolNameMatch = block.match(/toolName\s*:\s*['"`]([^'"`]+)['"`]/);
+            const moduleMatch = block.match(/module\s*:\s*['"`]([^'"`]+)['"`]/);
+            if (!toolNameMatch)
+                continue;
+            const sharedWith = sharedMatch[1]
+                .match(/['"`]([^'"`]+)['"`]/g)
+                ?.map((s) => s.replace(/['"`]/g, ''));
+            if (sharedWith && sharedWith.length > 0) {
+                sharedWithConfigs.push({
+                    toolName: toolNameMatch[1],
+                    primaryModule: moduleMatch?.[1] ?? 'unknown',
+                    sharedWith,
+                });
+            }
+        }
+    }
+    // Handler source-scan: find useAiClientAction() calls in .tsx files
+    // In monorepos, scan all configured dirs + default src/
+    const handlerScanDirs = [
+        (0, node_path_1.join)(opts.rootDir, 'src'),
+        ...(opts.nestjsDirs ?? []),
+        (0, node_path_1.join)(opts.rootDir, opts.componentsDir),
+    ].filter((d, i, arr) => arr.indexOf(d) === i); // dedupe
+    const tsxFiles = [];
+    for (const dir of handlerScanDirs) {
+        tsxFiles.push(...await findTsxFiles(dir));
+    }
+    const requiredActionIds = new Set(actionIds.map((a) => a.actionId));
+    const foundHandlerIds = new Set();
+    const allSourceHandlers = [];
+    for (const tsxFile of tsxFiles) {
+        const content = await (0, fs_utils_js_1.readFileSafe)(tsxFile);
+        if (content.includes('@ai-ignore'))
+            continue;
+        // Match useAiClientAction('actionId', ...) calls
+        const handlerMatches = content.matchAll(/useAiClientAction\(\s*['"`]([^'"`]+)['"`]/g);
+        for (const m of handlerMatches) {
+            const actionId = m[1];
+            foundHandlerIds.add(actionId);
+            allSourceHandlers.push({
+                actionId,
+                sourceFile: tsxFile.replace(opts.rootDir + '/', ''),
+            });
+        }
+    }
+    const handlerCoveredCount = Array.from(requiredActionIds).filter((id) => foundHandlerIds.has(id)).length;
+    const handlerTotalCount = requiredActionIds.size;
+    // Orphan handlers: registered in source but no matching UI tool actionId
+    const orphanHandlers = allSourceHandlers.filter((h) => !requiredActionIds.has(h.actionId));
+    // Missing handlers: actionIds defined in UI tools but no useAiClientAction found
+    const missingHandlers = actionIds
+        .filter((a) => !foundHandlerIds.has(a.actionId))
+        .map((a) => ({
+        actionId: a.actionId,
+        toolName: a.toolName,
+        sourceFile: a.sourceFile,
+    }));
+    return {
+        endpointToolCount: endpointScan.toolCount,
+        endpointFileCount: endpointScan.files.length,
+        uiToolCount: uiScan.toolCount,
+        uiFileCount: uiScan.files.length,
+        actionIdCount: actionIds.length,
+        routeTotal,
+        routeCovered,
+        routeIgnored,
+        routeCoveragePercent: routeTotal > 0 ? Math.round((routeCovered / routeTotal) * 100) : 100,
+        componentDirTotal,
+        componentDirCovered,
+        componentDirIgnored,
+        componentCoveragePercent: componentDirTotal > 0
+            ? Math.round((componentDirCovered / componentDirTotal) * 100)
+            : 100,
+        sharedWithConfigs,
+        handlerActionIds: Array.from(foundHandlerIds),
+        handlerCoveredCount,
+        handlerTotalCount,
+        handlerCoveragePercent: handlerTotalCount > 0
+            ? Math.round((handlerCoveredCount / handlerTotalCount) * 100)
+            : 100,
+        orphanHandlers,
+        uncoveredRoutes,
+        uncoveredComponents,
+        missingHandlers,
+        nestControllerTotal,
+        nestControllerCovered,
+        nestControllerIgnored,
+        nestControllerCoveragePercent: nestControllerTotal > 0
+            ? Math.round((nestControllerCovered / nestControllerTotal) * 100)
+            : 100,
+        nestToolCount,
+        uncoveredNestControllers,
+    };
+}
+/**
+ * Recursively find all .tsx files in a directory.
+ */
+async function findTsxFiles(dir) {
+    const results = [];
+    async function walk(currentDir) {
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = (0, node_path_1.join)(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules' || entry.name === '.git')
+                    continue;
+                await walk(fullPath);
+            }
+            else if (entry.name.endsWith('.tsx')) {
+                results.push(fullPath);
+            }
+        }
+    }
+    await walk(dir);
+    return results.sort();
+}
+/**
+ * Format a coverage report as a rich, color-coded human-readable string.
+ */
+function formatCoverageReport(report, options) {
+    if (options?.quiet) {
+        return formatCoverageReportQuiet(report);
+    }
+    const lines = [];
+    const hasHandlerIssues = report.missingHandlers.length > 0;
+    const hasOrphanHandlers = report.orphanHandlers.length > 0;
+    const hasRouteIssues = report.uncoveredRoutes.length > 0;
+    const hasComponentIssues = report.uncoveredComponents.length > 0;
+    const hasNestIssues = report.uncoveredNestControllers.length > 0;
+    const hasIssues = hasHandlerIssues || hasOrphanHandlers || hasRouteIssues || hasComponentIssues || hasNestIssues;
+    // Detect active frameworks from scan results
+    const hasNextRoutes = report.routeTotal > 0 || report.endpointFileCount > 0;
+    const hasNest = report.nestControllerTotal > 0 || report.nestToolCount > 0;
+    // Header
+    lines.push((0, format_js_1.header)('AI Tools Coverage Summary'));
+    // Endpoint Tools — framework-adaptive detail
+    const totalEndpointTools = report.endpointToolCount + report.nestToolCount;
+    const endpointParts = [];
+    if (hasNextRoutes || (!hasNest && report.endpointFileCount === 0)) {
+        endpointParts.push(`${report.endpointFileCount} route files`);
+    }
+    if (hasNest) {
+        endpointParts.push(`${report.nestControllerCovered} controllers`);
+    }
+    lines.push((0, format_js_1.metricLine)('\u2713', format_js_1.colors.green, 'Endpoint Tools:', totalEndpointTools, endpointParts.join(' + ')));
+    lines.push((0, format_js_1.metricLine)('\u2713', format_js_1.colors.green, 'UI Tools (ai-ui-tool.ts):', report.uiToolCount, `${report.uiFileCount} files`));
+    const handlerIcon = hasHandlerIssues ? '\u26A0' : '\u2713';
+    const handlerColor = hasHandlerIssues ? format_js_1.colors.yellow : format_js_1.colors.green;
+    lines.push((0, format_js_1.metricLine)(handlerIcon, handlerColor, 'Handler Coverage:', `${report.handlerCoveragePercent}%`, `${report.handlerCoveredCount}/${report.handlerTotalCount}`));
+    // Route Coverage — only show when Next.js routes exist or are expected
+    if (hasNextRoutes) {
+        const routeIcon = hasRouteIssues ? '\u26A0' : '\u2713';
+        const routeColor = hasRouteIssues ? format_js_1.colors.yellow : format_js_1.colors.green;
+        lines.push((0, format_js_1.metricLine)(routeIcon, routeColor, 'Route Coverage:', `${report.routeCoveragePercent}%`, `${report.routeCovered}/${report.routeTotal} routes${report.routeIgnored > 0 ? `, ${report.routeIgnored} ignored` : ''}`));
+    }
+    const componentIcon = hasComponentIssues ? '\u26A0' : '\u2713';
+    const componentColor = hasComponentIssues ? format_js_1.colors.yellow : format_js_1.colors.green;
+    lines.push((0, format_js_1.metricLine)(componentIcon, componentColor, 'Component Coverage:', `${report.componentCoveragePercent}%`, `${report.componentDirCovered}/${report.componentDirTotal} dirs${report.componentDirIgnored > 0 ? `, ${report.componentDirIgnored} ignored` : ''}`));
+    // NestJS Decorator Coverage — only show when NestJS is detected
+    if (hasNest) {
+        const nestIcon = report.uncoveredNestControllers.length > 0 ? '\u26A0' : '\u2713';
+        const nestColor = report.uncoveredNestControllers.length > 0 ? format_js_1.colors.yellow : format_js_1.colors.green;
+        lines.push((0, format_js_1.metricLine)(nestIcon, nestColor, 'Decorator Coverage (@AiTool):', `${report.nestControllerCoveragePercent}%`, `${report.nestControllerCovered}/${report.nestControllerTotal} controllers`));
+    }
+    const sharedCount = report.sharedWithConfigs.length;
+    lines.push((0, format_js_1.metricLine)('\u2713', format_js_1.colors.green, 'Cross-Module Sharing:', sharedCount > 0 ? `${sharedCount} Tools` : 'None'));
+    lines.push('');
+    lines.push((0, format_js_1.separator)());
+    // --- Detail sections (conditional) ---
+    // Missing handlers
+    if (hasHandlerIssues) {
+        lines.push('');
+        lines.push((0, format_js_1.sectionHeader)('Missing Handlers', report.missingHandlers.length, format_js_1.colors.red));
+        for (const h of report.missingHandlers) {
+            lines.push(`  ${format_js_1.colors.red}\u2717${format_js_1.colors.reset} ${format_js_1.colors.bold}${h.actionId}${format_js_1.colors.reset}` +
+                `  ${format_js_1.colors.dim}\u2190 ${h.toolName}${format_js_1.colors.reset}`);
+            lines.push(`    ${format_js_1.colors.dim}Defined in: ${h.sourceFile}${format_js_1.colors.reset}`);
+        }
+    }
+    // Orphan handlers
+    if (hasOrphanHandlers) {
+        lines.push('');
+        lines.push((0, format_js_1.sectionHeader)('Orphan Handlers', report.orphanHandlers.length, format_js_1.colors.yellow));
+        lines.push(`${format_js_1.colors.dim}These handlers have no corresponding UI tool definition:${format_js_1.colors.reset}`);
+        for (const o of report.orphanHandlers) {
+            lines.push(`  ${format_js_1.colors.yellow}\u26A0${format_js_1.colors.reset} ${format_js_1.colors.bold}${o.actionId}${format_js_1.colors.reset}` +
+                `  ${format_js_1.colors.dim}\u2192 ${o.sourceFile}${format_js_1.colors.reset}`);
+        }
+    }
+    // Uncovered routes
+    if (hasRouteIssues) {
+        lines.push('');
+        lines.push((0, format_js_1.sectionHeader)('Routes without ai-tool.ts', report.uncoveredRoutes.length, format_js_1.colors.yellow));
+        for (const route of report.uncoveredRoutes) {
+            lines.push(`  ${format_js_1.colors.yellow}\u26A0${format_js_1.colors.reset} ${route}`);
+            lines.push(`    ${format_js_1.colors.cyan}\u2192 glirastes scaffold --route "${route}"${format_js_1.colors.reset}`);
+        }
+        lines.push(`\n${format_js_1.colors.dim}Or add // @ai-ignore to route.ts to exclude${format_js_1.colors.reset}`);
+    }
+    // Uncovered components
+    if (hasComponentIssues) {
+        lines.push('');
+        lines.push((0, format_js_1.sectionHeader)('Components without ai-ui-tool.ts', report.uncoveredComponents.length, format_js_1.colors.yellow));
+        for (const dir of report.uncoveredComponents) {
+            lines.push(`  ${format_js_1.colors.yellow}\u26A0${format_js_1.colors.reset} ${dir}/`);
+            lines.push(`    ${format_js_1.colors.cyan}\u2192 Create ${dir}/ai-ui-tool.ts${format_js_1.colors.reset}`);
+        }
+        lines.push(`\n${format_js_1.colors.dim}Or add // @ai-ignore to any .ts/.tsx file or create .ai-ignore to exclude${format_js_1.colors.reset}`);
+    }
+    // Uncovered NestJS controllers
+    if (report.uncoveredNestControllers.length > 0) {
+        lines.push('');
+        lines.push((0, format_js_1.sectionHeader)('NestJS controllers without @AiTool', report.uncoveredNestControllers.length, format_js_1.colors.yellow));
+        lines.push(`${format_js_1.colors.dim}These controllers have HTTP endpoints but no @AiTool decorators:${format_js_1.colors.reset}`);
+        for (const ctrl of report.uncoveredNestControllers) {
+            const relPath = ctrl.controllerFile.includes('/src/')
+                ? ctrl.controllerFile.slice(ctrl.controllerFile.indexOf('/src/') + 1)
+                : ctrl.controllerFile;
+            lines.push(`  ${format_js_1.colors.yellow}\u26A0${format_js_1.colors.reset} ${format_js_1.colors.bold}${ctrl.controllerName}${format_js_1.colors.reset}` +
+                `  ${format_js_1.colors.dim}(${ctrl.httpMethodCount} endpoints)${format_js_1.colors.reset}`);
+            lines.push(`    ${format_js_1.colors.dim}${relPath}${format_js_1.colors.reset}`);
+            lines.push(`    ${format_js_1.colors.cyan}\u2192 Add @AiModule + @AiTool decorators, or create .ai-ignore to exclude${format_js_1.colors.reset}`);
+        }
+    }
+    // SharedWith configurations (when no issues — show as positive info)
+    if (sharedCount > 0 && !hasIssues) {
+        lines.push('');
+        lines.push((0, format_js_1.sectionHeader)('Cross-Module Sharing', sharedCount, format_js_1.colors.green));
+        for (const config of report.sharedWithConfigs) {
+            lines.push(`  ${format_js_1.colors.green}\u2713${format_js_1.colors.reset} ${format_js_1.colors.bold}${config.toolName}${format_js_1.colors.reset}` +
+                `  ${format_js_1.colors.dim}(${config.primaryModule})${format_js_1.colors.reset}` +
+                `  \u2192 ${config.sharedWith.join(', ')}`);
+        }
+    }
+    // Final summary
+    lines.push('');
+    lines.push((0, format_js_1.separator)());
+    lines.push('');
+    const totalTools = report.endpointToolCount + report.uiToolCount + report.nestToolCount;
+    const summaryIcon = hasIssues ? '\u26A0\uFE0F' : '\u2705';
+    const summaryColor = hasIssues ? format_js_1.colors.yellow : format_js_1.colors.green;
+    lines.push(`${summaryColor}${summaryIcon} Total: ${format_js_1.colors.bold}${totalTools} AI Tools${format_js_1.colors.reset}`);
+    lines.push('');
+    // Framework-adaptive summary lines
+    if (hasNextRoutes) {
+        lines.push(`  ${format_js_1.colors.dim}Routes:      ${report.routeCovered}/${report.routeTotal} have ai-tool.ts (${report.endpointToolCount} tools)${format_js_1.colors.reset}`);
+    }
+    if (hasNest) {
+        lines.push(`  ${format_js_1.colors.dim}Controllers: ${report.nestControllerCovered}/${report.nestControllerTotal} have @AiTool decorators (${report.nestToolCount} tools)${format_js_1.colors.reset}`);
+    }
+    lines.push(`  ${format_js_1.colors.dim}Components:  ${report.componentDirCovered}/${report.componentDirTotal} have ai-ui-tool.ts (${report.uiToolCount} tools)${format_js_1.colors.reset}`);
+    lines.push(`  ${format_js_1.colors.dim}Handlers:    ${report.handlerCoveredCount}/${report.handlerTotalCount} actionIds have useAiClientAction${format_js_1.colors.reset}`);
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Minimal quiet output for predev/prebuild hooks.
+ */
+function formatCoverageReportQuiet(report) {
+    const issues = [];
+    if (report.uncoveredRoutes.length > 0) {
+        issues.push(`${report.uncoveredRoutes.length} uncovered routes`);
+    }
+    if (report.uncoveredComponents.length > 0) {
+        issues.push(`${report.uncoveredComponents.length} uncovered components`);
+    }
+    if (report.missingHandlers.length > 0) {
+        issues.push(`${report.missingHandlers.length} missing handlers`);
+    }
+    if (report.orphanHandlers.length > 0) {
+        issues.push(`${report.orphanHandlers.length} orphan handlers`);
+    }
+    if (report.uncoveredNestControllers.length > 0) {
+        issues.push(`${report.uncoveredNestControllers.length} uncovered NestJS controllers`);
+    }
+    if (issues.length === 0) {
+        return `${format_js_1.colors.green}\u2713${format_js_1.colors.reset} AI coverage: ${report.endpointToolCount + report.uiToolCount + report.nestToolCount} tools, all OK`;
+    }
+    return `${format_js_1.colors.yellow}\u26A0${format_js_1.colors.reset} AI coverage: ${issues.join(', ')}`;
+}

package/dist/cjs/codegen/endpoint-scanner.d.ts

@@ -0,0 +1,16 @@
+import type { GenerateOptions, ScanResult } from './types.js';
+/**
+ * Scan for endpoint tool files (ai-tool.ts) in the API directory.
+ * Also detects route.ts files using withAiTool() from glirastes/server/nextjs.
+ */
+export declare function scanEndpointTools(options: GenerateOptions): Promise<ScanResult>;
+/**
+ * Generate the endpoint tools registry file.
+ *
+ * Output: a TypeScript file that imports all discovered endpoint tools and
+ * combines them into a single registry via endpointToolsToRegistry().
+ */
+export declare function generateEndpointRegistry(options: GenerateOptions): Promise<{
+    outputPath: string;
+    toolCount: number;
+}>;

package/dist/cjs/codegen/endpoint-scanner.js

@@ -0,0 +1,197 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanEndpointTools = scanEndpointTools;
+exports.generateEndpointRegistry = generateEndpointRegistry;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const fs_utils_js_1 = require("./fs-utils.js");
+const types_js_1 = require("./types.js");
+/**
+ * Scan for endpoint tool files (ai-tool.ts) in the API directory.
+ * Also detects route.ts files using withAiTool() from glirastes/server/nextjs.
+ */
+async function scanEndpointTools(options) {
+    const opts = (0, types_js_1.resolveDefaults)(options);
+    const apiDir = (0, node_path_1.join)(opts.rootDir, opts.apiDir);
+    const files = await (0, fs_utils_js_1.findFiles)(apiDir, opts.endpointToolFileName);
+    const discovered = [];
+    const discoveredDirs = new Set();
+    // 1. Standard ai-tool.ts files
+    for (const absolutePath of files) {
+        const content = await (0, fs_utils_js_1.readFileSafe)(absolutePath);
+        if (content.includes('@ai-ignore'))
+            continue;
+        if (await (0, fs_utils_js_1.isDirAiIgnored)((0, node_path_1.dirname)(absolutePath)))
+            continue;
+        const hasArray = /export\s+const\s+aiTools\s*[=:]/m.test(content);
+        const hasSingle = /export\s+const\s+aiTool\s*[=:]/m.test(content);
+        if (!hasArray && !hasSingle)
+            continue;
+        discovered.push({
+            absolutePath,
+            relativePath: absolutePath.replace(opts.rootDir + '/', ''),
+            importPath: (0, fs_utils_js_1.toImportPath)(absolutePath, opts.rootDir),
+            exportType: hasArray ? 'array' : 'single',
+        });
+        discoveredDirs.add((0, node_path_1.dirname)(absolutePath));
+    }
+    // 2. route.ts files with withAiTool() (inline tool definitions)
+    const routeFiles = await (0, fs_utils_js_1.findRouteFiles)(apiDir);
+    for (const routeFile of routeFiles) {
+        const routeDir = (0, node_path_1.dirname)(routeFile);
+        if (discoveredDirs.has(routeDir))
+            continue; // Already has ai-tool.ts
+        const content = await (0, fs_utils_js_1.readFileSafe)(routeFile);
+        if (content.includes('@ai-ignore'))
+            continue;
+        if (await (0, fs_utils_js_1.isDirAiIgnored)(routeDir))
+            continue;
+        if (!content.includes('withAiTool('))
+            continue;
+        discovered.push({
+            absolutePath: routeFile,
+            relativePath: routeFile.replace(opts.rootDir + '/', ''),
+            importPath: (0, fs_utils_js_1.toImportPath)(routeFile, opts.rootDir),
+            exportType: 'single', // withAiTool wraps a single handler
+        });
+    }
+    // Count tools (rough estimate: arrays have multiple, singles have 1)
+    let toolCount = 0;
+    for (const file of discovered) {
+        if (file.exportType === 'array') {
+            const content = await (0, fs_utils_js_1.readFileSafe)(file.absolutePath);
+            // Count defineEndpointTool or defineAiEndpointTool calls
+            const matches = content.match(/define(?:Ai)?EndpointTool\(/g);
+            toolCount += matches?.length ?? 1;
+        }
+        else {
+            toolCount += 1;
+        }
+    }
+    return { files: discovered, toolCount };
+}
+/**
+ * Generate the endpoint tools registry file.
+ *
+ * Output: a TypeScript file that imports all discovered endpoint tools and
+ * combines them into a single registry via endpointToolsToRegistry().
+ */
+async function generateEndpointRegistry(options) {
+    const opts = (0, types_js_1.resolveDefaults)(options);
+    const scan = await scanEndpointTools(options);
+    // NestJS @AiTool decorated controllers
+    let nestTools = [];
+    if (opts.nestjsDirs.length > 0) {
+        const { scanNestControllers } = await Promise.resolve().then(() => __importStar(require('./nestjs-scanner.js')));
+        const nestResult = await scanNestControllers(opts.nestjsDirs, opts.nestjsApiPrefix);
+        nestTools = nestResult.tools;
+    }
+    const imports = [];
+    const spreadParts = [];
+    scan.files.forEach((file, index) => {
+        if (file.exportType === 'array') {
+            const alias = `endpointTools${index}`;
+            imports.push(`import { aiTools as ${alias} } from '${file.importPath}';`);
+            spreadParts.push(`...${alias}`);
+        }
+        else {
+            const alias = `endpointTool${index}`;
+            imports.push(`import { aiTool as ${alias} } from '${file.importPath}';`);
+            spreadParts.push(alias);
+        }
+    });
+    // Generate inline defineEndpointTool() calls for NestJS tools
+    const nestInlineDefs = [];
+    const nestSpreadParts = [];
+    nestTools.forEach((tool, index) => {
+        const alias = `nestTool${index}`;
+        const desc = tool.description.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+        // Build path param schema fields (e.g. { id: z.string() })
+        const paramFields = tool.pathParams.map(p => `${p}: z.string()`).join(', ');
+        const inputSchema = paramFields
+            ? `z.object({ ${paramFields} }).passthrough()`
+            : 'z.object({}).passthrough()';
+        const lines = [
+            `  id: '${tool.name}'`,
+            `  toolName: '${tool.name}'`,
+            `  description: '${desc}'`,
+            `  path: '${tool.path}'`,
+            `  method: '${tool.method}'`,
+            `  inputSchema: ${inputSchema}`,
+        ];
+        if (tool.module)
+            lines.push(`  module: '${tool.module}'`);
+        if (tool.needsApproval !== undefined)
+            lines.push(`  needsApproval: ${tool.needsApproval}`);
+        if (tool.allowedRoles && tool.allowedRoles.length > 0) {
+            lines.push(`  allowedRoles: ${JSON.stringify(tool.allowedRoles)}`);
+        }
+        nestInlineDefs.push(`const ${alias} = defineEndpointTool({\n${lines.join(',\n')},\n});`);
+        nestSpreadParts.push(alias);
+    });
+    const allSpreadParts = [...spreadParts, ...nestSpreadParts];
+    const totalToolCount = scan.toolCount + nestTools.length;
+    const contractsImport = nestTools.length > 0
+        ? `import { z } from 'zod';\nimport { defineEndpointTool } from 'glirastes';\n`
+        : '';
+    const nestInlineBlock = nestInlineDefs.length > 0
+        ? `\n// From NestJS @AiTool decorators\n${nestInlineDefs.join('\n\n')}\n`
+        : '';
+    const code = `/* eslint-disable */
+/**
+ * AUTO-GENERATED FILE — do not edit manually.
+ * Generated by glirastes
+ *
+ * Sources: ${scan.files.length} ai-tool.ts files, ${nestTools.length} NestJS @AiTool decorators
+ * Tools: ${totalToolCount}
+ */
+
+${imports.join('\n')}
+import { endpointToolsToRegistry } from 'glirastes/server';
+${contractsImport}${nestInlineBlock}
+const endpointTools = [${allSpreadParts.join(', ')}] as const;
+
+export { endpointTools };
+export const endpointToolRegistry = endpointToolsToRegistry(endpointTools);
+`;
+    const outputPath = (0, node_path_1.join)(opts.rootDir, opts.outputDir, 'endpoint.generated.ts');
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(outputPath), { recursive: true });
+    await (0, promises_1.writeFile)(outputPath, code, 'utf-8');
+    if (!opts.quiet) {
+        console.log(`✓ Generated ${outputPath} (${totalToolCount} endpoint tools from ${scan.files.length} files + ${nestTools.length} NestJS controllers)`);
+    }
+    return { outputPath, toolCount: totalToolCount };
+}

package/dist/cjs/codegen/format.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared ANSI color codes and formatting utilities for CLI output.
+ */
+export declare const colors: {
+    reset: string;
+    bold: string;
+    dim: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    cyan: string;
+};
+export declare function separator(width?: number): string;
+export declare function header(title: string): string;
+export declare function sectionHeader(title: string, count: number, color: string): string;
+export declare function metricLine(icon: string, iconColor: string, label: string, value: string | number, detail?: string): string;

package/dist/cjs/codegen/format.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Shared ANSI color codes and formatting utilities for CLI output.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = void 0;
+exports.separator = separator;
+exports.header = header;
+exports.sectionHeader = sectionHeader;
+exports.metricLine = metricLine;
+exports.colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+};
+function separator(width = 50) {
+    return `${exports.colors.dim}${'─'.repeat(width)}${exports.colors.reset}`;
+}
+function header(title) {
+    return `\n${exports.colors.blue}${exports.colors.bold}${title}${exports.colors.reset}\n\n${separator()}\n`;
+}
+function sectionHeader(title, count, color) {
+    return `${color}${exports.colors.bold}${title} (${count}):${exports.colors.reset}\n`;
+}
+function metricLine(icon, iconColor, label, value, detail) {
+    const paddedLabel = label.padEnd(35);
+    const detailStr = detail ? ` ${exports.colors.dim}(${detail})${exports.colors.reset}` : '';
+    return `  ${iconColor}${icon}${exports.colors.reset} ${paddedLabel}${exports.colors.bold}${value}${exports.colors.reset}${detailStr}`;
+}