@auto-engineer/cli 0.13.3 → 0.14.0

package/dist/src/index.js

@@ -1,32 +1,87 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
+import * as fs from 'node:fs';
+import { createServer } from 'node:http';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { PipelineServer } from '@auto-engineer/pipeline';
 import chalk from 'chalk';
+import { Command } from 'commander';
 import * as dotenv from 'dotenv';
-import * as path from 'path';
-import * as fs from 'fs';
-import { fileURLToPath } from 'url';
-import Debug from 'debug';
-import { loadConfig, validateConfig } from './utils/config.js';
-import { handleError } from './utils/errors.js';
-import { createOutput } from './utils/terminal.js';
-import { Analytics } from './utils/analytics.js';
-import { PluginLoader } from './plugin-loader.js';
 import getPort, { portNumbers } from 'get-port';
-// Export DSL functions for use in auto.config.ts
-export { on, dispatch, fold, autoConfig } from './dsl/index.js';
-const debug = Debug('auto-engineer:cli');
-// Get version from package.json - works in both dev and production
-const getVersion = () => {
+import createJiti from 'jiti';
+import ora from 'ora';
+import { Server as SocketIOServer } from 'socket.io';
+import { FileSyncer } from './file-syncer/index.js';
+dotenv.config();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function isValidHandler(item) {
+    return item !== null && item !== undefined && typeof item === 'object' && 'handle' in item && 'name' in item;
+}
+function extractCommandHandler(module, filename, packageName) {
+    if (isValidHandler(module.default)) {
+        return module.default;
+    }
+    if (isValidHandler(module.commandHandler)) {
+        return module.commandHandler;
+    }
+    if (isValidHandler(module.handler)) {
+        return module.handler;
+    }
+    for (const [key, value] of Object.entries(module)) {
+        if (isValidHandler(value)) {
+            console.log(chalk.gray(`  Found handler via named export "${key}" in ${filename}`));
+            return value;
+        }
+    }
+    console.log(chalk.gray(`  No valid handler found in ${filename} from ${packageName}`));
+    return null;
+}
+async function detectCommandsByConvention(packageName) {
+    const handlers = [];
+    const packageShortName = packageName.replace('@auto-engineer/', '');
+    const workspaceCommandsPath = path.join(process.cwd(), 'packages', packageShortName, 'dist', 'commands');
+    const workspaceSrcCommandsPath = path.join(process.cwd(), 'packages', packageShortName, 'dist', 'src', 'commands');
+    const nodeModulesCommandsPath = path.join(process.cwd(), 'node_modules', packageName, 'dist', 'commands');
+    const nodeModulesSrcCommandsPath = path.join(process.cwd(), 'node_modules', packageName, 'dist', 'src', 'commands');
+    let commandsDir = null;
+    if (fs.existsSync(workspaceCommandsPath)) {
+        commandsDir = workspaceCommandsPath;
+    }
+    else if (fs.existsSync(workspaceSrcCommandsPath)) {
+        commandsDir = workspaceSrcCommandsPath;
+    }
+    else if (fs.existsSync(nodeModulesCommandsPath)) {
+        commandsDir = nodeModulesCommandsPath;
+    }
+    else if (fs.existsSync(nodeModulesSrcCommandsPath)) {
+        commandsDir = nodeModulesSrcCommandsPath;
+    }
+    if (!commandsDir) {
+        return handlers;
+    }
+    const commandFiles = fs.readdirSync(commandsDir).filter((file) => file.endsWith('.js'));
+    for (const filename of commandFiles) {
+        const filePath = path.join(commandsDir, filename);
+        const fileUrl = pathToFileURL(filePath).href;
+        try {
+            const module = (await import(fileUrl));
+            const handler = extractCommandHandler(module, filename, packageName);
+            if (handler) {
+                handlers.push(handler);
+            }
+        }
+        catch (error) {
+            console.warn(chalk.yellow(`  Failed to load command file ${filename}:`), error);
+        }
+    }
+    return handlers;
+}
+function getVersion() {
     try {
-        // Try to read from package.json relative to this file
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
-        // Try multiple possible locations for package.json
-        // In dev: src/index.ts -> ../package.json
-        // In dist: dist/src/index.js -> ../../package.json
         const possiblePaths = [
-            path.join(__dirname, '..', 'package.json'), // dev environment
-            path.join(__dirname, '..', '..', 'package.json'), // dist build
+            path.join(__dirname, '..', 'package.json'),
+            path.join(__dirname, '..', '..', 'package.json'),
         ];
         for (const packageJsonPath of possiblePaths) {
             if (fs.existsSync(packageJsonPath)) {
@@ -36,425 +91,248 @@ const getVersion = () => {
         }
     }
     catch {
-        // Fall through to env variable
+        // Fall through
     }
-    // Fallback to npm_package_version (works when run via npm scripts)
-    // If neither works, show unknown
     return process.env.npm_package_version ?? 'unknown';
-};
+}
 const VERSION = getVersion();
-const checkNodeVersion = () => {
-    const nodeVersion = process.version;
-    const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
-    if (majorVersion < 18) {
-        console.error(chalk.red(`Error: Node.js version ${nodeVersion} is not supported.`));
-        console.error(chalk.yellow('Auto-engineer requires Node.js 18.0.0 or higher.'));
-        console.error(chalk.blue('Please upgrade Node.js and try again.'));
-        process.exit(1);
+async function loadPipelineConfig(configPath) {
+    try {
+        if (configPath.endsWith('.ts')) {
+            const jiti = createJiti(import.meta.url, { interopDefault: true });
+            return await jiti.import(configPath);
+        }
+        const configUrl = pathToFileURL(path.resolve(configPath)).href;
+        const configModule = (await import(configUrl));
+        return configModule.default ?? configModule;
     }
-};
-const setupSignalHandlers = () => {
-    process.on('SIGINT', () => {
-        if (serverInstance !== null && serverInstance !== undefined) {
-            console.log('\n' + chalk.yellow('Shutting down server...'));
-            try {
-                void serverInstance.stop();
-            }
-            catch (error) {
-                console.error('Error stopping server:', error);
-            }
+    catch (error) {
+        console.error(chalk.red('Failed to load config:'), error);
+        return null;
+    }
+}
+async function tryLoadFromPath(modulePath) {
+    if (!fs.existsSync(modulePath))
+        return null;
+    const packageUrl = pathToFileURL(modulePath).href;
+    return (await import(packageUrl));
+}
+async function loadPlugin(packageName) {
+    const packageShortName = packageName.replace('@auto-engineer/', '');
+    const workspaceBase = path.join(process.cwd(), 'packages', packageShortName, 'dist');
+    const nodeModulesBase = path.join(process.cwd(), 'node_modules', packageName, 'dist');
+    const pathsToTry = [
+        path.join(workspaceBase, 'index.js'),
+        path.join(workspaceBase, 'src', 'index.js'),
+        path.join(nodeModulesBase, 'index.js'),
+        path.join(nodeModulesBase, 'src', 'index.js'),
+    ];
+    const nodePathsToTry = [path.join(workspaceBase, 'src', 'node.js'), path.join(nodeModulesBase, 'src', 'node.js')];
+    try {
+        for (const modulePath of pathsToTry) {
+            const plugin = await tryLoadFromPath(modulePath);
+            if (plugin?.COMMANDS)
+                return plugin;
         }
-        else {
-            console.log('\n' + chalk.yellow('Operation cancelled by user'));
+        for (const modulePath of nodePathsToTry) {
+            const plugin = await tryLoadFromPath(modulePath);
+            if (plugin?.COMMANDS)
+                return plugin;
         }
-        process.exit(0);
-    });
-    process.on('SIGTERM', () => {
-        if (serverInstance !== null && serverInstance !== undefined) {
-            console.log('\n' + chalk.yellow('Shutting down server...'));
-            try {
-                void serverInstance.stop();
-            }
-            catch (error) {
-                console.error('Error stopping server:', error);
-            }
+        const dynamicPlugin = (await import(packageName));
+        if (dynamicPlugin?.COMMANDS)
+            return dynamicPlugin;
+        try {
+            const nodeImport = (await import(`${packageName}/node`));
+            if (nodeImport?.COMMANDS)
+                return nodeImport;
         }
-        else {
-            console.log('\n' + chalk.yellow('Process terminated'));
+        catch {
+            // /node subpath not available for this package
         }
-        process.exit(0);
-    });
-    process.on('uncaughtException', (error) => {
-        console.error(chalk.red('Uncaught Exception:'), error);
-        process.exit(1);
-    });
-    process.on('unhandledRejection', (reason, promise) => {
-        console.error(chalk.red('Unhandled Rejection at:'), promise, chalk.red('reason:'), reason);
-        process.exit(1);
-    });
-};
-const createCLI = () => {
-    const program = new Command();
-    program
-        .name('auto-engineer')
-        .description('Auto Engineer - Build production ready full-stack apps with AI')
-        .version(VERSION, '-v, --version')
-        .option('-d, --debug', 'Enable debug mode')
-        .option('--no-color', 'Disable colored output')
-        .option('--json', 'Output in JSON format')
-        .option('--api-token <token>', 'API token for external services')
-        .option('--project-path <path>', 'Project path to work with')
-        .option('--host <url>', 'Message bus server URL (e.g., localhost:5555)');
-    return program;
-};
-const prepareCommandData = (alias, args, options, pluginLoader) => {
-    const mapper = pluginLoader.getCommandMapper(alias);
-    if (mapper !== undefined) {
-        return mapper(args, options);
+        return null;
     }
-    // Default handling for unknown commands
-    const baseData = {};
-    args.forEach((arg, index) => {
-        if (arg !== '') {
-            baseData[`arg${index + 1}`] = arg;
+    catch (error) {
+        console.warn(chalk.yellow(`Warning: Failed to load plugin ${packageName}:`), error);
+        return null;
+    }
+}
+async function loadCommandHandlers(plugins) {
+    const handlers = [];
+    for (const packageName of plugins) {
+        const plugin = await loadPlugin(packageName);
+        if (plugin?.COMMANDS) {
+            handlers.push(...plugin.COMMANDS);
+            continue;
         }
-    });
-    Object.keys(options).forEach((key) => {
-        if (options[key] !== undefined && key !== '_') {
-            baseData[key] = options[key];
+        const detectedHandlers = await detectCommandsByConvention(packageName);
+        if (detectedHandlers.length > 0) {
+            handlers.push(...detectedHandlers);
         }
-    });
-    return baseData;
-};
-const filterNonEmptyArgs = (args) => {
-    return args.filter((arg) => {
-        if (typeof arg === 'string')
-            return arg !== '';
-        if (Array.isArray(arg))
-            return true;
-        return false;
-    });
-};
-const debugCommandExecution = (args, cmdArgs, options) => {
-    if (process.env.DEBUG !== undefined && process.env.DEBUG.includes('cli:')) {
-        console.error('DEBUG cli: Raw args:', args);
-        console.error('DEBUG cli: Command args:', cmdArgs);
-        console.error('DEBUG cli: Options:', options);
-    }
-};
-const debugCommandData = (commandData) => {
-    if (process.env.DEBUG !== undefined && process.env.DEBUG.includes('cli:')) {
-        console.error('DEBUG cli: Prepared command data:', commandData);
-    }
-};
-const handleVersionOption = (options, alias, loadedCommands) => {
-    if (options.version === true) {
-        const commandInfo = loadedCommands.get(alias);
-        const version = commandInfo && 'version' in commandInfo && typeof commandInfo.version === 'string'
-            ? commandInfo.version
-            : 'unknown';
-        console.log(version);
-        return true;
-    }
-    return false;
-};
-const executeCommandAction = async (args, alias, pluginLoader, loadedCommands, config, analytics) => {
-    const cmdObject = args[args.length - 1];
-    const cmdArgs = args.slice(0, -1);
-    const options = cmdObject.opts();
-    const globalOpts = cmdObject.parent?.opts();
-    const hostOption = globalOpts?.host;
-    if (handleVersionOption(options, alias, loadedCommands)) {
-        return;
     }
-    await analytics.track({ command: alias, success: true });
-    debugCommandExecution(args, cmdArgs, options);
-    const nonEmptyArgs = filterNonEmptyArgs(cmdArgs);
-    const commandData = prepareCommandData(alias, nonEmptyArgs, options, pluginLoader);
-    debugCommandData(commandData);
-    if (hostOption !== undefined) {
-        pluginLoader.setHost(hostOption);
-    }
-    await pluginLoader.executeCommand(alias, commandData);
-    if (hostOption !== undefined) {
-        pluginLoader.setHost(config.host);
+    return handlers;
+}
+async function dispatchCommand(baseUrl, commandType, data) {
+    const response = await fetch(`${baseUrl}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: commandType, data }),
+    });
+    return response.json();
+}
+function findConfigFile() {
+    const candidates = ['auto.config.ts', 'auto.config.js'];
+    for (const candidate of candidates) {
+        const fullPath = path.join(process.cwd(), candidate);
+        if (fs.existsSync(fullPath)) {
+            return fullPath;
+        }
     }
-    await analytics.track({ command: alias, success: true });
-};
-const setupProgram = async (config) => {
-    const program = createCLI();
-    const analytics = new Analytics(config);
-    const output = createOutput(config);
-    const loadedCommands = new Map();
-    // Configure help to be minimal since we add our own
-    program.configureHelp({
-        sortSubcommands: true,
-        subcommandTerm: (cmd) => cmd.name(),
-        // Hide the Commands section
-        formatHelp: (cmd, helper) => {
-            const termWidth = helper.padWidth(cmd, helper);
-            const helpWidth = helper.helpWidth ?? 80;
-            const itemIndentWidth = 2;
-            const itemSeparatorWidth = 2;
-            function formatItem(term, description) {
-                if (description !== '') {
-                    const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-                    return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
-                }
-                return term;
-            }
-            function formatList(textArray) {
-                return textArray.join('\n').replace(/^/gm, ' '.repeat(itemIndentWidth));
-            }
-            const output = [];
-            // Usage
-            const commandUsage = helper.commandUsage(cmd);
-            output.push('Usage: ' + commandUsage, '');
-            // Description
-            const commandDescription = helper.commandDescription(cmd);
-            if (commandDescription !== '') {
-                output.push(commandDescription, '');
-            }
-            // Options
-            const optionList = helper.visibleOptions(cmd).map((option) => {
-                return formatItem(helper.optionTerm(option), helper.optionDescription(option));
-            });
-            if (optionList.length > 0) {
-                output.push('Options:', formatList(optionList), '');
-            }
-            // Skip the Commands section - we'll add our own
-            return output.join('\n');
-        },
+    return null;
+}
+async function startFileSyncServer(syncPort, watchDir) {
+    const httpServer = createServer();
+    const io = new SocketIOServer(httpServer, {
+        cors: { origin: '*' },
     });
-    // Check for auto.config.ts or auto.config.js file
-    let configPath = path.resolve(process.cwd(), 'auto.config.ts');
-    let hasPluginConfig = fs.existsSync(configPath);
-    if (!hasPluginConfig) {
-        configPath = path.resolve(process.cwd(), 'auto.config.js');
-        hasPluginConfig = fs.existsSync(configPath);
+    const fileSyncer = new FileSyncer(io, watchDir);
+    fileSyncer.start();
+    return new Promise((resolve) => {
+        httpServer.listen(syncPort, () => {
+            resolve({ fileSyncer, httpServer });
+        });
+    });
+}
+async function startServer(opts) {
+    const port = parseInt(opts.port, 10);
+    const actualPort = await getPort({ port: portNumbers(port, port + 100) });
+    const syncPort = await getPort({ port: portNumbers(actualPort + 1, actualPort + 100) });
+    const configPath = opts.config ?? findConfigFile();
+    if (!configPath) {
+        console.error(chalk.red('No pipeline config found. Create an auto.config.ts file.'));
+        process.exit(1);
     }
-    if (!hasPluginConfig) {
-        output.error('No auto.config.ts or auto.config.js found. Please create one with your required plugins.');
-        output.info('Example auto.config.js:');
-        console.log(`
-export default {
-  plugins: [
-    '@auto-engineer/narrative',
-    '@auto-engineer/server-generator-apollo-emmett',
-    '@auto-engineer/server-implementer',
-    // Add more plugins as needed
-  ]
-};`);
+    const spinner = ora('Loading pipeline config...').start();
+    const config = await loadPipelineConfig(configPath);
+    if (!config) {
+        spinner.fail('Failed to load pipeline config');
         process.exit(1);
     }
-    // Use plugin system
-    debug('Loading plugins from %s', configPath);
+    spinner.text = 'Loading plugins...';
+    const commandHandlers = await loadCommandHandlers(config.plugins);
+    spinner.succeed(`Loaded ${commandHandlers.length} command handlers from ${config.plugins.length} plugins`);
+    spinner.start('Starting pipeline server...');
     try {
-        const pluginLoader = new PluginLoader(config.host);
-        const commands = await pluginLoader.loadPlugins(configPath);
-        // Store loaded commands for dynamic help generation
-        commands.forEach((command, alias) => {
-            loadedCommands.set(alias, command);
+        const server = new PipelineServer({ port: actualPort });
+        server.registerCommandHandlers(commandHandlers);
+        server.registerPipeline(config.pipeline);
+        const watchDir = path.dirname(configPath);
+        const { fileSyncer, httpServer: syncHttpServer } = await startFileSyncServer(syncPort, watchDir);
+        process.on('SIGINT', () => {
+            console.log(chalk.yellow('\nShutting down servers...'));
+            fileSyncer.stop();
+            syncHttpServer.close();
+            void server.stop();
+            process.exit(0);
         });
-        // Register CLI commands that will dispatch through the message bus
-        for (const [alias, command] of commands.entries()) {
-            // Parse the command alias to get parts for commander
-            const parts = alias.split(':');
-            const primaryCommand = parts[0];
-            const subCommand = parts.slice(1).join(':');
-            let cmd;
-            if (subCommand) {
-                // Create as subcommand (e.g., "create:example" becomes "create example")
-                cmd = new Command(`${primaryCommand}:${subCommand}`);
-            }
-            else {
-                // Single command
-                cmd = new Command(primaryCommand);
-            }
-            cmd.description(command.description);
-            // Add arguments from the command manifest
-            if (command.args) {
-                command.args.forEach((arg) => {
-                    // Handle variadic arguments (e.g., flows...)
-                    const isVariadic = arg.name.endsWith('...');
-                    const argName = isVariadic ? arg.name : arg.name;
-                    const argString = arg.required === true ? `<${argName}>` : `[${argName}]`;
-                    cmd.argument(argString, arg.description ?? '');
-                });
-            }
-            // Add options from the command manifest
-            if (command.options) {
-                command.options.forEach((opt) => {
-                    cmd.option(opt.name, opt.description ?? '');
-                });
-            }
-            // Add version option to each command if package has version
-            const commandInfo = loadedCommands.get(alias);
-            if (commandInfo && 'version' in commandInfo) {
-                cmd.option('--version', 'Display version of the package providing this command');
-            }
-            cmd.action(async (...args) => {
-                try {
-                    await executeCommandAction(args, alias, pluginLoader, loadedCommands, config, analytics);
-                }
-                catch (error) {
-                    await analytics.track({ command: alias, success: false });
-                    if (error instanceof Error) {
-                        handleError(error);
-                    }
-                    else {
-                        handleError(new Error(String(error)));
-                    }
-                }
-            });
-            program.addCommand(cmd);
-        }
-        const pluginCount = pluginLoader.getLoadedPluginCount();
-        debug('Loaded %d commands from %d plugins', commands.size, pluginCount);
+        await server.start();
+        spinner.succeed(`Pipeline server running at http://localhost:${actualPort}`);
+        console.log(chalk.cyan('\nEndpoints:'));
+        console.log(`  ${chalk.gray('Health:')}    http://localhost:${actualPort}/health`);
+        console.log(`  ${chalk.gray('Registry:')} http://localhost:${actualPort}/registry`);
+        console.log(`  ${chalk.gray('Pipeline:')} http://localhost:${actualPort}/pipeline`);
+        console.log(`  ${chalk.gray('Diagram:')}  http://localhost:${actualPort}/pipeline/diagram`);
+        console.log(`  ${chalk.gray('Events:')}   http://localhost:${actualPort}/events (SSE)`);
+        console.log(`  ${chalk.gray('FileSync:')} ws://localhost:${syncPort} (Socket.IO)`);
+        console.log(chalk.gray('\nPress Ctrl+C to stop'));
     }
     catch (error) {
-        output.error('Failed to load plugins');
+        spinner.fail('Failed to start server');
         console.error(error);
         process.exit(1);
     }
-    // Generate dynamic help text from loaded commands
-    const generateDynamicHelp = () => {
-        const categories = new Map();
-        // Group commands by category
-        loadedCommands.forEach((command, alias) => {
-            const category = command.category ?? 'Other Commands';
-            if (!categories.has(category)) {
-                categories.set(category, []);
-            }
-            categories.get(category).push({ alias, command });
-        });
-        const helpText = [];
-        helpText.push('\nCommands:\n');
-        // Build help text for each category
-        categories.forEach((commands, category) => {
-            helpText.push(`\n  ${chalk.cyan(category)}\n`);
-            commands.forEach(({ alias, command }) => {
-                const usage = command.usage ?? alias;
-                const description = command.description ?? 'No description available';
-                // Calculate padding for alignment
-                const padding = ' '.repeat(Math.max(0, 60 - usage.length));
-                helpText.push(`    ${usage}${padding}${description}\n`);
-                // Add examples indented under the command
-                if (command.examples && command.examples.length > 0) {
-                    command.examples.forEach((example) => {
-                        helpText.push(`      ${chalk.gray(example)}\n`);
-                    });
-                }
-            });
-        });
-        // Add environment variables section
-        helpText.push(`
-\nEnvironment Variables:
-  ${chalk.gray('AI Providers (need at least one):')}
-  ANTHROPIC_API_KEY                      Anthropic Claude API key
-  OPENAI_API_KEY                         OpenAI API key
-  GEMINI_API_KEY                         Google Gemini API key
-  XAI_API_KEY                            X.AI Grok API key
-
-  ${chalk.gray('Debugging & Configuration:')}
-  DEBUG=*                                Enable all debug output
-  DEBUG=auto-engineer:*                  Enable auto-engineer debug only
-  NO_COLOR=1                             Disable colored output
-  AUTO_ENGINEER_ANALYTICS=false          Disable usage analytics
-
-Tips:
-  • Use DEBUG=* to troubleshoot command issues
-  • Run 'pnpm install' after create:example
-  • Commands available depend on plugins in auto.config.ts
-
-For docs & support: https://github.com/SamHatoum/auto-engineer\n`);
-        return helpText.join('');
-    };
-    program.addHelpText('after', generateDynamicHelp());
-    return program;
-};
-const loadEnvFile = () => {
-    const envPath = path.resolve(process.cwd(), '.env');
-    if (fs.existsSync(envPath)) {
-        dotenv.config({ path: envPath });
-    }
-};
-const initializeEnvironment = () => {
-    checkNodeVersion();
-    loadEnvFile();
-    setupSignalHandlers();
-};
-const handleProgramError = (error) => {
-    if (error instanceof Error &&
-        (error.message.includes('commander') ||
-            error.message.includes('helpDisplayed') ||
-            error.message.includes('version'))) {
-        process.exit(0);
-    }
-    if (error instanceof Error) {
-        handleError(error);
-    }
-    else {
-        console.error(chalk.red('Unknown error:'), error);
-        process.exit(1);
-    }
-};
-let serverStarted = false;
-let serverInstance = null;
-const startMessageBusServer = async () => {
-    if (serverStarted)
-        return;
-    else
-        serverStarted = true;
-    const { MessageBusServer } = await import('./server/server.js');
-    const { loadMessageBusConfig } = await import('./server/config-loader.js');
-    debug('Starting Auto Engineer Server...');
-    const server = new MessageBusServer({
-        port: await getPort({ port: portNumbers(5555, 6000) }),
-        enableFileSync: true,
-        fileSyncDir: process.cwd(),
-        fileSyncExtensions: ['.js', '.ts', '.tsx', '.jsx', '.html', '.css', 'auto.config'],
+}
+async function main() {
+    const program = new Command();
+    program
+        .name('auto')
+        .description('Auto Engineer - Build apps with Narrative Driven Development')
+        .version(VERSION, '-v, --version')
+        .option('-p, --port <number>', 'Server port', '5555')
+        .option('-d, --debug', 'Enable debug mode')
+        .option('-c, --config <path>', 'Path to pipeline config file')
+        .option('--host <url>', 'Connect to existing server instead of starting one');
+    program
+        .command('start', { isDefault: true })
+        .description('Start the pipeline server with loaded config (default)')
+        .action(async () => {
+        const opts = program.opts();
+        await startServer(opts);
     });
-    const configPath = path.resolve(process.cwd(), 'auto.config.ts');
-    if (fs.existsSync(configPath)) {
-        await loadMessageBusConfig(configPath, server);
-    }
-    serverInstance = server;
-    await server.start();
-};
-// TODO make this check for the latest version and make it easy for devs to upgrade
-const main = async () => {
-    try {
-        initializeEnvironment();
-        // For help/version, we need to load the config with defaults to show all commands
-        const hostArgIndex = process.argv.indexOf('--host');
-        const hostValue = hostArgIndex !== -1 && hostArgIndex + 1 < process.argv.length ? process.argv[hostArgIndex + 1] : undefined;
-        const config = loadConfig({
-            debug: process.argv.includes('-d') || process.argv.includes('--debug'),
-            noColor: process.argv.includes('--no-color'),
-            output: process.argv.includes('--json') ? 'json' : 'text',
-            host: hostValue,
-        });
-        validateConfig(config);
-        createOutput(config);
-        // Check if no command arguments provided (just 'auto')
-        if (process.argv.length === 2 || (process.argv.length === 3 && process.argv[2] === 'serve')) {
-            await startMessageBusServer();
-            return;
+    program
+        .command('dispatch <command>')
+        .description('Dispatch a command to the pipeline server')
+        .option('--data <json>', 'Command data as JSON', '{}')
+        .action(async (commandType, options) => {
+        const opts = program.opts();
+        const baseUrl = opts.host ?? `http://localhost:${opts.port}`;
+        const spinner = ora(`Dispatching ${commandType}...`).start();
+        try {
+            const data = JSON.parse(options.data);
+            const result = await dispatchCommand(baseUrl, commandType, data);
+            spinner.succeed(`Command dispatched: ${commandType}`);
+            console.log(chalk.gray(JSON.stringify(result, null, 2)));
         }
-        const fullProgram = await setupProgram(config);
-        await fullProgram.parseAsync(process.argv);
-    }
-    catch (error) {
-        handleProgramError(error);
-    }
-};
-// Only run main() if this is the entry point
-if (import.meta.url === `file://${process.argv[1]}`) {
-    main().catch((error) => {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(chalk.red('Fatal error:'), errorMessage);
-        process.exit(1);
+        catch (error) {
+            spinner.fail(`Failed to dispatch ${commandType}`);
+            console.error(error);
+            process.exit(1);
+        }
+    });
+    program
+        .command('status')
+        .description('Check pipeline server status')
+        .action(async () => {
+        const opts = program.opts();
+        const baseUrl = opts.host ?? `http://localhost:${opts.port}`;
+        try {
+            const healthResponse = await fetch(`${baseUrl}/health`);
+            if (!healthResponse.ok) {
+                console.log(chalk.red('Server is not healthy'));
+                process.exit(1);
+            }
+            const health = (await healthResponse.json());
+            console.log(chalk.green('Server is healthy'));
+            console.log(chalk.gray(`  Status: ${health.status}`));
+            console.log(chalk.gray(`  Uptime: ${Math.round(health.uptime)}s`));
+            const registryResponse = await fetch(`${baseUrl}/registry`);
+            const registry = (await registryResponse.json());
+            console.log(chalk.cyan('\nRegistry:'));
+            console.log(chalk.gray(`  Commands: ${registry.commandHandlers.length}`));
+            console.log(chalk.gray(`  Events: ${registry.eventHandlers.length}`));
+        }
+        catch {
+            console.log(chalk.red('Server is not running'));
+            process.exit(1);
+        }
+    });
+    program
+        .command('diagram')
+        .description('Open the pipeline diagram in a browser')
+        .action(async () => {
+        const opts = program.opts();
+        const baseUrl = opts.host ?? `http://localhost:${opts.port}`;
+        const diagramUrl = `${baseUrl}/pipeline/diagram`;
+        console.log(chalk.cyan(`Opening diagram at ${diagramUrl}`));
+        const { exec } = await import('node:child_process');
+        const platform = process.platform;
+        const command = platform === 'darwin' ? 'open' : platform === 'win32' ? 'start' : 'xdg-open';
+        exec(`${command} ${diagramUrl}`);
     });
+    await program.parseAsync(process.argv);
 }
+main().catch((error) => {
+    console.error(chalk.red('Error:'), error);
+    process.exit(1);
+});
 //# sourceMappingURL=index.js.map