swarm-orchestrator 7.0.0-alpha.0

package/dist/src/orchestrator/final-gates-remediation.js

@@ -0,0 +1,258 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRemediationStepForDelegate = buildRemediationStepForDelegate;
+exports.runFinalGatesPipeline = runFinalGatesPipeline;
+const path = __importStar(require("path"));
+const quality_gates_1 = require("../quality-gates");
+const registry_1 = require("../quality-gates/registry");
+const logger_1 = require("../logger");
+const logger = (0, logger_1.getLogger)('orchestrator');
+/**
+ * Shared auto-remediation logic for quality gate failures. Returns a
+ * remediation step descriptor if the gate failed and auto-fix is both
+ * enabled and not already triggered; otherwise returns null. Includes
+ * specific gate findings in the task so the fix agent knows exactly
+ * what to address.
+ *
+ * Mutates `context.qualityGatesTriggered[triggeredFlag] = true` when a
+ * step is produced, to prevent re-adding the same remediation on a
+ * subsequent gate-failure pass.
+ *
+ * @param host - orchestrator surface (used for agent resolution)
+ * @param gateResult - the gate result being remediated; may be undefined if the gate didn't run
+ * @param configEnabled - whether the auto-remediation is enabled in the gate config
+ * @param triggeredFlag - key on `context.qualityGatesTriggered` to flip when this remediation fires
+ * @param context - mutable remediation context
+ * @param agents - available agent map for `resolveAgent`
+ * @param taskDescription - base task text for the remediation step
+ * @param warningMessage - log line emitted when the remediation is scheduled
+ * @param afterStep - dependency step number for the new remediation step
+ * @param fallbackAgent - agent to use when `integrator_finalizer` is not available
+ * @returns remediation step descriptor, or null when no remediation should fire
+ */
+function buildRemediationStep(host, gateResult, configEnabled, triggeredFlag, context, agents, taskDescription, warningMessage, afterStep, fallbackAgent) {
+    if (!gateResult || gateResult.status !== 'fail')
+        return null;
+    if (!configEnabled)
+        return null;
+    if (!context.qualityGatesTriggered || context.qualityGatesTriggered[triggeredFlag])
+        return null;
+    const preferredAgent = host.resolveAgent(agents, 'integrator_finalizer')
+        ? 'integrator_finalizer'
+        : fallbackAgent;
+    logger.warn(warningMessage);
+    context.qualityGatesTriggered[triggeredFlag] = true;
+    // Append specific findings so the remediation agent knows exactly what to fix
+    let taskWithFindings = taskDescription;
+    if (gateResult.issues && gateResult.issues.length > 0) {
+        const findings = gateResult.issues.map(issue => {
+            let finding = `- ${issue.message}`;
+            if (issue.filePath)
+                finding += ` (${issue.filePath})`;
+            if (issue.hint)
+                finding += ` -- hint: ${issue.hint}`;
+            return finding;
+        }).join('\n');
+        taskWithFindings += `\n\nSpecific findings from the gate:\n${findings}`;
+    }
+    return { agent: preferredAgent, task: taskWithFindings, afterStep };
+}
+/**
+ * Exposes `buildRemediationStep` for the thin private delegate on
+ * `SwarmOrchestrator`. Tests access the class method via
+ * `(orch as any).buildRemediationStep(...)` so this wrapper preserves
+ * the exact call surface while keeping the module's internal helper
+ * unexported.
+ */
+function buildRemediationStepForDelegate(host, gateResult, configEnabled, triggeredFlag, context, agents, taskDescription, warningMessage, afterStep, fallbackAgent) {
+    return buildRemediationStep(host, gateResult, configEnabled, triggeredFlag, context, agents, taskDescription, warningMessage, afterStep, fallbackAgent);
+}
+/**
+ * Run the final quality gates pass and, if the gates fail with
+ * auto-fixable findings, schedule remediation replan(s) until either
+ * the gates pass or the auto-fix budget is exhausted.
+ *
+ * Behavior mirrors the inline block previously at
+ * swarm-orchestrator.ts:700-907 exactly. Preserves the
+ * gate-replan-gate-replan-gate ordering. Mutates
+ * `context.finalGateResults` after each gate run and
+ * `context.qualityGatesTriggered` when remediation fires.
+ *
+ * @param host - orchestrator surface providing workingDir, targetMode,
+ *   resolveAgent, and executeReplan
+ * @param context - mutable remediation context
+ * @param runDir - run directory used to resolve the gate output path
+ * @param agents - fallback agent map (used when `context.agents` is not set)
+ * @param gatesConfig - cached quality gates config
+ * @param options - orchestrator options (qualityGates, qualityGatesOutDir, plus pass-through for replan)
+ * @returns pipeline outcome including the final gate results, whether
+ *   any remediation was attempted, and the gate output directory
+ */
+async function runFinalGatesPipeline(host, context, runDir, agents, gatesConfig, options) {
+    // Live status presents this transition as a single in-place line; the
+    // logger entry is the forensic record visible with --verbose.
+    logger.debug('running final quality gates');
+    const presenter = require('../presenter');
+    presenter.getPresenter().gateRunningStart();
+    const gatesOut = options?.qualityGatesOutDir
+        ? path.isAbsolute(options.qualityGatesOutDir)
+            ? options.qualityGatesOutDir
+            : path.join(runDir, options.qualityGatesOutDir)
+        : path.join(runDir, 'quality-gates');
+    // Reuse cached gatesConfig from top of executeSwarm.
+    // Pass baseline so gates only flag issues on agent-created files,
+    // not pre-existing project code the agents weren't asked to change.
+    const baselineFiles = context.baselineSnapshot
+        ? new Set(context.baselineSnapshot.allFiles)
+        : undefined;
+    const baseCommit = context.baselineSnapshot?.headCommit || undefined;
+    const skippedReqIds = context.filteredRequirements
+        ? new Set(context.filteredRequirements.skipped.map(r => r.id))
+        : undefined;
+    // targetMode: skip orchestrator-internal self-improvement gates when
+    // we're operating on an external repo. Universal gates
+    // (hardcodedConfig, testFileProtection) continue to fire. See
+    // registry.ts for the classification rationale.
+    const skippedGateKeys = host.targetMode ? registry_1.SELF_IMPROVEMENT_GATE_KEYS : undefined;
+    let gatesResult = await (0, quality_gates_1.run_quality_gates)(host.workingDir, gatesConfig, gatesOut, baselineFiles, baseCommit, skippedReqIds, skippedGateKeys);
+    context.finalGateResults = gatesResult.results;
+    let remediationAttempted = false;
+    if (!gatesResult.passed && gatesConfig.failOnIssues) {
+        const failedIds = new Set(gatesResult.results.filter(r => r.status === 'fail').map(r => r.id));
+        const agentMap = context.agents || agents;
+        const canAutoFix = !!context.qualityGatesTriggered && ((failedIds.has('duplicate-blocks') && gatesConfig.autoAddRefactorStepOnDuplicateBlocks && !context.qualityGatesTriggered.duplicateRefactorAdded) ||
+            (failedIds.has('readme-claims') && gatesConfig.autoAddReadmeTruthStepOnReadmeClaims && !context.qualityGatesTriggered.readmeTruthAdded) ||
+            (failedIds.has('scaffold-defaults') && gatesConfig.autoAddScaffoldFixStepOnScaffoldDefaults && !context.qualityGatesTriggered.scaffoldFixAdded) ||
+            (failedIds.has('hardcoded-config') && gatesConfig.autoAddConfigFixStepOnHardcodedConfig && !context.qualityGatesTriggered.configFixAdded) ||
+            (failedIds.has('accessibility') && gatesConfig.autoAddAccessibilityFixStepOnAccessibility && !context.qualityGatesTriggered.accessibilityFixAdded) ||
+            (failedIds.has('test-coverage') && gatesConfig.autoAddTestCoverageStepOnTestCoverage && !context.qualityGatesTriggered.testCoverageFixAdded));
+        if (canAutoFix) {
+            // Remediation steps should depend only on steps that actually completed.
+            // Using the max step number can create dependencies on failed/blocked steps,
+            // causing the remediation to wait forever then timeout.
+            const completedStepNumbers = context.results
+                .filter(r => r.status === 'completed')
+                .map(r => r.stepNumber);
+            const maxCompletedStep = completedStepNumbers.length > 0
+                ? Math.max(...completedStepNumbers)
+                : 0; // no dependency if nothing completed
+            const lastAgent = context.plan.steps[context.plan.steps.length - 1]?.agentName || 'integrator_finalizer';
+            const addSteps = [];
+            const dupStep = buildRemediationStep(host, gatesResult.results.find(r => r.id === 'duplicate-blocks'), gatesConfig.autoAddRefactorStepOnDuplicateBlocks, 'duplicateRefactorAdded', context, agentMap, 'Quality gates flagged repeated code blocks. Extract shared utilities/hooks/middleware and refactor duplicates away. Use the gate report as the source of truth. Re-run tests and ensure quality gates pass.', '⚠️  Final quality gates: duplicate blocks detected; scheduling refactor', maxCompletedStep, lastAgent);
+            if (dupStep)
+                addSteps.push(dupStep);
+            const readmeStep = buildRemediationStep(host, gatesResult.results.find(r => r.id === 'readme-claims'), gatesConfig.autoAddReadmeTruthStepOnReadmeClaims, 'readmeTruthAdded', context, agentMap, 'Quality gates flagged README claims that are not backed by code. Either implement the missing features or downgrade/remove the claims. Use the gate report as the source of truth. Re-run tests and ensure quality gates pass.', '⚠️  Final quality gates: README claims mismatch; scheduling truth step', maxCompletedStep, lastAgent);
+            if (readmeStep)
+                addSteps.push(readmeStep);
+            const scaffoldStep = buildRemediationStep(host, gatesResult.results.find(r => r.id === 'scaffold-defaults'), gatesConfig.autoAddScaffoldFixStepOnScaffoldDefaults, 'scaffoldFixAdded', context, agentMap, 'Quality gates flagged scaffold defaults. Remove placeholder assets and generic scaffold README sections, and ensure HTML title/app metadata are meaningful. Use the gate report as the source of truth. Re-run tests and ensure quality gates pass.', '⚠️  Final quality gates: scaffold defaults detected; scheduling cleanup', maxCompletedStep, lastAgent);
+            if (scaffoldStep)
+                addSteps.push(scaffoldStep);
+            const configStep = buildRemediationStep(host, gatesResult.results.find(r => r.id === 'hardcoded-config'), gatesConfig.autoAddConfigFixStepOnHardcodedConfig, 'configFixAdded', context, agentMap, 'Quality gates flagged hardcoded config values. Move API base URLs, ports, retry counts, timeouts, and environment-specific values into env/typed config. For Vite proxy targets, prefer import.meta.env with a safe default. Use the gate report as the source of truth. Re-run tests and ensure quality gates pass.', '⚠️  Final quality gates: hardcoded config detected; scheduling cleanup', maxCompletedStep, lastAgent);
+            if (configStep)
+                addSteps.push(configStep);
+            const a11yStep = buildRemediationStep(host, gatesResult.results.find(r => r.id === 'accessibility'), gatesConfig.autoAddAccessibilityFixStepOnAccessibility, 'accessibilityFixAdded', context, agentMap, 'Quality gates flagged accessibility issues. Fix all items from the gate report: skip-to-content link, heading hierarchy, aria-labels, focus-visible styles, meta description + theme-color tags, responsive CSS (viewport meta, media queries or relative units), CSS custom properties on :root with prefers-color-scheme:dark override, semantic HTML landmarks (main, nav, header), img alt attributes. Use the gate report as the source of truth. Re-run tests and ensure quality gates pass.', '⚠️  Final quality gates: accessibility issues detected; scheduling fix', maxCompletedStep, lastAgent);
+            if (a11yStep)
+                addSteps.push(a11yStep);
+            const testCovStep = buildRemediationStep(host, gatesResult.results.find(r => r.id === 'test-coverage'), gatesConfig.autoAddTestCoverageStepOnTestCoverage, 'testCoverageFixAdded', context, agentMap, 'Quality gates flagged missing test coverage. Add tests for uncovered source files, ensure each test file contains real assertions, and add component-level tests for React projects. Use the gate report as the source of truth. Re-run tests and ensure quality gates pass.', '⚠️  Final quality gates: test coverage gaps detected; scheduling fix', maxCompletedStep, lastAgent);
+            if (testCovStep)
+                addSteps.push(testCovStep);
+            // Consolidate multiple gate failures into a single remediation step
+            // to avoid burning one premium request per gate failure.
+            if (addSteps.length > 1) {
+                const combinedTask = addSteps.map(s => s.task).join('\n\nALSO: ');
+                const singleStep = {
+                    agent: addSteps[0].agent,
+                    task: combinedTask,
+                };
+                if (addSteps[0].afterStep !== undefined) {
+                    singleStep.afterStep = addSteps[0].afterStep;
+                }
+                addSteps.length = 0;
+                addSteps.push(singleStep);
+                logger.warn(`⚠️  Final quality gates failed (${failedIds.size} gates); scheduling single consolidated remediation step...`);
+            }
+            else if (addSteps.length === 1) {
+                logger.warn('⚠️  Final quality gates failed; attempting one remediation pass...');
+            }
+            if (addSteps.length > 0) {
+                remediationAttempted = true;
+                await host.executeReplan(context, { retrySteps: [], addSteps }, agentMap, options);
+                gatesResult = await (0, quality_gates_1.run_quality_gates)(host.workingDir, gatesConfig, gatesOut, baselineFiles, baseCommit, skippedReqIds, skippedGateKeys);
+                context.finalGateResults = gatesResult.results;
+                // Second remediation attempt if gates still fail after first fix
+                if (!gatesResult.passed && gatesConfig.failOnIssues) {
+                    const stillFailed = gatesResult.results.filter(r => r.status === 'fail');
+                    if (stillFailed.length > 0) {
+                        const findings = stillFailed.flatMap(gate => gate.issues.map(issue => {
+                            let desc = `[${gate.id}] ${issue.message}`;
+                            if (issue.filePath)
+                                desc += ` (${issue.filePath})`;
+                            if (issue.hint)
+                                desc += ` -- hint: ${issue.hint}`;
+                            return desc;
+                        })).join('\n');
+                        const retryTask = [
+                            'The previous remediation attempt did not fully resolve the quality gate failures.',
+                            'The following issues remain. Fix each one specifically:',
+                            '',
+                            findings,
+                            '',
+                            'Verify your fixes by checking that the specific issues listed above are resolved.',
+                            'Run tests to ensure nothing is broken.',
+                        ].join('\n');
+                        const retryAgent = host.resolveAgent(agentMap, 'integrator_finalizer')
+                            ? 'integrator_finalizer'
+                            : lastAgent;
+                        const retryMaxStep = Math.max(...context.plan.steps.map(s => s.stepNumber));
+                        logger.warn('⚠️  First remediation did not resolve all gate failures. Running second attempt with specific findings...');
+                        await host.executeReplan(context, {
+                            retrySteps: [],
+                            addSteps: [{ agent: retryAgent, task: retryTask, afterStep: retryMaxStep }]
+                        }, agentMap, options);
+                        gatesResult = await (0, quality_gates_1.run_quality_gates)(host.workingDir, gatesConfig, gatesOut, baselineFiles, baseCommit, skippedReqIds, skippedGateKeys);
+                        context.finalGateResults = gatesResult.results;
+                    }
+                }
+            }
+        }
+    }
+    return {
+        finalGateResults: gatesResult.results,
+        remediationAttempted,
+        passed: gatesResult.passed,
+        gatesOut,
+    };
+}

