@weldr/runr 0.3.0

package/dist/commands/compare.js

@@ -0,0 +1,168 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { computeKpiFromEvents } from './report.js';
+import { getRunsRoot } from '../store/runs-root.js';
+export async function compareCommand(options) {
+    const result = await loadComparison(options);
+    const output = formatComparison(result);
+    console.log(output);
+}
+async function loadComparison(options) {
+    const kpiA = await loadKpiForRun(options.runA, options.repo);
+    const kpiB = await loadKpiForRun(options.runB, options.repo);
+    return {
+        runA: { id: options.runA, kpi: kpiA },
+        runB: { id: options.runB, kpi: kpiB }
+    };
+}
+async function loadKpiForRun(runId, repoPath) {
+    const runDir = path.join(getRunsRoot(repoPath), runId);
+    if (!fs.existsSync(runDir)) {
+        throw new Error(`Run not found: ${runDir}`);
+    }
+    const timelinePath = path.join(runDir, 'timeline.jsonl');
+    if (!fs.existsSync(timelinePath)) {
+        throw new Error(`Timeline not found: ${timelinePath}`);
+    }
+    const events = await readTimelineEvents(timelinePath);
+    return computeKpiFromEvents(events);
+}
+async function readTimelineEvents(timelinePath) {
+    const events = [];
+    const stream = fs.createReadStream(timelinePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            events.push(JSON.parse(trimmed));
+        }
+        catch {
+            continue;
+        }
+    }
+    return events;
+}
+function formatComparison(result) {
+    const { runA, runB } = result;
+    const lines = [];
+    lines.push('Compare');
+    lines.push(`  A: ${runA.id}`);
+    lines.push(`  B: ${runB.id}`);
+    lines.push('');
+    // Duration comparison
+    lines.push('Duration');
+    const durA = runA.kpi.total_duration_ms;
+    const durB = runB.kpi.total_duration_ms;
+    lines.push(`  A: ${formatDuration(durA)}`);
+    lines.push(`  B: ${formatDuration(durB)}`);
+    lines.push(`  Δ: ${formatDelta(durA, durB)}`);
+    lines.push('');
+    // Unattributed comparison
+    lines.push('Unattributed');
+    const unA = runA.kpi.unattributed_ms;
+    const unB = runB.kpi.unattributed_ms;
+    lines.push(`  A: ${formatDuration(unA)}`);
+    lines.push(`  B: ${formatDuration(unB)}`);
+    lines.push(`  Δ: ${formatDelta(unA, unB)}`);
+    lines.push('');
+    // Worker calls
+    lines.push('Worker Calls');
+    lines.push(`  A: claude=${runA.kpi.workers.claude} codex=${runA.kpi.workers.codex}`);
+    lines.push(`  B: claude=${runB.kpi.workers.claude} codex=${runB.kpi.workers.codex}`);
+    const claudeDelta = formatWorkerDelta(runA.kpi.workers.claude, runB.kpi.workers.claude);
+    const codexDelta = formatWorkerDelta(runA.kpi.workers.codex, runB.kpi.workers.codex);
+    lines.push(`  Δ: claude=${claudeDelta} codex=${codexDelta}`);
+    lines.push('');
+    // Verification
+    lines.push('Verification');
+    lines.push(`  A: attempts=${runA.kpi.verify.attempts} retries=${runA.kpi.verify.retries} duration=${formatDuration(runA.kpi.verify.total_duration_ms)}`);
+    lines.push(`  B: attempts=${runB.kpi.verify.attempts} retries=${runB.kpi.verify.retries} duration=${formatDuration(runB.kpi.verify.total_duration_ms)}`);
+    const attemptsDelta = runB.kpi.verify.attempts - runA.kpi.verify.attempts;
+    const retriesDelta = runB.kpi.verify.retries - runA.kpi.verify.retries;
+    const verifyDurDelta = formatDelta(runA.kpi.verify.total_duration_ms, runB.kpi.verify.total_duration_ms);
+    lines.push(`  Δ: attempts=${formatNumDelta(attemptsDelta)} retries=${formatNumDelta(retriesDelta)} duration=${verifyDurDelta}`);
+    lines.push('');
+    // Milestones
+    lines.push('Milestones');
+    lines.push(`  A: ${runA.kpi.milestones.completed}`);
+    lines.push(`  B: ${runB.kpi.milestones.completed}`);
+    const msDelta = runB.kpi.milestones.completed - runA.kpi.milestones.completed;
+    lines.push(`  Δ: ${formatNumDelta(msDelta)}`);
+    lines.push('');
+    // Phase comparison
+    lines.push('Phases');
+    const allPhases = new Set([
+        ...Object.keys(runA.kpi.phases),
+        ...Object.keys(runB.kpi.phases)
+    ]);
+    const phaseOrder = ['PLAN', 'IMPLEMENT', 'VERIFY', 'REVIEW', 'CHECKPOINT', 'FINALIZE'];
+    const sortedPhases = [...allPhases].sort((a, b) => {
+        const aIdx = phaseOrder.indexOf(a);
+        const bIdx = phaseOrder.indexOf(b);
+        if (aIdx === -1 && bIdx === -1)
+            return a.localeCompare(b);
+        if (aIdx === -1)
+            return 1;
+        if (bIdx === -1)
+            return -1;
+        return aIdx - bIdx;
+    });
+    for (const phase of sortedPhases) {
+        const pA = runA.kpi.phases[phase] ?? { duration_ms: 0, count: 0 };
+        const pB = runB.kpi.phases[phase] ?? { duration_ms: 0, count: 0 };
+        const durDelta = formatDelta(pA.duration_ms, pB.duration_ms);
+        const countDelta = pB.count - pA.count;
+        const highlight = pB.duration_ms > pA.duration_ms * 1.2 ? ' ⚠️' : '';
+        lines.push(`  ${phase}: A=${formatDuration(pA.duration_ms)}(x${pA.count}) B=${formatDuration(pB.duration_ms)}(x${pB.count}) Δ=${durDelta}(${formatNumDelta(countDelta)})${highlight}`);
+    }
+    lines.push('');
+    // Outcome
+    lines.push('Outcome');
+    lines.push(`  A: ${runA.kpi.outcome}${runA.kpi.stop_reason ? ` (${runA.kpi.stop_reason})` : ''}`);
+    lines.push(`  B: ${runB.kpi.outcome}${runB.kpi.stop_reason ? ` (${runB.kpi.stop_reason})` : ''}`);
+    return lines.join('\n');
+}
+function formatDuration(ms) {
+    if (ms === null)
+        return 'unknown';
+    if (ms < 0)
+        return `-${formatPositiveDuration(Math.abs(ms))}`;
+    return formatPositiveDuration(ms);
+}
+function formatPositiveDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60) {
+        return remainingSeconds > 0 ? `${minutes}m${remainingSeconds}s` : `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h${remainingMinutes}m` : `${hours}h`;
+}
+function formatDelta(a, b) {
+    if (a === null || b === null)
+        return 'n/a';
+    const diff = b - a;
+    if (diff === 0)
+        return '0';
+    const sign = diff > 0 ? '+' : '-';
+    return `${sign}${formatPositiveDuration(Math.abs(diff))}`;
+}
+function formatNumDelta(diff) {
+    if (diff === 0)
+        return '0';
+    return diff > 0 ? `+${diff}` : `${diff}`;
+}
+function formatWorkerDelta(a, b) {
+    if (a === 'unknown' || b === 'unknown')
+        return 'n/a';
+    return formatNumDelta(b - a);
+}

