swarm-orchestrator 7.0.0-alpha.0

package/dist/src/step-runner.js

@@ -0,0 +1,365 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepRunner = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const github_mcp_integrator_1 = require("./github-mcp-integrator");
+const session_executor_1 = __importDefault(require("./session-executor"));
+const test_command_discovery_1 = require("./test-command-discovery");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)('step-runner');
+class StepRunner {
+    proofDir;
+    sessionExecutor;
+    workingDir;
+    constructor(proofDir, workingDir) {
+        this.workingDir = workingDir || process.cwd();
+        this.proofDir = proofDir || path.join(this.workingDir, 'proof');
+        this.sessionExecutor = new session_executor_1.default(this.workingDir);
+    }
+    /**
+     * Initialize execution context for a plan
+     */
+    initializeExecution(plan, planFilename, options) {
+        const executionId = this.generateExecutionId();
+        const context = {
+            plan,
+            planFilename,
+            executionId,
+            startTime: new Date().toISOString(),
+            currentStep: 0,
+            stepResults: plan.steps.map(step => ({
+                stepNumber: step.stepNumber,
+                agentName: step.agentName,
+                status: 'pending'
+            })),
+            priorContext: []
+        };
+        if (options) {
+            context.options = options;
+        }
+        return context;
+    }
+    /**
+     * Generate the session starter prompt for a Copilot CLI session
+     * This is what the user should paste into their Copilot CLI session
+     */
+    generateSessionPrompt(step, agent, context) {
+        const lines = [];
+        lines.push('='.repeat(70));
+        lines.push(`COPILOT CLI SESSION - Step ${step.stepNumber}`);
+        lines.push('='.repeat(70));
+        lines.push('');
+        lines.push('You are operating as a GitHub Copilot CLI custom agent within a supervised,');
+        lines.push('sequential workflow.');
+        lines.push('');
+        lines.push('Context');
+        lines.push('-------');
+        lines.push(`- This repository is: ${context.plan.goal}`);
+        lines.push(`- Execution ID: ${context.executionId}`);
+        lines.push(`- Step: ${step.stepNumber} of ${context.plan.steps.length}`);
+        lines.push('- Your work must be fully auditable through session transcripts, git history,');
+        lines.push('  and test output.');
+        lines.push('');
+        lines.push('Your assigned role');
+        lines.push('------------------');
+        lines.push(`- Agent name: ${agent.name}`);
+        lines.push(`- Domain scope: ${agent.purpose}`);
+        lines.push('- You must stay strictly within this domain.');
+        lines.push('- If a task exceeds this scope, say so and stop.');
+        lines.push('');
+        lines.push('Your specific task for this step');
+        lines.push('---------------------------------');
+        lines.push(step.task);
+        lines.push('');
+        lines.push('Scope (what you ARE responsible for)');
+        lines.push('-------------------------------------');
+        agent.scope.forEach(item => {
+            lines.push(`- ${item}`);
+        });
+        lines.push('');
+        lines.push('Boundaries (what you should NOT do)');
+        lines.push('-----------------------------------');
+        agent.boundaries.forEach(item => {
+            lines.push(`- ${item}`);
+        });
+        lines.push('');
+        lines.push('Done definition (when you can say "done")');
+        lines.push('------------------------------------------');
+        agent.done_definition.forEach(item => {
+            lines.push(`- ${item}`);
+        });
+        lines.push('');
+        lines.push('Hard rules');
+        lines.push('----------');
+        lines.push('1. Do not invent features, flags, APIs, or tool behavior.');
+        lines.push('2. If you are uncertain about anything, explicitly say you are uncertain');
+        lines.push('   and list how to verify it.');
+        lines.push('3. Do not claim tests passed unless you actually ran them and can show');
+        lines.push('   the command output.');
+        lines.push('4. Do not say "done" unless all required artifacts listed below exist.');
+        lines.push('5. Prefer small, reviewable changes over large refactors.');
+        lines.push('');
+        const testDiscovery = (0, test_command_discovery_1.discoverTestCommand)(this.workingDir);
+        if (testDiscovery.warning && !(0, logger_1.isPrettyMode)()) {
+            logger.warn(`test command discovery: ${testDiscovery.warning}`);
+        }
+        lines.push((0, test_command_discovery_1.renderVerifyCommandSection)(testDiscovery));
+        lines.push('Refusal rules (when to stop and ask)');
+        lines.push('-------------------------------------');
+        agent.refusal_rules.forEach(rule => {
+            lines.push(`- ${rule}`);
+        });
+        lines.push('');
+        if (step.dependencies.length > 0) {
+            lines.push('Dependencies (steps you can rely on)');
+            lines.push('------------------------------------');
+            lines.push(`This step depends on: Steps ${step.dependencies.join(', ')}`);
+            lines.push('');
+            if (context.priorContext.length > 0) {
+                lines.push('Context from prior steps:');
+                context.priorContext.forEach(ctx => {
+                    lines.push(`  ${ctx}`);
+                });
+                lines.push('');
+            }
+        }
+        lines.push('Required artifacts for this step');
+        lines.push('--------------------------------');
+        lines.push(`You must produce all of the following before ending the session:`);
+        lines.push('');
+        lines.push('1. Implementation changes (code, config, etc.)');
+        lines.push('2. A verification section that includes:');
+        lines.push('   - What commands you ran');
+        lines.push('   - What tests were executed');
+        lines.push('   - The results of those tests');
+        lines.push('   - Any gaps or risks that remain');
+        lines.push('');
+        lines.push('Expected outputs:');
+        step.expectedOutputs.forEach(output => {
+            lines.push(`   - ${output}`);
+        });
+        lines.push('');
+        // add GitHub integration instructions
+        if (context.options?.mcp) {
+            lines.push('');
+            lines.push(github_mcp_integrator_1.GitHubMcpIntegrator.generateMcpPromptSection());
+            lines.push('');
+        }
+        if (context.options?.delegate) {
+            lines.push('');
+            lines.push(github_mcp_integrator_1.GitHubMcpIntegrator.generateDelegatePromptSection());
+            lines.push('');
+        }
+        const transcriptPath = agent.output_contract.transcript.replace('{N}', step.stepNumber.toString());
+        lines.push(`3. Proof transcript saved to: ${transcriptPath}`);
+        lines.push('');
+        lines.push('Session closure');
+        lines.push('---------------');
+        lines.push('- When the step is complete, run /share to capture the session transcript.');
+        lines.push('- The /share output is the authoritative record of this step.');
+        lines.push('- Save the transcript to the proof file listed above.');
+        lines.push('- Do not summarize results outside of the proof transcript.');
+        lines.push('');
+        lines.push('If any requirement cannot be met, stop and explain why before proceeding.');
+        lines.push('');
+        lines.push('='.repeat(70));
+        lines.push('BEGIN WORK');
+        lines.push('='.repeat(70));
+        return lines.join('\n');
+    }
+    /**
+     * Execute a step programmatically (automated execution)
+     * Returns session result with transcript path
+     */
+    async executeStepAutomated(step, agent, context, options) {
+        logger.info(`\nExecuting Step ${step.stepNumber} (${agent.name}) programmatically...`);
+        const sessionOptions = {
+            model: options?.model || undefined,
+            allowAllTools: true,
+            silent: false
+        };
+        // execute with retry
+        const maxRetries = options?.retries || 3;
+        const result = await this.sessionExecutor.executeWithRetry(this.sessionExecutor['buildStepPrompt'](step, agent, context), sessionOptions, maxRetries);
+        if (result.success && result.transcriptPath) {
+            logger.info(`✓ Step ${step.stepNumber} completed`);
+            logger.info(`  Transcript: ${result.transcriptPath}`);
+        }
+        else {
+            logger.error(`✗ Step ${step.stepNumber} failed after ${maxRetries} attempts`);
+            if (result.error) {
+                logger.error(`  Error: ${result.error}`);
+            }
+        }
+        return result;
+    }
+    /**
+     * Display instructions for executing a step
+     */
+    displayStepInstructions(step, agent, context) {
+        const prompt = this.generateSessionPrompt(step, agent, context);
+        logger.info('\n' + '='.repeat(70));
+        logger.info(`Step ${step.stepNumber}: ${step.task}`);
+        logger.info(`Agent: ${agent.name}`);
+        logger.info('='.repeat(70));
+        logger.info('');
+        logger.info('INSTRUCTIONS:');
+        logger.info('-------------');
+        logger.info('1. Open a new GitHub Copilot CLI session in this repository');
+        logger.info('2. Copy the prompt below and paste it into the session');
+        logger.info('3. Work with Copilot to complete the task');
+        logger.info('4. When done, run /share and save the transcript');
+        logger.info('');
+        logger.info('SESSION PROMPT (copy everything below):');
+        logger.info('');
+        logger.info(prompt);
+        logger.info('');
+    }
+    /**
+     * Mark a step as completed and update context
+     */
+    completeStep(context, stepNumber, transcriptPath, outputs) {
+        const resultIndex = context.stepResults.findIndex(r => r.stepNumber === stepNumber);
+        if (resultIndex === -1) {
+            throw new Error(`Step ${stepNumber} not found in execution context`);
+        }
+        const result = context.stepResults[resultIndex];
+        if (!result) {
+            throw new Error(`Step result ${stepNumber} is undefined`);
+        }
+        result.status = 'completed';
+        result.endTime = new Date().toISOString();
+        result.transcriptPath = transcriptPath;
+        result.outputs = outputs;
+        // Add to prior context for next steps
+        const contextSummary = `Step ${stepNumber} (${result.agentName}): ${outputs.join(', ')}`;
+        context.priorContext.push(contextSummary);
+        context.currentStep = stepNumber;
+    }
+    /**
+     * Mark a step as failed
+     */
+    failStep(context, stepNumber, errors) {
+        const resultIndex = context.stepResults.findIndex(r => r.stepNumber === stepNumber);
+        if (resultIndex === -1) {
+            throw new Error(`Step ${stepNumber} not found in execution context`);
+        }
+        const result = context.stepResults[resultIndex];
+        if (!result) {
+            throw new Error(`Step result ${stepNumber} is undefined`);
+        }
+        result.status = 'failed';
+        result.endTime = new Date().toISOString();
+        result.errors = errors;
+        context.currentStep = stepNumber;
+    }
+    /**
+     * Save execution context to file
+     */
+    saveExecutionContext(context) {
+        this.ensureProofDirectory();
+        const filename = `execution-${context.executionId}.json`;
+        const filepath = path.join(this.proofDir, filename);
+        fs.writeFileSync(filepath, JSON.stringify(context, null, 2), 'utf8');
+        return filepath;
+    }
+    /**
+     * Load execution context from file
+     */
+    loadExecutionContext(executionId) {
+        const filename = `execution-${executionId}.json`;
+        const filepath = path.join(this.proofDir, filename);
+        if (!fs.existsSync(filepath)) {
+            throw new Error(`Execution context not found: ${filepath}`);
+        }
+        const content = fs.readFileSync(filepath, 'utf8');
+        return JSON.parse(content);
+    }
+    generateExecutionId() {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        return `exec-${timestamp}`;
+    }
+    ensureProofDirectory() {
+        if (!fs.existsSync(this.proofDir)) {
+            fs.mkdirSync(this.proofDir, { recursive: true });
+        }
+    }
+    /**
+     * Generate execution summary
+     */
+    generateSummary(context) {
+        const lines = [];
+        lines.push('='.repeat(70));
+        lines.push('EXECUTION SUMMARY');
+        lines.push('='.repeat(70));
+        lines.push('');
+        lines.push(`Goal: ${context.plan.goal}`);
+        lines.push(`Execution ID: ${context.executionId}`);
+        lines.push(`Started: ${context.startTime}`);
+        if (context.endTime) {
+            lines.push(`Ended: ${context.endTime}`);
+        }
+        lines.push('');
+        lines.push('Step Results:');
+        lines.push('-------------');
+        context.stepResults.forEach(result => {
+            const step = context.plan.steps.find(s => s.stepNumber === result.stepNumber);
+            const statusIcon = result.status === 'completed' ? '✓' :
+                result.status === 'failed' ? '✗' :
+                    result.status === 'running' ? '⋯' : '○';
+            lines.push(`${statusIcon} Step ${result.stepNumber}: ${step?.task || 'Unknown'}`);
+            lines.push(`  Agent: ${result.agentName}`);
+            lines.push(`  Status: ${result.status}`);
+            if (result.transcriptPath) {
+                lines.push(`  Transcript: ${result.transcriptPath}`);
+            }
+            if (result.outputs && result.outputs.length > 0) {
+                lines.push(`  Outputs: ${result.outputs.join(', ')}`);
+            }
+            if (result.errors && result.errors.length > 0) {
+                lines.push(`  Errors: ${result.errors.join(', ')}`);
+            }
+            lines.push('');
+        });
+        return lines.join('\n');
+    }
+}
+exports.StepRunner = StepRunner;
+exports.default = StepRunner;