glirastes 0.3.0 → 0.3.2

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

@@ -0,0 +1,52 @@
+/**
+ * Configuration for code generation.
+ */
+export interface GenerateOptions {
+    /** Root directory of the project (where src/ lives) */
+    rootDir: string;
+    /** Directory pattern for API routes (e.g., 'src/app/api') */
+    apiDir?: string;
+    /** Directory pattern for components (e.g., 'src/components') */
+    componentsDir?: string;
+    /** Output directory for generated files (e.g., 'src/generated/ai-tools') */
+    outputDir?: string;
+    /** File name for endpoint tool definitions (default: 'ai-tool.ts') */
+    endpointToolFileName?: string;
+    /** File name for UI tool definitions (default: 'ai-ui-tool.ts') */
+    uiToolFileName?: string;
+    /** Directories to scan for NestJS controllers with @AiTool decorators */
+    nestjsDirs?: string[];
+    /** API prefix for NestJS routes (default: '/api') */
+    nestjsApiPrefix?: string;
+    /** Quiet mode — suppress informational output */
+    quiet?: boolean;
+}
+export interface ScanResult {
+    /** Discovered files with their relative paths */
+    files: DiscoveredFile[];
+    /** Total number of tools found */
+    toolCount: number;
+}
+export interface DiscoveredFile {
+    /** Absolute path to the file */
+    absolutePath: string;
+    /** Path relative to rootDir */
+    relativePath: string;
+    /** Import path (e.g., '@/app/api/tasks/ai-tool') */
+    importPath: string;
+    /** Whether the file exports an array (aiTools) or single (aiTool) */
+    exportType: 'array' | 'single';
+}
+export interface ExtractedActionId {
+    actionId: string;
+    toolName: string;
+    payloadKeys: string[];
+    sourceFile: string;
+}
+export interface ExtractedToolMeta {
+    toolName: string;
+    module?: string;
+    sharedWith?: string[];
+    sourceFile: string;
+}
+export declare function resolveDefaults(options: GenerateOptions): Required<GenerateOptions>;

package/dist/cjs/codegen/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDefaults = resolveDefaults;
+function resolveDefaults(options) {
+    return {
+        rootDir: options.rootDir,
+        apiDir: options.apiDir ?? 'src/app/api',
+        componentsDir: options.componentsDir ?? 'src/components',
+        outputDir: options.outputDir ?? 'src/generated/ai-tools',
+        endpointToolFileName: options.endpointToolFileName ?? 'ai-tool.ts',
+        uiToolFileName: options.uiToolFileName ?? 'ai-ui-tool.ts',
+        nestjsDirs: options.nestjsDirs ?? [],
+        nestjsApiPrefix: options.nestjsApiPrefix ?? '/api',
+        quiet: options.quiet ?? false,
+    };
+}

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

