@weldr/runr 0.3.1 → 0.7.2

package/dist/commands/continue.js

@@ -0,0 +1,276 @@
+/**
+ * runr continue - The "do the obvious next thing" command.
+ *
+ * This is the router that makes Runr feel like Rails:
+ * - If STOPPED with auto-fixable issue: run fix commands, then resume
+ * - If STOPPED with auto-resume reason: just resume
+ * - If orchestration cursor exists: continue orchestration
+ * - Otherwise: print the front door
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { resolveRepoState } from '../ux/state.js';
+import { computeBrain } from '../ux/brain.js';
+import { formatFrontDoor } from '../ux/render.js';
+import { getRunsRoot } from '../store/runs-root.js';
+import { resumeCommand } from './resume.js';
+import { recordContinueAttempt, recordAutoFixStep, recordContinueFailed, recordContinueSuccess, } from '../ux/telemetry.js';
+/**
+ * Execute a canonical command and capture output.
+ */
+async function executeCommand(cmd, cwd) {
+    const startTime = Date.now();
+    return new Promise((resolve) => {
+        const proc = spawn(cmd.binary, cmd.args, {
+            cwd,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            resolve({
+                command: cmd.raw,
+                exitCode: code ?? 1,
+                stdout,
+                stderr,
+                durationMs: Date.now() - startTime,
+            });
+        });
+        proc.on('error', (err) => {
+            resolve({
+                command: cmd.raw,
+                exitCode: 1,
+                stdout,
+                stderr: stderr + '\n' + err.message,
+                durationMs: Date.now() - startTime,
+            });
+        });
+    });
+}
+/**
+ * Slugify a command for use in filenames.
+ */
+function slugify(cmd) {
+    return cmd
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .toLowerCase()
+        .slice(0, 50);
+}
+/**
+ * Execute auto-fix commands and write artifacts.
+ */
+async function executeAutoFix(runId, commands, repoPath) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const runsRoot = getRunsRoot(repoPath);
+    const artifactDir = path.join(runsRoot, runId, 'artifacts', 'continue', timestamp);
+    // Create artifact directory
+    fs.mkdirSync(artifactDir, { recursive: true });
+    const artifact = {
+        timestamp: new Date().toISOString(),
+        runId,
+        strategy: 'auto_fix',
+        commands: [],
+        success: false,
+    };
+    let success = true;
+    for (let i = 0; i < commands.length; i++) {
+        const cmd = commands[i];
+        console.log(`Running: ${cmd.raw}`);
+        const result = await executeCommand(cmd, repoPath);
+        // Write log file
+        const logFileName = `${i + 1}-${slugify(cmd.raw)}.log`;
+        const logPath = path.join(artifactDir, logFileName);
+        const logContent = [
+            `Command: ${cmd.raw}`,
+            `Exit code: ${result.exitCode}`,
+            `Duration: ${result.durationMs}ms`,
+            '',
+            '=== STDOUT ===',
+            result.stdout,
+            '',
+            '=== STDERR ===',
+            result.stderr,
+        ].join('\n');
+        fs.writeFileSync(logPath, logContent);
+        // Record in artifact
+        artifact.commands.push({
+            command: cmd.raw,
+            exitCode: result.exitCode,
+            durationMs: result.durationMs,
+            logPath: logFileName,
+        });
+        // Record telemetry for each step
+        recordAutoFixStep(repoPath, runId, i, cmd.raw, result.exitCode);
+        // Check for failure
+        if (result.exitCode !== 0) {
+            console.log(`  Failed (exit ${result.exitCode})`);
+            artifact.success = false;
+            artifact.failedAt = i;
+            artifact.error = `Command "${cmd.raw}" failed with exit code ${result.exitCode}`;
+            success = false;
+            break;
+        }
+        console.log(`  OK (${result.durationMs}ms)`);
+    }
+    if (success) {
+        artifact.success = true;
+    }
+    // Write continue.json
+    const artifactPath = path.join(artifactDir, 'continue.json');
+    fs.writeFileSync(artifactPath, JSON.stringify(artifact, null, 2));
+    return { success, artifact };
+}
+/**
+ * Load diagnosis data for a stopped run.
+ */
+function loadDiagnosisData(stopJsonPath, diagnosticsPath) {
+    let stopDiagnosis = null;
+    let stopExplainer = null;
+    if (stopJsonPath && fs.existsSync(stopJsonPath)) {
+        try {
+            stopDiagnosis = JSON.parse(fs.readFileSync(stopJsonPath, 'utf-8'));
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    if (diagnosticsPath && fs.existsSync(diagnosticsPath)) {
+        try {
+            stopExplainer = JSON.parse(fs.readFileSync(diagnosticsPath, 'utf-8'));
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    return { stopDiagnosis, stopExplainer };
+}
+/**
+ * Print front door and exit.
+ */
+function printFrontDoorAndExit(brainOutput) {
+    console.log(formatFrontDoor(brainOutput));
+}
+/**
+ * Main continue command.
+ */
+export async function continueCommand(options) {
+    const repoPath = options.repo || process.cwd();
+    // Resolve repo state
+    const state = await resolveRepoState(repoPath);
+    // Load diagnosis data if we have a stopped run
+    let stopDiagnosis = null;
+    let stopExplainer = null;
+    if (state.latestStopped) {
+        const diagData = loadDiagnosisData(state.latestStopped.stopJsonPath, state.latestStopped.diagnosticsPath);
+        stopDiagnosis = diagData.stopDiagnosis;
+        stopExplainer = diagData.stopExplainer;
+    }
+    // Compute brain output
+    const brainOutput = computeBrain({
+        state,
+        stopDiagnosis,
+        stopExplainer,
+    });
+    const strategy = brainOutput.continueStrategy;
+    // Extract runId for telemetry (varies by strategy type)
+    const runIdForTelemetry = strategy.type === 'auto_resume' || strategy.type === 'auto_fix'
+        ? strategy.runId
+        : strategy.type === 'manual'
+            ? strategy.runId
+            : undefined;
+    // Record continue attempt with analysis for debugging
+    recordContinueAttempt(repoPath, runIdForTelemetry, strategy, brainOutput.stoppedAnalysis);
+    // Route based on strategy
+    switch (strategy.type) {
+        case 'auto_resume': {
+            console.log(`Auto-resuming run ${strategy.runId}...`);
+            await resumeCommand({
+                runId: strategy.runId,
+                time: 120,
+                maxTicks: 50,
+                allowDeps: false,
+                force: options.force ?? false,
+                repo: repoPath,
+                autoResume: true,
+            });
+            recordContinueSuccess(repoPath, strategy.runId, 'auto_resume');
+            break;
+        }
+        case 'auto_fix': {
+            // Check for ledger mode with --force
+            if (state.mode === 'ledger' && !options.force) {
+                console.error('Error: Ledger mode requires --force for auto-fix.');
+                console.error('Suggested: runr continue --force');
+                recordContinueFailed(repoPath, strategy.runId, 'ledger_mode_requires_force');
+                process.exitCode = 1;
+                return;
+            }
+            // Check for dirty tree in ledger mode
+            if (state.mode === 'ledger' && state.treeStatus === 'dirty' && !options.force) {
+                console.error('Error: Working tree is dirty and mode is ledger.');
+                console.error('Commit or stash changes first, or use --force.');
+                recordContinueFailed(repoPath, strategy.runId, 'dirty_tree_in_ledger_mode');
+                process.exitCode = 1;
+                return;
+            }
+            console.log(`Auto-fixing run ${strategy.runId}...`);
+            console.log(`Running ${strategy.commands.length} command(s):\n`);
+            const { success, artifact } = await executeAutoFix(strategy.runId, strategy.commands, repoPath);
+            if (!success) {
+                console.log('\nAuto-fix failed.');
+                console.log(`Artifact written: .runr/runs/${strategy.runId}/artifacts/continue/${artifact.timestamp.replace(/[:.]/g, '-')}/continue.json`);
+                console.log('\nNext steps:');
+                console.log(`  1) runr report ${strategy.runId}`);
+                console.log(`  2) runr intervene ${strategy.runId} --reason auto_fix_failed --note "..."`);
+                console.log(`  3) runr resume ${strategy.runId}`);
+                recordContinueFailed(repoPath, strategy.runId, 'auto_fix_command_failed', artifact.failedAt);
+                process.exitCode = 1;
+                return;
+            }
+            console.log('\nAuto-fix complete. Resuming...\n');
+            await resumeCommand({
+                runId: strategy.runId,
+                time: 120,
+                maxTicks: 50,
+                allowDeps: false,
+                force: options.force ?? false,
+                repo: repoPath,
+                autoResume: true,
+            });
+            recordContinueSuccess(repoPath, strategy.runId, 'auto_fix');
+            break;
+        }
+        case 'continue_orch': {
+            console.log(`Continuing orchestration ${strategy.orchestratorId}...`);
+            // Import and call the orchestration resume command
+            const { resumeOrchestrationCommand } = await import('./orchestrate.js');
+            await resumeOrchestrationCommand({
+                orchestratorId: strategy.orchestratorId,
+                repo: repoPath,
+            });
+            recordContinueSuccess(repoPath, undefined, 'continue_orch');
+            break;
+        }
+        case 'manual': {
+            console.log(`Cannot auto-continue: ${strategy.blockedReason}`);
+            console.log('');
+            printFrontDoorAndExit(brainOutput);
+            // Not recording as failure - manual is an expected outcome
+            break;
+        }
+        case 'nothing': {
+            printFrontDoorAndExit(brainOutput);
+            // Not recording - nothing to do is not a failure
+            break;
+        }
+    }
+}