package/dist/commands/doctor.js

@@ -0,0 +1,124 @@
+import { execa } from 'execa';
+import path from 'node:path';
+import { loadConfig, resolveConfigPath } from '../config/load.js';
+async function checkWorker(name, worker, repoPath) {
+    const result = {
+        name,
+        bin: worker.bin,
+        version: null,
+        headless: false,
+        error: null
+    };
+    // Check version
+    try {
+        const versionResult = await execa(worker.bin, ['--version'], {
+            timeout: 5000,
+            reject: false
+        });
+        if (versionResult.exitCode === 0) {
+            result.version = versionResult.stdout.trim().split('\n')[0];
+        }
+        else {
+            result.error = `Version check failed: ${versionResult.stderr || 'unknown error'}`;
+            return result;
+        }
+    }
+    catch (err) {
+        result.error = `Command not found: ${worker.bin}`;
+        return result;
+    }
+    // Check headless mode with a simple ping
+    try {
+        const testPrompt = 'Respond with exactly: PING_OK';
+        let testArgs;
+        if (name === 'codex') {
+            testArgs = ['exec', '--full-auto', '--json', '-C', repoPath];
+        }
+        else {
+            testArgs = ['-p', '--output-format', 'json', '--dangerously-skip-permissions'];
+        }
+        const headlessResult = await execa(worker.bin, testArgs, {
+            input: testPrompt,
+            timeout: 30000,
+            reject: false,
+            cwd: repoPath
+        });
+        if (headlessResult.exitCode === 0) {
+            result.headless = true;
+        }
+        else {
+            const stderr = headlessResult.stderr || '';
+            if (stderr.includes('stdin is not a terminal')) {
+                result.error = 'Headless mode not supported (stdin is not a terminal)';
+            }
+            else {
+                result.error = `Headless test failed: ${stderr.slice(0, 100)}`;
+            }
+        }
+    }
+    catch (err) {
+        result.error = `Headless test error: ${err.message}`;
+    }
+    return result;
+}
+export async function runDoctorChecks(config, repoPath) {
+    const checks = [];
+    for (const [name, workerConfig] of Object.entries(config.workers)) {
+        const check = await checkWorker(name, workerConfig, repoPath);
+        checks.push(check);
+    }
+    return checks;
+}
+export async function doctorCommand(options) {
+    const repoPath = path.resolve(options.repo || '.');
+    const configPath = resolveConfigPath(repoPath, options.config);
+    console.log('Doctor Check');
+    console.log('============\n');
+    let config;
+    try {
+        config = loadConfig(configPath);
+        console.log(`Config: ${configPath}`);
+        console.log(`Repo: ${repoPath}\n`);
+    }
+    catch (err) {
+        console.log(`Config: FAIL - ${err.message}`);
+        process.exitCode = 1;
+        return;
+    }
+    const checks = await runDoctorChecks(config, repoPath);
+    console.log('Workers\n-------');
+    for (const check of checks) {
+        const status = check.error ? 'FAIL' : 'PASS';
+        const version = check.version || 'unknown';
+        const headless = check.headless ? 'headless OK' : 'headless FAIL';
+        console.log(`${check.name}: ${status}`);
+        console.log(`  bin: ${check.bin}`);
+        console.log(`  version: ${version}`);
+        console.log(`  ${headless}`);
+        if (check.error) {
+            console.log(`  error: ${check.error}`);
+        }
+        console.log('');
+    }
+    // Show phase configuration
+    console.log('Phases\n------');
+    console.log(`  plan: ${config.phases.plan}`);
+    console.log(`  implement: ${config.phases.implement}`);
+    console.log(`  review: ${config.phases.review}`);
+    console.log('');
+    // Check that configured phase workers are available
+    const phaseWorkers = new Set([config.phases.plan, config.phases.implement, config.phases.review]);
+    const failedWorkers = checks.filter((c) => c.error).map((c) => c.name);
+    const usedButFailed = [...phaseWorkers].filter((w) => failedWorkers.includes(w));
+    const failed = checks.filter((c) => c.error);
+    if (failed.length > 0) {
+        console.log(`\nResult: ${failed.length} worker(s) failed`);
+        if (usedButFailed.length > 0) {
+            console.log(`Warning: Phase(s) configured to use failed worker(s): ${usedButFailed.join(', ')}`);
+        }
+        process.exitCode = 1;
+    }
+    else {
+        console.log('\nResult: All workers OK');
+    }
+}