@@ -0,0 +1,24 @@
+import type { GenerateOptions, ScanResult, ExtractedActionId } from './types.js';
+/**
+ * Scan for UI tool files (ai-ui-tool.ts) in the components directory.
+ */
+export declare function scanUiTools(options: GenerateOptions): Promise<ScanResult>;
+/**
+ * Extract actionIds from UI tool files using regex parsing.
+ */
+export declare function extractActionIds(options: GenerateOptions): Promise<ExtractedActionId[]>;
+/**
+ * Generate the UI tools registry file.
+ */
+export declare function generateUiRegistry(options: GenerateOptions): Promise<{
+    outputPath: string;
+    toolCount: number;
+}>;
+/**
+ * Generate the action ID registry file.
+ * Merges duplicate actionIds from multiple tools and unions their payloadKeys.
+ */
+export declare function generateActionIdRegistry(options: GenerateOptions): Promise<{
+    outputPath: string;
+    actionIdCount: number;
+}>;

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

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanUiTools = scanUiTools;
+exports.extractActionIds = extractActionIds;
+exports.generateUiRegistry = generateUiRegistry;
+exports.generateActionIdRegistry = generateActionIdRegistry;
+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 UI tool files (ai-ui-tool.ts) in the components directory.
+ */
+async function scanUiTools(options) {
+    const opts = (0, types_js_1.resolveDefaults)(options);
+    const componentsDir = (0, node_path_1.join)(opts.rootDir, opts.componentsDir);
+    const files = await (0, fs_utils_js_1.findFiles)(componentsDir, opts.uiToolFileName);
+    const discovered = [];
+    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 hasExport = /export\s+const\s+aiUiTools\s*[=:]/m.test(content);
+        if (!hasExport)
+            continue;
+        // Use relative import when output dir is outside src/ (monorepo layout)
+        const outputDir = (0, node_path_1.join)(opts.rootDir, opts.outputDir);
+        const importPath = absolutePath.startsWith((0, node_path_1.join)(opts.rootDir, 'src'))
+            ? (0, fs_utils_js_1.toImportPath)(absolutePath, opts.rootDir)
+            : (0, fs_utils_js_1.toRelativeImportPath)(absolutePath, outputDir);
+        discovered.push({
+            absolutePath,
+            relativePath: absolutePath.replace(opts.rootDir + '/', ''),
+            importPath,
+            exportType: 'array',
+        });
+    }
+    let toolCount = 0;
+    for (const file of discovered) {
+        const content = await (0, fs_utils_js_1.readFileSafe)(file.absolutePath);
+        const matches = content.match(/define(?:Ai)?UiTool\(/g);
+        toolCount += matches?.length ?? 0;
+    }
+    return { files: discovered, toolCount };
+}
+/**
+ * Extract actionIds from UI tool files using regex parsing.
+ */
+async function extractActionIds(options) {
+    const scan = await scanUiTools(options);
+    const actionIds = [];
+    for (const file of scan.files) {
+        const content = await (0, fs_utils_js_1.readFileSafe)(file.absolutePath);
+        // Match defineUiTool or defineAiUiTool blocks (brace-balanced)
+        const blocks = (0, fs_utils_js_1.extractBalancedBlocks)(content, /define(?:Ai)?UiTool\(\s*/);
+        for (const block of blocks) {
+            // Extract toolName
+            const toolNameMatch = block.match(/toolName\s*:\s*['"`]([^'"`]+)['"`]/);
+            if (!toolNameMatch)
+                continue;
+            const toolName = toolNameMatch[1];
+            // Extract all actionIds from uiAction templates (supports compound arrays)
+            const actionIdMatches = block.matchAll(/actionId\s*:\s*['"`]([^'"`]+)['"`]/g);
+            // Extract inputSchema keys as fallback payload keys (shared across all actions)
+            const fallbackPayloadKeys = [];
+            const schemaMatch = block.match(/inputSchema\s*:\s*z\.object\(\s*\{([^}]*)\}/);
+            if (schemaMatch) {
+                const schemaContent = schemaMatch[1];
+                const keyMatches = schemaContent.matchAll(/(\w+)\s*:/g);
+                for (const km of keyMatches) {
+                    fallbackPayloadKeys.push(km[1]);
+                }
+            }
+            let hasActionId = false;
+            for (const actionIdMatch of actionIdMatches) {
+                hasActionId = true;
+                const actionId = actionIdMatch[1];
+                // Extract payload keys from the nearest payload block (best-effort)
+                const payloadKeys = [];
+                const payloadMatch = block.match(/payload\s*:\s*\{([^}]*)\}/);
+                if (payloadMatch) {
+                    const payloadContent = payloadMatch[1];
+                    const keyMatches = payloadContent.matchAll(/(\w+)\s*:/g);
+                    for (const km of keyMatches) {
+                        payloadKeys.push(km[1]);
+                    }
+                }
+                actionIds.push({
+                    actionId,
+                    toolName,
+                    payloadKeys: payloadKeys.length > 0 ? payloadKeys : fallbackPayloadKeys,
+                    sourceFile: file.relativePath,
+                });
+            }
+            if (!hasActionId)
+                continue;
+        }
+    }
+    return actionIds;
+}
+/**
+ * Generate the UI tools registry file.
+ */
+async function generateUiRegistry(options) {
+    const opts = (0, types_js_1.resolveDefaults)(options);
+    const scan = await scanUiTools(options);
+    const imports = [];
+    const spreadParts = [];
+    scan.files.forEach((file, index) => {
+        const alias = `uiTools${index}`;
+        imports.push(`import { aiUiTools as ${alias} } from '${file.importPath}';`);
+        spreadParts.push(`...${alias}`);
+    });
+    const code = `/* eslint-disable */
+/**
+ * AUTO-GENERATED FILE — do not edit manually.
+ * Generated by glirastes
+ *
+ * Sources: ${scan.files.length} ai-ui-tool.ts files
+ * Tools: ${scan.toolCount}
+ */
+
+${imports.join('\n')}
+import { uiToolsToRegistry } from 'glirastes/server';
+
+const uiTools = [${spreadParts.join(', ')}] as const;
+
+export { uiTools };
+export const uiToolRegistry = uiToolsToRegistry(uiTools);
+`;
+    const outputPath = (0, node_path_1.join)(opts.rootDir, opts.outputDir, 'ui.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} (${scan.toolCount} UI tools from ${scan.files.length} files)`);
+    }
+    return { outputPath, toolCount: scan.toolCount };
+}
+/**
+ * Generate the action ID registry file.
+ * Merges duplicate actionIds from multiple tools and unions their payloadKeys.
+ */
+async function generateActionIdRegistry(options) {
+    const opts = (0, types_js_1.resolveDefaults)(options);
+    const actionIds = await extractActionIds(options);
+    // Merge by actionId
+    const merged = new Map();
+    for (const entry of actionIds) {
+        const existing = merged.get(entry.actionId);
+        if (existing) {
+            existing.tools.push({
+                toolName: entry.toolName,
+                sourceFile: entry.sourceFile,
+            });
+            for (const key of entry.payloadKeys) {
+                existing.payloadKeys.add(key);
+            }
+        }
+        else {
+            merged.set(entry.actionId, {
+                tools: [
+                    { toolName: entry.toolName, sourceFile: entry.sourceFile },
+                ],
+                payloadKeys: new Set(entry.payloadKeys),
+            });
+        }
+    }
+    // Generate code
+    const entries = [];
+    for (const [actionId, data] of merged) {
+        const toolsStr = data.tools
+            .map((t) => `{ toolName: '${t.toolName}', sourceFile: '${t.sourceFile}' }`)
+            .join(', ');
+        const keysStr = Array.from(data.payloadKeys)
+            .map((k) => `'${k}'`)
+            .join(', ');
+        entries.push(`  '${actionId}': {\n    tools: [${toolsStr}],\n    payloadKeys: [${keysStr}] as const,\n  }`);
+    }
+    const code = `/* eslint-disable */
+/**
+ * AUTO-GENERATED FILE — do not edit manually.
+ * Generated by glirastes
+ *
+ * Action IDs: ${merged.size}
+ */
+
+export const REQUIRED_ACTION_IDS = {
+${entries.join(',\n')}
+} as const;
+
+export type ActionId = keyof typeof REQUIRED_ACTION_IDS;
+`;
+    const outputPath = (0, node_path_1.join)(opts.rootDir, opts.outputDir, 'action-ids.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} (${merged.size} action IDs)`);
+    }
+    return { outputPath, actionIdCount: merged.size };
+}

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

@@ -0,0 +1,35 @@
+import type { GenerateOptions } from './types.js';
+export type IssueSeverity = 'error' | 'warning' | 'info';
+export interface ValidationIssue {
+    severity: IssueSeverity;
+    file: string;
+    message: string;
+    suggestion?: string;
+}
+export interface ValidationResult {
+    issues: ValidationIssue[];
+    errorCount: number;
+    warningCount: number;
+    infoCount: number;
+    passed: boolean;
+}
+/**
+ * Validate AI tool configuration across the project.
+ *
+ * Checks:
+ * 1. All API routes have an ai-tool.ts file (unless @ai-ignore)
+ * 2. All component directories with UI have ai-ui-tool.ts (unless @ai-ignore)
+ * 3. No orphaned ai-tool.ts files without corresponding route.ts
+ * 4. Tool files have required exports
+ * 5. Path consistency between file location and defined endpoint path
+ * 6. Module field is present in tool definitions
+ * 7. NestJS controllers have @AiTool decorators (unless @ai-ignore)
+ */
+export declare function validateAiTools(options: GenerateOptions): Promise<ValidationResult>;
+/**
+ * Format a validation result as a rich, color-coded human-readable string.
+ */
+export declare function formatValidationReport(result: ValidationResult, options?: {
+    quiet?: boolean;
+    showFix?: boolean;
+}): string;

package/dist/cjs/codegen/validator.js

@@ -0,0 +1,292 @@
+"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.validateAiTools = validateAiTools;
+exports.formatValidationReport = formatValidationReport;
+const node_path_1 = require("node:path");
+const fs_utils_js_1 = require("./fs-utils.js");
+const types_js_1 = require("./types.js");
+const format_js_1 = require("./format.js");
+/**
+ * Validate AI tool configuration across the project.
+ *
+ * Checks:
+ * 1. All API routes have an ai-tool.ts file (unless @ai-ignore)
+ * 2. All component directories with UI have ai-ui-tool.ts (unless @ai-ignore)
+ * 3. No orphaned ai-tool.ts files without corresponding route.ts
+ * 4. Tool files have required exports
+ * 5. Path consistency between file location and defined endpoint path
+ * 6. Module field is present in tool definitions
+ * 7. NestJS controllers have @AiTool decorators (unless @ai-ignore)
+ */
+async function validateAiTools(options) {
+    const opts = (0, types_js_1.resolveDefaults)(options);
+    const issues = [];
+    // 1. Check routes have ai-tool.ts
+    const apiDir = (0, node_path_1.join)(opts.rootDir, opts.apiDir);
+    const routeFiles = await (0, fs_utils_js_1.findRouteFiles)(apiDir);
+    for (const routeFile of routeFiles) {
+        const routeContent = await (0, fs_utils_js_1.readFileSafe)(routeFile);
+        if (routeContent.includes('@ai-ignore'))
+            continue;
+        const routeDir = (0, node_path_1.dirname)(routeFile);
+        if (await (0, fs_utils_js_1.isDirAiIgnored)(routeDir))
+            continue;
+        const toolFile = (0, node_path_1.join)(routeDir, opts.endpointToolFileName);
+        const toolContent = await (0, fs_utils_js_1.readFileSafe)(toolFile);
+        const relFile = routeFile.replace(opts.rootDir + '/', '');
+        if (!toolContent && !routeContent.includes('withAiTool(')) {
+            issues.push({
+                severity: 'warning',
+                file: relFile,
+                message: `Route without ${opts.endpointToolFileName}`,
+                suggestion: `glirastes scaffold --route "${relFile}"`,
+            });
+        }
+    }
+    // 2. Check ai-tool.ts files have corresponding route.ts
+    const toolFiles = await (0, fs_utils_js_1.findFiles)(apiDir, opts.endpointToolFileName);
+    for (const toolFile of toolFiles) {
+        const toolDir = (0, node_path_1.dirname)(toolFile);
+        const routeFile = (0, node_path_1.join)(toolDir, 'route.ts');
+        const routeContent = await (0, fs_utils_js_1.readFileSafe)(routeFile);
+        const relFile = toolFile.replace(opts.rootDir + '/', '');
+        if (!routeContent) {
+            const routeRelFile = routeFile.replace(opts.rootDir + '/', '');
+            issues.push({
+                severity: 'error',
+                file: relFile,
+                message: `${opts.endpointToolFileName} has no corresponding route.ts`,
+                suggestion: `Create ${routeRelFile} or remove ${relFile}`,
+            });
+        }
+    }
+    // 3. Check tool files have required exports
+    for (const toolFile of toolFiles) {
+        const content = await (0, fs_utils_js_1.readFileSafe)(toolFile);
+        if (content.includes('@ai-ignore'))
+            continue;
+        const relFile = toolFile.replace(opts.rootDir + '/', '');
+        const hasArrayExport = /export\s+const\s+aiTools\s*[=:]/m.test(content);
+        const hasSingleExport = /export\s+const\s+aiTool\s*[=:]/m.test(content);
+        if (!hasArrayExport && !hasSingleExport) {
+            issues.push({
+                severity: 'error',
+                file: relFile,
+                message: `Missing export: expected 'export const aiTools' or 'export const aiTool'`,
+                suggestion: `Add 'export const aiTool = defineEndpointTool({...})'`,
+            });
+        }
+        // Check for description
+        if (!content.includes('description')) {
+            issues.push({
+                severity: 'warning',
+                file: relFile,
+                message: 'Tool definition is missing a description',
+                suggestion: `Add description with usage hints for the AI`,
+            });
+        }
+    }
+    // 4. Check path consistency and module field
+    for (const toolFile of toolFiles) {
+        const content = await (0, fs_utils_js_1.readFileSafe)(toolFile);
+        if (content.includes('@ai-ignore'))
+            continue;
+        const relPath = toolFile.replace(opts.rootDir + '/', '');
+        // Extract path values from tool definitions
+        const pathMatches = content.matchAll(/path\s*:\s*['"`]([^'"`]+)['"`]/g);
+        for (const match of pathMatches) {
+            const definedPath = match[1];
+            // Derive expected path from file location: src/app/api/tasks/[id]/subtasks/ai-tool.ts → /api/tasks/:id/subtasks
+            const expectedPath = '/' + (0, node_path_1.dirname)(relPath)
+                .replace(/^src\/app\//, '')
+                .replace(/\[([^\]]+)\]/g, ':$1'); // convert [param] to :param
+            // Check that the defined path starts with the expected base
+            if (!definedPath.startsWith(expectedPath.replace(/\/+$/, ''))) {
+                issues.push({
+                    severity: 'warning',
+                    file: relPath,
+                    message: `Path '${definedPath}' doesn't match file location '${expectedPath}'`,
+                    suggestion: `Update path to '${expectedPath}'`,
+                });
+            }
+        }
+        // Check for module field presence (brace-balanced)
+        const toolBlocksArr = (0, fs_utils_js_1.extractBalancedBlocks)(content, /define(?:Ai)?EndpointTool\(\s*/);
+        for (const block of toolBlocksArr) {
+            const hasModule = /module\s*:/.test(block);
+            if (!hasModule) {
+                const toolNameMatch = block.match(/toolName\s*:\s*['"`]([^'"`]+)['"`]/);
+                const toolName = toolNameMatch?.[1] ?? 'unknown';
+                issues.push({
+                    severity: 'info',
+                    file: relPath,
+                    message: `Tool '${toolName}' has no module field`,
+                    suggestion: `Add module: 'task_query' | 'task_mutation' | 'navigation' | ...`,
+                });
+            }
+        }
+    }
+    // 5. Check UI tool files have required exports
+    const componentsDir = (0, node_path_1.join)(opts.rootDir, opts.componentsDir);
+    const uiToolFiles = await (0, fs_utils_js_1.findFiles)(componentsDir, opts.uiToolFileName);
+    for (const uiToolFile of uiToolFiles) {
+        const content = await (0, fs_utils_js_1.readFileSafe)(uiToolFile);
+        if (content.includes('@ai-ignore'))
+            continue;
+        const relFile = uiToolFile.replace(opts.rootDir + '/', '');
+        const hasExport = /export\s+const\s+aiUiTools\s*[=:]/m.test(content);
+        if (!hasExport) {
+            issues.push({
+                severity: 'error',
+                file: relFile,
+                message: `Missing export: expected 'export const aiUiTools'`,
+                suggestion: `Add 'export const aiUiTools = [defineUiTool({...})]'`,
+            });
+        }
+        // Check module field in UI tool definitions (brace-balanced)
+        const uiToolBlocksArr = (0, fs_utils_js_1.extractBalancedBlocks)(content, /define(?:Ai)?UiTool\(\s*/);
+        for (const block of uiToolBlocksArr) {
+            const hasModule = /module\s*:/.test(block);
+            if (!hasModule) {
+                const toolNameMatch = block.match(/toolName\s*:\s*['"`]([^'"`]+)['"`]/);
+                const toolName = toolNameMatch?.[1] ?? 'unknown';
+                issues.push({
+                    severity: 'info',
+                    file: relFile,
+                    message: `UI tool '${toolName}' has no module field`,
+                    suggestion: `Add module field for intent-based routing`,
+                });
+            }
+        }
+    }
+    // 6. Check NestJS controllers have @AiTool decorators
+    if (opts.nestjsDirs.length > 0) {
+        const { scanNestControllers } = await Promise.resolve().then(() => __importStar(require('./nestjs-scanner.js')));
+        const nestResult = await scanNestControllers(opts.nestjsDirs, opts.nestjsApiPrefix);
+        for (const ctrl of nestResult.uncoveredControllers) {
+            const relFile = ctrl.controllerFile.replace(opts.rootDir + '/', '');
+            issues.push({
+                severity: 'warning',
+                file: relFile,
+                message: `${ctrl.controllerName} has ${ctrl.httpMethodCount} HTTP endpoint(s) but no @AiTool decorators`,
+                suggestion: `Add @AiModule + @AiTool decorators, or add // @ai-ignore to exclude`,
+            });
+        }
+    }
+    // Tally results
+    const errorCount = issues.filter((i) => i.severity === 'error').length;
+    const warningCount = issues.filter((i) => i.severity === 'warning').length;
+    const infoCount = issues.filter((i) => i.severity === 'info').length;
+    return {
+        issues,
+        errorCount,
+        warningCount,
+        infoCount,
+        passed: errorCount === 0,
+    };
+}
+/**
+ * Format a validation result as a rich, color-coded human-readable string.
+ */
+function formatValidationReport(result, options) {
+    if (options?.quiet && result.issues.length === 0) {
+        return `${format_js_1.colors.green}\u2713${format_js_1.colors.reset} AI tools validation passed`;
+    }
+    const lines = [];
+    // Header
+    lines.push((0, format_js_1.header)('AI Tools Validation'));
+    // No issues
+    if (result.issues.length === 0) {
+        lines.push(`${format_js_1.colors.green}\u2705 All AI tools are properly configured!${format_js_1.colors.reset}`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    const errors = result.issues.filter((i) => i.severity === 'error');
+    const warnings = result.issues.filter((i) => i.severity === 'warning');
+    const infos = result.issues.filter((i) => i.severity === 'info');
+    // Errors
+    if (errors.length > 0) {
+        lines.push(`${format_js_1.colors.red}${format_js_1.colors.bold}\u274C ${errors.length} Error(s):${format_js_1.colors.reset}\n`);
+        for (const issue of errors) {
+            lines.push(`  ${format_js_1.colors.red}\u274C${format_js_1.colors.reset} ${format_js_1.colors.bold}${issue.file}${format_js_1.colors.reset}`);
+            lines.push(`     ${issue.message}`);
+            if (issue.suggestion) {
+                lines.push(`     ${format_js_1.colors.cyan}\u2192 ${issue.suggestion}${format_js_1.colors.reset}`);
+            }
+            lines.push('');
+        }
+    }
+    // Warnings
+    if (warnings.length > 0) {
+        lines.push(`${format_js_1.colors.yellow}${format_js_1.colors.bold}\u26A0\uFE0F  ${warnings.length} Warning(s):${format_js_1.colors.reset}\n`);
+        for (const issue of warnings) {
+            lines.push(`  ${format_js_1.colors.yellow}\u26A0\uFE0F${format_js_1.colors.reset}  ${format_js_1.colors.bold}${issue.file}${format_js_1.colors.reset}`);
+            lines.push(`     ${issue.message}`);
+            if (issue.suggestion) {
+                lines.push(`     ${format_js_1.colors.cyan}\u2192 ${issue.suggestion}${format_js_1.colors.reset}`);
+            }
+            lines.push('');
+        }
+    }
+    // Info (only when not quiet)
+    if (infos.length > 0 && !options?.quiet) {
+        lines.push(`${format_js_1.colors.blue}${format_js_1.colors.bold}\u2139\uFE0F  ${infos.length} Info(s):${format_js_1.colors.reset}\n`);
+        for (const issue of infos) {
+            lines.push(`  ${format_js_1.colors.blue}\u2139\uFE0F${format_js_1.colors.reset}  ${format_js_1.colors.bold}${issue.file}${format_js_1.colors.reset}`);
+            lines.push(`     ${issue.message}`);
+            if (issue.suggestion) {
+                lines.push(`     ${format_js_1.colors.cyan}\u2192 ${issue.suggestion}${format_js_1.colors.reset}`);
+            }
+            lines.push('');
+        }
+    }
+    // Quick fix section
+    if (options?.showFix) {
+        const missingAiTools = result.issues.filter((i) => i.severity === 'warning' && i.suggestion?.startsWith('glirastes scaffold'));
+        if (missingAiTools.length > 0) {
+            lines.push(`${format_js_1.colors.cyan}${format_js_1.colors.bold}Quick Fix:${format_js_1.colors.reset}`);
+            lines.push(`${format_js_1.colors.dim}Run scaffold command for missing ai-tool.ts files:${format_js_1.colors.reset}\n`);
+            for (const issue of missingAiTools) {
+                lines.push(`  ${format_js_1.colors.cyan}${issue.suggestion}${format_js_1.colors.reset}`);
+            }
+            lines.push('');
+        }
+    }
+    // Summary line
+    lines.push(`${format_js_1.colors.dim}Summary: ${result.errorCount} errors, ${result.warningCount} warnings, ${result.infoCount} infos${format_js_1.colors.reset}`);
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1 @@
+export * from './types.js';

package/dist/cjs/index.js

@@ -0,0 +1,23 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// glirastes — main entry point
+//
+// Re-exports all shared types, interfaces, and helpers that live in `types.ts`
+// so consumers can do `import { ModuleMeta, defineUiTool } from 'glirastes'`.
+// Subpath exports (`glirastes/server`, `glirastes/react`, etc.) remain the
+// primary API surface for runtime functionality.
+__exportStar(require("./types.js"), exports);