swarm-orchestrator 7.0.0-alpha.0

package/dist/src/metrics-collector.js

@@ -0,0 +1,209 @@
+"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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)('metrics-collector');
+/**
+ * Collects metrics during orchestrator execution
+ * Tracks time, commits, verifications, and recovery events
+ */
+class MetricsCollector {
+    executionId;
+    goal;
+    startTime;
+    endTime;
+    waveCount = 0;
+    stepCount = 0;
+    commitCount = 0;
+    verificationsPassed = 0;
+    verificationsFailed = 0;
+    recoveryEvents = [];
+    agentsUsed = new Set();
+    constructor(executionId, goal) {
+        this.executionId = executionId;
+        this.goal = goal;
+        this.startTime = new Date();
+    }
+    /**
+     * Mark start of new wave
+     */
+    startWave(waveNumber) {
+        this.waveCount = Math.max(this.waveCount, waveNumber);
+    }
+    /**
+     * Track step execution
+     */
+    trackStep(stepNumber, agentName) {
+        this.stepCount = Math.max(this.stepCount, stepNumber);
+        this.agentsUsed.add(agentName);
+    }
+    /**
+     * Track commit produced
+     */
+    trackCommit(agentName) {
+        this.commitCount++;
+        if (agentName) {
+            this.agentsUsed.add(agentName);
+        }
+    }
+    /**
+     * Track verification result
+     */
+    trackVerification(passed) {
+        if (passed) {
+            this.verificationsPassed++;
+        }
+        else {
+            this.verificationsFailed++;
+        }
+    }
+    /**
+     * Track recovery event
+     */
+    trackRecovery(event) {
+        this.recoveryEvents.push(event);
+        this.agentsUsed.add(event.agentName);
+    }
+    /**
+     * Mark execution end and finalize metrics
+     */
+    finalize() {
+        this.endTime = new Date();
+        return {
+            executionId: this.executionId,
+            goal: this.goal,
+            startTime: this.startTime.toISOString(),
+            endTime: this.endTime.toISOString(),
+            totalTimeMs: this.endTime.getTime() - this.startTime.getTime(),
+            waveCount: this.waveCount,
+            stepCount: this.stepCount,
+            commitCount: this.commitCount,
+            verificationsPassed: this.verificationsPassed,
+            verificationsFailed: this.verificationsFailed,
+            recoveryEvents: this.recoveryEvents,
+            agentsUsed: Array.from(this.agentsUsed).sort()
+        };
+    }
+    /**
+     * Get current metrics snapshot (without finalizing)
+     */
+    getSnapshot() {
+        const now = new Date();
+        return {
+            executionId: this.executionId,
+            goal: this.goal,
+            startTime: this.startTime.toISOString(),
+            totalTimeMs: now.getTime() - this.startTime.getTime(),
+            waveCount: this.waveCount,
+            stepCount: this.stepCount,
+            commitCount: this.commitCount,
+            verificationsPassed: this.verificationsPassed,
+            verificationsFailed: this.verificationsFailed,
+            recoveryEvents: this.recoveryEvents,
+            agentsUsed: Array.from(this.agentsUsed).sort()
+        };
+    }
+    /**
+     * Persist full session state to runs/<id>/session-state.json.
+     * Creates the directory if missing.
+     */
+    saveSession(id, state) {
+        const dir = path.join(process.cwd(), 'runs', id);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(path.join(dir, 'session-state.json'), JSON.stringify(state, null, 2), 'utf8');
+    }
+    /**
+     * Load a previously saved session. Returns null if not found.
+     */
+    loadSession(id) {
+        const filePath = path.join(process.cwd(), 'runs', id, 'session-state.json');
+        if (!fs.existsSync(filePath))
+            return null;
+        try {
+            return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`[metrics] Failed to load session ${id}: ${msg}`);
+            return null;
+        }
+    }
+    /**
+     * Generate a Markdown audit report from session state.
+     */
+    generateAuditReport(state) {
+        const lines = [
+            `# Audit Report: ${state.sessionId}`,
+            '',
+            '## Timeline',
+            `- Status: ${state.status}`,
+            `- Last completed step: ${state.lastCompletedStep}`,
+            `- Total steps: ${state.graph.steps.length}`,
+            '',
+            '## Cost Breakdown',
+            `- Steps executed: ${state.lastCompletedStep}`,
+            `- Branches: ${Object.keys(state.branchMap).length}`,
+            `- Transcripts: ${Object.keys(state.transcripts).length}`,
+            '',
+            '## Diffs Summary',
+            ...state.graph.steps.map(s => {
+                const branch = state.branchMap[String(s.stepNumber)] || 'no branch';
+                return `- Step ${s.stepNumber} (${s.agent}): branch \`${branch}\``;
+            }),
+            '',
+            '## Gates',
+            ...state.gateResults.map(g => `- ${g.title}: ${g.status} (${g.issues.length} issue(s))`),
+            '',
+            '## Evidence',
+            ...state.graph.steps.map(s => {
+                const transcript = state.transcripts[String(s.stepNumber)];
+                if (transcript) {
+                    const lineCount = transcript.split('\n').length;
+                    return `- Step ${s.stepNumber} (${s.agent}): transcript present (${lineCount} lines)`;
+                }
+                return `- Step ${s.stepNumber} (${s.agent}): no transcript`;
+            }),
+            '',
+            '## Steps',
+            ...state.graph.steps.map(s => `- Step ${s.stepNumber}: ${s.task} (${s.agent})`),
+        ];
+        return lines.join('\n');
+    }
+}
+exports.default = MetricsCollector;

