swarm-orchestrator 7.0.0-alpha.0

package/dist/src/bootstrap-evidence.js

@@ -0,0 +1,88 @@
+"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.BootstrapEvidenceManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Bootstrap Evidence Manager - persist and load bootstrap artifacts
+ */
+class BootstrapEvidenceManager {
+    schemaVersion = '1.0.0';
+    /**
+     * Save bootstrap evidence to runs/ directory
+     */
+    saveEvidence(evidence, runDir) {
+        const evidenceDir = path.join(runDir, 'bootstrap');
+        if (!fs.existsSync(evidenceDir)) {
+            fs.mkdirSync(evidenceDir, { recursive: true });
+        }
+        const evidencePath = path.join(evidenceDir, 'analysis.json');
+        const json = JSON.stringify(evidence, null, 2);
+        fs.writeFileSync(evidencePath, json, 'utf8');
+        return evidencePath;
+    }
+    /**
+     * Load bootstrap evidence
+     */
+    loadEvidence(runDir) {
+        const evidencePath = path.join(runDir, 'bootstrap', 'analysis.json');
+        if (!fs.existsSync(evidencePath)) {
+            throw new Error(`Bootstrap evidence not found: ${evidencePath}`);
+        }
+        const content = fs.readFileSync(evidencePath, 'utf8');
+        const evidence = JSON.parse(content);
+        // Validate schema version
+        if (evidence.schemaVersion !== this.schemaVersion) {
+            throw new Error(`Schema version mismatch: expected ${this.schemaVersion}, got ${evidence.schemaVersion}`);
+        }
+        return evidence;
+    }
+    /**
+     * Create evidence object from analysis and plan
+     */
+    createEvidence(goal, analysisResult, plan) {
+        return {
+            schemaVersion: this.schemaVersion,
+            goal,
+            analyzedRepos: analysisResult.repos.map(r => r.repoPath),
+            analysisResult,
+            generatedPlan: plan,
+            createdAt: new Date().toISOString()
+        };
+    }
+}
+exports.BootstrapEvidenceManager = BootstrapEvidenceManager;
+exports.default = BootstrapEvidenceManager;

package/dist/src/bootstrap-orchestrator.js

