swarm-orchestrator 7.0.0-alpha.0

package/dist/src/repo-analyzer.js

@@ -0,0 +1,342 @@
+"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.RepoAnalyzer = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Repo Analyzer - deep static analysis of repository structure
+ * NO GUESSING - only provable signals from actual files
+ */
+class RepoAnalyzer {
+    /**
+     * Analyze a single repository
+     */
+    async analyzeRepo(repoPath) {
+        if (!fs.existsSync(repoPath)) {
+            throw new Error(`Repository path does not exist: ${repoPath}`);
+        }
+        const repoName = path.basename(repoPath);
+        const gitRemote = this.getGitRemote(repoPath);
+        const analysis = {
+            repoPath,
+            repoName,
+            languages: await this.detectLanguages(repoPath),
+            buildScripts: await this.findBuildScripts(repoPath),
+            testScripts: await this.findTestScripts(repoPath),
+            dependencies: await this.extractDependencies(repoPath),
+            techDebtMarkers: await this.findTechDebtMarkers(repoPath),
+            baselineConcerns: await this.identifyBaselineConcerns(repoPath),
+            ...(gitRemote && { gitRemote })
+        };
+        return analysis;
+    }
+    /**
+     * Detect languages from file extensions (no guessing)
+     */
+    async detectLanguages(repoPath) {
+        const extensionMap = {
+            '.ts': 'TypeScript',
+            '.js': 'JavaScript',
+            '.tsx': 'TypeScript',
+            '.jsx': 'JavaScript',
+            '.py': 'Python',
+            '.go': 'Go',
+            '.java': 'Java',
+            '.rb': 'Ruby',
+            '.rs': 'Rust',
+            '.c': 'C',
+            '.cpp': 'C++',
+            '.cs': 'C#'
+        };
+        const languages = new Set();
+        // Scan src/ directory if exists
+        const srcDir = path.join(repoPath, 'src');
+        if (fs.existsSync(srcDir)) {
+            this.scanDirectoryForExtensions(srcDir, extensionMap, languages);
+        }
+        // Scan root level too
+        const rootFiles = fs.readdirSync(repoPath);
+        for (const file of rootFiles) {
+            const ext = path.extname(file);
+            if (extensionMap[ext]) {
+                languages.add(extensionMap[ext]);
+            }
+        }
+        return Array.from(languages).sort();
+    }
+    scanDirectoryForExtensions(dir, extensionMap, languages) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            if (entry.name === 'node_modules')
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                this.scanDirectoryForExtensions(fullPath, extensionMap, languages);
+            }
+            else {
+                const ext = path.extname(entry.name);
+                if (extensionMap[ext]) {
+                    languages.add(extensionMap[ext]);
+                }
+            }
+        }
+    }
+    /**
+     * Find build scripts from package.json, Makefile, etc.
+     */
+    async findBuildScripts(repoPath) {
+        const scripts = [];
+        // Check package.json
+        const packageJsonPath = path.join(repoPath, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            if (pkg.scripts) {
+                const buildLikeScripts = ['build', 'compile', 'dist', 'bundle'];
+                for (const scriptName of buildLikeScripts) {
+                    if (pkg.scripts[scriptName]) {
+                        scripts.push({
+                            name: scriptName,
+                            command: pkg.scripts[scriptName],
+                            source: `package.json:scripts.${scriptName}`
+                        });
+                    }
+                }
+            }
+        }
+        // Check Makefile
+        const makefilePath = path.join(repoPath, 'Makefile');
+        if (fs.existsSync(makefilePath)) {
+            const content = fs.readFileSync(makefilePath, 'utf8');
+            const buildTarget = content.match(/^build:/m);
+            if (buildTarget) {
+                scripts.push({
+                    name: 'build',
+                    command: 'make build',
+                    source: 'Makefile:build'
+                });
+            }
+        }
+        return scripts;
+    }
+    /**
+     * Find test scripts
+     */
+    async findTestScripts(repoPath) {
+        const scripts = [];
+        // Check package.json
+        const packageJsonPath = path.join(repoPath, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            if (pkg.scripts?.test) {
+                let framework;
+                // Detect test framework from command
+                if (pkg.scripts.test.includes('mocha'))
+                    framework = 'mocha';
+                else if (pkg.scripts.test.includes('jest'))
+                    framework = 'jest';
+                else if (pkg.scripts.test.includes('vitest'))
+                    framework = 'vitest';
+                else if (pkg.scripts.test.includes('ava'))
+                    framework = 'ava';
+                scripts.push({
+                    name: 'test',
+                    command: pkg.scripts.test,
+                    source: 'package.json:scripts.test',
+                    ...(framework && { framework })
+                });
+            }
+        }
+        return scripts;
+    }
+    /**
+     * Extract dependencies from package.json, go.mod, requirements.txt, etc.
+     */
+    async extractDependencies(repoPath) {
+        const deps = [];
+        // package.json
+        const packageJsonPath = path.join(repoPath, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            if (pkg.dependencies) {
+                for (const [name, version] of Object.entries(pkg.dependencies)) {
+                    deps.push({
+                        name,
+                        version: version,
+                        type: 'production',
+                        source: 'package.json:dependencies'
+                    });
+                }
+            }
+            if (pkg.devDependencies) {
+                for (const [name, version] of Object.entries(pkg.devDependencies)) {
+                    deps.push({
+                        name,
+                        version: version,
+                        type: 'development',
+                        source: 'package.json:devDependencies'
+                    });
+                }
+            }
+        }
+        return deps;
+    }
+    /**
+     * Find tech debt markers
+     */
+    async findTechDebtMarkers(repoPath) {
+        const markers = [];
+        // Look for .skip() in test files
+        const testDir = path.join(repoPath, 'test');
+        if (fs.existsSync(testDir)) {
+            this.findSkippedTests(testDir, markers);
+        }
+        // Look for TODO comments in src/
+        const srcDir = path.join(repoPath, 'src');
+        if (fs.existsSync(srcDir)) {
+            this.findTodoComments(srcDir, markers);
+        }
+        return markers;
+    }
+    findSkippedTests(dir, markers) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                this.findSkippedTests(fullPath, markers);
+            }
+            else if (entry.name.endsWith('.test.ts') || entry.name.endsWith('.test.js')) {
+                const content = fs.readFileSync(fullPath, 'utf8');
+                const lines = content.split('\n');
+                lines.forEach((line, idx) => {
+                    if (line.includes('.skip(') || line.includes('it.skip(') || line.includes('describe.skip(')) {
+                        markers.push({
+                            type: 'skipped_test',
+                            location: `${fullPath}:${idx + 1}`,
+                            evidence: line.trim(),
+                            severity: 'medium'
+                        });
+                    }
+                });
+            }
+        }
+    }
+    findTodoComments(dir, markers) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            if (entry.name === 'node_modules')
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                this.findTodoComments(fullPath, markers);
+            }
+            else if (entry.name.endsWith('.ts') || entry.name.endsWith('.js')) {
+                const content = fs.readFileSync(fullPath, 'utf8');
+                const lines = content.split('\n');
+                lines.forEach((line, idx) => {
+                    if (line.includes('TODO') || line.includes('FIXME')) {
+                        markers.push({
+                            type: 'todo_comment',
+                            location: `${fullPath}:${idx + 1}`,
+                            evidence: line.trim(),
+                            severity: 'low'
+                        });
+                    }
+                });
+            }
+        }
+    }
+    /**
+     * Identify missing baseline concerns
+     */
+    async identifyBaselineConcerns(repoPath) {
+        const concerns = [];
+        // Check for CI config
+        const ciPaths = [
+            '.github/workflows',
+            '.gitlab-ci.yml',
+            '.circleci/config.yml',
+            'Jenkinsfile'
+        ];
+        const hasCi = ciPaths.some(p => fs.existsSync(path.join(repoPath, p)));
+        if (!hasCi) {
+            concerns.push({
+                type: 'missing_ci',
+                reason: 'No CI configuration detected',
+                evidence: `Checked: ${ciPaths.join(', ')}`
+            });
+        }
+        // Check for config management (only if src/ exists)
+        const srcDir = path.join(repoPath, 'src');
+        if (fs.existsSync(srcDir)) {
+            const hasConfigFile = ['config.ts', 'config.js', '.env.example', 'config.json']
+                .some(f => fs.existsSync(path.join(repoPath, f)) || fs.existsSync(path.join(srcDir, f)));
+            if (!hasConfigFile) {
+                concerns.push({
+                    type: 'missing_config',
+                    reason: 'No config management detected',
+                    evidence: 'Checked: config.ts, config.js, .env.example, config.json'
+                });
+            }
+        }
+        return concerns;
+    }
+    /**
+     * Get git remote URL
+     */
+    getGitRemote(repoPath) {
+        const gitConfigPath = path.join(repoPath, '.git', 'config');
+        if (!fs.existsSync(gitConfigPath)) {
+            return undefined;
+        }
+        try {
+            const content = fs.readFileSync(gitConfigPath, 'utf8');
+            const match = content.match(/url\s*=\s*(.+)/);
+            return match ? match[1].trim() : undefined;
+        }
+        catch {
+            // .git/config unreadable; remote URL is optional metadata
+            return undefined;
+        }
+    }
+}
+exports.RepoAnalyzer = RepoAnalyzer;
+exports.default = RepoAnalyzer;

