glirastes 0.2.1 → 0.3.1

package/SECURITY.md

@@ -0,0 +1,46 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability in **glirastes**, please report it
+privately. **Do not open a public GitHub issue.**
+
+Email: **security@chainmatics.net**
+
+Alternatively, use [GitHub's private vulnerability reporting](https://github.com/chainmatics/glirastes/security/advisories/new).
+
+We will:
+
+- Acknowledge your report within **2 business days**
+- Provide an initial assessment within **5 business days**
+- Coordinate a fix and public disclosure, typically within **90 days** of the
+  initial report
+
+When the fix ships, we publish a [GitHub Security Advisory](https://github.com/chainmatics/glirastes/security/advisories)
+and credit the reporter (unless anonymity is preferred).
+
+## Supported Versions
+
+Only the latest released minor version of `glirastes` receives security
+updates. Please upgrade before reporting issues against older versions.
+
+## Scope
+
+In scope:
+
+- The `glirastes` npm package and its subpath exports
+- Code in this repository
+
+Out of scope:
+
+- Third-party dependencies (please report directly to the upstream maintainer)
+- The Glirastes platform / Citadel (closed source, separate disclosure path)
+
+## Safe Harbor
+
+We will not pursue legal action against researchers who:
+
+- Make a good-faith effort to avoid privacy violations, data destruction, and
+  service disruption
+- Report findings privately as described above
+- Give us a reasonable window to remediate before public disclosure

package/codegen/package.json

@@ -0,0 +1,5 @@
+{
+  "main": "../dist/cjs/codegen/index.js",
+  "module": "../dist/codegen/index.js",
+  "types": "../dist/codegen/index.d.ts"
+}

package/dist/cjs/codegen/asset-sync.d.ts

@@ -0,0 +1,20 @@
+export interface AssetSyncOptions {
+    apiKey: string;
+    glirasterUrl: string;
+    name: string;
+    type: 'skill' | 'mcp-server';
+    version: string;
+    toolCount: number;
+    config: Record<string, unknown>;
+    toolManifest: Record<string, unknown>;
+    /** Pre-generated files to upload alongside the manifest */
+    generatedFiles?: Array<{
+        path: string;
+        content: string;
+    }>;
+}
+export interface AssetSyncResult {
+    action: 'created' | 'updated';
+    assetId: string;
+}
+export declare function syncAssetToGlirastes(options: AssetSyncOptions): Promise<AssetSyncResult>;

package/dist/cjs/codegen/asset-sync.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncAssetToGlirastes = syncAssetToGlirastes;
+async function syncAssetToGlirastes(options) {
+    const url = `${options.glirasterUrl}/v1/registry/assets/sync`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': options.apiKey,
+        },
+        body: JSON.stringify({
+            name: options.name,
+            type: options.type,
+            version: options.version,
+            toolCount: options.toolCount,
+            config: options.config,
+            toolManifest: options.toolManifest,
+            generatedFiles: options.generatedFiles,
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Glirastes sync failed (${response.status}): ${text}`);
+    }
+    const data = await response.json();
+    return { action: data.action, assetId: data.asset.id };
+}

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

@@ -0,0 +1,66 @@
+import type { GenerateOptions } from './types.js';
+export interface CoverageReport {
+    endpointToolCount: number;
+    endpointFileCount: number;
+    uiToolCount: number;
+    uiFileCount: number;
+    actionIdCount: number;
+    routeTotal: number;
+    routeCovered: number;
+    routeIgnored: number;
+    routeCoveragePercent: number;
+    componentDirTotal: number;
+    componentDirCovered: number;
+    componentDirIgnored: number;
+    componentCoveragePercent: number;
+    sharedWithConfigs: Array<{
+        toolName: string;
+        primaryModule: string;
+        sharedWith: string[];
+    }>;
+    /** Handler coverage: how many actionIds have registered handlers in source */
+    handlerActionIds: string[];
+    handlerCoveredCount: number;
+    handlerTotalCount: number;
+    handlerCoveragePercent: number;
+    /** Orphan handlers: useAiClientAction calls without a matching UI tool actionId */
+    orphanHandlers: Array<{
+        actionId: string;
+        sourceFile: string;
+    }>;
+    /** Routes without a corresponding ai-tool.ts (relative paths) */
+    uncoveredRoutes: string[];
+    /** Component directories without ai-ui-tool.ts (relative paths) */
+    uncoveredComponents: string[];
+    /** Action IDs that have no registered useAiClientAction handler */
+    missingHandlers: Array<{
+        actionId: string;
+        toolName: string;
+        sourceFile: string;
+    }>;
+    /** NestJS controller coverage */
+    nestControllerTotal: number;
+    nestControllerCovered: number;
+    nestControllerIgnored: number;
+    nestControllerCoveragePercent: number;
+    /** Number of @AiTool-decorated methods found across NestJS controllers */
+    nestToolCount: number;
+    /** NestJS controllers found without @AiTool decorators (not ignored) */
+    uncoveredNestControllers: Array<{
+        controllerFile: string;
+        controllerName: string;
+        httpMethodCount: number;
+    }>;
+}
+/**
+ * Check AI tool coverage across the project.
+ * Reports on endpoint tools, UI tools, route coverage,
+ * component coverage, and sharedWith configurations.
+ */
+export declare function checkAiCoverage(options: GenerateOptions): Promise<CoverageReport>;
+/**
+ * Format a coverage report as a rich, color-coded human-readable string.
+ */
+export declare function formatCoverageReport(report: CoverageReport, options?: {
+    quiet?: boolean;
+}): string;

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;
+}>;