ai-foreman 1.6.2 → 1.7.1

package/dist/workflowDb.js

@@ -0,0 +1,261 @@
+import { createHash, randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { hostname } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import Database from "better-sqlite3";
+export const WORKFLOW_DB_FILE = ".rafi/recovery.sqlite3";
+/** Authoritative persistence for every resumable workflow in a project. */
+export class WorkflowDb {
+    projectDir;
+    path;
+    db;
+    constructor(projectDir, path = join(resolve(projectDir), WORKFLOW_DB_FILE)) {
+        this.projectDir = projectDir;
+        this.path = path;
+        mkdirSync(dirname(path), { recursive: true });
+        ensureRecoveryGitignore(resolve(projectDir));
+        this.db = new Database(path);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("synchronous = FULL");
+        this.db.pragma("foreign_keys = ON");
+        this.migrate();
+        this.importLegacyOnce();
+    }
+    close() { this.db.close(); }
+    createRun(input, now = new Date()) {
+        const at = now.toISOString();
+        const run = {
+            runId: input.runId ?? randomUUID(), kind: input.kind, status: "running", checkpoint: input.checkpoint ?? "created",
+            originalWork: input.originalWork ?? {}, remainingWork: input.remainingWork ?? input.originalWork ?? {}, state: input.state ?? {},
+            legacy: Boolean(input.legacy), createdAt: at, updatedAt: at,
+        };
+        this.db.transaction(() => {
+            this.db.prepare(`INSERT INTO workflow_runs(run_id,kind,status,checkpoint,original_work_json,remaining_work_json,state_json,legacy,created_at,updated_at)
+        VALUES(?,?,?,?,?,?,?,?,?,?)`).run(run.runId, run.kind, run.status, run.checkpoint, json(run.originalWork), json(run.remainingWork), json(run.state), run.legacy ? 1 : 0, at, at);
+            this.insertEvent(run.runId, "run_created", run.checkpoint, { kind: run.kind }, at);
+        })();
+        return run;
+    }
+    getRun(runId) {
+        const row = this.db.prepare("SELECT * FROM workflow_runs WHERE run_id=?").get(runId);
+        return row ? rowToRun(row) : undefined;
+    }
+    activeRuns() {
+        return this.db.prepare("SELECT * FROM workflow_runs WHERE status IN ('running','paused','blocked') ORDER BY created_at").all().map(rowToRun);
+    }
+    transition(runId, update, now = new Date()) {
+        const at = now.toISOString();
+        return this.db.transaction(() => {
+            const current = this.getRun(runId);
+            if (!current)
+                throw new Error(`workflow run not found: ${runId}`);
+            const next = { ...current, status: update.status ?? current.status, checkpoint: update.checkpoint, remainingWork: update.remainingWork ?? current.remainingWork, state: update.state ?? current.state, updatedAt: at };
+            this.db.prepare("UPDATE workflow_runs SET status=?,checkpoint=?,remaining_work_json=?,state_json=?,updated_at=? WHERE run_id=?")
+                .run(next.status, next.checkpoint, json(next.remainingWork), json(next.state), at, runId);
+            this.insertEvent(runId, update.event ?? "checkpoint", update.checkpoint, update.payload ?? {}, at);
+            return next;
+        })();
+    }
+    events(runId) {
+        const rows = this.db.prepare("SELECT sequence,event_type,checkpoint,payload_json,created_at FROM workflow_events WHERE run_id=? ORDER BY sequence").all(runId);
+        return rows.map((row) => ({ sequence: row.sequence, type: row.event_type, checkpoint: row.checkpoint, payload: parseJson(row.payload_json), at: row.created_at }));
+    }
+    recordSettings(runId, role, boundary, settings, now = new Date()) {
+        this.db.transaction(() => {
+            this.db.prepare("INSERT OR REPLACE INTO role_settings(run_id,role,boundary,revision,settings_json,created_at) VALUES(?,?,?,?,?,?)")
+                .run(runId, role, boundary, settings.settings_revision, json(settings), now.toISOString());
+            this.insertEvent(runId, "settings_boundary", `role:${role}:${boundary}`, { revision: settings.settings_revision }, now.toISOString());
+        })();
+    }
+    recordProjectSettingsRevision(revision, defaults, now = new Date()) {
+        this.db.prepare("INSERT OR REPLACE INTO project_settings_revisions(revision,defaults_json,created_at) VALUES(?,?,?)").run(revision, json(defaults), now.toISOString());
+    }
+    recordTelemetry(runId, snapshot, now = new Date()) {
+        this.db.prepare("INSERT INTO workflow_telemetry(run_id,snapshot_json,created_at) VALUES(?,?,?)").run(runId, json(snapshot), now.toISOString());
+    }
+    recordSession(runId, role, stream, sessionId, transition, settings, now = new Date()) {
+        this.db.prepare(`INSERT INTO provider_sessions(run_id,role,stream,provider,model,session_id,transition,settings_revision,created_at)
+      VALUES(?,?,?,?,?,?,?,?,?)`).run(runId, role, stream, settings.make, settings.model, sessionId ?? null, transition, settings.settings_revision, now.toISOString());
+    }
+    recordIssue(runId, issue) {
+        const result = this.db.prepare("INSERT INTO workflow_issues(run_id,code,issue_json,created_at) VALUES(?,?,?,?)").run(runId, issue.code, json(issue), issue.occurred_at);
+        this.insertEvent(runId, "issue", issue.phase, { issueId: Number(result.lastInsertRowid), code: issue.code }, issue.occurred_at);
+        return Number(result.lastInsertRowid);
+    }
+    issues(runId) {
+        return this.db.prepare("SELECT issue_json FROM workflow_issues WHERE run_id=? ORDER BY issue_id").all(runId).map((row) => parseJson(row.issue_json));
+    }
+    planOperation(input, now = new Date()) {
+        const at = now.toISOString();
+        this.db.prepare(`INSERT INTO operation_journal(idempotency_key,run_id,kind,status,intent_json,created_at,updated_at)
+      VALUES(?,?,?,'planned',?,?,?) ON CONFLICT(idempotency_key) DO NOTHING`).run(input.idempotencyKey, input.runId, input.kind, json(input.intent), at, at);
+        return this.operation(input.idempotencyKey);
+    }
+    updateOperation(idempotencyKey, status, details = {}, now = new Date()) {
+        if (!this.operation(idempotencyKey))
+            throw new Error(`operation not found: ${idempotencyKey}`);
+        this.db.prepare("UPDATE operation_journal SET status=?,result_json=?,external_id=?,error=?,updated_at=? WHERE idempotency_key=?")
+            .run(status, details.result === undefined ? null : json(details.result), details.externalId ?? null, details.error ?? null, now.toISOString(), idempotencyKey);
+        return this.operation(idempotencyKey);
+    }
+    operation(idempotencyKey) {
+        const row = this.db.prepare("SELECT * FROM operation_journal WHERE idempotency_key=?").get(idempotencyKey);
+        return row ? operationFromRow(row) : undefined;
+    }
+    operations(runId) {
+        return this.db.prepare("SELECT * FROM operation_journal WHERE run_id=? ORDER BY created_at,idempotency_key").all(runId).map(operationFromRow);
+    }
+    putEvidence(kind, value, now = new Date()) {
+        const bytes = Buffer.isBuffer(value) ? value : Buffer.from(sanitizeText(value));
+        const digest = createHash("sha256").update(bytes).digest("hex");
+        this.db.prepare("INSERT OR IGNORE INTO content_refs(digest,kind,content,created_at) VALUES(?,?,?,?)").run(digest, kind, bytes, now.toISOString());
+        return digest;
+    }
+    getEvidence(digest) {
+        const row = this.db.prepare("SELECT content FROM content_refs WHERE digest=?").get(digest);
+        return row?.content;
+    }
+    beginPublication(runId, intent, previousDigests, now = new Date()) {
+        const transactionId = randomUUID();
+        const at = now.toISOString();
+        this.db.prepare("INSERT INTO publication_transactions(transaction_id,run_id,status,intent_json,previous_digests_json,created_at,updated_at) VALUES(?,?,'prepared',?,?,?,?)")
+            .run(transactionId, runId, json(intent), json(previousDigests), at, at);
+        this.insertEvent(runId, "publication_prepared", "publication", { transactionId }, at);
+        return { transactionId, runId, status: "prepared", intent, previousDigests, createdAt: at, updatedAt: at };
+    }
+    updatePublication(transactionId, status, now = new Date()) {
+        const current = this.publication(transactionId);
+        if (!current)
+            throw new Error(`publication transaction not found: ${transactionId}`);
+        this.db.prepare("UPDATE publication_transactions SET status=?,updated_at=? WHERE transaction_id=?").run(status, now.toISOString(), transactionId);
+        this.insertEvent(current.runId, `publication_${status}`, "publication", { transactionId }, now.toISOString());
+        return { ...current, status, updatedAt: now.toISOString() };
+    }
+    publication(transactionId) {
+        const row = this.db.prepare("SELECT * FROM publication_transactions WHERE transaction_id=?").get(transactionId);
+        return row ? { transactionId: row.transaction_id, runId: row.run_id, status: row.status, intent: parseJson(row.intent_json), previousDigests: parseJson(row.previous_digests_json), createdAt: row.created_at, updatedAt: row.updated_at } : undefined;
+    }
+    incompletePublications() {
+        const rows = this.db.prepare("SELECT transaction_id FROM publication_transactions WHERE status NOT IN ('committed','rolled_back') ORDER BY created_at").all();
+        return rows.map((row) => this.publication(row.transaction_id));
+    }
+    acquireLease(runId, owner = `${hostname()}:${process.pid}:${randomUUID()}`, now = new Date(), staleMs = 45_000) {
+        const at = now.toISOString();
+        const host = hostname();
+        const pid = process.pid;
+        const processStart = processStartIdentity();
+        return this.db.transaction(() => {
+            const current = this.currentLease();
+            if (current && leaseVerifiedLive(current, now, staleMs))
+                throw new Error(`project workflow lease is held by ${current.owner} for run ${current.runId}`);
+            const generation = (current?.generation ?? 0) + 1;
+            this.db.prepare(`INSERT INTO project_lease(singleton,owner,generation,pid,host,process_start,heartbeat_at,run_id)
+        VALUES(1,?,?,?,?,?,?,?) ON CONFLICT(singleton) DO UPDATE SET owner=excluded.owner,generation=excluded.generation,pid=excluded.pid,host=excluded.host,process_start=excluded.process_start,heartbeat_at=excluded.heartbeat_at,run_id=excluded.run_id`)
+                .run(owner, generation, pid, host, processStart, at, runId);
+            this.db.prepare("UPDATE workflow_runs SET lease_generation=? WHERE run_id=?").run(generation, runId);
+            this.insertEvent(runId, current ? "lease_takeover" : "lease_acquired", "lease", { owner, generation, previous: current?.owner }, at);
+            return { owner, generation, pid, host, processStart, heartbeatAt: at, runId };
+        })();
+    }
+    heartbeatLease(lease, now = new Date()) {
+        const at = now.toISOString();
+        const result = this.db.prepare("UPDATE project_lease SET heartbeat_at=? WHERE singleton=1 AND owner=? AND generation=?").run(at, lease.owner, lease.generation);
+        if (result.changes !== 1)
+            throw new Error("workflow lease ownership changed");
+        return { ...lease, heartbeatAt: at };
+    }
+    releaseLease(lease, now = new Date()) {
+        this.db.transaction(() => {
+            const result = this.db.prepare("DELETE FROM project_lease WHERE singleton=1 AND owner=? AND generation=?").run(lease.owner, lease.generation);
+            if (result.changes === 1)
+                this.insertEvent(lease.runId, "lease_released", "lease", { generation: lease.generation }, now.toISOString());
+        })();
+    }
+    currentLease() {
+        const row = this.db.prepare("SELECT * FROM project_lease WHERE singleton=1").get();
+        return row ? { owner: row.owner, generation: row.generation, pid: row.pid, host: row.host, processStart: row.process_start, heartbeatAt: row.heartbeat_at, runId: row.run_id } : undefined;
+    }
+    importLegacyOnce(now = new Date()) {
+        const sources = [join(this.projectDir, ".foreman", "runs"), join(this.projectDir, ".rafi", "interviews"), join(this.projectDir, ".tickets", "delivery-sessions")];
+        let count = 0;
+        for (const directory of sources) {
+            if (!existsSync(directory) || !statSync(directory).isDirectory())
+                continue;
+            for (const name of readdirSync(directory).filter((entry) => entry.endsWith(".json"))) {
+                const path = join(directory, name);
+                const digest = createHash("sha256").update(readFileSync(path)).digest("hex");
+                if (this.db.prepare("SELECT 1 FROM legacy_imports WHERE source_path=? AND digest=?").get(path, digest))
+                    continue;
+                let parsed;
+                try {
+                    parsed = JSON.parse(readFileSync(path, "utf8"));
+                }
+                catch {
+                    parsed = { unreadable: true };
+                }
+                const runId = `legacy_${digest.slice(0, 24)}`;
+                if (!this.getRun(runId)) {
+                    this.createRun({ runId, kind: "legacy", checkpoint: "legacy-imported", originalWork: { source: path }, remainingWork: {}, state: { source: path, record: parsed }, legacy: true }, now);
+                    this.transition(runId, { status: "superseded", checkpoint: "legacy-imported", remainingWork: {}, event: "legacy_record_preserved" }, now);
+                }
+                this.db.prepare("INSERT INTO legacy_imports(source_path,digest,run_id,imported_at) VALUES(?,?,?,?)").run(path, digest, runId, now.toISOString());
+                count += 1;
+            }
+        }
+        return count;
+    }
+    insertEvent(runId, type, checkpoint, payload, at) {
+        this.db.prepare("INSERT INTO workflow_events(run_id,event_type,checkpoint,payload_json,created_at) VALUES(?,?,?,?,?)").run(runId, type, checkpoint, json(payload), at);
+    }
+    migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS workflow_runs(run_id TEXT PRIMARY KEY,kind TEXT NOT NULL,status TEXT NOT NULL,checkpoint TEXT NOT NULL,original_work_json TEXT NOT NULL,remaining_work_json TEXT NOT NULL,state_json TEXT NOT NULL,lease_generation INTEGER,legacy INTEGER NOT NULL DEFAULT 0,created_at TEXT NOT NULL,updated_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS workflow_events(sequence INTEGER PRIMARY KEY AUTOINCREMENT,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),event_type TEXT NOT NULL,checkpoint TEXT NOT NULL,payload_json TEXT NOT NULL,created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS role_settings(run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),role TEXT NOT NULL,boundary INTEGER NOT NULL,revision INTEGER NOT NULL,settings_json TEXT NOT NULL,created_at TEXT NOT NULL,PRIMARY KEY(run_id,role,boundary));
+      CREATE TABLE IF NOT EXISTS project_settings_revisions(revision INTEGER PRIMARY KEY,defaults_json TEXT NOT NULL,created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS workflow_telemetry(id INTEGER PRIMARY KEY AUTOINCREMENT,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),snapshot_json TEXT NOT NULL,created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS provider_sessions(id INTEGER PRIMARY KEY AUTOINCREMENT,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),role TEXT NOT NULL,stream TEXT NOT NULL,provider TEXT NOT NULL,model TEXT NOT NULL,session_id TEXT,transition TEXT NOT NULL,settings_revision INTEGER NOT NULL,created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS workflow_issues(issue_id INTEGER PRIMARY KEY AUTOINCREMENT,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),code TEXT NOT NULL,issue_json TEXT NOT NULL,created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS operation_journal(idempotency_key TEXT PRIMARY KEY,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),kind TEXT NOT NULL,status TEXT NOT NULL,intent_json TEXT NOT NULL,result_json TEXT,external_id TEXT,error TEXT,created_at TEXT NOT NULL,updated_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS content_refs(digest TEXT PRIMARY KEY,kind TEXT NOT NULL,content BLOB NOT NULL,created_at TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS project_lease(singleton INTEGER PRIMARY KEY CHECK(singleton=1),owner TEXT NOT NULL,generation INTEGER NOT NULL,pid INTEGER NOT NULL,host TEXT NOT NULL,process_start TEXT NOT NULL,heartbeat_at TEXT NOT NULL,run_id TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS legacy_imports(source_path TEXT NOT NULL,digest TEXT NOT NULL,run_id TEXT NOT NULL,imported_at TEXT NOT NULL,PRIMARY KEY(source_path,digest));
+      CREATE TABLE IF NOT EXISTS publication_transactions(transaction_id TEXT PRIMARY KEY,run_id TEXT NOT NULL,status TEXT NOT NULL,intent_json TEXT NOT NULL,previous_digests_json TEXT NOT NULL,created_at TEXT NOT NULL,updated_at TEXT NOT NULL);
+      CREATE INDEX IF NOT EXISTS workflow_events_run ON workflow_events(run_id,sequence);
+      CREATE INDEX IF NOT EXISTS operations_run ON operation_journal(run_id,status);
+    `);
+    }
+}
+function rowToRun(row) { return { runId: row.run_id, kind: row.kind, status: row.status, checkpoint: row.checkpoint, originalWork: parseJson(row.original_work_json), remainingWork: parseJson(row.remaining_work_json), state: parseJson(row.state_json), ...(row.lease_generation === null ? {} : { leaseGeneration: row.lease_generation }), legacy: Boolean(row.legacy), createdAt: row.created_at, updatedAt: row.updated_at }; }
+function operationFromRow(row) { return { idempotencyKey: row.idempotency_key, runId: row.run_id, kind: row.kind, status: row.status, intent: parseJson(row.intent_json), ...(row.result_json ? { result: parseJson(row.result_json) } : {}), ...(row.external_id ? { externalId: row.external_id } : {}), ...(row.error ? { error: row.error } : {}), createdAt: row.created_at, updatedAt: row.updated_at }; }
+function json(value) { return JSON.stringify(value ?? null); }
+function parseJson(value) { return JSON.parse(value); }
+function sanitizeText(value) { return value.replace(/\b(sk-[A-Za-z0-9_-]{12,}|(?:api[_-]?key|token|password)\s*[:=]\s*\S+)/gi, "[REDACTED]"); }
+function processStartIdentity(pid = process.pid) { try {
+    return readFileSync(`/proc/${pid}/stat`, "utf8").split(" ")[21] ?? "unavailable";
+}
+catch {
+    return "unavailable";
+} }
+function leaseVerifiedLive(lease, now, staleMs) {
+    if (now.getTime() - new Date(lease.heartbeatAt).getTime() > staleMs)
+        return false;
+    if (lease.host !== hostname())
+        return true;
+    try {
+        process.kill(lease.pid, 0);
+        return processStartIdentity(lease.pid) === lease.processStart;
+    }
+    catch {
+        return false;
+    }
+}
+function ensureRecoveryGitignore(projectDir) {
+    const localExclude = join(projectDir, ".git", "info", "exclude");
+    const path = existsSync(localExclude) ? localExclude : join(projectDir, ".gitignore");
+    const entries = [WORKFLOW_DB_FILE, `${WORKFLOW_DB_FILE}-wal`, `${WORKFLOW_DB_FILE}-shm`];
+    const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+    const missing = entries.filter((entry) => !existing.split(/\r?\n/).includes(entry));
+    if (missing.length)
+        appendFileSync(path, `${existing && !existing.endsWith("\n") ? "\n" : ""}${missing.join("\n")}\n`, "utf8");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-foreman",
-  "version": "1.6.2",
+  "version": "1.7.1",
   "description": "An orchestrator that keeps Codex CLI / Claude Code builders moving through their step list unattended. Part of Rafi.",
   "license": "Apache-2.0",
   "type": "module",
@@ -41,6 +41,18 @@
       "types": "./dist/buildRuns.d.ts",
       "default": "./dist/buildRuns.js"
     },
+    "./workflow-db.js": {
+      "types": "./dist/workflowDb.d.ts",
+      "default": "./dist/workflowDb.js"
+    },
+    "./session-lifecycle.js": {
+      "types": "./dist/sessionLifecycle.d.ts",
+      "default": "./dist/sessionLifecycle.js"
+    },
+    "./operation-recovery.js": {
+      "types": "./dist/operationRecovery.d.ts",
+      "default": "./dist/operationRecovery.js"
+    },
     "./ticket-planning.js": {
       "types": "./dist/ticketPlanning.d.ts",
       "default": "./dist/ticketPlanning.js"
@@ -53,6 +65,10 @@
       "types": "./dist/tickets/setupConfig.d.ts",
       "default": "./dist/tickets/setupConfig.js"
     },
+    "./sources/source-registry.js": {
+      "types": "./dist/sources/sourceRegistry.d.ts",
+      "default": "./dist/sources/sourceRegistry.js"
+    },
     "./cli/tickets.js": {
       "types": "./dist/cli/tickets.d.ts",
       "default": "./dist/cli/tickets.js"
@@ -81,6 +97,7 @@
     "dev": "tsx src/index.ts",
     "test": "tsx --test test/*.test.ts",
     "typecheck": "tsc --noEmit",
+    "test:live-providers": "RAFI_LIVE_PROVIDER_SESSIONS=1 tsx --test test/providerSmoke.test.ts",
     "prepublishOnly": "pnpm build && pnpm test && pnpm typecheck"
   },
   "keywords": [
@@ -101,8 +118,8 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.148"
   },
   "dependencies": {
-    "special-agents": "0.7.0",
-    "rafi-spec": "0.7.0",
+    "special-agents": "0.8.1",
+    "rafi-spec": "0.8.1",
     "@clack/prompts": "^1.4.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",