package/dist/src/report-generator.js

@@ -0,0 +1,146 @@
+"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.ReportGenerator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function readJsonSafe(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function readJsonRequired(filePath, label) {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`${label} not found at ${filePath}`);
+    }
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+}
+class ReportGenerator {
+    generate(runDir) {
+        if (!fs.existsSync(runDir)) {
+            throw new Error(`Run directory not found: ${runDir}`);
+        }
+        const sessionState = readJsonRequired(path.join(runDir, 'session-state.json'), 'session-state.json');
+        const metrics = readJsonRequired(path.join(runDir, 'metrics.json'), 'metrics.json');
+        const costAttribution = readJsonSafe(path.join(runDir, 'cost-attribution.json'));
+        const owaspRaw = readJsonSafe(path.join(runDir, 'owasp-compliance.json'));
+        const falsificationBattery = readJsonSafe(path.join(runDir, 'falsification-battery.json'));
+        // Build a lookup for per-step cost data
+        const costByStep = new Map();
+        if (costAttribution?.perStep) {
+            for (const record of costAttribution.perStep) {
+                costByStep.set(record.stepNumber, record);
+            }
+        }
+        // Identify repaired steps from recovery events
+        const repairedSteps = new Set();
+        if (metrics.recoveryEvents) {
+            for (const event of metrics.recoveryEvents) {
+                repairedSteps.add(event.stepNumber);
+            }
+        }
+        const steps = sessionState.graph.steps.map(step => {
+            const costRecord = costByStep.get(step.stepNumber);
+            const wasRepaired = repairedSteps.has(step.stepNumber);
+            // Determine verification status from session state
+            let verificationStatus = 'passed';
+            if (wasRepaired) {
+                verificationStatus = 'repaired';
+            }
+            else if (sessionState.status === 'failed' && step.stepNumber > sessionState.lastCompletedStep) {
+                verificationStatus = 'failed';
+            }
+            return {
+                stepNumber: step.stepNumber,
+                agentName: step.agent,
+                task: step.task,
+                verificationStatus,
+                checksPassed: [],
+                checksFailed: [],
+                repairAttempts: wasRepaired ? 1 : 0,
+                estimatedCost: costRecord?.estimatedPremiumRequests ?? null,
+                actualCost: costRecord?.actualPremiumRequests ?? null,
+                durationMs: costRecord?.durationMs ?? 0
+            };
+        });
+        const failedCount = steps.filter(s => s.verificationStatus === 'failed').length;
+        const repairedCount = steps.filter(s => s.verificationStatus === 'repaired').length;
+        const passedCount = steps.length - failedCount - repairedCount;
+        return {
+            executionId: path.basename(runDir),
+            goal: sessionState.graph.goal,
+            tool: 'swarm-orchestrator',
+            model: costAttribution?.modelUsed ?? 'unknown',
+            startedAt: metrics.startTime,
+            completedAt: metrics.endTime,
+            durationMs: metrics.totalTimeMs,
+            steps,
+            results: {
+                attempted: steps.length,
+                passed: passedCount,
+                failed: failedCount,
+                repaired: repairedCount
+            },
+            waves: {
+                count: metrics.waveCount
+            },
+            cost: costAttribution ? {
+                estimatedPremiumRequests: costAttribution.totalEstimatedPremiumRequests,
+                actualPremiumRequests: costAttribution.totalActualPremiumRequests,
+                accuracy: costAttribution.estimateAccuracy,
+                modelMultiplier: costAttribution.modelMultiplier,
+                overageTriggered: costAttribution.overageTriggered
+            } : null,
+            owaspSummary: owaspRaw ? {
+                applicableRisks: owaspRaw.applicableRisks,
+                mitigatedRisks: owaspRaw.mitigatedRisks,
+                partialRisks: owaspRaw.partialRisks
+            } : null,
+            verification: {
+                totalGitDiffs: metrics.commitCount,
+                buildPasses: metrics.verificationsPassed,
+                testPasses: metrics.verificationsPassed,
+                transcriptMatches: 0
+            },
+            falsificationBattery
+        };
+    }
+}
+exports.ReportGenerator = ReportGenerator;

