glirastes 0.2.1 → 0.3.1

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

package/dist/cjs/codegen/fs-utils.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Recursively find all files matching a given name in a directory.
+ */
+export declare function findFiles(dir: string, fileName: string): Promise<string[]>;
+/**
+ * Check if a file contains the @ai-ignore marker.
+ */
+export declare function hasAiIgnore(filePath: string): Promise<boolean>;
+/**
+ * Check if a directory should be ignored for AI tool coverage.
+ * Checks for @ai-ignore in index.ts/index.tsx or .ai-ignore marker file.
+ */
+export declare function isDirAiIgnored(dirPath: string): Promise<boolean>;
+/**
+ * Convert an absolute file path to a module import path.
+ * e.g., /project/src/app/api/tasks/ai-tool.ts → @/app/api/tasks/ai-tool
+ */
+export declare function toImportPath(absolutePath: string, rootDir: string, srcPrefix?: string, alias?: string): string;
+/**
+ * Convert an absolute file path to a relative import path from a given output directory.
+ * Used when source and output are in different parts of a monorepo where @/ aliases don't work.
+ */
+export declare function toRelativeImportPath(absolutePath: string, outputDir: string): string;
+/**
+ * Read file contents, returns empty string if file doesn't exist.
+ */
+export declare function readFileSafe(filePath: string): Promise<string>;
+/**
+ * Find all route.ts files in a directory.
+ */
+export declare function findRouteFiles(dir: string): Promise<string[]>;
+/**
+ * Extract all top-level brace-balanced blocks for a given function call.
+ * Handles nested braces correctly (e.g., z.object({...}), uiAction: { payload: {...} }).
+ *
+ * @param content    Source file content
+ * @param fnPattern  Regex that matches the function call prefix up to (but not including) the opening `{`.
+ *                   Must NOT have the `g` flag — it is added internally.
+ * @returns Array of the inner content of each matched block (between the outermost `{` and `}`).
+ */
+export declare function extractBalancedBlocks(content: string, fnPattern: RegExp): string[];
+/**
+ * Get all immediate subdirectories of a directory.
+ */
+export declare function getSubdirectories(dir: string): Promise<string[]>;

