@cassiomc1/forgeloop 1.2.3 → 1.3.0

package/src/core/work-state.js

@@ -19,6 +19,7 @@ import { assertJsonBytes } from "./json-safety.js";
 import { assertCoverageList } from "./coverage.js";
 import { canonicalFingerprint } from "./artifacts.js";
 import { taskArtifactPath } from "./task-paths.js";
+import { getActiveTaskTransaction, withTaskTransaction } from "./transaction.js";
 
 export const WORK_STATE_PATH = ".forgeloop/work-state.json";
 
@@ -163,6 +164,9 @@ export function assertWorkStateSemantics(state) {
   if (state.verificationCycle !== undefined && (!Number.isInteger(state.verificationCycle) || state.verificationCycle < 1)) {
     throw new WorkStateError("verificationCycle must be a positive integer");
   }
+  if (state.revision !== undefined && (!Number.isInteger(state.revision) || state.revision < 0)) {
+    throw new WorkStateError("revision must be a non-negative integer");
+  }
   if (state.lastCompletionAttempt !== undefined) {
     if (!state.lastCompletionAttempt || typeof state.lastCompletionAttempt !== "object" || Array.isArray(state.lastCompletionAttempt)) {
       throw new WorkStateError("lastCompletionAttempt must be an object");
@@ -216,6 +220,7 @@ export function createWorkState(input) {
     blockers: [...(input.blockers ?? [])],
     verificationEvidence: [...(input.verificationEvidence ?? [])],
     lastUpdated: input.lastUpdated ?? new Date().toISOString(),
+    revision: input.revision ?? 0,
   };
   if (input.verificationCycle !== undefined) state.verificationCycle = input.verificationCycle;
   if (input.lastCompletionAttempt !== undefined) state.lastCompletionAttempt = structuredClone(input.lastCompletionAttempt);
@@ -238,12 +243,20 @@ export async function readWorkState(target, options = {}) {
 
   await assertSafePath(target, relPath);
   const statePath = ensureWithin(target, relPath);
-  if (!(await fileExists(statePath))) return null;
   let state;
   try {
-    const bytes = await readBytes(statePath);
-    assertJsonBytes(bytes, relPath);
-    state = JSON.parse(bytes.toString("utf8"));
+    const transaction = getActiveTaskTransaction();
+    const staged = transaction ? await transaction.readText(relPath) : null;
+    if (staged === null) {
+      if (!(await fileExists(statePath))) return null;
+      const bytes = await readBytes(statePath);
+      assertJsonBytes(bytes, relPath);
+      state = JSON.parse(bytes.toString("utf8"));
+    } else {
+      const bytes = Buffer.from(staged, "utf8");
+      assertJsonBytes(bytes, relPath);
+      state = JSON.parse(staged);
+    }
   } catch (error) {
     throw new WorkStateError(`Unable to parse ${relPath}: ${error.message}`);
   }
@@ -276,11 +289,62 @@ export async function writeWorkState(target, state, options = {}) {
 
   await validateStoredState(state, packageRoot);
   await assertSafePath(target, relPath);
-  const statePath = ensureWithin(target, relPath);
-  await writeFileAtomic(statePath, `${JSON.stringify(state, null, 2)}\n`, { dryRun });
+  const serialized = `${JSON.stringify(state, null, 2)}\n`;
+  const transaction = getActiveTaskTransaction();
+  if (!dryRun && transaction) {
+    await transaction.stageText(relPath, serialized);
+  } else {
+    const statePath = ensureWithin(target, relPath);
+    await writeFileAtomic(statePath, serialized, { dryRun });
+  }
   return state;
 }
 
+export async function mutateWorkState(target, { expectedRevision, packageRoot = getPackageRoot(), taskId, statePath } = {}, updater) {
+  if (!Number.isInteger(expectedRevision) || expectedRevision < 0) {
+    const error = new WorkStateError("expectedRevision must be a non-negative integer");
+    error.code = "E_STATE_REVISION_CONFLICT";
+    throw error;
+  }
+  if (!getActiveTaskTransaction()) {
+    return withTaskTransaction({
+      target,
+      taskId: taskId ?? "legacy-work-state",
+      lockTaskId: taskId ?? "legacy-work-state",
+      operation: "mutate-work-state",
+    }, async () => mutateWorkState(target, { expectedRevision, packageRoot, taskId, statePath }, updater));
+  }
+  const current = await readWorkState(target, { packageRoot, taskId, statePath });
+  if (!current || (current.revision ?? 0) !== expectedRevision) {
+    const error = new WorkStateError("Work state revision does not match expected revision");
+    error.code = "E_STATE_REVISION_CONFLICT";
+    throw error;
+  }
+  const updated = await updater(structuredClone(current));
+  const next = createWorkState({
+    ...updated,
+    revision: expectedRevision + 1,
+    lastUpdated: updated.lastUpdated ?? new Date().toISOString(),
+  });
+  await writeWorkState(target, next, { packageRoot, taskId, statePath });
+  return next;
+}
+
+export async function initializeWorkState(target, state, { packageRoot = getPackageRoot(), taskId, statePath } = {}) {
+  if (getActiveTaskTransaction()) {
+    const current = await readWorkState(target, { packageRoot, taskId, statePath });
+    if (current) return current;
+    await writeWorkState(target, state, { packageRoot, taskId, statePath });
+    return state;
+  }
+  return withTaskTransaction({
+    target,
+    taskId: taskId ?? "legacy-work-state",
+    lockTaskId: taskId ?? "legacy-work-state",
+    operation: "initialize-work-state",
+  }, async () => initializeWorkState(target, state, { packageRoot, taskId, statePath }));
+}
+
 export async function clearWorkState(target, options = {}) {
   const relPath = options?.statePath ?? options?.relativePath ?? (options?.taskId ? taskArtifactPath(options.taskId, "state") : WORK_STATE_PATH);
   await assertSafePath(target, relPath);