@weldr/runr 0.4.0 → 0.7.3

package/dist/commands/meta.js

@@ -0,0 +1,245 @@
+import { execa } from 'execa';
+import path from 'node:path';
+import fs from 'node:fs';
+import { getRunrPaths } from '../store/runs-root.js';
+/**
+ * Detect which meta-agent tool is available
+ */
+async function detectTool() {
+    // Try Claude Code first
+    try {
+        const result = await execa('claude', ['--version'], {
+            timeout: 5000,
+            reject: false
+        });
+        if (result.exitCode === 0) {
+            return 'claude';
+        }
+    }
+    catch {
+        // Claude not found, continue
+    }
+    // Try Codex CLI
+    try {
+        const result = await execa('codex', ['--version'], {
+            timeout: 5000,
+            reject: false
+        });
+        if (result.exitCode === 0) {
+            return 'codex';
+        }
+    }
+    catch {
+        // Codex not found
+    }
+    return null;
+}
+/**
+ * Check if working tree is clean
+ */
+async function checkWorkingTree(repoPath) {
+    try {
+        const result = await execa('git', ['status', '--porcelain'], {
+            cwd: repoPath,
+            reject: false
+        });
+        if (result.exitCode !== 0) {
+            throw new Error('git status failed');
+        }
+        const lines = result.stdout.trim().split('\n').filter(line => line.length > 0);
+        return {
+            clean: lines.length === 0,
+            uncommittedCount: lines.length
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to check working tree: ${error.message}`);
+    }
+}
+/**
+ * Check if repository is properly set up for Runr
+ */
+function checkRepoSetup(repoPath) {
+    const paths = getRunrPaths(repoPath);
+    const configPath = path.join(paths.runr_root, 'runr.config.json');
+    const gitignorePath = path.join(repoPath, '.gitignore');
+    const agentsMdPath = path.join(repoPath, 'AGENTS.md');
+    const configExists = fs.existsSync(configPath);
+    const agentsMdExists = fs.existsSync(agentsMdPath);
+    // Check gitignore
+    let gitignoreOk = false;
+    try {
+        const content = fs.readFileSync(gitignorePath, 'utf-8');
+        const lines = content.split('\n').map(l => l.trim());
+        gitignoreOk = lines.some(line => line.startsWith('.runr/') || line === '.runr' || line === '.runr/');
+    }
+    catch {
+        // .gitignore doesn't exist
+    }
+    const missingSetup = [];
+    if (!configExists)
+        missingSetup.push('.runr/runr.config.json');
+    if (!gitignoreOk)
+        missingSetup.push('.gitignore entries');
+    if (!agentsMdExists)
+        missingSetup.push('AGENTS.md');
+    return {
+        configExists,
+        gitignoreOk,
+        agentsMdExists,
+        missingSetup
+    };
+}
+/**
+ * Check Claude Code integration status
+ */
+function checkClaudeIntegration(repoPath) {
+    const skillPath = path.join(repoPath, '.claude/skills/runr-workflow/SKILL.md');
+    const commandPaths = [
+        path.join(repoPath, '.claude/commands/runr-bundle.md'),
+        path.join(repoPath, '.claude/commands/runr-submit.md'),
+        path.join(repoPath, '.claude/commands/runr-resume.md')
+    ];
+    const skillsPresent = fs.existsSync(skillPath);
+    const commandsPresent = commandPaths.every(p => fs.existsSync(p));
+    const missingFiles = [];
+    if (!skillsPresent)
+        missingFiles.push('.claude/skills/runr-workflow/SKILL.md');
+    commandPaths.forEach(p => {
+        if (!fs.existsSync(p)) {
+            missingFiles.push(path.relative(repoPath, p));
+        }
+    });
+    return {
+        skillsPresent,
+        commandsPresent,
+        missingFiles
+    };
+}
+/**
+ * Launch the meta-agent tool
+ */
+async function launchTool(tool, repoPath, interactive) {
+    console.log(`\nLaunching ${tool === 'claude' ? 'Claude Code' : 'Codex CLI'} with Runr workflow...\n`);
+    if (tool === 'claude') {
+        console.log('Agent will follow rules from:');
+        console.log('- AGENTS.md (workflow guide)');
+        const claudeCheck = checkClaudeIntegration(repoPath);
+        if (claudeCheck.skillsPresent) {
+            console.log('- .claude/skills/runr-workflow (safety playbook)');
+        }
+        if (claudeCheck.commandsPresent) {
+            console.log('- .claude/commands/ (runr shortcuts)');
+        }
+    }
+    else {
+        console.log('Agent will follow rules from:');
+        console.log('- AGENTS.md (workflow guide, read by Codex)');
+    }
+    if (!interactive && tool === 'claude') {
+        console.log('\nPermission mode: skip all permissions (allows Bash, Edit, etc.)');
+    }
+    console.log('Exit with Ctrl+C\n');
+    console.log('─'.repeat(60));
+    console.log();
+    // Launch the tool in interactive mode
+    try {
+        // Build args based on tool
+        const args = [];
+        if (tool === 'claude' && !interactive) {
+            // Use dangerously-skip-permissions to bypass all confirmation dialogs
+            // This matches what Runr uses when running Claude as a worker
+            // Allows the agent to use Bash (for runr commands), Edit, and other tools
+            args.push('--dangerously-skip-permissions');
+        }
+        await execa(tool, args, {
+            cwd: repoPath,
+            stdio: 'inherit'
+        });
+    }
+    catch (error) {
+        // User likely pressed Ctrl+C
+        console.log('\nMeta-agent session ended.');
+    }
+}
+/**
+ * Main meta command implementation
+ */
+export async function metaCommand(options) {
+    const repoPath = path.resolve(options.repo || '.');
+    // Step 1: Detect tool
+    let tool;
+    if (options.tool === 'auto' || !options.tool) {
+        const detected = await detectTool();
+        if (!detected) {
+            console.error('❌ No meta-agent tool found\n');
+            console.error('Install one of:');
+            console.error('  • Claude Code: https://code.claude.com');
+            console.error('  • Codex CLI: https://github.com/openai/codex-cli');
+            process.exit(2);
+        }
+        tool = detected;
+    }
+    else {
+        tool = options.tool;
+        // Verify the requested tool is available
+        const detected = await detectTool();
+        if (detected !== tool) {
+            console.error(`❌ Requested tool "${tool}" not found`);
+            console.error('Run with --tool auto to detect available tools');
+            process.exit(2);
+        }
+    }
+    // Step 2: Check working tree
+    try {
+        const treeCheck = await checkWorkingTree(repoPath);
+        if (!treeCheck.clean) {
+            if (options.allowDirty) {
+                console.log('⚠️  WARNING: Working tree has uncommitted changes\n');
+                console.log('Running agents on uncommitted work risks data loss.');
+                console.log('You used --allow-dirty to override this safety check.\n');
+            }
+            else {
+                console.error('⛔ BLOCKED: Working tree has uncommitted changes\n');
+                console.error('Running agents on uncommitted work risks data loss.\n');
+                console.error('Fix with:');
+                console.error('  git commit -am "WIP: save before agent"');
+                console.error('  # OR');
+                console.error('  git stash\n');
+                console.error('To override (not recommended):');
+                console.error('  runr meta --allow-dirty');
+                process.exit(1);
+            }
+        }
+    }
+    catch (error) {
+        console.error(`❌ Failed to check working tree: ${error.message}`);
+        process.exit(1);
+    }
+    // Step 3: Check repo setup
+    const setup = checkRepoSetup(repoPath);
+    if (setup.missingSetup.length > 0) {
+        console.error('⚠️  Incomplete Runr setup\n');
+        console.error('Missing:');
+        setup.missingSetup.forEach(item => console.error(`  • ${item}`));
+        console.error('\nFix with:');
+        console.error('  runr init --pack solo');
+        console.error();
+        process.exit(1);
+    }
+    // Step 4: Claude-specific checks
+    if (tool === 'claude') {
+        const claudeCheck = checkClaudeIntegration(repoPath);
+        if (!claudeCheck.skillsPresent || !claudeCheck.commandsPresent) {
+            console.log('💡 Tip: Claude Code integration incomplete\n');
+            console.log('Missing:');
+            claudeCheck.missingFiles.forEach(file => console.log(`  • ${file}`));
+            console.log('\nFor better integration, run:');
+            console.log('  runr init --pack solo --with-claude\n');
+            console.log('(This will add Claude Code skills and commands)\n');
+            // Don't block, just inform
+        }
+    }
+    // Step 5: Launch tool
+    await launchTool(tool, repoPath, options.interactive || false);
+}

package/dist/commands/mode.js

@@ -0,0 +1,157 @@
+/**
+ * runr mode - View or set workflow mode
+ *
+ * Mode determines how strictly Runr enforces audit trail requirements:
+ * - flow: Productivity-first, interventions allowed freely
+ * - ledger: Audit-first, stricter controls on interventions
+ *
+ * Usage:
+ *   runr mode             # Show current mode
+ *   runr mode flow        # Set mode to flow
+ *   runr mode ledger      # Set mode to ledger
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig, resolveConfigPath } from '../config/load.js';
+const VALID_MODES = ['flow', 'ledger'];
+/**
+ * Get current mode from config.
+ */
+export function getCurrentMode(repoPath) {
+    try {
+        const configPath = resolveConfigPath(repoPath);
+        if (!fs.existsSync(configPath)) {
+            return 'flow';
+        }
+        const config = loadConfig(configPath);
+        return config.workflow?.mode || 'flow';
+    }
+    catch {
+        return 'flow';
+    }
+}
+/**
+ * Print mode banner (called at start of commands).
+ */
+export function printModeBanner(repoPath) {
+    const mode = getCurrentMode(repoPath);
+    const version = '0.7.0'; // TODO: Read from package.json
+    console.log(`Runr v${version} | Mode: ${mode}`);
+}
+/**
+ * Check if a mode-restricted operation is allowed.
+ */
+export function checkModeRestriction(repoPath, operation, forceOverride) {
+    const mode = getCurrentMode(repoPath);
+    if (forceOverride) {
+        return { allowed: true };
+    }
+    if (mode === 'ledger') {
+        switch (operation) {
+            case 'amend_last':
+                return {
+                    allowed: false,
+                    error: `Error: --amend-last is not allowed in Ledger mode.
+In Ledger mode, use explicit commits:
+  runr intervene <run_id> --commit "message" --reason <reason>
+Or switch to Flow mode with: runr config mode flow`
+                };
+        }
+    }
+    return { allowed: true };
+}
+/**
+ * Set mode in config file.
+ */
+function setMode(repoPath, newMode) {
+    const configPath = resolveConfigPath(repoPath);
+    const configExists = fs.existsSync(configPath);
+    if (!configExists) {
+        // Create new config
+        const dir = path.dirname(configPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const newConfig = {
+            workflow: {
+                mode: newMode,
+                profile: 'solo',
+                integration_branch: 'dev',
+                release_branch: 'main'
+            }
+        };
+        fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2));
+        return;
+    }
+    // Update existing config
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(content);
+        if (!config.workflow) {
+            config.workflow = {};
+        }
+        config.workflow.mode = newMode;
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+    catch (err) {
+        throw new Error(`Failed to update config: ${err.message}`);
+    }
+}
+/**
+ * Mode command: View or set workflow mode.
+ */
+export async function modeCommand(options) {
+    const { repo, newMode } = options;
+    if (newMode) {
+        // Validate mode
+        if (!VALID_MODES.includes(newMode)) {
+            console.error(`Error: Invalid mode '${newMode}'`);
+            console.error(`Valid modes: ${VALID_MODES.join(', ')}`);
+            process.exitCode = 1;
+            return;
+        }
+        // Set mode
+        try {
+            setMode(repo, newMode);
+            console.log(`Mode set to: ${newMode}`);
+            if (newMode === 'ledger') {
+                console.log('');
+                console.log('Ledger mode restrictions:');
+                console.log('  - --amend-last is not allowed');
+                console.log('  - All merges should go through runr submit');
+                console.log('  - Higher audit coverage expectations');
+            }
+            else {
+                console.log('');
+                console.log('Flow mode enabled:');
+                console.log('  - Interventions allowed freely');
+                console.log('  - --amend-last allowed');
+                console.log('  - Flexible workflow for productivity');
+            }
+        }
+        catch (err) {
+            console.error(err.message);
+            process.exitCode = 1;
+        }
+    }
+    else {
+        // Show current mode
+        const mode = getCurrentMode(repo);
+        console.log(`Current mode: ${mode}`);
+        console.log('');
+        if (mode === 'flow') {
+            console.log('Flow mode (productivity-first):');
+            console.log('  - Interventions allowed freely');
+            console.log('  - --amend-last allowed');
+            console.log('  - Flexible workflow');
+        }
+        else {
+            console.log('Ledger mode (audit-first):');
+            console.log('  - --amend-last not allowed');
+            console.log('  - Strict audit trail');
+            console.log('  - All changes through runr submit');
+        }
+        console.log('');
+        console.log('To change mode: runr config mode <flow|ledger>');
+    }
+}

package/dist/commands/orchestrate.js

@@ -798,3 +798,32 @@ function outputWaitResult(result, json, elapsedMs) {
         }
     }
 }
+/**
+ * Generate and display orchestration receipt.
+ */
+export async function receiptCommand(options) {
+    const { getReceipt, writeReceipt, generateReceiptMarkdown } = await import('../orchestrator/receipt.js');
+    const repoPath = path.resolve(options.repo);
+    // Get receipt (from cache or generate from state)
+    const receipt = getReceipt(repoPath, options.orchestratorId);
+    if (!receipt) {
+        console.error(`Orchestration not found: ${options.orchestratorId}`);
+        process.exitCode = 1;
+        return;
+    }
+    // Write artifacts if requested
+    if (options.write) {
+        const paths = writeReceipt(receipt, repoPath);
+        console.log(`Receipt written:`);
+        console.log(`  JSON: ${paths.json}`);
+        console.log(`  MD: ${paths.md}`);
+        console.log('');
+    }
+    // Output
+    if (options.json) {
+        console.log(JSON.stringify(receipt, null, 2));
+    }
+    else {
+        console.log(generateReceiptMarkdown(receipt));
+    }
+}

package/dist/commands/packs.js

@@ -0,0 +1,47 @@
+import { loadAllPacks, getPacksDirectory } from '../packs/loader.js';
+/**
+ * List available packs
+ */
+export async function packsCommand(options = {}) {
+    const packs = loadAllPacks();
+    if (options.verbose) {
+        console.log(`Loading packs from: ${getPacksDirectory()}\n`);
+    }
+    if (packs.length === 0) {
+        console.log('No packs found.');
+        console.log('');
+        console.log('Packs are workflow presets that provide:');
+        console.log('  • Default configuration (branches, verification)');
+        console.log('  • Documentation templates (AGENTS.md, CLAUDE.md)');
+        console.log('  • Idempotent initialization actions');
+        return;
+    }
+    const validPacks = packs.filter(p => p.validation.valid);
+    const invalidPacks = packs.filter(p => !p.validation.valid);
+    console.log('Available workflow packs:\n');
+    // Display valid packs
+    for (const pack of validPacks) {
+        console.log(`  \x1b[1m${pack.name}\x1b[0m`);
+        console.log(`    ${pack.manifest.description}`);
+        console.log('');
+    }
+    if (validPacks.length > 0) {
+        console.log('Usage:');
+        console.log(`  runr init --pack solo             # Solo dev workflow (dev→main)`);
+        console.log(`  runr init --pack pr               # PR workflow (feature→main)`);
+        console.log(`  runr init --pack trunk            # Trunk-based (main only)`);
+        console.log(`  runr init --pack solo --dry-run   # Preview changes`);
+        console.log('');
+    }
+    // Display invalid packs
+    if (invalidPacks.length > 0) {
+        console.log('\x1b[33mInvalid packs:\x1b[0m\n');
+        for (const pack of invalidPacks) {
+            console.log(`  ${pack.name}`);
+            for (const error of pack.validation.errors) {
+                console.log(`    ❌ ${error}`);
+            }
+            console.log('');
+        }
+    }
+}

package/dist/commands/preflight.js

@@ -72,12 +72,15 @@ export async function runPreflight(options) {
         }
     }
     // Check worker binaries exist (cheaper than ping, catches "command not found")
+    // Only check workers that are actually used by phases
     const workers = options.config.workers;
+    const phases = options.config.phases;
+    const usedWorkers = new Set([phases.plan, phases.implement, phases.review]);
     const binaryCheckPromises = [];
-    if (workers.claude) {
+    if (workers.claude && usedWorkers.has('claude')) {
         binaryCheckPromises.push(checkWorkerBinary('claude', workers.claude));
     }
-    if (workers.codex) {
+    if (workers.codex && usedWorkers.has('codex')) {
         binaryCheckPromises.push(checkWorkerBinary('codex', workers.codex));
     }
     const binaryResults = await Promise.all(binaryCheckPromises);
@@ -103,12 +106,12 @@ export async function runPreflight(options) {
     }
     else {
         const pingResults = [];
-        // Ping all configured workers in parallel
+        // Ping all workers that are actually used by phases
         const pingPromises = [];
-        if (workers.claude) {
+        if (workers.claude && usedWorkers.has('claude')) {
             pingPromises.push(pingClaude(workers.claude));
         }
-        if (workers.codex) {
+        if (workers.codex && usedWorkers.has('codex')) {
             pingPromises.push(pingCodex(workers.codex));
         }
         const results = await Promise.all(pingPromises);