swarm-orchestrator 7.0.0-alpha.0

package/dist/src/share-parser.js

@@ -0,0 +1,477 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShareParser = void 0;
+const transcript_verification_1 = require("./share/transcript-verification");
+class ShareParser {
+    /**
+     * parse /share transcript and extract key facts with comprehensive verification
+     */
+    parse(content) {
+        const index = {
+            changedFiles: [],
+            commandsExecuted: [],
+            testsRun: [],
+            prLinks: [],
+            gitCommits: [],
+            packageOperations: [],
+            buildOperations: [],
+            lintOperations: [],
+            mcpSections: [],
+            claims: []
+        };
+        const lines = content.split('\n');
+        // extract changed files
+        index.changedFiles = this.extractChangedFiles(lines);
+        // extract commands executed
+        index.commandsExecuted = this.extractCommands(lines);
+        // extract test runs
+        index.testsRun = this.extractTestRuns(lines, index.commandsExecuted);
+        // extract PR links
+        index.prLinks = this.extractPRLinks(lines);
+        // extract git commits
+        index.gitCommits = this.extractGitCommits(lines, index.commandsExecuted);
+        // extract package operations
+        index.packageOperations = this.extractPackageOperations(lines, index.commandsExecuted);
+        // extract build operations
+        index.buildOperations = this.extractBuildOperations(lines, index.commandsExecuted);
+        // extract lint operations
+        index.lintOperations = this.extractLintOperations(lines, index.commandsExecuted);
+        // extract MCP sections
+        index.mcpSections = this.extractMcpSections(lines);
+        // extract and verify claims
+        index.claims = (0, transcript_verification_1.extractClaims)(lines, index);
+        return index;
+    }
+    extractChangedFiles(lines) {
+        const files = new Set();
+        // look for git status output
+        let inGitStatus = false;
+        for (const line of lines) {
+            if (line.includes('git status') || line.includes('git diff')) {
+                inGitStatus = true;
+                continue;
+            }
+            if (inGitStatus) {
+                // match modified files
+                const modifiedMatch = line.match(/^\s*modified:\s+(.+)$/);
+                if (modifiedMatch && modifiedMatch[1]) {
+                    files.add(modifiedMatch[1].trim());
+                }
+                // match new files
+                const newFileMatch = line.match(/^\s*new file:\s+(.+)$/);
+                if (newFileMatch && newFileMatch[1]) {
+                    files.add(newFileMatch[1].trim());
+                }
+                // match deleted files
+                const deletedMatch = line.match(/^\s*deleted:\s+(.+)$/);
+                if (deletedMatch && deletedMatch[1]) {
+                    files.add(deletedMatch[1].trim());
+                }
+                // end of git status block
+                if (line.trim() === '' || line.includes('$') || line.includes('>')) {
+                    inGitStatus = false;
+                }
+            }
+            // also look for explicit file mentions in code blocks
+            const filePathMatch = line.match(/^[\s]*(?:edited|created|modified|deleted):\s+([^\s]+\.[a-z]+)/i);
+            if (filePathMatch && filePathMatch[1]) {
+                files.add(filePathMatch[1]);
+            }
+        }
+        return Array.from(files);
+    }
+    extractCommands(lines) {
+        const commands = [];
+        // Accumulator for multi-line Copilot CLI commands (continued with │ prefix)
+        let pendingCopilotCmd = '';
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (!line) {
+                // Blank line ends any pending multi-line command
+                if (pendingCopilotCmd) {
+                    commands.push(pendingCopilotCmd);
+                    pendingCopilotCmd = '';
+                }
+                continue;
+            }
+            // Copilot CLI transcript format: commands prefixed with box-drawing │ (U+2502)
+            // e.g. "  │ source venv/bin/activate && python -m pytest tests/ -v"
+            const copilotMatch = line.match(/^\s*\u2502\s+(.+)/);
+            if (copilotMatch) {
+                const fragment = copilotMatch[1].trim();
+                // └ lines are output summaries (e.g. "└ 86 lines..."), not commands
+                if (!fragment.startsWith('\u2514') && !fragment.match(/^\d+ lines/)) {
+                    if (pendingCopilotCmd) {
+                        // Continuation of a multi-line command (e.g. && on previous line)
+                        pendingCopilotCmd += ' ' + fragment;
+                    }
+                    else {
+                        pendingCopilotCmd = fragment;
+                    }
+                }
+                else if (pendingCopilotCmd) {
+                    // Output summary terminates the pending command
+                    commands.push(pendingCopilotCmd);
+                    pendingCopilotCmd = '';
+                }
+                continue;
+            }
+            // Non-│ line ends any pending multi-line Copilot command
+            if (pendingCopilotCmd) {
+                commands.push(pendingCopilotCmd);
+                pendingCopilotCmd = '';
+            }
+            // look for command prompts
+            if (line.match(/^[\$>]\s+/) || line.match(/^npm\s+/) || line.match(/^git\s+/)) {
+                const cmd = line.replace(/^[\$>]\s+/, '').trim();
+                if (cmd) {
+                    commands.push(cmd);
+                }
+            }
+            // look for commands in code blocks
+            if (line.includes('```') && i + 1 < lines.length) {
+                const nextLine = lines[i + 1];
+                if (nextLine && (nextLine.startsWith('$') || nextLine.startsWith('npm') || nextLine.startsWith('git'))) {
+                    const cmd = nextLine.replace(/^[\$>]\s+/, '').trim();
+                    if (cmd) {
+                        commands.push(cmd);
+                    }
+                }
+            }
+        }
+        // Flush any trailing command
+        if (pendingCopilotCmd) {
+            commands.push(pendingCopilotCmd);
+        }
+        return commands;
+    }
+    extractTestRuns(lines, commands) {
+        const testRuns = [];
+        // find test commands
+        const testCommands = commands.filter(cmd => cmd.includes('test') ||
+            cmd.includes('jest') ||
+            cmd.includes('mocha') ||
+            cmd.includes('pytest') ||
+            cmd.includes('go test') ||
+            cmd.includes('cargo test'));
+        for (const cmd of testCommands) {
+            // verify test actually ran by looking for output
+            const hasOutput = this.hasTestOutput(lines, cmd);
+            if (hasOutput) {
+                testRuns.push({
+                    command: cmd,
+                    verified: true
+                });
+            }
+            else {
+                testRuns.push({
+                    command: cmd,
+                    verified: false,
+                    reason: 'no test output found in transcript'
+                });
+            }
+        }
+        return testRuns;
+    }
+    hasTestOutput(lines, testCommand) {
+        // look for common test output patterns after the command
+        const cmdIndex = lines.findIndex(line => line.includes(testCommand));
+        if (cmdIndex === -1)
+            return false;
+        // check next 80 lines for test output (Node.js test runner can be verbose)
+        const outputLines = lines.slice(cmdIndex + 1, cmdIndex + 81);
+        for (const line of outputLines) {
+            // mocha/jest patterns
+            if (line.match(/\d+\s+passing/))
+                return true;
+            if (line.match(/\d+\s+tests?\s+passed/))
+                return true;
+            // pytest patterns
+            if (line.match(/\d+\s+passed/))
+                return true;
+            // go test patterns
+            if (line.match(/PASS/))
+                return true;
+            if (line.match(/ok\s+/))
+                return true;
+            // Node.js built-in test runner patterns (node --test)
+            if (line.match(/tests\s+\d+/))
+                return true; // "ℹ tests 10"
+            if (line.match(/pass\s+\d+/))
+                return true; // "ℹ pass 10"
+            if (line.match(/fail\s+0/))
+                return true; // "ℹ fail 0"
+            if (line.match(/duration_ms/))
+                return true; // "ℹ duration_ms 123"
+            // generic success patterns
+            if (line.match(/all tests passed/i))
+                return true;
+            if (line.match(/all\s+\d+\s+tests?\s+pass/i))
+                return true;
+        }
+        return false;
+    }
+    extractPRLinks(lines) {
+        const links = new Set();
+        for (const line of lines) {
+            // github PR URLs
+            const prMatch = line.match(/https:\/\/github\.com\/[^\/]+\/[^\/]+\/pull\/\d+/g);
+            if (prMatch) {
+                prMatch.forEach(url => links.add(url));
+            }
+            // shortened PR references
+            const shortMatch = line.match(/#(\d+)/g);
+            if (shortMatch) {
+                // note: we can't construct full URL without repo context
+                // so we just note the PR number
+                shortMatch.forEach(ref => links.add(ref));
+            }
+        }
+        return Array.from(links);
+    }
+    extractGitCommits(lines, commands) {
+        const commits = [];
+        const commitMap = new Map();
+        // look for git commit commands in extracted commands list
+        const commitCommands = commands.filter(cmd => cmd.match(/git\s+commit/));
+        for (const cmd of commitCommands) {
+            // try single-line quoted message first
+            const messageMatch = cmd.match(/git\s+commit\s+-m\s+["']([^"']+)["']/);
+            if (messageMatch && messageMatch[1]) {
+                const message = messageMatch[1];
+                commitMap.set(message, { message, verified: true });
+            }
+            else {
+                // message may span multiple lines or have an unclosed quote;
+                // grab everything after -m " as the first line of the message
+                const partialMatch = cmd.match(/git\s+commit\s+-m\s+["'](.+)/);
+                if (partialMatch && partialMatch[1]) {
+                    const message = partialMatch[1].replace(/["']$/, '').trim();
+                    if (message) {
+                        commitMap.set(message, { message, verified: true });
+                    }
+                }
+            }
+        }
+        // also scan raw lines for git commit commands that extractCommands may
+        // have missed (e.g. chained commands: cd ... && git commit -m "...")
+        for (const line of lines) {
+            const inlineMatch = line.match(/git\s+commit\s+-m\s+["']([^"'\n]+)/);
+            if (inlineMatch && inlineMatch[1]) {
+                const message = inlineMatch[1].trim();
+                if (message && !commitMap.has(message)) {
+                    commitMap.set(message, { message, verified: true });
+                }
+            }
+        }
+        // look for commit SHAs in git output
+        // format: [branch-name sha] message  (branch can contain / and -)
+        for (const line of lines) {
+            const shaMatch = line.match(/\[[\w/.:-]+\s+([a-f0-9]{7,40})\]\s+(.+)/);
+            if (shaMatch && shaMatch[1] && shaMatch[2]) {
+                const sha = shaMatch[1];
+                const messageAfterSha = shaMatch[2].trim();
+                // try to match with an already-known commit
+                let foundCommit = false;
+                for (const [message, commit] of commitMap.entries()) {
+                    if (messageAfterSha.includes(message) || message.includes(messageAfterSha)) {
+                        commit.sha = sha;
+                        foundCommit = true;
+                        break;
+                    }
+                }
+                if (!foundCommit && messageAfterSha) {
+                    commitMap.set(messageAfterSha, { message: messageAfterSha, sha, verified: true });
+                }
+            }
+        }
+        // convert map to array
+        for (const commit of commitMap.values()) {
+            const result = {
+                message: commit.message || 'commit detected',
+                verified: true
+            };
+            if (commit.sha) {
+                result.sha = commit.sha;
+            }
+            commits.push(result);
+        }
+        return commits;
+    }
+    extractPackageOperations(lines, commands) {
+        const operations = [];
+        const processedCommands = new Set();
+        // npm/yarn/pnpm patterns
+        const packageManagers = ['npm', 'yarn', 'pnpm', 'bun'];
+        for (const cmd of commands) {
+            // skip if already processed
+            if (processedCommands.has(cmd)) {
+                continue;
+            }
+            for (const pm of packageManagers) {
+                // install operations (install, add, i)
+                const installMatch = cmd.match(new RegExp(`^${pm}\\s+(?:add|install|i)\\s+(.+)`));
+                if (installMatch && installMatch[1]) {
+                    const argString = installMatch[1];
+                    // filter out flags and extract package names
+                    const packages = argString
+                        .split(/\s+/)
+                        .filter(p => p.trim() !== '' && !p.startsWith('-'));
+                    if (packages.length > 0) {
+                        operations.push({
+                            operation: 'install',
+                            packages
+                        });
+                        processedCommands.add(cmd);
+                        break; // found a match, move to next command
+                    }
+                }
+                // uninstall operations
+                const uninstallMatch = cmd.match(new RegExp(`^${pm}\\s+(?:remove|uninstall|rm)\\s+(.+)`));
+                if (uninstallMatch && uninstallMatch[1]) {
+                    const argString = uninstallMatch[1];
+                    const packages = argString
+                        .split(/\s+/)
+                        .filter(p => p.trim() !== '' && !p.startsWith('-'));
+                    if (packages.length > 0) {
+                        operations.push({
+                            operation: 'uninstall',
+                            packages
+                        });
+                        processedCommands.add(cmd);
+                        break;
+                    }
+                }
+                // update operations
+                if (cmd.match(new RegExp(`^${pm}\\s+(?:update|upgrade)`))) {
+                    operations.push({
+                        operation: 'update',
+                        packages: ['all packages']
+                    });
+                    processedCommands.add(cmd);
+                    break;
+                }
+            }
+        }
+        return operations;
+    }
+    extractBuildOperations(lines, commands) {
+        const operations = [];
+        const buildTools = [
+            { tool: 'tsc', pattern: /\btsc\b/ },
+            { tool: 'webpack', pattern: /\bwebpack\b/ },
+            { tool: 'vite', pattern: /\bvite\s+build\b/ },
+            { tool: 'rollup', pattern: /\brollup\b/ },
+            { tool: 'esbuild', pattern: /\besbuild\b/ },
+            { tool: 'swc', pattern: /\bswc\b/ },
+            { tool: 'babel', pattern: /\bbabel\b/ },
+            { tool: 'next', pattern: /\bnext\s+build\b/ },
+            { tool: 'nuxt', pattern: /\bnuxt\s+build\b/ },
+            { tool: 'npm build', pattern: /\bnpm\s+run\s+build\b/ },
+            { tool: 'yarn build', pattern: /\byarn\s+build\b/ }
+        ];
+        for (const { tool, pattern } of buildTools) {
+            const buildCmd = commands.find(cmd => pattern.test(cmd));
+            if (buildCmd) {
+                // verify build succeeded by looking for output
+                const verified = this.hasBuildOutput(lines, buildCmd);
+                operations.push({ tool, verified });
+            }
+        }
+        return operations;
+    }
+    hasBuildOutput(lines, buildCommand) {
+        const cmdIndex = lines.findIndex(line => line.includes(buildCommand));
+        if (cmdIndex === -1)
+            return false;
+        // check next 100 lines for build success indicators
+        const outputLines = lines.slice(cmdIndex + 1, cmdIndex + 101);
+        for (const line of outputLines) {
+            // success patterns
+            if (line.match(/build\s+succe(ss|eded)/i))
+                return true;
+            if (line.match(/compiled successfully/i))
+                return true;
+            if (line.match(/built in \d+/i))
+                return true;
+            if (line.match(/✓.*built/i))
+                return true;
+            if (line.match(/done in \d+/i))
+                return true;
+            if (line.match(/successfully built/i))
+                return true;
+        }
+        return false;
+    }
+    extractLintOperations(lines, commands) {
+        const operations = [];
+        const lintTools = [
+            { tool: 'eslint', pattern: /\beslint\b/ },
+            { tool: 'prettier', pattern: /\bprettier\b/ },
+            { tool: 'biome', pattern: /\bbiome\s+(?:check|lint)\b/ },
+            { tool: 'tslint', pattern: /\btslint\b/ },
+            { tool: 'npm lint', pattern: /\bnpm\s+run\s+lint\b/ },
+            { tool: 'yarn lint', pattern: /\byarn\s+lint\b/ }
+        ];
+        for (const { tool, pattern } of lintTools) {
+            const lintCmd = commands.find(cmd => pattern.test(cmd));
+            if (lintCmd) {
+                // verify lint succeeded
+                const verified = this.hasLintOutput(lines, lintCmd);
+                operations.push({ tool, verified });
+            }
+        }
+        return operations;
+    }
+    hasLintOutput(lines, lintCommand) {
+        const cmdIndex = lines.findIndex(line => line.includes(lintCommand));
+        if (cmdIndex === -1)
+            return false;
+        // check next 50 lines for lint output
+        const outputLines = lines.slice(cmdIndex + 1, cmdIndex + 51);
+        for (const line of outputLines) {
+            // success patterns
+            if (line.match(/✓.*no.*(error|warning|problem)/i))
+                return true;
+            if (line.match(/0\s+errors/i))
+                return true;
+            if (line.match(/all.*passed/i))
+                return true;
+            if (line.match(/✨.*done/i))
+                return true;
+        }
+        return false;
+    }
+    extractMcpSections(lines) {
+        const sections = [];
+        // look for MCP Evidence headers
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (!line)
+                continue;
+            if (line.match(/##\s+MCP\s+Evidence/i)) {
+                // extract section content (everything until next ## or end)
+                let content = '';
+                let j = i + 1;
+                while (j < lines.length && !lines[j]?.match(/^##\s+/)) {
+                    content += (lines[j] || '') + '\n';
+                    j++;
+                }
+                const trimmedContent = content.trim();
+                // verify MCP section has actual evidence
+                const hasIssueRef = /issue\s+#?\d+/i.test(trimmedContent);
+                const hasPrRef = /pr\s+#?\d+|pull request/i.test(trimmedContent);
+                const hasWorkflowRef = /workflow|\.github\/workflows|CI/i.test(trimmedContent);
+                const hasDecision = /decision|influenced|based on|considering/i.test(trimmedContent);
+                const verified = (hasIssueRef || hasPrRef || hasWorkflowRef) && hasDecision && trimmedContent.length >= 50;
+                sections.push({
+                    content: trimmedContent,
+                    verified
+                });
+            }
+        }
+        return sections;
+    }
+}
+exports.ShareParser = ShareParser;
+exports.default = ShareParser;

package/dist/src/spinner.js

@@ -0,0 +1,146 @@
+"use strict";
+// Author: Bradley R. Kinnard
+// Terminal spinner for visual feedback during long operations
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressTracker = exports.Spinner = void 0;
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)('spinner');
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const DOTS_FRAMES = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'];
+const BOUNCE_FRAMES = ['⠁', '⠂', '⠄', '⡀', '⢀', '⠠', '⠐', '⠈'];
+const PULSE_FRAMES = ['🐝', '🐝 ', '🐝  ', '🐝   ', '🐝  ', '🐝 ', '🐝'];
+const FRAME_SETS = {
+    dots: DOTS_FRAMES,
+    spinner: SPINNER_FRAMES,
+    bounce: BOUNCE_FRAMES,
+    pulse: PULSE_FRAMES
+};
+class Spinner {
+    frames;
+    frameIndex = 0;
+    interval = null;
+    message;
+    prefix;
+    isRunning = false;
+    constructor(message, options = {}) {
+        this.frames = FRAME_SETS[options.style || 'dots'];
+        this.message = message;
+        this.prefix = options.prefix || '';
+    }
+    start() {
+        if (this.isRunning)
+            return;
+        // When stdout is not a TTY (piped to a file, CI log, etc.) cursor-control
+        // escapes show up as literal bytes and corrupt the captured output.
+        if (!process.stdout.isTTY)
+            return;
+        this.isRunning = true;
+        this.frameIndex = 0;
+        // hide cursor
+        process.stdout.write('\x1B[?25l');
+        this.interval = setInterval(() => {
+            const frame = this.frames[this.frameIndex];
+            process.stdout.write(`\r${this.prefix}${frame} ${this.message}`);
+            this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+        }, 80);
+    }
+    update(message) {
+        this.message = message;
+    }
+    stop(finalMessage) {
+        if (!this.isRunning) {
+            // Even when start() was skipped, emit the final message via logger.
+            if (finalMessage) {
+                logger.info(`${this.prefix}${finalMessage}`);
+            }
+            return;
+        }
+        this.isRunning = false;
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        // clear line and show cursor
+        process.stdout.write('\r\x1B[K');
+        process.stdout.write('\x1B[?25h');
+        if (finalMessage) {
+            logger.info(`${this.prefix}${finalMessage}`);
+        }
+    }
+    succeed(message) {
+        this.stop(`${this.color('✓', '32', '39')} ${message || this.message}`);
+    }
+    fail(message) {
+        this.stop(`${this.color('✗', '31', '39')} ${message || this.message}`);
+    }
+    warn(message) {
+        this.stop(`${this.color('!', '33', '39')} ${message || this.message}`);
+    }
+    info(message) {
+        this.stop(`${this.color('·', '2', '22')} ${message || this.message}`);
+    }
+    /** Wrap a glyph in ANSI color/style codes when stdout supports them. */
+    color(ch, open, close) {
+        if (!process.stdout.isTTY || process.env.NO_COLOR)
+            return ch;
+        return `\x1b[${open}m${ch}\x1b[${close}m`;
+    }
+}
+exports.Spinner = Spinner;
+/**
+ * Multi-step progress tracker with visual feedback
+ */
+class ProgressTracker {
+    activeSpinners = new Map();
+    stepStatus = new Map();
+    startStep(stepId, message, prefix = '  ') {
+        const spinner = new Spinner(message, { style: 'dots', prefix });
+        this.activeSpinners.set(stepId, spinner);
+        this.stepStatus.set(stepId, 'running');
+        spinner.start();
+    }
+    updateStep(stepId, message) {
+        const spinner = this.activeSpinners.get(stepId);
+        if (spinner) {
+            spinner.update(message);
+        }
+    }
+    completeStep(stepId, message) {
+        const spinner = this.activeSpinners.get(stepId);
+        if (spinner) {
+            spinner.succeed(message);
+            this.activeSpinners.delete(stepId);
+            this.stepStatus.set(stepId, 'done');
+        }
+    }
+    failStep(stepId, message) {
+        const existing = this.activeSpinners.get(stepId);
+        if (existing) {
+            existing.fail(message);
+            this.activeSpinners.delete(stepId);
+        }
+        else {
+            const spinner = new Spinner(message, { style: 'dots', prefix: '  ' });
+            spinner.fail(message);
+        }
+        this.stepStatus.set(stepId, 'failed');
+    }
+    warnStep(stepId, message) {
+        const spinner = this.activeSpinners.get(stepId);
+        if (spinner) {
+            spinner.warn(message);
+            this.activeSpinners.delete(stepId);
+        }
+    }
+    stopAll() {
+        for (const spinner of this.activeSpinners.values()) {
+            spinner.stop();
+        }
+        this.activeSpinners.clear();
+    }
+    getRunningCount() {
+        return this.activeSpinners.size;
+    }
+}
+exports.ProgressTracker = ProgressTracker;
+exports.default = Spinner;