swarm-orchestrator 7.0.0-alpha.0

package/dist/src/cli/misc-handlers.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * Miscellaneous CLI command handlers extracted from cli-handlers.ts.
+ * Covers recipes, recipe-info, agents export, and the `use` command.
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleUseCommand = handleUseCommand;
+exports.handleRecipesCommand = handleRecipesCommand;
+exports.handleRecipeInfoCommand = handleRecipeInfoCommand;
+exports.handleAgentsCommand = handleAgentsCommand;
+const path = __importStar(require("path"));
+const plan_files_1 = require("../plan-files");
+const recipe_loader_1 = require("../recipe-loader");
+const agents_exporter_1 = __importDefault(require("../agents-exporter"));
+const flags_1 = require("./flags");
+const logger_1 = require("../logger");
+const logger = (0, logger_1.getLogger)('cli:misc');
+const swarm_handlers_1 = require("./swarm-handlers");
+// ---------------------------------------------------------------------------
+// recipe command handlers
+// ---------------------------------------------------------------------------
+async function handleUseCommand(args) {
+    const recipeName = args[1];
+    if (!recipeName) {
+        logger.error('Error: recipe name required\nUsage: swarm use <recipe> [--param key=value ...]');
+        return 1;
+    }
+    let recipe;
+    try {
+        recipe = (0, recipe_loader_1.loadRecipe)(recipeName);
+    }
+    catch (error) {
+        logger.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    // Parse --param key=value pairs from remaining args
+    const userParams = {};
+    for (let i = 2; i < args.length; i++) {
+        if (args[i] === '--param' && args[i + 1]) {
+            const eq = args[i + 1].indexOf('=');
+            if (eq === -1) {
+                logger.error(`Invalid parameter format: "${args[i + 1]}". Expected key=value`);
+                return 1;
+            }
+            const key = args[i + 1].substring(0, eq);
+            const value = args[i + 1].substring(eq + 1);
+            userParams[key] = value;
+            i++; // skip the value token
+        }
+    }
+    let plan;
+    try {
+        plan = (0, recipe_loader_1.parameterizeRecipe)(recipe, userParams);
+    }
+    catch (error) {
+        logger.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    logger.info(`🐝 Recipe: ${recipe.name}\n`);
+    logger.info(`   ${recipe.description}`);
+    logger.info(`   Category: ${recipe.category}`);
+    logger.info(`   Steps: ${plan.steps.length}\n`);
+    plan.steps.forEach(step => {
+        logger.info(`   Step ${step.stepNumber}: ${step.task.substring(0, 80)}${step.task.length > 80 ? '...' : ''}`);
+    });
+    logger.info('');
+    // Save the parameterized plan, then delegate to executeSwarm
+    const planPath = (0, plan_files_1.savePlanFile)(plan, `recipe-${recipeName}-${Date.now()}.json`);
+    logger.info(`Plan saved: ${planPath}\n`);
+    try {
+        const options = (0, flags_1.parseSwarmFlags)(args);
+        const exitCode = await (0, swarm_handlers_1.executeSwarm)(path.basename(planPath), options);
+        // Record recipe run in knowledge base after execution
+        try {
+            const { KnowledgeBaseManager } = await Promise.resolve().then(() => __importStar(require('../knowledge-base')));
+            const kb = new KnowledgeBaseManager();
+            kb.recordRecipeRun({
+                recipe: recipeName,
+                parameters: userParams,
+                tool: options.cliAgent || 'copilot',
+                passed: exitCode === 0,
+                duration: 0,
+                stepsCompleted: plan.steps.length,
+                totalSteps: plan.steps.length,
+            });
+        }
+        catch {
+            // Knowledge base recording is non-critical
+        }
+        return exitCode;
+    }
+    catch (error) {
+        logger.error('Error executing recipe:', error instanceof Error ? error.message : error);
+        return 1;
+    }
+}
+function handleRecipesCommand() {
+    const recipes = (0, recipe_loader_1.listRecipeDetails)();
+    if (recipes.length === 0) {
+        logger.info('No recipes found.');
+        return 0;
+    }
+    logger.info('\n╔══════════════════════════════════════════════════════════════════════╗');
+    logger.info('║  Available Recipes                                                   ║');
+    logger.info('╚══════════════════════════════════════════════════════════════════════╝\n');
+    for (const recipe of recipes) {
+        logger.info(`  ${recipe.name}`);
+        logger.info(`    ${recipe.description}`);
+        logger.info(`    Category: ${recipe.category} | Steps: ${recipe.steps.length}`);
+        const paramNames = Object.keys(recipe.parameters);
+        if (paramNames.length > 0) {
+            logger.info(`    Parameters: ${paramNames.join(', ')}`);
+        }
+        logger.info('');
+    }
+    logger.info('Usage: swarm use <recipe> [--param key=value ...]\n');
+    return 0;
+}
+function handleRecipeInfoCommand(args) {
+    const recipeName = args[1];
+    if (!recipeName) {
+        logger.error('Error: recipe name required\nUsage: swarm recipe-info <name>');
+        return 1;
+    }
+    let recipe;
+    try {
+        recipe = (0, recipe_loader_1.loadRecipe)(recipeName);
+    }
+    catch (error) {
+        logger.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    logger.info(`\nRecipe: ${recipe.name}`);
+    logger.info(`Description: ${recipe.description}`);
+    logger.info(`Category: ${recipe.category}\n`);
+    logger.info('Parameters:');
+    for (const [key, param] of Object.entries(recipe.parameters)) {
+        const defaultStr = param.default !== undefined ? ` (default: ${param.default})` : ' (required)';
+        const optionsStr = param.options ? ` [${param.options.join(' | ')}]` : '';
+        logger.info(`  --param ${key}=<value>  ${param.description}${defaultStr}${optionsStr}`);
+    }
+    logger.info('');
+    logger.info('Steps:');
+    for (const step of recipe.steps) {
+        const deps = step.dependencies.length > 0 ? ` (after step ${step.dependencies.join(', ')})` : '';
+        logger.info(`  ${step.stepNumber}. [${step.agentName}] ${step.task.substring(0, 70)}${step.task.length > 70 ? '...' : ''}${deps}`);
+    }
+    logger.info('');
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// agents command handler
+// ---------------------------------------------------------------------------
+async function handleAgentsCommand(args) {
+    const subcommand = args[1];
+    if (subcommand !== 'export') {
+        logger.error('Usage: swarm agents export [--output-dir dir] [--min-runs N] [--diff]');
+        return 1;
+    }
+    // Parse flags
+    const outputDirIdx = args.indexOf('--output-dir');
+    const outputDir = outputDirIdx !== -1 && args[outputDirIdx + 1]
+        ? args[outputDirIdx + 1]
+        : path.join(process.cwd(), 'agents');
+    const minRunsIdx = args.indexOf('--min-runs');
+    let minRuns = 5;
+    if (minRunsIdx !== -1 && args[minRunsIdx + 1]) {
+        const parsed = parseInt(args[minRunsIdx + 1], 10);
+        if (!isNaN(parsed) && parsed > 0)
+            minRuns = parsed;
+    }
+    const diff = args.includes('--diff');
+    logger.info('🐝 Swarm Orchestrator - Agent Export\n');
+    logger.info(`Output directory: ${outputDir}`);
+    logger.info(`Minimum runs for data-driven export: ${minRuns}`);
+    if (diff)
+        logger.info('Diff mode: enabled\n');
+    else
+        logger.info('');
+    const exporter = new agents_exporter_1.default();
+    const result = exporter.export({ outputDir, minRuns, diff });
+    if (result.fromData) {
+        logger.info(`Exported ${result.agentsExported.length} agent(s) with data-driven recommendations.`);
+    }
+    else {
+        logger.info(`Exported ${result.agentsExported.length} agent(s) from base definitions (insufficient run data).`);
+    }
+    for (const name of result.agentsExported) {
+        const filename = name.toLowerCase().replace(/[^a-z0-9]+/g, '_') + '.agent.md';
+        logger.info(`  - ${filename}`);
+    }
+    if (diff && result.diffs.length > 0) {
+        logger.info(`\nChanges detected (${result.diffs.length} diff(s)):`);
+        for (const d of result.diffs) {
+            logger.info(`  ${d.agentName} / ${d.field}:`);
+            if (d.previous)
+                logger.info(`    - ${d.previous.slice(0, 100)}`);
+            logger.info(`    + ${d.current.slice(0, 100)}`);
+        }
+    }
+    else if (diff) {
+        logger.info('\nNo changes detected since last export.');
+    }
+    logger.info(`\nAgent files written to: ${outputDir}`);
+    return 0;
+}

package/dist/src/cli/plan-handlers.js

@@ -0,0 +1,350 @@
+"use strict";
+/**
+ * Plan-related CLI command handlers extracted from cli-handlers.ts.
+ * Each handler validates its arguments, performs the work, and returns an
+ * exit code (0 = success, 1 = failure). No handler calls process.exit.
+ */
+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.generatePlan = generatePlan;
+exports.importPlanFromTranscript = importPlanFromTranscript;
+exports.executePlan = executePlan;
+exports.handlePlanCommand = handlePlanCommand;
+exports.handleExecuteCommand = handleExecuteCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_loader_1 = require("../config-loader");
+const plan_generator_1 = require("../plan-generator");
+const plan_files_1 = require("../plan-files");
+const step_runner_1 = require("../step-runner");
+const adapters_1 = require("../adapters");
+const flags_1 = require("./flags");
+const usage_1 = require("./usage");
+const logger_1 = require("../logger");
+const logger = (0, logger_1.getLogger)('cli:plan');
+// ---------------------------------------------------------------------------
+// Plan helpers (exported from this module; called by the handle* functions)
+// ---------------------------------------------------------------------------
+function generatePlan(goal, copilotMode = false) {
+    const configLoader = new config_loader_1.ConfigLoader();
+    const agents = configLoader.loadAllAgents();
+    const generator = new plan_generator_1.PlanGenerator(agents);
+    if (copilotMode) {
+        logger.info('╔══════════════════════════════════════════════════════════════════════╗');
+        logger.info('║  COPILOT CLI PLANNING MODE                                           ║');
+        logger.info('╚══════════════════════════════════════════════════════════════════════╝\n');
+        logger.info('📋 Goal:', goal, '\n');
+        logger.info('Instructions:');
+        logger.info('  1. Copy the prompt below');
+        logger.info('  2. Start a new Copilot CLI session: copilot');
+        logger.info('  3. Paste the prompt and press Enter');
+        logger.info('  4. When Copilot responds with JSON, run: /share');
+        logger.info('  5. Save the /share transcript to a file');
+        logger.info('  6. Import the plan: swarm plan import <runid> <transcript-path>\n');
+        logger.info('═'.repeat(70));
+        logger.info('PROMPT (copy from next line until the marker):');
+        logger.info('═'.repeat(70));
+        logger.info();
+        const prompt = generator.generateCopilotPlanningPrompt(goal);
+        logger.info(prompt);
+        logger.info();
+        logger.info('═'.repeat(70));
+        logger.info('END OF PROMPT');
+        logger.info('═'.repeat(70));
+        logger.info();
+        return;
+    }
+    logger.info('╔══════════════════════════════════════════════════════════════════════╗');
+    logger.info('║  INTELLIGENT PLAN GENERATION (Fallback Mode)                        ║');
+    logger.info('╚══════════════════════════════════════════════════════════════════════╝\n');
+    logger.info('📋 Goal:', goal, '\n');
+    logger.info('💡 Tip: Use --copilot for Copilot CLI-generated plans\n');
+    logger.info(`Loaded ${agents.length} agent profiles:`);
+    agents.forEach(agent => {
+        logger.info(`  ✓ ${agent.name}: ${agent.purpose}`);
+    });
+    logger.info();
+    const plan = generator.createPlan(goal);
+    logger.info('Generated Execution Plan:');
+    logger.info('═'.repeat(70));
+    logger.info();
+    plan.steps.forEach(step => {
+        logger.info(`Step ${step.stepNumber}: ${step.task}`);
+        logger.info(`  👤 Agent: ${step.agentName}`);
+        if (step.dependencies.length > 0) {
+            logger.info(`  🔗 Dependencies: Steps ${step.dependencies.join(', ')}`);
+        }
+        logger.info(`  📦 Expected outputs:`);
+        step.expectedOutputs.forEach(output => {
+            logger.info(`     • ${output}`);
+        });
+        logger.info();
+    });
+    const executionOrder = generator.getExecutionOrder(plan);
+    logger.info(`🔄 Execution Order: ${executionOrder.join(' → ')}\n`);
+    const planPath = (0, plan_files_1.savePlanFile)(plan);
+    logger.info(`✅ Plan saved to: ${planPath}`);
+    logger.info(`\n▶  To execute: swarm swarm ${path.basename(planPath)}\n`);
+}
+function importPlanFromTranscript(runId, transcriptPath) {
+    logger.info('╔══════════════════════════════════════════════════════════════════════╗');
+    logger.info('║  IMPORT COPILOT-GENERATED PLAN                                       ║');
+    logger.info('╚══════════════════════════════════════════════════════════════════════╝\n');
+    logger.info('📁 Transcript:', transcriptPath);
+    logger.info('🆔 Run ID:', runId);
+    logger.info();
+    try {
+        if (!fs.existsSync(transcriptPath)) {
+            throw new Error(`Transcript file not found: ${transcriptPath}`);
+        }
+        const transcriptContent = fs.readFileSync(transcriptPath, 'utf-8');
+        const configLoader = new config_loader_1.ConfigLoader();
+        const agents = configLoader.loadAllAgents();
+        const generator = new plan_generator_1.PlanGenerator(agents);
+        logger.info('🔍 Parsing transcript for JSON plan...');
+        const plan = generator.parseCopilotPlanFromTranscript(transcriptContent);
+        logger.info('✅ Plan parsed successfully!\n');
+        logger.info('Plan details:');
+        logger.info(`  Goal: ${plan.goal}`);
+        logger.info(`  Steps: ${plan.steps.length}`);
+        logger.info(`  Created: ${plan.createdAt}\n`);
+        logger.info('Steps:');
+        logger.info('═'.repeat(70));
+        plan.steps.forEach(step => {
+            logger.info(`\nStep ${step.stepNumber}: ${step.task}`);
+            logger.info(`  👤 Agent: ${step.agentName}`);
+            if (step.dependencies.length > 0) {
+                logger.info(`  🔗 Dependencies: ${step.dependencies.join(', ')}`);
+            }
+            logger.info(`  📦 Outputs: ${step.expectedOutputs.join(', ')}`);
+        });
+        logger.info('\n' + '═'.repeat(70));
+        const executionOrder = generator.getExecutionOrder(plan);
+        logger.info(`\n🔄 Execution Order: ${executionOrder.join(' → ')}`);
+        const planPath = (0, plan_files_1.savePlanFile)(plan);
+        logger.info(`\n✅ Plan saved to: ${planPath}`);
+        logger.info(`\n▶  To execute: swarm swarm ${path.basename(planPath)}\n`);
+        return 0;
+    }
+    catch (error) {
+        logger.error('\n❌ Error importing plan:');
+        logger.error('  ', error instanceof Error ? error.message : String(error));
+        logger.error('\nTroubleshooting:');
+        logger.error('  • Ensure the transcript contains valid JSON output from Copilot');
+        logger.error('  • The JSON must match the ExecutionPlan schema');
+        logger.error('  • Check that all agent names are valid');
+        logger.error('  • Ensure dependencies form a valid DAG (no cycles)\n');
+        return 1;
+    }
+}
+function executePlan(planFilename, options) {
+    logger.info('Swarm Orchestrator - Plan Execution\n');
+    const plan = (0, plan_files_1.loadPlanFile)(planFilename);
+    logger.info(`Plan: ${plan.goal}`);
+    logger.info(`Steps: ${plan.steps.length}`);
+    const { CostEstimator } = require('../cost-estimator');
+    const seqModel = (0, adapters_1.defaultModelForAdapter)(options?.cliAgent);
+    const seqEstimator = new CostEstimator();
+    const seqEstimate = seqEstimator.estimate(plan, { modelName: seqModel });
+    logger.info(`\n💰 Cost Estimate: ${seqEstimate.lowEstimate}-${seqEstimate.totalPremiumRequests} premium requests`);
+    logger.info(`   ${plan.steps.length} steps | ${seqModel} (${seqEstimate.modelMultiplier}x)`);
+    if (options?.delegate || options?.mcp) {
+        logger.info('\nGitHub Integration:');
+        if (options.delegate)
+            logger.info('  ✓ /delegate enabled - agents will be instructed to create PRs');
+        if (options.mcp)
+            logger.info('  ✓ MCP required - agents must provide GitHub context evidence');
+    }
+    logger.info('');
+    const configLoader = new config_loader_1.ConfigLoader();
+    const agents = configLoader.loadAllAgents();
+    const runner = new step_runner_1.StepRunner();
+    const context = runner.initializeExecution(plan, planFilename, options);
+    logger.info(`Execution ID: ${context.executionId}\n`);
+    const generator = new plan_generator_1.PlanGenerator(agents);
+    const executionOrder = generator.getExecutionOrder(plan);
+    logger.info(`Execution Order: ${executionOrder.join(' → ')}\n`);
+    logger.info('='.repeat(70));
+    logger.info('SEQUENTIAL EXECUTION GUIDE');
+    logger.info('='.repeat(70));
+    logger.info('');
+    logger.info('This tool will guide you through each step of the plan.');
+    logger.info('For each step, you will:');
+    logger.info('  1. Receive a session prompt to copy/paste into Copilot CLI');
+    logger.info('  2. Complete the work in that Copilot session');
+    logger.info('  3. Run /share to capture the transcript');
+    logger.info('  4. Save the transcript to the specified proof file');
+    logger.info('  5. Return here to mark the step complete and get the next step');
+    logger.info('');
+    logger.info('Press ENTER to begin with Step 1...');
+    logger.info('');
+    const firstStepNumber = executionOrder[0];
+    if (firstStepNumber === undefined) {
+        logger.error('No steps to execute');
+        return 1;
+    }
+    const firstStep = plan.steps.find(s => s.stepNumber === firstStepNumber);
+    if (!firstStep) {
+        logger.error(`Step ${firstStepNumber} not found in plan`);
+        return 1;
+    }
+    const agent = agents.find(a => a.name === firstStep.agentName);
+    if (!agent) {
+        logger.error(`Agent ${firstStep.agentName} not found`);
+        return 1;
+    }
+    runner.displayStepInstructions(firstStep, agent, context);
+    const contextPath = runner.saveExecutionContext(context);
+    logger.info(`\n✓ Execution context saved to: ${contextPath}`);
+    logger.info(`\nTo continue execution after completing this step, run:`);
+    logger.info(`  swarm status ${context.executionId}\n`);
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// Exported command handlers
+// ---------------------------------------------------------------------------
+async function handlePlanCommand(args) {
+    const normalizedArgs = (0, flags_1.normalizeLeadingGlobalFlags)(args);
+    const outputFormat = (0, flags_1.parseOutputFormat)(normalizedArgs);
+    const positional = (0, flags_1.extractPositionalArgs)(normalizedArgs.slice(1), {
+        booleanFlags: ['--help', '-h', '--verbose', '--json', '--copilot'],
+        valueFlags: ['--output'],
+    });
+    if (normalizedArgs.includes('--help') || normalizedArgs.includes('-h') || positional.length === 0) {
+        (0, usage_1.showUsage)();
+        return 0;
+    }
+    const subcommand = positional[0];
+    if (subcommand === 'import') {
+        if (positional.length < 3) {
+            logger.error('Error: plan import requires: <runid> <transcript-path>\n');
+            (0, usage_1.showUsage)();
+            return 1;
+        }
+        const runId = positional[1];
+        const transcriptPath = positional[2];
+        if (!runId || !transcriptPath) {
+            logger.error('Error: all arguments required\n');
+            (0, usage_1.showUsage)();
+            return 1;
+        }
+        if (outputFormat === 'json') {
+            try {
+                if (!fs.existsSync(transcriptPath)) {
+                    throw new Error(`Transcript file not found: ${transcriptPath}`);
+                }
+                const transcriptContent = fs.readFileSync(transcriptPath, 'utf-8');
+                const configLoader = new config_loader_1.ConfigLoader();
+                const agents = configLoader.loadAllAgents();
+                const generator = new plan_generator_1.PlanGenerator(agents);
+                const plan = generator.parseCopilotPlanFromTranscript(transcriptContent);
+                const planPath = (0, plan_files_1.savePlanFile)(plan);
+                (0, logger_1.writeStructuredOutput)({ runId, transcriptPath, planFile: planPath, plan });
+                return 0;
+            }
+            catch (error) {
+                logger.error('Error importing plan:', error instanceof Error ? error.message : error);
+                return 1;
+            }
+        }
+        return importPlanFromTranscript(runId, transcriptPath);
+    }
+    if (normalizedArgs.includes('--copilot')) {
+        const goal = positional.join(' ');
+        if (!goal) {
+            logger.error('Error: goal required for --copilot mode\n');
+            (0, usage_1.showUsage)();
+            return 1;
+        }
+        try {
+            if (outputFormat === 'json') {
+                const configLoader = new config_loader_1.ConfigLoader();
+                const agents = configLoader.loadAllAgents();
+                const generator = new plan_generator_1.PlanGenerator(agents);
+                (0, logger_1.writeStructuredOutput)({
+                    goal,
+                    mode: 'copilot',
+                    prompt: generator.generateCopilotPlanningPrompt(goal),
+                });
+                return 0;
+            }
+            generatePlan(goal, true);
+            return 0;
+        }
+        catch (error) {
+            logger.error('Error generating Copilot prompt:', error instanceof Error ? error.message : error);
+            return 1;
+        }
+    }
+    // plan <goal> (regular mode)
+    const goal = positional.join(' ');
+    try {
+        if (outputFormat === 'json') {
+            const configLoader = new config_loader_1.ConfigLoader();
+            const agents = configLoader.loadAllAgents();
+            const generator = new plan_generator_1.PlanGenerator(agents);
+            const plan = generator.createPlan(goal);
+            const planPath = (0, plan_files_1.savePlanFile)(plan);
+            (0, logger_1.writeStructuredOutput)({ goal: plan.goal, planFile: planPath, plan });
+            return 0;
+        }
+        generatePlan(goal, false);
+        return 0;
+    }
+    catch (error) {
+        logger.error('Error generating plan:', error instanceof Error ? error.message : error);
+        return 1;
+    }
+}
+async function handleExecuteCommand(args) {
+    if (args.length < 2 || !args[1]) {
+        logger.error('Error: Plan filename required\n');
+        (0, usage_1.showUsage)();
+        return 1;
+    }
+    const planFilename = args[1];
+    const options = {};
+    if (args.includes('--delegate'))
+        options.delegate = true;
+    if (args.includes('--mcp'))
+        options.mcp = true;
+    try {
+        return executePlan(planFilename, Object.keys(options).length > 0 ? options : undefined);
+    }
+    catch (error) {
+        logger.error('Error executing plan:', error instanceof Error ? error.message : error);
+        return 1;
+    }
+}