ai-foreman 1.7.4 → 1.7.6

package/dist/buildRuns.js

@@ -2,16 +2,22 @@ import { createHash, randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { hostname } from "node:os";
 import { join, resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+import Database from "better-sqlite3";
 import { WorkflowDb } from "./workflowDb.js";
-export const BUILD_RUN_VERSION = 1;
+import { isTicketsInitialized, loadTicketsConfig, resolveTicketPaths } from "./tickets/config.js";
+import { loadTickets } from "./tickets/ticketLoader.js";
+export const BUILD_RUN_VERSION = 2;
 export const BUILD_RUN_DIRECTORY = ".foreman/runs";
 export const BUILD_HEARTBEAT_MS = 10_000;
 export const BUILD_LEASE_STALE_MS = 45_000;
 export function createBuildRun(input) {
     const now = input.now ?? new Date();
     const stamp = now.toISOString();
+    const worktree = resolve(input.worktree ?? input.repositoryRoot);
+    const snapshot = captureGitSnapshot(worktree, input);
     const run = {
-        version: 1,
+        version: 2,
         runId: randomUUID(),
         status: "running",
         tickets: [...input.tickets],
@@ -23,12 +29,14 @@ export function createBuildRun(input) {
         qa: input.qa ? { settings: normalizeCapturedSettings(input.qa) } : undefined,
         repository: {
             root: resolve(input.repositoryRoot),
-            worktree: resolve(input.worktree ?? input.repositoryRoot),
-            branch: input.branch,
-            baseHead: input.baseHead,
-            startHead: input.startHead,
-            partialFingerprint: fingerprintWorkingFiles(input.worktree ?? input.repositoryRoot),
+            worktree,
+            branch: input.branch ?? snapshot.branch,
+            baseHead: input.baseHead ?? snapshot.baselineHead,
+            startHead: input.startHead ?? snapshot.startHead,
+            git: snapshot,
+            baselineComplete: Boolean(snapshot.baselineHead && snapshot.startHead && snapshot.branch),
         },
+        progress: { completedTickets: [], completedOperations: [], remainingTickets: [...input.tickets], nextAction: input.tickets[0] ? `Start ${input.tickets[0]}` : "Plan next work" },
         receipts: {},
         lease: currentLease(now),
         createdAt: stamp,
@@ -71,7 +79,12 @@ export function saveBuildRun(projectDir, run, now = new Date()) {
     validateBuildRun(run);
     const directory = join(resolve(projectDir), BUILD_RUN_DIRECTORY);
     mkdirSync(directory, { recursive: true });
-    const next = { ...run, updatedAt: now.toISOString() };
+    const completedOperations = Object.keys(run.receipts).sort();
+    const next = {
+        ...run,
+        progress: { ...run.progress, completedOperations, remainingTickets: remainingTickets(run) },
+        updatedAt: now.toISOString(),
+    };
     const target = join(directory, `${run.runId}.json`);
     const temp = `${target}.${process.pid}.${randomUUID()}.tmp`;
     writeFileSync(temp, `${JSON.stringify(next, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
@@ -145,7 +158,7 @@ export function releaseBuildLease(projectDir, run, status = "interrupted") {
     return saved;
 }
 export function completeBuildRun(projectDir, run, now = new Date()) {
-    const saved = saveBuildRun(projectDir, { ...run, status: "completed", checkpoint: "complete", lease: undefined, completedAt: now.toISOString() }, now);
+    const saved = saveBuildRun(projectDir, { ...run, status: "completed", checkpoint: "complete", lease: undefined, completedAt: now.toISOString(), progress: { ...run.progress, completedTickets: [...run.tickets], remainingTickets: [], nextAction: "None; build complete" } }, now);
     releaseWorkflowLease(projectDir, run.runId, now);
     return saved;
 }
@@ -157,7 +170,7 @@ export function readBuildRuns(projectDir) {
         try {
             const run = JSON.parse(readFileSync(join(directory, name), "utf8"));
             validateBuildRun(run);
-            return [run];
+            return [upgradeBuildRun(run)];
         }
         catch {
             return [];
@@ -167,7 +180,42 @@ export function readBuildRuns(projectDir) {
 export function recoverableBuildRuns(projectDir, now = new Date()) {
     return readBuildRuns(projectDir)
         .filter((run) => run.status !== "completed")
-        .map((run) => ({ ...run, active: isLeaseActive(run, now) }));
+        .map((run) => ({ ...inferLegacyRunTickets(projectDir, run), active: isLeaseActive(run, now) }));
+}
+/**
+ * Current-branch runs created before ticket checkpointing did not retain their
+ * selected ticket. Recover it from Foreman's tracker events so --ticket can
+ * still address those durable runs without rewriting the legacy record.
+ */
+function inferLegacyRunTickets(projectDir, run) {
+    if (run.tickets.length > 0 || !isTicketsInitialized(projectDir))
+        return run;
+    let db;
+    try {
+        const paths = resolveTicketPaths(loadTicketsConfig(projectDir), projectDir);
+        if (!existsSync(paths.stateDb))
+            return run;
+        db = new Database(paths.stateDb, { readonly: true, fileMustExist: true });
+        const rows = db.prepare(`
+      SELECT ticket_id
+      FROM ticket_events
+      WHERE actor = 'foreman'
+        AND ticket_id IS NOT NULL
+        AND julianday(timestamp) >= julianday(?)
+        AND julianday(timestamp) <= julianday(?)
+      ORDER BY timestamp, id
+    `).all(run.createdAt, run.updatedAt);
+        const tickets = [...new Set(rows.map((row) => row.ticket_id).filter(Boolean))];
+        if (tickets.length === 0)
+            return run;
+        return { ...run, tickets, currentTicket: tickets.at(-1) };
+    }
+    catch {
+        return run;
+    }
+    finally {
+        db?.close();
+    }
 }
 export function isLeaseActive(run, now = new Date()) {
     if (!run.lease)
@@ -193,12 +241,106 @@ export function buildRecoveryPreview(run) {
         `checkpoint ${run.checkpoint}`,
         `worktree ${run.repository.worktree}`,
         `branch ${run.repository.branch ?? "current"}`,
-        `partial files fingerprint ${run.repository.partialFingerprint ?? "unavailable"}`,
+        `baseline ${run.repository.baselineComplete ? `${run.repository.git.baseRef ?? "recorded"} @ ${run.repository.git.baselineHead}` : "incomplete legacy baseline"}`,
+        `preserved paths ${run.repository.git.runOwnedPaths.join(", ") || run.repository.git.statusPaths.join(", ") || "none recorded"}`,
         `completed operations ${completed.length ? completed.join(", ") : "none"}`,
         `session ${run.builder?.sessionId ? "exact Builder session available" : "fresh Builder session required"}`,
         `QA session ${run.qa?.sessionId ? "exact QA session available" : "fresh QA session required"}`,
     ];
 }
+export function projectBuildRecovery(projectDir, run, now = new Date(), ticketOverride) {
+    let operationNames = [];
+    let issues = [];
+    let workflowState = {};
+    if (existsSync(join(resolve(projectDir), ".rafi", "recovery.sqlite3"))) {
+        const workflow = new WorkflowDb(projectDir);
+        try {
+            operationNames = workflow.operations(run.runId).filter((operation) => operation.status === "confirmed").map((operation) => operation.kind);
+            issues = workflow.issues(run.runId).map((issue) => issue.detail);
+            workflowState = workflow.getRun(run.runId)?.state ?? {};
+        }
+        finally {
+            workflow.close();
+        }
+    }
+    const stateTicket = typeof workflowState.currentTicket === "string" ? workflowState.currentTicket : undefined;
+    const ticketId = ticketOverride ?? stateTicket ?? run.currentTicket ?? run.progress.remainingTickets[0] ?? run.tickets[0];
+    let ticketTitle;
+    if (ticketId && isTicketsInitialized(projectDir)) {
+        try {
+            const paths = resolveTicketPaths(loadTicketsConfig(projectDir), projectDir);
+            ticketTitle = loadTickets(paths.tickets).find((ticket) => ticket.id === ticketId)?.title;
+        }
+        catch { /* durable run data remains enough for a legacy preview */ }
+    }
+    const stateWorktree = typeof workflowState.worktree === "string" ? workflowState.worktree : undefined;
+    const recoveryWorktree = stateWorktree && existsSync(stateWorktree) ? stateWorktree : run.repository.worktree;
+    const stateBranch = typeof workflowState.branch === "string" ? workflowState.branch : undefined;
+    const expectedChanges = gitStatusPaths(recoveryWorktree);
+    const baseChanges = resolve(run.repository.root) === resolve(recoveryWorktree) ? [] : gitStatusPaths(run.repository.root);
+    const identityChanged = recoveryWorktree === run.repository.worktree && run.repository.git.worktreeIdentity && worktreeIdentity(recoveryWorktree) !== run.repository.git.worktreeIdentity;
+    const branchNow = gitValue(recoveryWorktree, ["branch", "--show-current"]);
+    const expectedBranch = stateBranch ?? run.repository.git.branch;
+    const branchChanged = Boolean(expectedBranch && branchNow && branchNow !== expectedBranch);
+    const unexpectedChanges = baseChanges.map((path) => ({ path, risk: "base-worktree changes may conflict with recovery" }));
+    if (identityChanged)
+        unexpectedChanges.push({ path: recoveryWorktree, risk: "preserved worktree identity changed" });
+    if (branchChanged)
+        unexpectedChanges.push({ path: recoveryWorktree, risk: `branch changed from ${expectedBranch} to ${branchNow}` });
+    const completed = [...new Set([...run.progress.completedTickets, ...run.progress.completedOperations, ...operationNames])];
+    const remaining = run.progress.remainingTickets.length ? run.progress.remainingTickets : remainingTickets(run);
+    const interruption = run.interruption?.lastError ?? run.interruption?.summary ?? run.failure?.summary ?? issues.at(-1) ?? run.status;
+    const validation = run.progress.validation
+        ? `${run.progress.validation.status}${run.progress.validation.qa ? `; QA ${run.progress.validation.qa}` : ""}`
+        : run.qa?.sessionId ? "QA session checkpointed" : "no completed QA/validation checkpoint recorded";
+    const nextAction = ticketOverride
+        ? `Resume ${ticketOverride} from ${run.checkpoint}`
+        : run.progress.nextAction ?? (ticketId ? `Resume ${ticketId} from ${run.checkpoint}` : `Resume from ${run.checkpoint}`);
+    const primary = ticketId ? `${ticketId}${ticketTitle ? `: ${ticketTitle}` : ""}` : "legacy run (ticket unavailable)";
+    return {
+        run, ticketId, ticketTitle,
+        compactLabel: `${primary} — ${run.status}`,
+        compactHint: `${run.builder?.settings.make ?? "runtime unavailable"}; ${stateBranch ?? branchNow ?? run.repository.branch ?? "current branch"}; updated ${relativeTime(run.updatedAt, now)}`,
+        completed, remaining,
+        lastSuccess: run.progress.lastSuccessfulAction ?? run.checkpoint,
+        interruption,
+        validation,
+        expectedChanges,
+        unexpectedChanges,
+        nextAction,
+        worktree: recoveryWorktree,
+        branch: stateBranch ?? branchNow ?? run.repository.git.branch ?? run.repository.branch,
+        exactSessionId: typeof workflowState.sessionId === "string" ? workflowState.sessionId : run.builder?.sessionId,
+    };
+}
+export function formatBuildRecoveryProjection(projection) {
+    const { run } = projection;
+    const lines = [
+        `run ${run.runId}`,
+        `ticket ${projection.ticketId ?? "unavailable"}${projection.ticketTitle ? `: ${projection.ticketTitle}` : ""}`,
+        `status ${run.status}; checkpoint ${run.checkpoint}`,
+        `completed ${projection.completed.join(", ") || "none recorded"}`,
+        `current ${run.progress.currentStep ?? projection.ticketId ?? "not recorded"}`,
+        `remaining ${projection.remaining.join(", ") || "none"}`,
+        `last successful action ${projection.lastSuccess}`,
+        `interruption/failure ${projection.interruption}`,
+        `validation/QA ${projection.validation}`,
+        `branch ${projection.branch ?? "current"}; worktree ${projection.worktree}`,
+        `baseline ${run.repository.baselineComplete ? `${run.repository.git.baseRef ?? "recorded"} @ ${run.repository.git.baselineHead}` : "incomplete; automatic rollback is unavailable"}`,
+        `session ${projection.exactSessionId ? "exact Builder session available" : "fresh Builder session required"}`,
+        `runtime ${run.builder?.settings.make ?? "unavailable"}; model ${run.builder?.settings.model ?? "unavailable"}`,
+        `updated ${run.updatedAt}`,
+        `preserved expected in-progress paths ${projection.expectedChanges.join(", ") || "none currently dirty"}`,
+    ];
+    if (projection.unexpectedChanges.length) {
+        lines.push("WARNING: unexpected recovery state (recovery remains available):");
+        for (const item of projection.unexpectedChanges)
+            lines.push(`  ${item.path}: ${item.risk}`);
+        lines.push("recommended action: preserve or move these changes before recovery if they overlap the interrupted work");
+    }
+    lines.push(`next action ${projection.nextAction}`);
+    return lines;
+}
 function currentLease(now) {
     return { hostname: hostname(), pid: process.pid, processStart: processStartIdentity(process.pid), heartbeatAt: now.toISOString() };
 }
@@ -210,17 +352,8 @@ function processStartIdentity(pid) {
         return pid === process.pid ? `${Date.now() - Math.round(process.uptime() * 1000)}` : "unknown";
     }
 }
-function fingerprintWorkingFiles(worktree) {
-    try {
-        const stat = statSync(resolve(worktree));
-        return createHash("sha256").update(`${stat.dev}:${stat.ino}:${stat.mtimeMs}`).digest("hex");
-    }
-    catch {
-        return undefined;
-    }
-}
 function validateBuildRun(run) {
-    if (run.version !== BUILD_RUN_VERSION || !run.runId || !run.repository?.root || !run.repository.worktree || !run.createdAt || !run.updatedAt) {
+    if (![1, 2].includes(run.version) || !run.runId || !run.repository?.root || !run.repository.worktree || !run.createdAt || !run.updatedAt) {
         throw new Error("invalid build run record");
     }
 }
@@ -229,6 +362,8 @@ function workflowStatus(status) {
         return "completed";
     if (status === "failed")
         return "failed";
+    if (status === "superseded")
+        return "superseded";
     if (status === "blocked")
         return "blocked";
     if (status === "interrupted" || status === "recoverable")
@@ -239,6 +374,92 @@ function remainingTickets(run) {
     const current = run.currentTicket ? run.tickets.indexOf(run.currentTicket) : 0;
     return run.status === "completed" ? [] : run.tickets.slice(Math.max(0, current));
 }
+function captureGitSnapshot(worktree, input) {
+    const git = (args) => {
+        try {
+            return execFileSync("git", args, { cwd: worktree, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const statusPaths = (git(["status", "--porcelain=v1", "-z"]) ?? "").split("\0").filter(Boolean).map((line) => line.slice(3)).sort();
+    const head = input.startHead ?? git(["rev-parse", "HEAD"]);
+    const branch = input.branch ?? git(["branch", "--show-current"]);
+    return {
+        baselineHead: input.baseHead ?? head,
+        baseRef: input.baseRef ?? branch,
+        branch,
+        startHead: head,
+        worktree,
+        worktreeIdentity: worktreeIdentity(worktree),
+        statusPaths,
+        initialStatusPaths: [...statusPaths],
+        runOwnedPaths: [],
+        createdBranch: false,
+        createdWorktree: worktree !== resolve(input.repositoryRoot),
+        upstream: git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"]),
+    };
+}
+function worktreeIdentity(worktree) {
+    try {
+        const stat = statSync(resolve(worktree));
+        return createHash("sha256").update(`${stat.dev}:${stat.ino}`).digest("hex");
+    }
+    catch {
+        return undefined;
+    }
+}
+function gitValue(cwd, args) {
+    try {
+        return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function gitStatusPaths(cwd) {
+    return (gitValue(cwd, ["status", "--porcelain=v1", "-z"]) ?? "").split("\0").filter(Boolean).map((line) => line.slice(3)).sort();
+}
+function relativeTime(value, now) {
+    const seconds = Math.max(0, Math.floor((now.getTime() - new Date(value).getTime()) / 1000));
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86_400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86_400)}d ago`;
+}
+function upgradeBuildRun(run) {
+    if (run.version === 2)
+        return run;
+    const legacy = run;
+    const remaining = legacy.status === "completed" ? [] : legacy.tickets.slice(Math.max(0, legacy.currentTicket ? legacy.tickets.indexOf(legacy.currentTicket) : 0));
+    return {
+        ...legacy,
+        version: 2,
+        legacy: true,
+        repository: {
+            ...legacy.repository,
+            baselineComplete: false,
+            git: {
+                baselineHead: legacy.repository.baseHead,
+                branch: legacy.repository.branch,
+                startHead: legacy.repository.startHead,
+                worktree: legacy.repository.worktree,
+                statusPaths: [], initialStatusPaths: [], runOwnedPaths: [], createdBranch: false, createdWorktree: false,
+            },
+        },
+        progress: {
+            completedTickets: legacy.status === "completed" ? [...legacy.tickets] : [],
+            completedOperations: Object.keys(legacy.receipts).sort(),
+            remainingTickets: remaining,
+            lastSuccessfulAction: legacy.checkpoint,
+            nextAction: remaining[0] ? `Resume ${remaining[0]}` : "Inspect legacy run",
+        },
+    };
+}
 function releaseWorkflowLease(projectDir, runId, now = new Date()) {
     const workflow = new WorkflowDb(projectDir);
     try {

package/dist/cli/events.js

@@ -1,11 +1,19 @@
+import { currentActivity } from "../activity.js";
 /** Print a compact live feed of builder activity. */
 export async function printEvents(events) {
     let atLineStart = true;
     for await (const ev of events) {
         if (ev.kind === "text") {
             if (ev.text) {
-                process.stdout.write(ev.text);
-                atLineStart = ev.text.endsWith("\n");
+                const reporter = currentActivity();
+                if (reporter) {
+                    reporter.writePersistent(ev.text);
+                    atLineStart = true;
+                }
+                else {
+                    process.stdout.write(ev.text);
+                    atLineStart = ev.text.endsWith("\n");
+                }
             }
         }
         else if (ev.kind === "tool") {
@@ -13,7 +21,7 @@ export async function printEvents(events) {
                 process.stdout.write("\n");
                 atLineStart = true;
             }
-            console.log(`  -> ${ev.name} ${briefInput(ev.input)}`);
+            writeLine(`  -> ${ev.name} ${briefInput(ev.input)}`);
         }
         else if (ev.kind === "turn-complete") {
             if (!atLineStart) {
@@ -22,19 +30,30 @@ export async function printEvents(events) {
             }
             const tag = ev.result.isError ? "turn errored" : "turn complete";
             const cost = ev.result.costUsd > 0 ? ` ($${ev.result.costUsd.toFixed(4)})` : "";
-            console.log(`  - ${tag}${cost}`);
+            writeLine(`  - ${tag}${cost}`);
         }
         else if (ev.kind === "error") {
             if (!atLineStart) {
                 process.stdout.write("\n");
                 atLineStart = true;
             }
-            console.log(`  ! error: ${ev.message}`);
+            writeLine(`  ! error: ${ev.message}`);
+        }
+        else if (ev.kind === "retry" && !currentActivity()) {
+            const attempt = ev.attempt ? ` (${ev.attempt}${ev.maximum ? `/${ev.maximum}` : ""})` : "";
+            writeLine(`  ! ${ev.provider}: ${ev.reason}; retrying${attempt}`);
         }
     }
     if (!atLineStart)
         process.stdout.write("\n");
 }
+function writeLine(line) {
+    const reporter = currentActivity();
+    if (reporter)
+        reporter.writePersistent(line);
+    else
+        console.log(line);
+}
 function briefInput(input) {
     if (input && typeof input === "object") {
         const o = input;

package/dist/cli/runtimeAuthPrompt.js

@@ -3,6 +3,7 @@ import { requireClaudeSDK } from "../adapters/claude.js";
 import { checkRuntimeReady, RuntimeAuthError, runtimeCommandLabel, } from "../runtimeAuth.js";
 import { resolveExecutablePath } from "../runtimeReadiness.js";
 import { otherRuntime, runtimeDisplayName } from "./runtimeSelection.js";
+import { currentActivity } from "../activity.js";
 export async function ensureRuntimeReadyForCommand(projectDir, runtime, labelOrOptions) {
     const opts = typeof labelOrOptions === "string"
         ? { label: labelOrOptions }
@@ -37,9 +38,12 @@ export async function ensureRuntimeReadyForCommand(projectDir, runtime, labelOrO
             const choice = opts.choose
                 ? await opts.choose(failure, { otherRuntime: fallbackRuntime, allowSwitch })
                 : await promptRuntimeRecovery(failure, opts.label, fallbackRuntime, allowSwitch);
-            if (choice === "retry")
+            if (choice === "retry") {
+                currentActivity()?.note(`rafi: retrying ${runtime} readiness check`);
                 continue;
+            }
             if (choice === "switch" && allowSwitch) {
+                currentActivity()?.note(`rafi: checking fallback runtime ${fallbackRuntime}`);
                 try {
                     const probe = await check(projectDir, fallbackRuntime);
                     if (fallbackRuntime === "claude") {