package/dist/src/report-renderer.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportRenderer = void 0;
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes === 0)
+        return `${seconds}s`;
+    return `${minutes}m ${remainingSeconds}s`;
+}
+class ReportRenderer {
+    static toMarkdown(report) {
+        const lines = [
+            '# Swarm Orchestrator Run Report',
+            '',
+            `**Run:** ${report.executionId}`,
+            `**Goal:** ${report.goal}`,
+            `**Tool:** ${report.tool} | **Model:** ${report.model}`,
+            `**Duration:** ${formatDuration(report.durationMs)}`,
+            `**Date:** ${report.startedAt}`,
+            '',
+            '## Results',
+            '',
+            `Steps: ${report.results.attempted} attempted, ${report.results.passed} passed, ${report.results.failed} failed, ${report.results.repaired} repaired`,
+            `Waves: ${report.waves.count} waves`,
+            '',
+            '## Per-Step Detail',
+            '',
+            '| Step | Agent | Task | Status | Checks Passed | Repairs | Cost (est/actual) |',
+            '|------|-------|------|--------|---------------|---------|-------------------|'
+        ];
+        for (const step of report.steps) {
+            const checks = step.checksPassed.length > 0 ? step.checksPassed.join(', ') : 'none';
+            const costStr = step.estimatedCost !== null && step.actualCost !== null
+                ? `${step.estimatedCost} / ${step.actualCost}`
+                : 'n/a';
+            lines.push(`| ${step.stepNumber} | ${step.agentName} | ${step.task} | ${step.verificationStatus} | ${checks} | ${step.repairAttempts} | ${costStr} |`);
+        }
+        lines.push('');
+        if (report.cost) {
+            const accuracyPct = (report.cost.accuracy * 100).toFixed(1);
+            lines.push('## Cost Attribution');
+            lines.push('');
+            lines.push(`Estimated: ${report.cost.estimatedPremiumRequests} premium requests | Actual: ${report.cost.actualPremiumRequests} | Accuracy: ${accuracyPct}%`);
+            lines.push(`Model: ${report.model} (${report.cost.modelMultiplier}x multiplier)`);
+            lines.push(`Overage: ${report.cost.overageTriggered ? 'yes' : 'no'}`);
+            lines.push('');
+        }
+        lines.push('## Verification Evidence');
+        lines.push('');
+        lines.push(`Git diffs: ${report.verification.totalGitDiffs} | Build passes: ${report.verification.buildPasses} | Test passes: ${report.verification.testPasses} | Transcript matches: ${report.verification.transcriptMatches}`);
+        lines.push('');
+        if (report.falsificationBattery) {
+            lines.push('## Falsification Battery');
+            lines.push('');
+            lines.push(`Composite score: ${report.falsificationBattery.compositeScore}`);
+            lines.push(`Human review: ${report.falsificationBattery.humanReviewRequired ? 'yes' : 'no'}`);
+            for (const layer of report.falsificationBattery.layers) {
+                lines.push(`- ${layer.layer}: ${layer.status} (${layer.durationMs}ms) ${layer.evidenceSummary}`);
+            }
+            lines.push('');
+        }
+        if (report.owaspSummary) {
+            lines.push('## OWASP Compliance');
+            lines.push('');
+            lines.push(`Applicable risks: ${report.owaspSummary.applicableRisks}/10 | Mitigated: ${report.owaspSummary.mitigatedRisks} | Partial: ${report.owaspSummary.partialRisks}`);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    static toJson(report) {
+        return JSON.stringify(report, null, 2);
+    }
+    static toSummaryLine(report) {
+        const parts = [
+            `Run ${report.executionId}:`,
+            `${report.results.passed}/${report.results.attempted} steps passed`,
+            `| ${report.waves.count} waves`
+        ];
+        if (report.cost) {
+            parts.push(`| ${report.cost.actualPremiumRequests} premium requests (est ${report.cost.estimatedPremiumRequests})`);
+        }
+        if (report.owaspSummary) {
+            parts.push(`| OWASP ${report.owaspSummary.mitigatedRisks}/${report.owaspSummary.applicableRisks} mitigated`);
+        }
+        return parts.join(' ');
+    }
+}
+exports.ReportRenderer = ReportRenderer;

package/dist/src/requirement-filter.js

@@ -0,0 +1,52 @@
+"use strict";
+// Connects task classification to tier maps and produces
+// filtered requirements for agent prompt injection.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequirementFilter = void 0;
+class RequirementFilter {
+    tierMaps;
+    constructor(tierMaps) {
+        this.tierMaps = tierMaps;
+    }
+    filter(classification) {
+        const requirements = this.tierMaps[classification.taskType] || [];
+        const enforced = [];
+        const recommended = [];
+        const skipped = [];
+        for (const req of requirements) {
+            switch (req.tier) {
+                case 'enforce':
+                    enforced.push(req);
+                    break;
+                case 'recommend':
+                    recommended.push(req);
+                    break;
+                case 'skip':
+                    skipped.push(req);
+                    break;
+            }
+        }
+        return { taskType: classification.taskType, enforced, recommended, skipped };
+    }
+    toPromptInjection(filtered) {
+        const sections = [];
+        if (filtered.enforced.length > 0) {
+            sections.push('## Required (these are mandatory, your code will be rejected if missing):');
+            for (const req of filtered.enforced) {
+                sections.push(`- ${req.description}`);
+            }
+        }
+        if (filtered.recommended.length > 0) {
+            if (sections.length > 0)
+                sections.push('');
+            sections.push('## Recommended (include where applicable):');
+            for (const req of filtered.recommended) {
+                sections.push(`- ${req.description}`);
+            }
+        }
+        // Tier 3 (skip) items are intentionally absent from the prompt.
+        // Not mentioned, not suggested, not hinted at.
+        return sections.join('\n');
+    }
+}
+exports.RequirementFilter = RequirementFilter;