@@ -0,0 +1,205 @@
+"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.BootstrapOrchestrator = void 0;
+const path = __importStar(require("path"));
+const repo_analyzer_1 = __importDefault(require("./repo-analyzer"));
+const github_issues_ingester_1 = __importDefault(require("./github-issues-ingester"));
+const multi_repo_coordinator_1 = __importDefault(require("./multi-repo-coordinator"));
+const bootstrap_evidence_1 = __importDefault(require("./bootstrap-evidence"));
+const plan_generator_1 = require("./plan-generator");
+const config_loader_1 = require("./config-loader");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)('bootstrap-orchestrator');
+/**
+ * Bootstrap Orchestrator - main entry point for bootstrap mode
+ * Coordinates analysis, ingestion, and plan generation
+ */
+class BootstrapOrchestrator {
+    repoAnalyzer;
+    issuesIngester;
+    multiRepoCoordinator;
+    evidenceManager;
+    planGenerator;
+    constructor() {
+        this.repoAnalyzer = new repo_analyzer_1.default();
+        this.issuesIngester = new github_issues_ingester_1.default();
+        this.multiRepoCoordinator = new multi_repo_coordinator_1.default();
+        this.evidenceManager = new bootstrap_evidence_1.default();
+        const configLoader = new config_loader_1.ConfigLoader();
+        const agents = configLoader.loadAllAgents();
+        this.planGenerator = new plan_generator_1.PlanGenerator(agents);
+    }
+    /**
+     * Execute full bootstrap analysis and plan generation
+     */
+    async bootstrap(repoPaths, goal, runDir) {
+        logger.info('🔍 Bootstrap Analysis Starting...\n');
+        // Step 1: Analyze all repos
+        logger.info(`Analyzing ${repoPaths.length} repository(ies)...`);
+        const repoAnalyses = await Promise.all(repoPaths.map(p => this.repoAnalyzer.analyzeRepo(p)));
+        for (const analysis of repoAnalyses) {
+            logger.info(`  ✓ ${analysis.repoName}: ${analysis.languages.join(', ')}`);
+            logger.info(`    Build scripts: ${analysis.buildScripts.length}`);
+            logger.info(`    Test scripts: ${analysis.testScripts.length}`);
+            logger.info(`    Dependencies: ${analysis.dependencies.length}`);
+            logger.info(`    Tech debt markers: ${analysis.techDebtMarkers.length}`);
+            logger.info(`    Baseline concerns: ${analysis.baselineConcerns.length}`);
+        }
+        logger.info();
+        // Step 2: Identify cross-repo relationships
+        logger.info('Identifying cross-repo relationships...');
+        const relationships = this.multiRepoCoordinator.identifyRelationships(repoAnalyses);
+        logger.info(`  Found ${relationships.length} relationship(s)`);
+        for (const rel of relationships) {
+            logger.info(`    ${rel.sourceRepo} → ${rel.targetRepo} (${rel.type})`);
+        }
+        logger.info();
+        // Step 3: Ingest GitHub issues
+        logger.info('Fetching GitHub issues...');
+        const allIssues = [];
+        for (const repoPath of repoPaths) {
+            const issues = await this.issuesIngester.fetchIssues(repoPath);
+            allIssues.push(...issues);
+        }
+        logger.info(`  Found ${allIssues.length} open issue(s)`);
+        // Link relevant issues to goal
+        const relevantIssues = this.issuesIngester.linkIssuesToTasks(allIssues, goal);
+        logger.info(`  ${relevantIssues.length} issue(s) relevant to goal`);
+        for (const issue of relevantIssues.slice(0, 5)) {
+            logger.info(`    #${issue.number}: ${issue.title}`);
+        }
+        logger.info();
+        // Step 4: Build analysis result
+        const analysisResult = {
+            repos: repoAnalyses,
+            relationships,
+            issues: relevantIssues,
+            goal,
+            analyzedAt: new Date().toISOString()
+        };
+        // Step 5: Generate annotated plan
+        logger.info('Generating execution plan...');
+        const plan = this.generateAnnotatedPlan(goal, analysisResult, repoPaths);
+        logger.info(`  Generated ${plan.steps.length} step(s)`);
+        logger.info();
+        // Step 6: Save evidence
+        logger.info('Saving bootstrap evidence...');
+        const evidence = this.evidenceManager.createEvidence(goal, analysisResult, plan);
+        const evidencePath = this.evidenceManager.saveEvidence(evidence, runDir);
+        logger.info(`  ✓ Evidence saved: ${evidencePath}`);
+        logger.info();
+        logger.info('✅ Bootstrap analysis complete!\n');
+        return { evidencePath, plan };
+    }
+    /**
+     * Generate plan with source annotations.
+     * Stamps each step with the resolved target repo path so execution
+     * creates worktrees from the correct repository, not the orchestrator's own repo.
+     */
+    generateAnnotatedPlan(goal, analysis, repoPaths) {
+        // Use PlanGenerator to create base plan
+        const basePlan = this.planGenerator.createPlan(goal);
+        // Resolve target repo paths so worktrees are created from the right git history
+        const resolvedRepoPaths = (repoPaths || []).map(p => path.resolve(p));
+        const primaryRepo = resolvedRepoPaths[0];
+        if (primaryRepo) {
+            if (!basePlan.metadata) {
+                basePlan.metadata = { totalSteps: basePlan.steps.length };
+            }
+            basePlan.metadata.targetDir = primaryRepo;
+        }
+        // Annotate steps with analysis evidence
+        const annotatedSteps = basePlan.steps.map(step => {
+            // Stamp step with the target repo so execution knows where to create worktrees
+            if (primaryRepo && !step.repo) {
+                step.repo = step.repo || primaryRepo;
+            }
+            const annotations = [];
+            // Link to relevant issues
+            for (const issue of analysis.issues) {
+                if (this.isStepRelatedToIssue(step.task, issue.title)) {
+                    annotations.push({
+                        type: 'github_issue',
+                        reference: `#${issue.number}`,
+                        evidence: `Issue: ${issue.title} (${issue.url})`
+                    });
+                }
+            }
+            // Link to tech debt if tester/security step
+            if (step.agentName === 'tester_elite' || step.agentName === 'security_auditor') {
+                const relevantDebt = analysis.repos.flatMap(r => r.techDebtMarkers).slice(0, 3);
+                for (const debt of relevantDebt) {
+                    annotations.push({
+                        type: 'tech_debt',
+                        reference: debt.location,
+                        evidence: debt.evidence
+                    });
+                }
+            }
+            // Link to build scripts if relevant
+            if (step.task.toLowerCase().includes('build') || step.task.toLowerCase().includes('compile')) {
+                const buildScripts = analysis.repos.flatMap(r => r.buildScripts);
+                for (const script of buildScripts) {
+                    annotations.push({
+                        type: 'build_script',
+                        reference: script.source,
+                        evidence: `Build command: ${script.command}`
+                    });
+                }
+            }
+            return {
+                ...step,
+                sourceAnnotations: annotations
+            };
+        });
+        return {
+            ...basePlan,
+            steps: annotatedSteps
+        };
+    }
+    isStepRelatedToIssue(task, issueTitle) {
+        const taskWords = task.toLowerCase().split(/\s+/);
+        const issueWords = issueTitle.toLowerCase().split(/\s+/);
+        // Simple keyword overlap check
+        const overlap = taskWords.filter(w => w.length > 3 && issueWords.includes(w));
+        return overlap.length >= 2;
+    }
+}
+exports.BootstrapOrchestrator = BootstrapOrchestrator;
+exports.default = BootstrapOrchestrator;

package/dist/src/bootstrap-types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Types for bootstrap analysis and multi-repo orchestration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });