swarm-orchestrator 7.0.0-alpha.0

package/dist/src/session-manager.js

@@ -0,0 +1,221 @@
+"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.SessionManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const share_parser_1 = require("./share-parser");
+class SessionManager {
+    runsDir;
+    constructor(runsDir) {
+        this.runsDir = runsDir || path.join(process.cwd(), 'runs');
+    }
+    /**
+     * create a new run directory structure
+     */
+    createRun(runId) {
+        const runDir = path.join(this.runsDir, runId);
+        if (!fs.existsSync(this.runsDir)) {
+            fs.mkdirSync(this.runsDir, { recursive: true });
+        }
+        if (fs.existsSync(runDir)) {
+            throw new Error(`run ${runId} already exists`);
+        }
+        fs.mkdirSync(runDir);
+        fs.mkdirSync(path.join(runDir, 'steps'));
+        return runDir;
+    }
+    /**
+     * create a step directory within a run
+     */
+    createStepDir(runId, stepNumber) {
+        const stepDir = path.join(this.runsDir, runId, 'steps', this.padStepNumber(stepNumber));
+        if (!fs.existsSync(stepDir)) {
+            fs.mkdirSync(stepDir, { recursive: true });
+        }
+        return stepDir;
+    }
+    /**
+     * import a /share transcript and parse it
+     */
+    importShare(runId, stepNumber, agentName, transcriptPathOrContent) {
+        const stepDir = this.createStepDir(runId, stepNumber);
+        // determine if input is path or content
+        let content;
+        if (fs.existsSync(transcriptPathOrContent)) {
+            // it's a file path
+            content = fs.readFileSync(transcriptPathOrContent, 'utf8');
+        }
+        else if (transcriptPathOrContent.startsWith('http')) {
+            // it's a URL - not supported yet
+            throw new Error('URL import not yet implemented');
+        }
+        else {
+            // treat as raw content
+            content = transcriptPathOrContent;
+        }
+        // parse the share transcript
+        const parser = new share_parser_1.ShareParser();
+        const index = parser.parse(content);
+        // save the share transcript to step directory
+        const sharePath = path.join(stepDir, 'share.md');
+        fs.writeFileSync(sharePath, content, 'utf8');
+        // save the index
+        const indexPath = path.join(stepDir, 'index.json');
+        fs.writeFileSync(indexPath, JSON.stringify(index, null, 2), 'utf8');
+        // create step share record
+        const stepShare = {
+            stepNumber,
+            agentName,
+            transcriptPath: sharePath,
+            index,
+            importedAt: new Date().toISOString()
+        };
+        // update run context
+        this.updateRunContext(runId, stepShare);
+        return stepShare;
+    }
+    /**
+     * get prior context for a step (all previous shares)
+     */
+    getPriorContext(runId, currentStep) {
+        const runContextPath = path.join(this.runsDir, runId, 'context.json');
+        if (!fs.existsSync(runContextPath)) {
+            return [];
+        }
+        const context = JSON.parse(fs.readFileSync(runContextPath, 'utf8'));
+        return context.shares
+            .filter(share => share.stepNumber < currentStep)
+            .sort((a, b) => a.stepNumber - b.stepNumber);
+    }
+    /**
+     * generate context summary for next step
+     */
+    generateContextSummary(runId, currentStep) {
+        const priorShares = this.getPriorContext(runId, currentStep);
+        if (priorShares.length === 0) {
+            return 'no prior context';
+        }
+        const lines = [];
+        lines.push('context from prior steps:');
+        lines.push('');
+        for (const share of priorShares) {
+            lines.push(`step ${share.stepNumber} (${share.agentName}):`);
+            if (share.index.changedFiles.length > 0) {
+                lines.push(`  changed files: ${share.index.changedFiles.join(', ')}`);
+            }
+            if (share.index.testsRun.length > 0) {
+                const verifiedTests = share.index.testsRun.filter(t => t.verified);
+                if (verifiedTests.length > 0) {
+                    lines.push(`  tests verified: ${verifiedTests.map(t => t.command).join(', ')}`);
+                }
+            }
+            if (share.index.prLinks.length > 0) {
+                lines.push(`  PRs created: ${share.index.prLinks.join(', ')}`);
+            }
+            // check for unverified claims
+            const unverified = share.index.claims.filter(c => !c.verified);
+            if (unverified.length > 0) {
+                lines.push(`  ⚠ unverified claims: ${unverified.length}`);
+                unverified.forEach(claim => {
+                    lines.push(`    - ${claim.claim.substring(0, 80)}`);
+                    lines.push(`      reason: ${claim.evidence}`);
+                });
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * save summary for a step
+     */
+    saveSummary(runId, stepNumber, summary) {
+        const stepDir = this.createStepDir(runId, stepNumber);
+        const summaryPath = path.join(stepDir, 'summary.md');
+        fs.writeFileSync(summaryPath, summary, 'utf8');
+    }
+    /**
+     * save verification notes for a step
+     */
+    saveVerification(runId, stepNumber, verification) {
+        const stepDir = this.createStepDir(runId, stepNumber);
+        const verificationPath = path.join(stepDir, 'verification.md');
+        fs.writeFileSync(verificationPath, verification, 'utf8');
+    }
+    /**
+     * get unverified claims across all steps in a run
+     */
+    getUnverifiedClaims(runId) {
+        const runContextPath = path.join(this.runsDir, runId, 'context.json');
+        if (!fs.existsSync(runContextPath)) {
+            return [];
+        }
+        const context = JSON.parse(fs.readFileSync(runContextPath, 'utf8'));
+        return context.shares
+            .map(share => ({
+            step: share.stepNumber,
+            agent: share.agentName,
+            claims: share.index.claims.filter(c => !c.verified)
+        }))
+            .filter(item => item.claims.length > 0);
+    }
+    updateRunContext(runId, stepShare) {
+        const runContextPath = path.join(this.runsDir, runId, 'context.json');
+        let context;
+        if (fs.existsSync(runContextPath)) {
+            context = JSON.parse(fs.readFileSync(runContextPath, 'utf8'));
+        }
+        else {
+            context = {
+                runId,
+                runDir: path.join(this.runsDir, runId),
+                shares: []
+            };
+        }
+        // remove any existing share for this step (replace)
+        context.shares = context.shares.filter(s => s.stepNumber !== stepShare.stepNumber);
+        // add new share
+        context.shares.push(stepShare);
+        // sort by step number
+        context.shares.sort((a, b) => a.stepNumber - b.stepNumber);
+        // save
+        fs.writeFileSync(runContextPath, JSON.stringify(context, null, 2), 'utf8');
+    }
+    padStepNumber(stepNumber) {
+        return stepNumber.toString().padStart(2, '0');
+    }
+}
+exports.SessionManager = SessionManager;
+exports.default = SessionManager;

package/dist/src/share/transcript-verification.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractClaims = extractClaims;
+/**
+ * Probabilistic claim-verification pass: scan transcript lines for natural-language
+ * claims (tests passing, build successful, commit made) and cross-reference each
+ * claim against the deterministic extraction results already produced by the
+ * transcript-extraction pass.
+ *
+ * This is heuristic — line patterns are matched case-insensitively and lines
+ * that look like agent-prompt instructions are skipped. Returns a claims[] with
+ * verified=true when supporting evidence exists in the index, verified=false
+ * otherwise (with a reason).
+ */
+function extractClaims(lines, index) {
+    const claims = [];
+    const instructionPrefixes = [
+        'scope:',
+        'done when:',
+        'role:',
+        'rules:',
+        'rule:',
+        'context:',
+        'you are ',
+        'your task',
+        'your job',
+        'your goal',
+        'important:',
+        'note:',
+        'constraints:',
+        'requirements:',
+    ];
+    for (const line of lines) {
+        const lowerLine = line.toLowerCase();
+        const trimmedLower = lowerLine.trim().toLowerCase();
+        if (instructionPrefixes.some((prefix) => trimmedLower.startsWith(prefix))) {
+            continue;
+        }
+        if (trimmedLower.match(/^[-*]\s+(ensure|make sure|verify|confirm|must|should)\b/)) {
+            continue;
+        }
+        // tests passing
+        if ((lowerLine.match(/\btests?\b/) && lowerLine.match(/\b(pass|passed|passing)\b/)) ||
+            lowerLine.includes('all tests passed') ||
+            lowerLine.includes('tests are passing')) {
+            const hasVerifiedTests = index.testsRun.some((t) => t.verified);
+            claims.push({
+                claim: line.trim(),
+                verified: hasVerifiedTests,
+                evidence: hasVerifiedTests
+                    ? `verified test command: ${index.testsRun.find((t) => t.verified)?.command}`
+                    : 'no test execution found in transcript',
+            });
+        }
+        // build succeeded
+        if (lowerLine.match(/\b(build|builds)\s+(succeed|succeeded|passed|successful)/i) ||
+            lowerLine.includes('compiled successfully')) {
+            const hasBuildCommand = index.buildOperations.some((b) => b.verified);
+            claims.push({
+                claim: line.trim(),
+                verified: hasBuildCommand,
+                evidence: hasBuildCommand
+                    ? `verified build with: ${index.buildOperations.find((b) => b.verified)?.tool}`
+                    : 'no build command found in transcript',
+            });
+        }
+        // lint passing
+        if (lowerLine.match(/\b(lint|linting)\s+(pass|passed|succeeded)/i) ||
+            lowerLine.match(/no\s+lint\s+errors?/i)) {
+            const hasLintCommand = index.lintOperations.some((l) => l.verified);
+            claims.push({
+                claim: line.trim(),
+                verified: hasLintCommand,
+                evidence: hasLintCommand
+                    ? `verified lint with: ${index.lintOperations.find((l) => l.verified)?.tool}`
+                    : 'no lint command found in transcript',
+            });
+        }
+        // deployment
+        if (lowerLine.match(/\b(deploy|deployed|deployment)\s+(succeed|succeeded|successful)/i)) {
+            const hasDeployCommand = index.commandsExecuted.some((cmd) => cmd.includes('deploy') || cmd.includes('publish'));
+            claims.push({
+                claim: line.trim(),
+                verified: hasDeployCommand,
+                evidence: hasDeployCommand
+                    ? 'verified deployment command found'
+                    : 'no deployment command found in transcript',
+            });
+        }
+        // package install
+        if (lowerLine.match(/\b(installed|added)\s+package/i) || lowerLine.match(/\bnpm\s+install/i)) {
+            const hasPackageOp = index.packageOperations.some((op) => op.operation === 'install');
+            claims.push({
+                claim: line.trim(),
+                verified: hasPackageOp,
+                evidence: hasPackageOp
+                    ? `verified package install: ${index.packageOperations.find((op) => op.operation === 'install')?.packages.join(', ')}`
+                    : 'no package install command found',
+            });
+        }
+        // git commit
+        if (lowerLine.match(/\bcommitted\s+(the\s+)?changes?/i) || lowerLine.match(/\bgit\s+commit/i)) {
+            const hasCommit = index.gitCommits.length > 0;
+            claims.push({
+                claim: line.trim(),
+                verified: hasCommit,
+                evidence: hasCommit
+                    ? `verified commit: ${index.gitCommits[0]?.message}`
+                    : 'no git commit found in transcript',
+            });
+        }
+        // MCP consultation
+        if (lowerLine.match(/\b(consulted|checked|reviewed)\s+(mcp|github|issues?)/i) &&
+            (lowerLine.includes('mcp') ||
+                lowerLine.includes('github') ||
+                lowerLine.includes('context'))) {
+            const hasMcp = index.mcpSections.some((m) => m.verified);
+            claims.push({
+                claim: line.trim(),
+                verified: hasMcp,
+                evidence: hasMcp
+                    ? 'verified MCP Evidence section found'
+                    : 'no MCP Evidence section or insufficient evidence',
+            });
+        }
+    }
+    return claims;
+}