package/dist/src/orchestrator/git-state-utils.js

@@ -0,0 +1,119 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeGitState = sanitizeGitState;
+exports.installDependenciesIfNeeded = installDependenciesIfNeeded;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../logger");
+const logger = (0, logger_1.getLogger)('orchestrator');
+/**
+ * Clean up leftover git state from crashed runs: abort pending merges,
+ * reset staged/unmerged index entries, and restore working tree files.
+ * Prevents cascading failures when binary files (e.g. .pyc, .db) from
+ * a previous merge conflict block branch creation or verification commits.
+ *
+ * @param workingDir - repository root where the git operations run
+ */
+function sanitizeGitState(workingDir) {
+    const opts = { cwd: workingDir, stdio: 'pipe', encoding: 'utf8' };
+    try {
+        (0, child_process_1.execSync)('git merge --abort', opts);
+        logger.info('  [cleanup] Aborted in-progress merge from previous run');
+    }
+    catch { /* no merge in progress; expected */ }
+    // Check for unmerged or staged entries that would block new operations
+    try {
+        const status = (0, child_process_1.execSync)('git status --porcelain', opts).trim();
+        const hasUnmerged = status.split('\n').some(line => line.startsWith('U') || line.startsWith('AA') || line.startsWith('DD'));
+        if (hasUnmerged) {
+            (0, child_process_1.execSync)('git reset HEAD', opts);
+            (0, child_process_1.execSync)('git checkout -- .', opts);
+            logger.info('  [cleanup] Reset unmerged files from previous crashed run');
+        }
+    }
+    catch { /* status check failed; not critical */ }
+    // Prune stale worktrees left by previous crashes
+    try {
+        (0, child_process_1.execSync)('git worktree prune', opts);
+    }
+    catch { /* prune failed; not critical */ }
+}
+/**
+ * Detect whether agents introduced new dependencies and install them.
+ * Runs after all branches are merged but before quality gates so that
+ * `npm test` has access to any newly-added packages.
+ *
+ * @param workingDir - repository root with package.json and node_modules
+ */
+async function installDependenciesIfNeeded(workingDir) {
+    const pkgPath = path.join(workingDir, 'package.json');
+    const nodeModulesPath = path.join(workingDir, 'node_modules');
+    if (!fs.existsSync(pkgPath))
+        return;
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const allDeps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+        };
+        if (Object.keys(allDeps).length === 0)
+            return;
+        // Check if any declared dependency is missing from node_modules
+        const missing = Object.keys(allDeps).filter(dep => {
+            return !fs.existsSync(path.join(nodeModulesPath, dep));
+        });
+        if (missing.length === 0)
+            return;
+        logger.info(`\n📦 Installing ${missing.length} new dependenc${missing.length === 1 ? 'y' : 'ies'}: ${missing.join(', ')}`);
+        // Use the right package manager for the project
+        const installCmd = fs.existsSync(path.join(workingDir, 'yarn.lock'))
+            ? 'yarn install --frozen-lockfile 2>/dev/null || yarn install'
+            : fs.existsSync(path.join(workingDir, 'pnpm-lock.yaml'))
+                ? 'pnpm install --no-frozen-lockfile'
+                : 'npm install --loglevel=error';
+        (0, child_process_1.execSync)(installCmd, {
+            cwd: workingDir,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 120_000,
+        });
+        logger.info('  ✅ Dependencies installed');
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.warn(`  ⚠️  Dependency install failed (quality gates may report test failures): ${msg}`);
+    }
+}