package/dist/cjs/codegen/fs-utils.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFiles = findFiles;
+exports.hasAiIgnore = hasAiIgnore;
+exports.isDirAiIgnored = isDirAiIgnored;
+exports.toImportPath = toImportPath;
+exports.toRelativeImportPath = toRelativeImportPath;
+exports.readFileSafe = readFileSafe;
+exports.findRouteFiles = findRouteFiles;
+exports.extractBalancedBlocks = extractBalancedBlocks;
+exports.getSubdirectories = getSubdirectories;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+/**
+ * Recursively find all files matching a given name in a directory.
+ */
+async function findFiles(dir, fileName) {
+    const results = [];
+    async function walk(currentDir) {
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return; // Directory doesn't exist or is inaccessible
+        }
+        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 === fileName) {
+                results.push(fullPath);
+            }
+        }
+    }
+    await walk(dir);
+    return results.sort();
+}
+/**
+ * Check if a file contains the @ai-ignore marker.
+ */
+async function hasAiIgnore(filePath) {
+    try {
+        const content = await (0, promises_1.readFile)(filePath, 'utf-8');
+        return content.includes('@ai-ignore');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a directory should be ignored for AI tool coverage.
+ * Checks for @ai-ignore in index.ts/index.tsx or .ai-ignore marker file.
+ */
+async function isDirAiIgnored(dirPath) {
+    // Check for .ai-ignore marker file
+    try {
+        await (0, promises_1.stat)((0, node_path_1.join)(dirPath, '.ai-ignore'));
+        return true;
+    }
+    catch {
+        // Not found, continue
+    }
+    // Check for @ai-ignore in index.ts or index.tsx
+    for (const indexFile of ['index.ts', 'index.tsx']) {
+        const indexPath = (0, node_path_1.join)(dirPath, indexFile);
+        if (await hasAiIgnore(indexPath))
+            return true;
+    }
+    return false;
+}
+/**
+ * Convert an absolute file path to a module import path.
+ * e.g., /project/src/app/api/tasks/ai-tool.ts → @/app/api/tasks/ai-tool
+ */
+function toImportPath(absolutePath, rootDir, srcPrefix = 'src', alias = '@') {
+    const rel = (0, node_path_1.relative)(rootDir, absolutePath);
+    // Remove src/ prefix and .ts extension
+    const withoutSrc = rel.startsWith(srcPrefix + node_path_1.sep)
+        ? rel.slice(srcPrefix.length + 1)
+        : rel;
+    const withoutExt = withoutSrc.replace(/\.tsx?$/, '');
+    return `${alias}/${withoutExt.split(node_path_1.sep).join('/')}`;
+}
+/**
+ * Convert an absolute file path to a relative import path from a given output directory.
+ * Used when source and output are in different parts of a monorepo where @/ aliases don't work.
+ */
+function toRelativeImportPath(absolutePath, outputDir) {
+    const rel = (0, node_path_1.relative)(outputDir, absolutePath);
+    const withoutExt = rel.replace(/\.tsx?$/, '');
+    const normalized = withoutExt.split(node_path_1.sep).join('/');
+    return normalized.startsWith('.') ? normalized : `./${normalized}`;
+}
+/**
+ * Read file contents, returns empty string if file doesn't exist.
+ */
+async function readFileSafe(filePath) {
+    try {
+        return await (0, promises_1.readFile)(filePath, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Find all route.ts files in a directory.
+ */
+async function findRouteFiles(dir) {
+    return findFiles(dir, 'route.ts');
+}
+/**
+ * Extract all top-level brace-balanced blocks for a given function call.
+ * Handles nested braces correctly (e.g., z.object({...}), uiAction: { payload: {...} }).
+ *
+ * @param content    Source file content
+ * @param fnPattern  Regex that matches the function call prefix up to (but not including) the opening `{`.
+ *                   Must NOT have the `g` flag — it is added internally.
+ * @returns Array of the inner content of each matched block (between the outermost `{` and `}`).
+ */
+function extractBalancedBlocks(content, fnPattern) {
+    const results = [];
+    const globalPattern = new RegExp(fnPattern.source, 'g');
+    let prefixMatch;
+    while ((prefixMatch = globalPattern.exec(content)) !== null) {
+        // Find the opening { after the function call prefix
+        const searchStart = prefixMatch.index + prefixMatch[0].length;
+        const braceStart = content.indexOf('{', searchStart);
+        if (braceStart === -1)
+            continue;
+        // Walk forward counting braces
+        let depth = 0;
+        let i = braceStart;
+        for (; i < content.length; i++) {
+            if (content[i] === '{')
+                depth++;
+            else if (content[i] === '}')
+                depth--;
+            if (depth === 0)
+                break;
+        }
+        if (depth === 0) {
+            // Extract inner content (between outermost braces)
+            results.push(content.slice(braceStart + 1, i));
+        }
+    }
+    return results;
+}
+/**
+ * Get all immediate subdirectories of a directory.
+ */
+async function getSubdirectories(dir) {
+    try {
+        const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isDirectory() && e.name !== 'node_modules' && e.name !== '.git')
+            .map((e) => (0, node_path_1.join)(dir, e.name));
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -0,0 +1,13 @@
+export { scanEndpointTools, generateEndpointRegistry } from './endpoint-scanner.js';
+export { scanUiTools, generateUiRegistry, generateActionIdRegistry } from './ui-scanner.js';
+export { generateModuleRegistry } from './module-generator.js';
+export { validateAiTools, formatValidationReport, type ValidationResult, type ValidationIssue } from './validator.js';
+export { checkAiCoverage, formatCoverageReport, type CoverageReport } from './coverage.js';
+export { scaffoldAiTool, formatScaffoldResult, type ScaffoldResult } from './scaffolder.js';
+export { colors } from './format.js';
+export { generateAgentSkills, type GenerateSkillsOptions, type GenerateSkillsResult } from './skill-generator.js';
+export { generateMcpServer, type GenerateMcpOptions, type GenerateMcpResult } from './mcp-generator.js';
+export { recommendOutputFormat, type OutputFormat, type RecommendationInput } from './output-recommender.js';
+export { syncAssetToGlirastes, type AssetSyncOptions, type AssetSyncResult } from './asset-sync.js';
+export { scanNestControllers, type DiscoveredNestTool, type NestScanResult } from './nestjs-scanner.js';
+export type { ScanResult, GenerateOptions } from './types.js';

package/dist/cjs/codegen/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanNestControllers = exports.syncAssetToGlirastes = exports.recommendOutputFormat = exports.generateMcpServer = exports.generateAgentSkills = exports.colors = exports.formatScaffoldResult = exports.scaffoldAiTool = exports.formatCoverageReport = exports.checkAiCoverage = exports.formatValidationReport = exports.validateAiTools = exports.generateModuleRegistry = exports.generateActionIdRegistry = exports.generateUiRegistry = exports.scanUiTools = exports.generateEndpointRegistry = exports.scanEndpointTools = void 0;
+var endpoint_scanner_js_1 = require("./endpoint-scanner.js");
+Object.defineProperty(exports, "scanEndpointTools", { enumerable: true, get: function () { return endpoint_scanner_js_1.scanEndpointTools; } });
+Object.defineProperty(exports, "generateEndpointRegistry", { enumerable: true, get: function () { return endpoint_scanner_js_1.generateEndpointRegistry; } });
+var ui_scanner_js_1 = require("./ui-scanner.js");
+Object.defineProperty(exports, "scanUiTools", { enumerable: true, get: function () { return ui_scanner_js_1.scanUiTools; } });
+Object.defineProperty(exports, "generateUiRegistry", { enumerable: true, get: function () { return ui_scanner_js_1.generateUiRegistry; } });
+Object.defineProperty(exports, "generateActionIdRegistry", { enumerable: true, get: function () { return ui_scanner_js_1.generateActionIdRegistry; } });
+var module_generator_js_1 = require("./module-generator.js");
+Object.defineProperty(exports, "generateModuleRegistry", { enumerable: true, get: function () { return module_generator_js_1.generateModuleRegistry; } });
+var validator_js_1 = require("./validator.js");
+Object.defineProperty(exports, "validateAiTools", { enumerable: true, get: function () { return validator_js_1.validateAiTools; } });
+Object.defineProperty(exports, "formatValidationReport", { enumerable: true, get: function () { return validator_js_1.formatValidationReport; } });
+var coverage_js_1 = require("./coverage.js");
+Object.defineProperty(exports, "checkAiCoverage", { enumerable: true, get: function () { return coverage_js_1.checkAiCoverage; } });
+Object.defineProperty(exports, "formatCoverageReport", { enumerable: true, get: function () { return coverage_js_1.formatCoverageReport; } });
+var scaffolder_js_1 = require("./scaffolder.js");
+Object.defineProperty(exports, "scaffoldAiTool", { enumerable: true, get: function () { return scaffolder_js_1.scaffoldAiTool; } });
+Object.defineProperty(exports, "formatScaffoldResult", { enumerable: true, get: function () { return scaffolder_js_1.formatScaffoldResult; } });
+var format_js_1 = require("./format.js");
+Object.defineProperty(exports, "colors", { enumerable: true, get: function () { return format_js_1.colors; } });
+var skill_generator_js_1 = require("./skill-generator.js");
+Object.defineProperty(exports, "generateAgentSkills", { enumerable: true, get: function () { return skill_generator_js_1.generateAgentSkills; } });
+var mcp_generator_js_1 = require("./mcp-generator.js");
+Object.defineProperty(exports, "generateMcpServer", { enumerable: true, get: function () { return mcp_generator_js_1.generateMcpServer; } });
+var output_recommender_js_1 = require("./output-recommender.js");
+Object.defineProperty(exports, "recommendOutputFormat", { enumerable: true, get: function () { return output_recommender_js_1.recommendOutputFormat; } });
+var asset_sync_js_1 = require("./asset-sync.js");
+Object.defineProperty(exports, "syncAssetToGlirastes", { enumerable: true, get: function () { return asset_sync_js_1.syncAssetToGlirastes; } });
+var nestjs_scanner_js_1 = require("./nestjs-scanner.js");
+Object.defineProperty(exports, "scanNestControllers", { enumerable: true, get: function () { return nestjs_scanner_js_1.scanNestControllers; } });

package/dist/cjs/codegen/mcp-generator.d.ts

@@ -0,0 +1,50 @@
+import type { GenerateOptions } from './types.js';
+import type { AgentSkillConfig } from '../types.js';
+export interface GenerateMcpOptions extends GenerateOptions {
+    /** Skill configuration (app name, base URL, auth) */
+    skillConfig: AgentSkillConfig;
+    /** Custom output directory for MCP server files (default: mcp-server/) */
+    mcpOutputDir?: string;
+}
+export interface GenerateMcpResult {
+    /** Generated files with their relative paths and content */
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+    /** Number of MCP tools generated */
+    toolCount: number;
+    /** Module names that contain tools */
+    modulesUsed: string[];
+    /** Full extracted tool metadata for syncing to Glirastes */
+    tools: Array<{
+        toolName: string;
+        description: string;
+        method: string;
+        path: string;
+        module?: string;
+        allowedRoles?: string[];
+        needsApproval?: boolean;
+        inputFields: Array<{
+            name: string;
+            type: string;
+            required: boolean;
+            description?: string;
+        }>;
+        outputFields: Array<{
+            name: string;
+            type: string;
+        }>;
+    }>;
+}
+/**
+ * Generate an MCP server project from discovered tool definitions.
+ *
+ * Scans the project for endpoint and UI tool definitions and produces
+ * a complete MCP server project as in-memory file contents. The caller
+ * is responsible for writing the files to disk.
+ *
+ * The generated server uses stdio transport and registers one MCP tool
+ * per discovered endpoint/UI tool, grouped by module.
+ */
+export declare function generateMcpServer(options: GenerateMcpOptions): Promise<GenerateMcpResult>;