package/dist/src/metrics-types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions for productivity analytics and personalization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/multi-repo-coordinator.js

@@ -0,0 +1,179 @@
+"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.MultiRepoCoordinator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Multi-Repo Coordinator - identify cross-repo relationships
+ * Analysis only, no execution
+ */
+class MultiRepoCoordinator {
+    /**
+     * Identify relationships between multiple repositories
+     */
+    identifyRelationships(repos) {
+        if (repos.length < 2) {
+            return [];
+        }
+        const relationships = [];
+        // Check for API dependencies (import statements referencing other repos)
+        for (let i = 0; i < repos.length; i++) {
+            for (let j = i + 1; j < repos.length; j++) {
+                const apiDeps = this.findApiDependencies(repos[i], repos[j]);
+                relationships.push(...apiDeps);
+            }
+        }
+        // Check for shared schemas (TypeScript types exported/imported)
+        for (let i = 0; i < repos.length; i++) {
+            for (let j = i + 1; j < repos.length; j++) {
+                const schemas = this.findSharedSchemas(repos[i], repos[j]);
+                relationships.push(...schemas);
+            }
+        }
+        // Check for build coupling (one repo's build depends on another)
+        for (let i = 0; i < repos.length; i++) {
+            for (let j = i + 1; j < repos.length; j++) {
+                const buildCoupling = this.findBuildCoupling(repos[i], repos[j]);
+                relationships.push(...buildCoupling);
+            }
+        }
+        return relationships;
+    }
+    /**
+     * Find API dependencies between repos
+     */
+    findApiDependencies(repo1, repo2) {
+        const relationships = [];
+        // Check if repo1 has repo2 as a dependency
+        const repo1DepOnRepo2 = repo1.dependencies.some(d => d.name === repo2.repoName || d.name.includes(repo2.repoName));
+        if (repo1DepOnRepo2) {
+            relationships.push({
+                sourceRepo: repo1.repoName,
+                targetRepo: repo2.repoName,
+                type: 'api_dependency',
+                evidence: [
+                    repo1.dependencies.find(d => d.name === repo2.repoName || d.name.includes(repo2.repoName)).source
+                ],
+                details: `${repo1.repoName} depends on ${repo2.repoName}`
+            });
+        }
+        // Check reverse
+        const repo2DepOnRepo1 = repo2.dependencies.some(d => d.name === repo1.repoName || d.name.includes(repo1.repoName));
+        if (repo2DepOnRepo1) {
+            relationships.push({
+                sourceRepo: repo2.repoName,
+                targetRepo: repo1.repoName,
+                type: 'api_dependency',
+                evidence: [
+                    repo2.dependencies.find(d => d.name === repo1.repoName || d.name.includes(repo1.repoName)).source
+                ],
+                details: `${repo2.repoName} depends on ${repo1.repoName}`
+            });
+        }
+        return relationships;
+    }
+    /**
+     * Find shared schemas (look for types/ or schema/ directories)
+     */
+    findSharedSchemas(repo1, repo2) {
+        const relationships = [];
+        // Check if both have schema directories
+        const repo1SchemaDir = path.join(repo1.repoPath, 'src', 'types');
+        const repo2SchemaDir = path.join(repo2.repoPath, 'src', 'types');
+        const repo1HasTypes = fs.existsSync(repo1SchemaDir);
+        const repo2HasTypes = fs.existsSync(repo2SchemaDir);
+        if (repo1HasTypes && repo2HasTypes) {
+            // Look for similarly named type files
+            const repo1Types = this.getTypeFiles(repo1SchemaDir);
+            const repo2Types = this.getTypeFiles(repo2SchemaDir);
+            const commonTypes = repo1Types.filter(t => repo2Types.includes(t));
+            if (commonTypes.length > 0) {
+                relationships.push({
+                    sourceRepo: repo1.repoName,
+                    targetRepo: repo2.repoName,
+                    type: 'schema_sharing',
+                    evidence: commonTypes.map(t => `Both repos have: ${t}`),
+                    details: `Shared type files: ${commonTypes.join(', ')}`
+                });
+            }
+        }
+        return relationships;
+    }
+    getTypeFiles(dir) {
+        try {
+            return fs.readdirSync(dir)
+                .filter(f => f.endsWith('.ts') || f.endsWith('.d.ts'))
+                .map(f => path.basename(f));
+        }
+        catch {
+            // Directory unreadable (missing, permissions); return empty list
+            return [];
+        }
+    }
+    /**
+     * Find build coupling (build scripts reference other repos)
+     */
+    findBuildCoupling(repo1, repo2) {
+        const relationships = [];
+        // Check if build scripts reference other repo
+        for (const script of repo1.buildScripts) {
+            if (script.command.includes(repo2.repoName) || script.command.includes(path.basename(repo2.repoPath))) {
+                relationships.push({
+                    sourceRepo: repo1.repoName,
+                    targetRepo: repo2.repoName,
+                    type: 'build_coupling',
+                    evidence: [script.source, `Command: ${script.command}`],
+                    details: `${repo1.repoName} build depends on ${repo2.repoName}`
+                });
+            }
+        }
+        // Check reverse
+        for (const script of repo2.buildScripts) {
+            if (script.command.includes(repo1.repoName) || script.command.includes(path.basename(repo1.repoPath))) {
+                relationships.push({
+                    sourceRepo: repo2.repoName,
+                    targetRepo: repo1.repoName,
+                    type: 'build_coupling',
+                    evidence: [script.source, `Command: ${script.command}`],
+                    details: `${repo2.repoName} build depends on ${repo1.repoName}`
+                });
+            }
+        }
+        return relationships;
+    }
+}
+exports.MultiRepoCoordinator = MultiRepoCoordinator;
+exports.default = MultiRepoCoordinator;

