swarm-orchestrator 7.0.0-alpha.0

package/dist/src/pm-agent.js

@@ -0,0 +1,296 @@
+"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.PMAgent = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_loader_1 = require("./config-loader");
+const session_executor_1 = __importDefault(require("./session-executor"));
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)('pm-agent');
+// Approximate tokens per character (GPT-family average).
+const CHARS_PER_TOKEN = 4;
+/**
+ * PMAgent - Project Manager agent that reviews a generated plan before
+ * swarm execution. Validates step ordering, dependency correctness,
+ * scope coverage, and agent assignment.
+ *
+ * Usage:
+ *   const pm = new PMAgent(agents);
+ *   const result = pm.reviewPlan(plan);
+ *
+ * The review is purely local (no LLM call) by default. When a Copilot
+ * CLI session is available, it can optionally run an LLM-assisted review.
+ */
+class PMAgent {
+    availableAgents;
+    constructor(availableAgents) {
+        this.availableAgents = availableAgents;
+    }
+    /**
+     * Run a local (deterministic) review of the plan.
+     * Checks for common issues:
+     *   - Circular dependencies
+     *   - References to non-existent agents
+     *   - Orphaned steps (no dependency path to step 1)
+     *   - Missing integration/finalization step
+     *   - Duplicate step numbers
+     */
+    reviewPlan(plan) {
+        const start = Date.now();
+        const reviewNotes = [];
+        const changesApplied = [];
+        const revisedPlan = this.deepCopyPlan(plan);
+        // 1. Check for duplicate step numbers
+        const stepNumbers = revisedPlan.steps.map(s => s.stepNumber);
+        const seen = new Set();
+        for (const num of stepNumbers) {
+            if (seen.has(num)) {
+                reviewNotes.push(`Duplicate step number: ${num}`);
+            }
+            seen.add(num);
+        }
+        // 2. Check for references to non-existent agents
+        const agentNames = new Set(this.availableAgents.map(a => a.name));
+        const normalizedAgentNames = new Set(this.availableAgents.map(a => config_loader_1.ConfigLoader.normalizeAgentName(a.name)));
+        for (const step of revisedPlan.steps) {
+            if (!agentNames.has(step.agentName) && !normalizedAgentNames.has(config_loader_1.ConfigLoader.normalizeAgentName(step.agentName))) {
+                reviewNotes.push(`Step ${step.stepNumber} references unknown agent: ${step.agentName}`);
+            }
+        }
+        // 3. Check for circular dependencies
+        const circularSteps = this.detectCircularDeps(revisedPlan.steps);
+        if (circularSteps.length > 0) {
+            reviewNotes.push(`Circular dependencies detected involving step(s): ${circularSteps.join(', ')}`);
+        }
+        // 4. Check for dependencies on non-existent steps
+        const validSteps = new Set(revisedPlan.steps.map(s => s.stepNumber));
+        for (const step of revisedPlan.steps) {
+            for (const dep of step.dependencies) {
+                if (!validSteps.has(dep)) {
+                    reviewNotes.push(`Step ${step.stepNumber} depends on non-existent step ${dep}`);
+                }
+            }
+        }
+        // 5. Check for missing reviewer step (last step should be reviewer)
+        if (revisedPlan.steps.length > 1) {
+            const lastStep = revisedPlan.steps[revisedPlan.steps.length - 1];
+            const hasReviewer = lastStep.agentName === 'reviewer';
+            if (!hasReviewer && agentNames.has('reviewer')) {
+                reviewNotes.push('Plan is missing a final integration/finalization step');
+            }
+        }
+        // 6. Ensure metadata is up to date
+        if (!revisedPlan.metadata || revisedPlan.metadata.totalSteps !== revisedPlan.steps.length) {
+            revisedPlan.metadata = {
+                ...revisedPlan.metadata,
+                totalSteps: revisedPlan.steps.length
+            };
+            changesApplied.push('Updated metadata.totalSteps');
+        }
+        const estimatedTokenCost = Math.ceil(JSON.stringify(revisedPlan).length / CHARS_PER_TOKEN);
+        return {
+            revisedPlan,
+            reviewNotes,
+            changesApplied,
+            durationMs: Date.now() - start,
+            estimatedTokenCost,
+            skipped: false
+        };
+    }
+    /**
+     * Build a prompt for LLM-assisted plan review (for use with Copilot CLI).
+     */
+    buildReviewPrompt(plan) {
+        const sections = [];
+        sections.push('=== PM AGENT - Plan Review ===');
+        sections.push('');
+        sections.push('You are a project manager reviewing an execution plan for a parallel');
+        sections.push('swarm of coding agents. Review the plan for:');
+        sections.push('  1. Correct dependency ordering (no circular deps)');
+        sections.push('  2. Appropriate agent assignment for each task');
+        sections.push('  3. Completeness (all aspects of the goal covered)');
+        sections.push('  4. Step granularity (not too coarse, not too fine)');
+        sections.push('  5. Final integration step is present');
+        sections.push('');
+        sections.push('--- AVAILABLE AGENTS ---');
+        for (const agent of this.availableAgents) {
+            sections.push(`  ${agent.name}: ${agent.purpose}`);
+        }
+        sections.push('');
+        sections.push('--- PLAN TO REVIEW ---');
+        sections.push(JSON.stringify(plan, null, 2));
+        sections.push('');
+        sections.push('--- INSTRUCTIONS ---');
+        sections.push('Output only a revised JSON plan object if changes are needed,');
+        sections.push('or respond with "PLAN_APPROVED" if the plan is already good.');
+        sections.push('Do not add commentary outside of a valid JSON block or PLAN_APPROVED.');
+        return sections.join('\n');
+    }
+    /**
+     * Run an LLM-assisted review via Copilot CLI session.
+     * Falls back to local review if the session fails.
+     */
+    async reviewPlanWithLLM(plan, sessionOptions, outputDir) {
+        const start = Date.now();
+        // Always run local review first
+        const localResult = this.reviewPlan(plan);
+        const prompt = this.buildReviewPrompt(plan);
+        const transcriptPath = path.join(outputDir, 'pm-review-transcript.md');
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        const opts = {
+            ...sessionOptions,
+            shareToFile: transcriptPath,
+            logPrefix: '[PM-AGENT]'
+        };
+        try {
+            const executor = new session_executor_1.default();
+            const result = await executor.executeSession(prompt, opts);
+            if (!result.success) {
+                // Fall back to local-only review
+                return {
+                    ...localResult,
+                    reviewNotes: [...localResult.reviewNotes, 'LLM review failed, using local review only'],
+                    durationMs: Date.now() - start
+                };
+            }
+            // Try to parse revised plan from output
+            const revised = this.parseRevisedPlan(result.output, plan);
+            if (revised) {
+                return {
+                    revisedPlan: revised,
+                    reviewNotes: [...localResult.reviewNotes, 'LLM review applied changes'],
+                    changesApplied: [...localResult.changesApplied, 'LLM-revised plan'],
+                    durationMs: Date.now() - start,
+                    estimatedTokenCost: Math.ceil((prompt.length + (result.output?.length || 0)) / CHARS_PER_TOKEN),
+                    skipped: false
+                };
+            }
+            // PLAN_APPROVED or unparseable output - use local result
+            return {
+                ...localResult,
+                reviewNotes: [...localResult.reviewNotes, 'LLM approved plan without changes'],
+                durationMs: Date.now() - start
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`[pm-agent] LLM review failed, using local review only: ${msg}`);
+            return {
+                ...localResult,
+                reviewNotes: [...localResult.reviewNotes, 'LLM review unavailable, using local review only'],
+                durationMs: Date.now() - start
+            };
+        }
+    }
+    /**
+     * Detect circular dependencies in plan steps.
+     * Returns step numbers involved in cycles.
+     */
+    detectCircularDeps(steps) {
+        const visited = new Set();
+        const inStack = new Set();
+        const cycleSteps = [];
+        const stepMap = new Map(steps.map(s => [s.stepNumber, s]));
+        const dfs = (stepNum) => {
+            if (inStack.has(stepNum)) {
+                cycleSteps.push(stepNum);
+                return true;
+            }
+            if (visited.has(stepNum))
+                return false;
+            visited.add(stepNum);
+            inStack.add(stepNum);
+            const step = stepMap.get(stepNum);
+            if (step) {
+                for (const dep of step.dependencies) {
+                    if (dfs(dep)) {
+                        cycleSteps.push(stepNum);
+                        return true;
+                    }
+                }
+            }
+            inStack.delete(stepNum);
+            return false;
+        };
+        for (const step of steps) {
+            dfs(step.stepNumber);
+        }
+        return [...new Set(cycleSteps)];
+    }
+    /**
+     * Try to parse a revised plan from LLM output.
+     * Returns null if output does not contain a valid plan JSON.
+     */
+    parseRevisedPlan(output, originalPlan) {
+        if (!output || output.includes('PLAN_APPROVED'))
+            return null;
+        // Try to extract JSON from the output
+        const jsonMatch = output.match(/\{[\s\S]*"steps"[\s\S]*\}/);
+        if (!jsonMatch)
+            return null;
+        try {
+            const parsed = JSON.parse(jsonMatch[0]);
+            if (parsed.steps && Array.isArray(parsed.steps)) {
+                return {
+                    goal: parsed.goal || originalPlan.goal,
+                    createdAt: originalPlan.createdAt,
+                    steps: parsed.steps,
+                    metadata: {
+                        totalSteps: parsed.steps.length,
+                        estimatedDuration: parsed.metadata?.estimatedDuration
+                    }
+                };
+            }
+        }
+        catch {
+            // LLM output is not valid JSON; expected when model returns prose instead of structured data
+        }
+        return null;
+    }
+    /**
+     * Deep-copy a plan to avoid mutating the original.
+     */
+    deepCopyPlan(plan) {
+        return JSON.parse(JSON.stringify(plan));
+    }
+}
+exports.PMAgent = PMAgent;
+exports.default = PMAgent;