package/dist/commands/follow.js

@@ -0,0 +1,251 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { getRunsRoot } from '../store/runs-root.js';
+const TERMINAL_PHASES = ['STOPPED', 'DONE'];
+const POLL_INTERVAL_MS = 1000;
+/**
+ * Find the best run to follow: prefer running runs, else latest.
+ * Returns { runId, wasRunning } so caller can inform user.
+ */
+export function findBestRunToFollow(repoPath) {
+    const runsDir = getRunsRoot(repoPath);
+    if (!fs.existsSync(runsDir)) {
+        return null;
+    }
+    const runIds = fs
+        .readdirSync(runsDir, { withFileTypes: true })
+        .filter((e) => e.isDirectory() && /^\d{14}$/.test(e.name))
+        .map((e) => e.name)
+        .sort()
+        .reverse();
+    if (runIds.length === 0) {
+        return null;
+    }
+    // Check for a running run (newest first)
+    for (const runId of runIds) {
+        const statePath = path.join(runsDir, runId, 'state.json');
+        if (!fs.existsSync(statePath))
+            continue;
+        try {
+            const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            if (!TERMINAL_PHASES.includes(state.phase)) {
+                return { runId, wasRunning: true };
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    // No running run, return latest
+    return { runId: runIds[0], wasRunning: false };
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60) {
+        return remainingSeconds > 0 ? `${minutes}m${remainingSeconds}s` : `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h${remainingMinutes}m` : `${hours}h`;
+}
+function readLastWorkerCall(runDir) {
+    const statePath = path.join(runDir, 'state.json');
+    if (!fs.existsSync(statePath))
+        return null;
+    try {
+        const content = fs.readFileSync(statePath, 'utf-8');
+        const state = JSON.parse(content);
+        if (state.last_worker_call && typeof state.last_worker_call === 'object') {
+            return state.last_worker_call;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function formatEvent(event) {
+    const time = new Date(event.timestamp).toLocaleTimeString();
+    const prefix = `[${time}] ${event.type}`;
+    switch (event.type) {
+        case 'run_started':
+            return `${prefix} - task: ${event.payload.task}`;
+        case 'preflight': {
+            const pf = event.payload;
+            const guardStatus = pf.guard?.ok ? 'pass' : 'FAIL';
+            const pingStatus = pf.ping?.skipped ? 'skipped' : pf.ping?.ok ? 'pass' : 'FAIL';
+            return `${prefix} - guard: ${guardStatus}, ping: ${pingStatus}`;
+        }
+        case 'phase_start':
+            return `${prefix} → ${event.payload.phase}`;
+        case 'plan_generated': {
+            const plan = event.payload;
+            const count = plan.milestones?.length ?? 0;
+            return `${prefix} - ${count} milestones`;
+        }
+        case 'implement_complete': {
+            const impl = event.payload;
+            const files = impl.changed_files?.length ?? 0;
+            return `${prefix} - ${files} files changed`;
+        }
+        case 'review_complete': {
+            const review = event.payload;
+            return `${prefix} - verdict: ${review.verdict}`;
+        }
+        case 'tier_passed':
+        case 'tier_failed': {
+            const tier = event.payload;
+            return `${prefix} - ${tier.tier} (${tier.passed ?? 0} passed, ${tier.failed ?? 0} failed)`;
+        }
+        case 'worker_fallback': {
+            const fb = event.payload;
+            return `${prefix} - ${fb.from} → ${fb.to} (${fb.reason})`;
+        }
+        case 'parse_failed': {
+            const pf = event.payload;
+            return `${prefix} - stage: ${pf.stage}, retry: ${pf.retry_count}`;
+        }
+        case 'late_worker_result_ignored': {
+            const late = event.payload;
+            return `${prefix} - ${late.stage} from ${late.worker}`;
+        }
+        case 'stop': {
+            const stop = event.payload;
+            const suffix = stop.worker_in_flight ? ' (worker was in-flight)' : '';
+            return `${prefix} - reason: ${stop.reason}${suffix}`;
+        }
+        case 'run_complete': {
+            const rc = event.payload;
+            return `${prefix} - outcome: ${rc.outcome}`;
+        }
+        case 'milestone_complete':
+            return `${prefix} - milestone ${event.payload.milestone_index}`;
+        case 'stalled_timeout': {
+            const st = event.payload;
+            const sec = st.elapsed_ms ? Math.round(st.elapsed_ms / 1000) : '?';
+            return `${prefix} - after ${sec}s`;
+        }
+        default:
+            return prefix;
+    }
+}
+async function tailTimeline(timelinePath, fromLine) {
+    if (!fs.existsSync(timelinePath)) {
+        return { events: [], newLineCount: 0 };
+    }
+    const events = [];
+    const fileStream = fs.createReadStream(timelinePath);
+    const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+    let lineNum = 0;
+    for await (const line of rl) {
+        lineNum++;
+        if (lineNum <= fromLine)
+            continue;
+        if (!line.trim())
+            continue;
+        try {
+            const event = JSON.parse(line);
+            events.push(event);
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return { events, newLineCount: lineNum };
+}
+function readState(statePath) {
+    if (!fs.existsSync(statePath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(statePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export async function followCommand(options) {
+    const runDir = path.join(getRunsRoot(options.repo), options.runId);
+    if (!fs.existsSync(runDir)) {
+        console.error(`Run directory not found: ${runDir}`);
+        process.exitCode = 1;
+        return;
+    }
+    const timelinePath = path.join(runDir, 'timeline.jsonl');
+    const statePath = path.join(runDir, 'state.json');
+    console.log(`Following run ${options.runId}...`);
+    console.log('---');
+    let lastLineCount = 0;
+    let terminated = false;
+    // Initial read of existing events
+    const initial = await tailTimeline(timelinePath, 0);
+    for (const event of initial.events) {
+        console.log(formatEvent(event));
+    }
+    lastLineCount = initial.newLineCount;
+    // Check if already terminated
+    const initialState = readState(statePath);
+    if (initialState && TERMINAL_PHASES.includes(initialState.phase)) {
+        console.log('---');
+        console.log(`Run already terminated: ${initialState.phase}`);
+        if (initialState.stop_reason) {
+            console.log(`Reason: ${initialState.stop_reason}`);
+        }
+        return;
+    }
+    // Poll for new events with progress age display
+    let lastStatusLine = '';
+    while (!terminated) {
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        const update = await tailTimeline(timelinePath, lastLineCount);
+        for (const event of update.events) {
+            // Clear status line before printing event
+            if (lastStatusLine) {
+                process.stdout.write('\r' + ' '.repeat(lastStatusLine.length) + '\r');
+                lastStatusLine = '';
+            }
+            console.log(formatEvent(event));
+        }
+        lastLineCount = update.newLineCount;
+        // Check for termination
+        const state = readState(statePath);
+        if (state && TERMINAL_PHASES.includes(state.phase)) {
+            terminated = true;
+            if (lastStatusLine) {
+                process.stdout.write('\r' + ' '.repeat(lastStatusLine.length) + '\r');
+            }
+            console.log('---');
+            console.log(`Run terminated: ${state.phase}`);
+            if (state.stop_reason) {
+                console.log(`Reason: ${state.stop_reason}`);
+            }
+        }
+        else if (state) {
+            // Show progress age status line
+            const progressAge = state.last_progress_at
+                ? formatDuration(Date.now() - new Date(state.last_progress_at).getTime())
+                : '?';
+            const workerCall = readLastWorkerCall(runDir);
+            const workerStatus = workerCall
+                ? `worker_in_flight=${workerCall.worker}:${workerCall.stage}`
+                : 'idle';
+            const statusLine = `  [${state.phase}] last progress ${progressAge} ago, ${workerStatus}`;
+            // Only update if changed
+            if (statusLine !== lastStatusLine) {
+                if (lastStatusLine) {
+                    process.stdout.write('\r' + ' '.repeat(lastStatusLine.length) + '\r');
+                }
+                process.stdout.write(statusLine);
+                lastStatusLine = statusLine;
+            }
+        }
+    }
+}