package/dist/src/orchestrator/async-meta-analysis.js

@@ -0,0 +1,84 @@
+"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.runAsyncMetaAnalysis = runAsyncMetaAnalysis;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../logger");
+const logger = (0, logger_1.getLogger)('orchestrator');
+/**
+ * Run meta-analysis off the critical path. Fires asynchronously via setImmediate
+ * from the scheduler so the next step can launch without waiting for KB updates.
+ *
+ * Writes `analysis-batch-<waveIndex>.json` to `runDir` and feeds detected
+ * knowledge updates into the KnowledgeBase on the context. Swallows errors
+ * with a warning so analytics failures never block execution.
+ *
+ * No-ops when `context.metaAnalyzer` or `context.knowledgeBase` is undefined.
+ *
+ * @param context - subset of the swarm execution context carrying metaAnalyzer, knowledgeBase, results, waveAnalyses
+ * @param plan - the current execution plan
+ * @param runDir - directory where the analysis snapshot is persisted
+ * @param completedSteps - step numbers that have completed so far (defines the "wave" analyzed)
+ */
+function runAsyncMetaAnalysis(context, plan, runDir, completedSteps) {
+    if (!context.metaAnalyzer || !context.knowledgeBase)
+        return;
+    // Use the most recent completed step as the "wave" we are analyzing
+    const waveIndex = completedSteps.length;
+    try {
+        const waveAnalysis = context.metaAnalyzer.analyzeWave(waveIndex, completedSteps, context.results, plan, context.executionId);
+        context.waveAnalyses?.push(waveAnalysis);
+        // Persist analysis snapshot
+        const analysisPath = path.join(runDir, `analysis-batch-${waveIndex}.json`);
+        fs.writeFileSync(analysisPath, JSON.stringify(waveAnalysis, null, 2), 'utf8');
+        // Feed insights back into the knowledge base
+        if (waveAnalysis.knowledgeUpdates.length > 0) {
+            waveAnalysis.knowledgeUpdates.forEach(update => {
+                context.knowledgeBase.addOrUpdatePattern({
+                    category: update.category,
+                    insight: update.insight,
+                    confidence: update.confidence,
+                    evidence: [update.evidence],
+                    impact: update.confidence === 'high' ? 'high' : 'medium'
+                });
+            });
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.warn(`[analytics] Wave analysis failed (non-fatal): ${msg}`);
+    }
+}

package/dist/src/orchestrator/fatal-run-error.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FatalRunError = void 0;
+exports.isFatalRunError = isFatalRunError;
+/**
+ * Thrown when an agent CLI reports an unrecoverable, account-level failure
+ * (usage-limit, auth, extended rate-limit). The orchestrator catches this
+ * and aborts the run instead of replanning into the same wall.
+ *
+ * Distinct from a verification failure: those are step-level signals that
+ * the agent produced a wrong patch, and the replan/repair loop can usefully
+ * try again. A FatalRunError signals that *no* further agent invocations
+ * will succeed for this run, so retrying would only burn more wall-clock
+ * for the same outcome.
+ *
+ * The contained `cause` carries the classifier verdict (kind + evidence)
+ * so postmortem reports and the SWE-bench harness can attribute the abort
+ * to the specific account-level wall that triggered it.
+ */
+class FatalRunError extends Error {
+    fatalKind;
+    evidence;
+    stepNumber;
+    agentName;
+    constructor(fatal, context = {}) {
+        const where = context.stepNumber !== undefined
+            ? ` (step ${context.stepNumber}${context.agentName ? `, ${context.agentName}` : ''})`
+            : '';
+        super(`agent CLI reported unrecoverable ${fatal.kind} error${where}: ${fatal.message}. ` +
+            `Aborting run; replanning cannot recover from an account-level wall. ` +
+            `Resolve the upstream issue (upgrade plan, refresh credentials, wait through the rate-limit window) and rerun.`);
+        this.name = 'FatalRunError';
+        this.fatalKind = fatal.kind;
+        this.evidence = fatal.evidence;
+        this.stepNumber = context.stepNumber;
+        this.agentName = context.agentName;
+    }
+}
+exports.FatalRunError = FatalRunError;
+function isFatalRunError(err) {
+    return err instanceof FatalRunError
+        || (typeof err === 'object' && err !== null && err.name === 'FatalRunError');
+}