@nitrostack/cli 1.0.0

package/dist/commands/dev.js

@@ -0,0 +1,365 @@
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs';
+import { spawn, execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import chokidar from 'chokidar';
+import ora from 'ora';
+// ES module equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// ═══════════════════════════════════════════════════════════════════════════
+// BRANDING & UI COMPONENTS
+// ═══════════════════════════════════════════════════════════════════════════
+const NITRO_BANNER = `
+${chalk.hex('#FF6B35').bold('╔══════════════════════════════════════════════════════════════════╗')}
+${chalk.hex('#FF6B35').bold('║')}                                                                  ${chalk.hex('#FF6B35').bold('║')}
+${chalk.hex('#FF6B35').bold('║')}   ${chalk.hex('#FF6B35').bold('███╗   ██╗██╗████████╗██████╗  ██████╗ ')}                       ${chalk.hex('#FF6B35').bold('║')}
+${chalk.hex('#FF6B35').bold('║')}   ${chalk.hex('#FF8C42').bold('████╗  ██║██║╚══██╔══╝██╔══██╗██╔═══██╗')}                       ${chalk.hex('#FF6B35').bold('║')}
+${chalk.hex('#FF6B35').bold('║')}   ${chalk.hex('#FFA94D').bold('██╔██╗ ██║██║   ██║   ██████╔╝██║   ██║')}                       ${chalk.hex('#FF6B35').bold('║')}
+${chalk.hex('#FF6B35').bold('║')}   ${chalk.hex('#FFCC80').bold('██║╚██╗██║██║   ██║   ██╔══██╗██║   ██║')}                       ${chalk.hex('#FF6B35').bold('║')}
+${chalk.hex('#FF6B35').bold('║')}   ${chalk.hex('#FFE0B2').bold('██║ ╚████║██║   ██║   ██║  ██║╚██████╔╝')}                       ${chalk.hex('#FF6B35').bold('║')}
+${chalk.hex('#FF6B35').bold('║')}   ${chalk.dim('╚═╝  ╚═══╝╚═╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ')}                       ${chalk.hex('#FF6B35').bold('║')}
+${chalk.hex('#FF6B35').bold('║')}                                                                  ${chalk.hex('#FF6B35').bold('║')}
+${chalk.hex('#FF6B35').bold('║')}   ${chalk.white.bold('S T A C K')}   ${chalk.dim('─────────────────────────────────────────')}   ${chalk.hex('#FF6B35').bold('║')}
+${chalk.hex('#FF6B35').bold('║')}                                                                  ${chalk.hex('#FF6B35').bold('║')}
+${chalk.hex('#FF6B35').bold('║')}   ${chalk.dim('MCP Development Framework')}                                    ${chalk.hex('#FF6B35').bold('║')}
+${chalk.hex('#FF6B35').bold('║')}                                                                  ${chalk.hex('#FF6B35').bold('║')}
+${chalk.hex('#FF6B35').bold('╚══════════════════════════════════════════════════════════════════╝')}
+`;
+class DevUI {
+    stages = [];
+    currentSpinner = null;
+    startTime = Date.now();
+    constructor() {
+        this.stages = [
+            { name: 'Project', status: 'pending' },
+            { name: 'TypeScript', status: 'pending' },
+            { name: 'Widgets', status: 'pending' },
+            { name: 'MCP Server', status: 'pending' },
+        ];
+    }
+    showBanner() {
+        console.clear();
+        console.log(NITRO_BANNER);
+    }
+    updateStage(name, status, message) {
+        const stage = this.stages.find(s => s.name === name);
+        if (stage) {
+            stage.status = status;
+            stage.message = message;
+        }
+    }
+    startSpinner(text) {
+        if (this.currentSpinner) {
+            this.currentSpinner.stop();
+        }
+        this.currentSpinner = ora({
+            text,
+            color: 'yellow',
+            spinner: 'dots12'
+        }).start();
+        return this.currentSpinner;
+    }
+    stopSpinner(success = true, text) {
+        if (this.currentSpinner) {
+            if (success) {
+                this.currentSpinner.succeed(text);
+            }
+            else {
+                this.currentSpinner.fail(text);
+            }
+            this.currentSpinner = null;
+        }
+    }
+    showReadyScreen(config) {
+        const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
+        console.log('\n');
+        console.log(chalk.hex('#FF6B35').bold('┌──────────────────────────────────────────────────────────────────┐'));
+        console.log(chalk.hex('#FF6B35').bold('│') + chalk.green.bold('                    ✓ Development Server Ready                    ') + chalk.hex('#FF6B35').bold('│'));
+        console.log(chalk.hex('#FF6B35').bold('├──────────────────────────────────────────────────────────────────┤'));
+        console.log(chalk.hex('#FF6B35').bold('│') + '                                                                  ' + chalk.hex('#FF6B35').bold('│'));
+        console.log(chalk.hex('#FF6B35').bold('│') + `   ${chalk.white.bold('MCP Server')}  ${chalk.dim('Running (STDIO transport)')}                      ` + chalk.hex('#FF6B35').bold('│'));
+        if (config.hasWidgets) {
+            console.log(chalk.hex('#FF6B35').bold('│') + `   ${chalk.white.bold('Widgets')}     ${chalk.cyan(`http://localhost:${config.widgetsPort}`)}                         ` + chalk.hex('#FF6B35').bold('│'));
+        }
+        console.log(chalk.hex('#FF6B35').bold('│') + '                                                                  ' + chalk.hex('#FF6B35').bold('│'));
+        console.log(chalk.hex('#FF6B35').bold('├──────────────────────────────────────────────────────────────────┤'));
+        console.log(chalk.hex('#FF6B35').bold('│') + '                                                                  ' + chalk.hex('#FF6B35').bold('│'));
+        console.log(chalk.hex('#FF6B35').bold('│') + `   ${chalk.yellow.bold('To use NitroStack Studio:')}                                    ` + chalk.hex('#FF6B35').bold('│'));
+        console.log(chalk.hex('#FF6B35').bold('│') + `   ${chalk.dim('1. Start NitroStack Studio separately')}                         ` + chalk.hex('#FF6B35').bold('│'));
+        console.log(chalk.hex('#FF6B35').bold('│') + `   ${chalk.dim('2. Enter project path:')} ${chalk.cyan(config.projectPath.substring(0, 30))}${config.projectPath.length > 30 ? '...' : '   '}` + chalk.hex('#FF6B35').bold('│'));
+        console.log(chalk.hex('#FF6B35').bold('│') + '                                                                  ' + chalk.hex('#FF6B35').bold('│'));
+        console.log(chalk.hex('#FF6B35').bold('├──────────────────────────────────────────────────────────────────┤'));
+        console.log(chalk.hex('#FF6B35').bold('│') + `   ${chalk.dim(`Started in ${elapsed}s`)}                                              ` + chalk.hex('#FF6B35').bold('│'));
+        console.log(chalk.hex('#FF6B35').bold('│') + `   ${chalk.dim('Press')} ${chalk.white('Ctrl+C')} ${chalk.dim('to stop')}                                        ` + chalk.hex('#FF6B35').bold('│'));
+        console.log(chalk.hex('#FF6B35').bold('│') + '                                                                  ' + chalk.hex('#FF6B35').bold('│'));
+        console.log(chalk.hex('#FF6B35').bold('└──────────────────────────────────────────────────────────────────┘'));
+        console.log('\n');
+    }
+    showShutdown() {
+        console.log('\n');
+        console.log(chalk.hex('#FF6B35').bold('┌──────────────────────────────────────────────────────────────────┐'));
+        console.log(chalk.hex('#FF6B35').bold('│') + chalk.yellow.bold('                       Shutting down...                          ') + chalk.hex('#FF6B35').bold('│'));
+        console.log(chalk.hex('#FF6B35').bold('└──────────────────────────────────────────────────────────────────┘'));
+    }
+    showError(message) {
+        console.log('\n');
+        console.log(chalk.red.bold('┌──────────────────────────────────────────────────────────────────┐'));
+        console.log(chalk.red.bold('│') + chalk.red.bold('                           ✗ Error                               ') + chalk.red.bold('│'));
+        console.log(chalk.red.bold('├──────────────────────────────────────────────────────────────────┤'));
+        console.log(chalk.red.bold('│') + `   ${chalk.white(message.substring(0, 60).padEnd(60))}   ` + chalk.red.bold('│'));
+        console.log(chalk.red.bold('└──────────────────────────────────────────────────────────────────┘'));
+    }
+    log(message, type = 'info') {
+        const prefix = {
+            info: chalk.blue('ℹ'),
+            success: chalk.green('✓'),
+            warn: chalk.yellow('⚠'),
+            error: chalk.red('✗'),
+        }[type];
+        console.log(`${prefix} ${message}`);
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// UTILITY FUNCTIONS
+// ═══════════════════════════════════════════════════════════════════════════
+function isNitrostackFromNpm() {
+    try {
+        const result = execSync('npm list -g nitrostack --json', {
+            encoding: 'utf-8',
+            stdio: 'pipe'
+        });
+        const parsed = JSON.parse(result);
+        if (parsed.dependencies && parsed.dependencies.nitrostack) {
+            const nitrostackInfo = parsed.dependencies.nitrostack;
+            return nitrostackInfo.version && !nitrostackInfo.resolved?.includes('file:');
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+function isLocalDevelopment() {
+    return __dirname.includes('/src/cli/') || __dirname.includes('\\src\\cli\\');
+}
+function execSilent(command, options = {}) {
+    try {
+        execSync(command, {
+            ...options,
+            stdio: 'pipe',
+            encoding: 'utf-8',
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function devCommand(options) {
+    const ui = new DevUI();
+    let tscWatchProcess = null;
+    let widgetsDevProcess = null;
+    let isShuttingDown = false;
+    const shutdown = (code = 0) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        ui.showShutdown();
+        if (tscWatchProcess) {
+            tscWatchProcess.kill();
+            tscWatchProcess = null;
+        }
+        if (widgetsDevProcess) {
+            widgetsDevProcess.kill();
+            widgetsDevProcess = null;
+        }
+        setTimeout(() => {
+            console.log(chalk.dim('\nGoodbye! 👋\n'));
+            process.exit(code);
+        }, 500);
+    };
+    process.on('SIGINT', () => shutdown(0));
+    process.on('SIGTERM', () => shutdown(0));
+    try {
+        // Show banner
+        ui.showBanner();
+        const projectPath = process.cwd();
+        // ─────────────────────────────────────────────────────────────────────
+        // STAGE 1: Validate Project
+        // ─────────────────────────────────────────────────────────────────────
+        let spinner = ui.startSpinner('Validating project...');
+        const packageJsonPath = path.join(projectPath, 'package.json');
+        if (!fs.existsSync(packageJsonPath)) {
+            ui.stopSpinner(false, 'package.json not found');
+            throw new Error('Not a NitroStack project');
+        }
+        const widgetsPath = path.join(projectPath, 'src', 'widgets');
+        const widgetsPackageJsonPath = path.join(widgetsPath, 'package.json');
+        const hasWidgets = fs.existsSync(widgetsPackageJsonPath);
+        ui.stopSpinner(true, `Project validated ${hasWidgets ? chalk.dim('(with widgets)') : ''}`);
+        // ─────────────────────────────────────────────────────────────────────
+        // STAGE 2: Setup Widgets (if present)
+        // ─────────────────────────────────────────────────────────────────────
+        if (hasWidgets) {
+            spinner = ui.startSpinner('Checking widget dependencies...');
+            const fromNpm = isNitrostackFromNpm();
+            const isLocalDev = isLocalDevelopment();
+            const widgetsNodeModulesPath = path.join(widgetsPath, 'node_modules');
+            const widgetsNitrostackPath = path.join(widgetsNodeModulesPath, '@nitrostack');
+            if (!fs.existsSync(widgetsNodeModulesPath) || !fs.existsSync(widgetsNitrostackPath)) {
+                // Link local packages if in dev mode
+                if (isLocalDev && !fromNpm) {
+                    spinner.text = 'Linking local @nitrostack/widgets...';
+                    execSilent('npm link @nitrostack/widgets', { cwd: widgetsPath });
+                }
+                spinner.text = 'Installing widget dependencies...';
+                const installSuccess = execSilent('npm install', { cwd: widgetsPath });
+                if (!installSuccess) {
+                    ui.stopSpinner(false, 'Failed to install widget dependencies');
+                    throw new Error('Widget dependency installation failed');
+                }
+            }
+            ui.stopSpinner(true, 'Widget dependencies ready');
+            // Check if widgets need initial build
+            const widgetsOutPath = path.join(widgetsPath, '.next');
+            if (!fs.existsSync(widgetsOutPath)) {
+                spinner = ui.startSpinner('Building widgets for first time...');
+                const buildSuccess = execSilent('npm run build', {
+                    cwd: widgetsPath,
+                    env: { ...process.env, NODE_ENV: 'production' }
+                });
+                if (buildSuccess) {
+                    ui.stopSpinner(true, 'Widgets built');
+                }
+                else {
+                    ui.stopSpinner(false, 'Widget build failed (will try dev server)');
+                }
+            }
+        }
+        // ─────────────────────────────────────────────────────────────────────
+        // STAGE 3: Build TypeScript
+        // ─────────────────────────────────────────────────────────────────────
+        const distIndexPath = path.join(projectPath, 'dist', 'index.js');
+        if (!fs.existsSync(distIndexPath)) {
+            spinner = ui.startSpinner('Building MCP server...');
+            const buildSuccess = execSilent('npx tsc', { cwd: projectPath });
+            if (!buildSuccess) {
+                ui.stopSpinner(false, 'TypeScript build failed');
+                throw new Error('Build failed. Please fix errors and try again.');
+            }
+            ui.stopSpinner(true, 'MCP server built');
+        }
+        // ─────────────────────────────────────────────────────────────────────
+        // STAGE 4: Start TypeScript Watch Mode
+        // ─────────────────────────────────────────────────────────────────────
+        spinner = ui.startSpinner('Starting TypeScript compiler...');
+        tscWatchProcess = spawn('npx', ['tsc', '--watch', '--preserveWatchOutput'], {
+            cwd: projectPath,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: true,
+        });
+        // Only log compilation status, suppress verbose output
+        let tscReady = false;
+        if (tscWatchProcess.stdout) {
+            tscWatchProcess.stdout.on('data', (data) => {
+                const output = data.toString();
+                if (output.includes('Found 0 errors') || output.includes('Watching for file changes')) {
+                    if (!tscReady) {
+                        tscReady = true;
+                    }
+                    else {
+                        console.log(chalk.green('✓') + chalk.dim(' MCP server recompiled'));
+                    }
+                }
+                else if (output.includes('error TS')) {
+                    console.log(chalk.red('✗') + chalk.dim(' TypeScript error - check your code'));
+                }
+            });
+        }
+        ui.stopSpinner(true, 'TypeScript watch mode started');
+        // ─────────────────────────────────────────────────────────────────────
+        // STAGE 5: Start Widget Dev Server (if present)
+        // ─────────────────────────────────────────────────────────────────────
+        const widgetsPort = 3001;
+        if (hasWidgets) {
+            spinner = ui.startSpinner('Starting widget dev server...');
+            widgetsDevProcess = spawn('npm', ['run', 'dev', '--', '--port', String(widgetsPort)], {
+                cwd: widgetsPath,
+                env: { ...process.env, NODE_ENV: 'development' },
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: true,
+            });
+            // Wait for widgets to be ready
+            await new Promise((resolve) => {
+                const timeout = setTimeout(resolve, 8000);
+                if (widgetsDevProcess?.stdout) {
+                    widgetsDevProcess.stdout.on('data', (data) => {
+                        const output = data.toString();
+                        if (output.includes('Ready') || output.includes('started') || output.includes(String(widgetsPort))) {
+                            clearTimeout(timeout);
+                            resolve();
+                        }
+                    });
+                }
+            });
+            ui.stopSpinner(true, `Widget dev server running on :${widgetsPort}`);
+            // Set up watcher for new widget pages
+            const widgetPagesPath = path.join(widgetsPath, 'app');
+            const widgetNextCachePath = path.join(widgetsPath, '.next');
+            const watcher = chokidar.watch(widgetPagesPath, {
+                ignored: /(^|[\/\\])\../,
+                persistent: true,
+                ignoreInitial: true,
+                awaitWriteFinish: { stabilityThreshold: 1000, pollInterval: 100 }
+            });
+            let lastRestart = 0;
+            const RESTART_COOLDOWN = 3000;
+            watcher.on('add', (filepath) => {
+                if (filepath.endsWith('page.tsx') || filepath.endsWith('page.jsx')) {
+                    const now = Date.now();
+                    if (now - lastRestart < RESTART_COOLDOWN)
+                        return;
+                    console.log(chalk.yellow('⚡') + chalk.dim(' New widget detected, restarting...'));
+                    lastRestart = Date.now();
+                    if (widgetsDevProcess) {
+                        widgetsDevProcess.kill();
+                    }
+                    if (fs.existsSync(widgetNextCachePath)) {
+                        fs.rmSync(widgetNextCachePath, { recursive: true, force: true });
+                    }
+                    widgetsDevProcess = spawn('npm', ['run', 'dev', '--', '--port', String(widgetsPort)], {
+                        cwd: widgetsPath,
+                        env: { ...process.env, NODE_ENV: 'development' },
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                        shell: true,
+                    });
+                }
+            });
+        }
+        // ─────────────────────────────────────────────────────────────────────
+        // READY!
+        // ─────────────────────────────────────────────────────────────────────
+        ui.showReadyScreen({
+            widgetsPort,
+            hasWidgets,
+            mcpServerPath: distIndexPath,
+            projectPath,
+        });
+        // Set up log forwarding for errors only
+        widgetsDevProcess?.stderr?.on('data', (data) => {
+            const output = data.toString();
+            if (output.includes('error')) {
+                console.log(chalk.red('✗') + chalk.dim(' Widgets: ') + output.trim());
+            }
+        });
+        // Keep process alive
+        await new Promise(() => { });
+    }
+    catch (error) {
+        ui.showError(error instanceof Error ? error.message : String(error));
+        shutdown(1);
+    }
+}

package/dist/commands/generate-types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates TypeScript types from tool definitions
+ * Scans all *.tools.ts files and extracts types from Zod schemas and examples
+ */
+export declare function generateTypes(options?: {
+    output?: string;
+}): Promise<void>;
+//# sourceMappingURL=generate-types.d.ts.map

package/dist/commands/generate-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-types.d.ts","sourceRoot":"","sources":["../../src/commands/generate-types.ts"],"names":[],"mappings":"AAQA;;;GAGG;AACH,wBAAsB,aAAa,CAAC,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;CAAO,iBA4BrE"}

package/dist/commands/generate-types.js

@@ -0,0 +1,219 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Generates TypeScript types from tool definitions
+ * Scans all *.tools.ts files and extracts types from Zod schemas and examples
+ */
+export async function generateTypes(options = {}) {
+    const projectRoot = process.cwd();
+    const outputPath = options.output || path.join(projectRoot, 'src', 'types', 'generated-tools.ts');
+    console.log('🔍 Scanning for tool definitions...');
+    // Find all *.tools.ts files
+    const toolFiles = await findToolFiles(path.join(projectRoot, 'src'));
+    if (toolFiles.length === 0) {
+        console.log('⚠️  No tool files found');
+        return;
+    }
+    console.log(`📝 Found ${toolFiles.length} tool file(s)`);
+    // Parse tools and generate types
+    const types = await generateTypesFromFiles(toolFiles);
+    // Write output file
+    const outputDir = path.dirname(outputPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    fs.writeFileSync(outputPath, types);
+    console.log(`✅ Generated types at: ${outputPath}`);
+}
+async function findToolFiles(dir) {
+    const files = [];
+    if (!fs.existsSync(dir)) {
+        return files;
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory() && !entry.name.includes('node_modules') && !entry.name.includes('dist')) {
+            files.push(...await findToolFiles(fullPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.tools.ts')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+async function generateTypesFromFiles(files) {
+    let output = `/**
+ * Auto-generated types from tool definitions
+ * DO NOT EDIT THIS FILE MANUALLY
+ * 
+ * Generated by: nitrostack generate-types
+ * Generated at: ${new Date().toISOString()}
+ */
+
+// ==========================================
+// Common Types
+// ==========================================
+
+export interface ToolInput<T = unknown> {
+  [key: string]: T;
+}
+
+export interface ToolOutput<T = unknown> {
+  [key: string]: T;
+}
+
+// ==========================================
+// Tool-specific Types
+// ==========================================
+
+`;
+    const toolTypes = new Map();
+    for (const file of files) {
+        const content = fs.readFileSync(file, 'utf-8');
+        // Extract @Tool decorators
+        const toolRegex = /@Tool\(\{[\s\S]*?name:\s*['"]([^'"]+)['"]\s*,[\s\S]*?\}\)/g;
+        let match;
+        while ((match = toolRegex.exec(content)) !== null) {
+            const toolName = match[1];
+            const decoratorContent = match[0];
+            // Extract inputSchema (Zod schema)
+            const inputSchemaMatch = decoratorContent.match(/inputSchema:\s*z\.object\(\{([\s\S]*?)\}\)/);
+            // Extract example response
+            const examplesMatch = decoratorContent.match(/examples:\s*\{[\s\S]*?response:\s*(\{[\s\S]*?\})\s*\}/);
+            if (inputSchemaMatch || examplesMatch) {
+                const pascalCaseName = toPascalCase(toolName);
+                // Generate input type from Zod schema
+                let inputType = 'Record<string, unknown>';
+                if (inputSchemaMatch) {
+                    inputType = generateTypeFromZodSchema(inputSchemaMatch[1]);
+                }
+                // Generate output type from example
+                let outputType = 'unknown';
+                if (examplesMatch) {
+                    outputType = generateTypeFromExample(examplesMatch[1]);
+                }
+                toolTypes.set(toolName, { input: inputType, output: outputType });
+                output += `// ${toolName}\n`;
+                output += `export type ${pascalCaseName}Input = ${inputType};\n`;
+                output += `export type ${pascalCaseName}Output = ${outputType};\n\n`;
+            }
+        }
+    }
+    // Add a union type of all tool names
+    output += `// ==========================================\n`;
+    output += `// Tool Name Union\n`;
+    output += `// ==========================================\n\n`;
+    output += `export type ToolName = ${Array.from(toolTypes.keys()).map(name => `'${name}'`).join(' | ')};\n\n`;
+    // Add a mapped type for inputs and outputs
+    output += `// ==========================================\n`;
+    output += `// Mapped Types\n`;
+    output += `// ==========================================\n\n`;
+    output += `export interface ToolInputs {\n`;
+    for (const [toolName] of toolTypes) {
+        const pascalCase = toPascalCase(toolName);
+        output += `  '${toolName}': ${pascalCase}Input;\n`;
+    }
+    output += `}\n\n`;
+    output += `export interface ToolOutputs {\n`;
+    for (const [toolName] of toolTypes) {
+        const pascalCase = toPascalCase(toolName);
+        output += `  '${toolName}': ${pascalCase}Output;\n`;
+    }
+    output += `}\n`;
+    return output;
+}
+function toPascalCase(str) {
+    return str
+        .split(/[_-]/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+function generateTypeFromZodSchema(zodContent) {
+    // Simple parser for basic Zod schemas
+    // This is a simplified version - in production, you might want to use actual Zod parsing
+    const fields = [];
+    // Match field definitions like: field_name: z.string().describe('...')
+    const fieldRegex = /(\w+):\s*z\.(\w+)\(\)(?:\.optional\(\))?(?:\.describe\([^)]*\))?/g;
+    let match;
+    while ((match = fieldRegex.exec(zodContent)) !== null) {
+        const fieldName = match[1];
+        const zodType = match[2];
+        const isOptional = zodContent.includes(`${fieldName}:`) && zodContent.includes('.optional()');
+        let tsType = 'unknown';
+        switch (zodType) {
+            case 'string':
+                tsType = 'string';
+                break;
+            case 'number':
+                tsType = 'number';
+                break;
+            case 'boolean':
+                tsType = 'boolean';
+                break;
+            case 'enum':
+                // Extract enum values if possible
+                const enumMatch = zodContent.match(new RegExp(`${fieldName}:\\s*z\\.enum\\(\\[([^\\]]+)\\]\\)`));
+                if (enumMatch) {
+                    tsType = enumMatch[1].replace(/'/g, '"');
+                }
+                else {
+                    tsType = 'string';
+                }
+                break;
+            case 'array':
+                tsType = 'unknown[]';
+                break;
+            case 'object':
+                tsType = 'Record<string, unknown>';
+                break;
+        }
+        fields.push(`${fieldName}${isOptional ? '?' : ''}: ${tsType}`);
+    }
+    return fields.length > 0 ? `{\n  ${fields.join(';\n  ')};\n}` : 'Record<string, unknown>';
+}
+function generateTypeFromExample(exampleJson) {
+    try {
+        // Parse the example JSON to infer types
+        // This is a simplified version
+        const cleaned = exampleJson
+            .replace(/\/\/.*/g, '') // Remove comments
+            .trim();
+        const obj = eval('(' + cleaned + ')');
+        return generateTypeFromObject(obj);
+    }
+    catch (e) {
+        return 'unknown';
+    }
+}
+function generateTypeFromObject(obj, indent = '  ') {
+    if (obj === null || obj === undefined) {
+        return 'unknown';
+    }
+    if (Array.isArray(obj)) {
+        if (obj.length === 0) {
+            return 'unknown[]';
+        }
+        const itemType = generateTypeFromObject(obj[0], indent + '  ');
+        return `Array<${itemType}>`;
+    }
+    if (typeof obj === 'object') {
+        const fields = [];
+        for (const [key, value] of Object.entries(obj)) {
+            const type = generateTypeFromObject(value, indent + '  ');
+            fields.push(`${key}: ${type}`);
+        }
+        return `{\n${indent}${fields.join(`;\n${indent}`)};\n${indent.slice(2)}}`;
+    }
+    if (typeof obj === 'string')
+        return 'string';
+    if (typeof obj === 'number')
+        return 'number';
+    if (typeof obj === 'boolean')
+        return 'boolean';
+    return 'unknown';
+}

package/dist/commands/generate.d.ts

@@ -0,0 +1,12 @@
+interface GenerateOptions {
+    module?: string;
+    output?: string;
+    force?: boolean;
+    skipRelated?: boolean;
+}
+/**
+ * Generate command
+ */
+export declare function generate(type: string, name: string, options?: GenerateOptions): Promise<void>;
+export {};
+//# sourceMappingURL=generate.d.ts.map

package/dist/commands/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/commands/generate.ts"],"names":[],"mappings":"AA8TA,UAAU,eAAe;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6FvG"}