package/dist/src/orchestrator/pause-controller.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PauseController = void 0;
+/**
+ * Owns the pause/resume state that `SwarmOrchestrator` uses to suspend
+ * the scheduling loop mid-execution. Extracted from swarm-orchestrator.ts
+ * so the orchestrator class only forwards to an isolated controller.
+ *
+ * Two flags coordinate the handshake:
+ *   - `pauseRequested` signals the scheduler to stop launching new steps
+ *     the next time the loop checks.
+ *   - `resumeRequested` is set by `requestResume` and consumed by
+ *     `waitForResume` to release the pause.
+ */
+class PauseController {
+    pauseRequested = false;
+    resumeRequested = false;
+    /**
+     * Request pause of current execution. The scheduler observes the flag
+     * at the top of its loop and suspends launching further steps.
+     */
+    requestPause() {
+        this.pauseRequested = true;
+    }
+    /**
+     * Request resume of paused execution. Clears the pause flag and signals
+     * `waitForResume` to return.
+     */
+    requestResume() {
+        this.resumeRequested = true;
+        this.pauseRequested = false;
+    }
+    /**
+     * @returns `true` when a pause has been requested and not yet resumed.
+     */
+    isPauseRequested() {
+        return this.pauseRequested;
+    }
+    /**
+     * Block until `requestResume` fires or the pause is otherwise cleared.
+     * Polls every 500ms, matching the original inline implementation.
+     */
+    async waitForResume() {
+        return new Promise((resolve) => {
+            const checkInterval = setInterval(() => {
+                if (this.resumeRequested || !this.pauseRequested) {
+                    clearInterval(checkInterval);
+                    this.resumeRequested = false;
+                    resolve();
+                }
+            }, 500); // Check every 500ms
+        });
+    }
+}
+exports.PauseController = PauseController;