package/dist/src/post-run-reporter.js

@@ -0,0 +1,203 @@
+"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.runPostExecution = runPostExecution;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("./logger");
+const analytics_log_1 = __importDefault(require("./analytics-log"));
+const external_tool_manager_1 = __importDefault(require("./external-tool-manager"));
+const deployment_manager_1 = __importDefault(require("./deployment-manager"));
+const pr_automation_1 = __importDefault(require("./pr-automation"));
+const adapters_1 = require("./adapters");
+const logger = (0, logger_1.getLogger)('post-run');
+async function runPostExecution(workingDir, runDir, context, plan, options) {
+    // Finalize metrics and save to analytics log
+    if (context.metricsCollector) {
+        const metrics = context.metricsCollector.finalize();
+        // Save metrics to run directory
+        const metricsPath = path.join(runDir, 'metrics.json');
+        fs.writeFileSync(metricsPath, JSON.stringify(metrics, null, 2), 'utf8');
+        // Append to analytics log
+        const analyticsLog = new analytics_log_1.default();
+        analyticsLog.appendRun(metrics);
+        logger.debug(`metrics ${metricsPath}`);
+        // Save cost attribution alongside metrics
+        if (context.costEstimate && context.stepCostRecords) {
+            const modelName = options?.model || (0, adapters_1.defaultModelForAdapter)(options?.cliAgent);
+            const totalEstimated = context.costEstimate.totalPremiumRequests;
+            const totalActual = context.stepCostRecords.reduce((s, r) => s + r.actualPremiumRequests, 0);
+            const attribution = {
+                totalEstimatedPremiumRequests: totalEstimated,
+                totalActualPremiumRequests: totalActual,
+                estimateAccuracy: context.costEstimator?.getAccuracy() ?? 1.0,
+                modelUsed: modelName,
+                modelMultiplier: context.costEstimate.modelMultiplier,
+                overageTriggered: context.costEstimate.overageCostUSD > 0,
+                perStep: context.stepCostRecords,
+            };
+            const costPath = path.join(runDir, 'cost-attribution.json');
+            fs.writeFileSync(costPath, JSON.stringify(attribution, null, 2), 'utf8');
+        }
+        // Persist session state for audit/resume support
+        // Use the runDir basename as session ID so it matches the directory
+        // the CLI created (context.executionId differs by a few ms)
+        const runDirId = path.basename(runDir);
+        const completedSteps = context.results.filter(r => r.status === 'completed');
+        const sessionState = {
+            sessionId: runDirId,
+            graph: {
+                goal: plan.goal,
+                steps: plan.steps.map(s => ({ stepNumber: s.stepNumber, task: s.task, agent: s.agentName }))
+            },
+            branchMap: Object.fromEntries(context.results
+                .filter(r => r.branchName)
+                .map(r => [String(r.stepNumber), r.branchName])),
+            transcripts: Object.fromEntries(context.results
+                .filter(r => r.sessionResult?.transcriptPath)
+                .map(r => [String(r.stepNumber), r.sessionResult.transcriptPath])),
+            metrics: metrics,
+            gateResults: context.finalGateResults || [],
+            status: completedSteps.length === plan.steps.length ? 'completed' : 'failed',
+            lastCompletedStep: Math.max(0, ...completedSteps.map(r => r.stepNumber))
+        };
+        // Write directly to runDir (saveSession uses cwd which differs for demos)
+        fs.writeFileSync(path.join(runDir, 'session-state.json'), JSON.stringify(sessionState, null, 2), 'utf8');
+        // Also persist via collector so audit/metrics CLI can find it from project root
+        context.metricsCollector.saveSession(runDirId, sessionState);
+    }
+    // OWASP ASI compliance report (when --owasp-report is set)
+    if (options?.owaspReport) {
+        try {
+            const { OwaspMapper } = await Promise.resolve().then(() => __importStar(require('./owasp-mapper')));
+            const { OwaspReportRenderer } = await Promise.resolve().then(() => __importStar(require('./owasp-report-renderer')));
+            const verificationResults = context.results
+                .map(r => r.verificationResult)
+                .filter((v) => v !== undefined);
+            const repaired = context.results.filter(r => (r.retryCount ?? 0) > 0 && r.status === 'completed').length;
+            const failed = context.results.filter(r => r.status === 'failed').length;
+            const completed = context.results.filter(r => r.status === 'completed').length;
+            const passed = completed - repaired;
+            const exhausted = context.results.filter(r => r.status === 'failed' && (r.retryCount ?? 0) > 0).length;
+            // Read version from package.json at project root
+            let toolVersion = '4.1.0';
+            try {
+                const pkgPath = path.join(__dirname, '..', 'package.json');
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+                toolVersion = pkg.version || toolVersion;
+            }
+            catch {
+                // Fall back to hardcoded version if package.json is unavailable
+            }
+            const meta = {
+                executionId: context.executionId,
+                toolVersion,
+                strictIsolation: !!options.strictIsolation,
+                adapterType: options.cliAgent || 'copilot',
+                totalSteps: plan.steps.length,
+                passedSteps: passed,
+                repairedSteps: repaired,
+                failedSteps: failed,
+                retriesExhausted: exhausted,
+            };
+            const mapper = new OwaspMapper();
+            const complianceReport = mapper.map(verificationResults, meta);
+            fs.writeFileSync(path.join(runDir, 'owasp-compliance.md'), OwaspReportRenderer.toMarkdown(complianceReport), 'utf8');
+            fs.writeFileSync(path.join(runDir, 'owasp-compliance.json'), OwaspReportRenderer.toJson(complianceReport), 'utf8');
+            logger.info(`  OWASP ASI: ${complianceReport.mitigatedRisks}/${complianceReport.applicableRisks} applicable risks mitigated`);
+        }
+        catch (owaspErr) {
+            logger.warn(`  OWASP report generation failed: ${owaspErr instanceof Error ? owaspErr.message : owaspErr}`);
+        }
+    }
+    // Record execution in knowledge base
+    if (context.knowledgeBase) {
+        const totalPatternsDetected = context.waveAnalyses?.reduce((sum, analysis) => sum + analysis.detectedPatterns.length, 0) || 0;
+        context.knowledgeBase.recordRun(totalPatternsDetected);
+        // Record cost history for future estimation calibration
+        if (context.costEstimate && context.stepCostRecords) {
+            const modelName = options?.model || (0, adapters_1.defaultModelForAdapter)(options?.cliAgent);
+            const totalRetries = context.stepCostRecords.reduce((s, r) => s + r.retryCount, 0);
+            const totalActual = context.stepCostRecords.reduce((s, r) => s + r.actualPremiumRequests, 0);
+            const totalEstimated = context.costEstimate.totalPremiumRequests;
+            const evidence = {
+                runId: context.executionId,
+                estimated: totalEstimated,
+                actual: totalActual,
+                retries: totalRetries,
+                steps: plan.steps.length,
+                model: modelName,
+            };
+            context.knowledgeBase.addOrUpdatePattern({
+                category: 'cost_history',
+                insight: `${plan.steps.length} steps, model ${modelName}, ${totalActual} premium requests, ${totalRetries} retries`,
+                confidence: 'high',
+                evidence: [JSON.stringify(evidence)],
+                impact: 'medium',
+            });
+        }
+    }
+    // Auto-create PR if requested
+    if (options?.autoPR) {
+        logger.info('\n📝 Creating PR...');
+        try {
+            const toolManager = new external_tool_manager_1.default({
+                enableExternal: options.enableExternal || false,
+                dryRun: options.dryRun || false,
+                logFile: path.join(runDir, 'external-commands.log')
+            });
+            const deploymentManager = new deployment_manager_1.default(toolManager, workingDir);
+            const prAutomation = new pr_automation_1.default(toolManager, workingDir);
+            const deployments = deploymentManager.loadDeploymentMetadata(runDir);
+            // generatePRSummary accepts a narrow PRSummaryContext (duck-typed in
+            // pr-automation.ts). `mainBranch` on the PostRunContext feeds
+            // PRSummary.baseBranch; plan fills in plan.goal.
+            const summary = prAutomation.generatePRSummary({ ...context, plan }, deployments);
+            const prResult = await prAutomation.createPR(summary);
+            if (prResult.success) {
+                logger.info(`✅ PR created: ${prResult.url}`);
+            }
+            else {
+                logger.warn(`⚠️  PR creation failed: ${prResult.error}`);
+            }
+        }
+        catch (error) {
+            logger.warn(`⚠️  PR automation error: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}

package/dist/src/pr-automation.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRAutomation = void 0;
+/**
+ * PR Automation - auto-creates PRs with execution summaries
+ */
+class PRAutomation {
+    toolManager;
+    workingDir;
+    constructor(toolManager, workingDir) {
+        this.toolManager = toolManager;
+        this.workingDir = workingDir || process.cwd();
+    }
+    /**
+     * Generate PR summary from execution context
+     */
+    generatePRSummary(context, deployments) {
+        const completedSteps = context.results.filter(r => r.status === 'completed').length;
+        const failedSteps = context.results.filter(r => r.status === 'failed').length;
+        const totalSteps = context.results.length;
+        let body = '## Swarm Execution Summary\n\n';
+        body += `**Execution ID:** \`${context.executionId}\`\n`;
+        body += `**Goal:** ${context.plan.goal}\n`;
+        body += `**Completed:** ${completedSteps}/${totalSteps} steps\n\n`;
+        if (failedSteps > 0) {
+            body += `⚠️ **${failedSteps} step(s) failed**\n\n`;
+        }
+        // Add deployment links
+        if (deployments.length > 0) {
+            body += '## 🚀 Preview Deployments\n\n';
+            for (const deployment of deployments) {
+                if (deployment.previewUrl) {
+                    body += `- **${deployment.platform}** (Step ${deployment.stepNumber}): ${deployment.previewUrl}\n`;
+                }
+            }
+            body += '\n';
+        }
+        // Add step details
+        body += '## Steps Executed\n\n';
+        for (const result of context.results) {
+            const icon = result.status === 'completed' ? '✅' :
+                result.status === 'failed' ? '❌' :
+                    result.status === 'running' ? '🚧' : '⏸';
+            body += `${icon} **Step ${result.stepNumber}** (${result.agentName}): ${result.status}\n`;
+            if (result.verificationResult) {
+                const passed = result.verificationResult.passed ? '✓' : '✗';
+                body += `  - Verification: ${passed} ${result.verificationResult.passed ? 'passed' : 'failed'}\n`;
+            }
+        }
+        body += '\n---\n';
+        body += `*Generated by Swarm Orchestrator*\n`;
+        return {
+            title: `[Swarm] ${context.plan.goal}`,
+            body,
+            baseBranch: context.mainBranch,
+            headBranch: `swarm/${context.executionId}`
+        };
+    }
+    /**
+     * Create PR via gh CLI
+     */
+    async createPR(summary) {
+        const tools = await this.toolManager.detectAvailableTools();
+        if (!tools.gh) {
+            return {
+                success: false,
+                error: 'gh CLI not available'
+            };
+        }
+        // Create PR
+        const execution = await this.toolManager.executeCommand('gh', [
+            'pr', 'create',
+            '--base', summary.baseBranch,
+            '--head', summary.headBranch,
+            '--title', summary.title,
+            '--body', summary.body
+        ], {
+            workingDir: this.workingDir,
+            requireTool: 'gh'
+        });
+        if (execution.exitCode !== 0) {
+            return {
+                success: false,
+                error: execution.error || 'Failed to create PR'
+            };
+        }
+        // Extract PR URL from output
+        const url = this.extractPRUrl(execution.output || '');
+        return {
+            success: true,
+            ...(url && { url })
+        };
+    }
+    /**
+     * Extract PR URL from gh CLI output
+     */
+    extractPRUrl(output) {
+        const match = output.match(/(https:\/\/github\.com\/[^\s]+)/);
+        return match ? match[1] : undefined;
+    }
+}
+exports.PRAutomation = PRAutomation;
+exports.default = PRAutomation;