@naxodev/apnea 0.1.0 → 0.2.1

package/extension/workflows/commit.ts

@@ -3,7 +3,10 @@ import { Effect, Result } from "effect"
 import { asVerdict, parseFrontMatter } from "../domain/frontmatter.ts"
 import { abs, phaseDir, rel } from "../domain/paths.ts"
 import { nextAfter, toolAllowed } from "../domain/state-machine.ts"
-import { extractVerifyCommands } from "../domain/verify-commands.ts"
+import {
+  extractVerifyBlocks,
+  formatVerifyCommand,
+} from "../domain/verify-commands.ts"
 import {
   ArtifactInvalid,
   GateRefused,
@@ -13,8 +16,14 @@ import {
 import { ok, type ToolResult } from "../result.ts"
 import { Config } from "../services/config.ts"
 import { FileSystem } from "../services/file-system.ts"
-import { RunStore } from "../services/run-store.ts"
-import { Vcs } from "../services/vcs.ts"
+import { RunStore, type RunStoreService } from "../services/run-store.ts"
+import {
+  Vcs,
+  type VcsService,
+  withTransactionTrailer,
+  withoutTransactionTrailer,
+} from "../services/vcs.ts"
+import type { RunState } from "../domain/types.ts"
 
 export type CommitParams = {
   message?: string
@@ -25,6 +34,18 @@ export type CommitParams = {
 /**
  * Require APPROVED code review, run phase package verify commands,
  * jj/git commit, advance phase. Refusals are tagged failures only.
+ *
+ * The commit itself is a crash-recoverable transaction:
+ *
+ *   gates → verify.log → prepare → save pending_commit (durable point)
+ *   → complete or recognize → bookmark (jj, final phase) → advance + clear
+ *
+ * Once `pending_commit` is saved, cancellation does NOT undo the
+ * transaction — the prepared anchor is durable and a later commit call
+ * resumes or recognizes it. A call that loads an existing `pending_commit`
+ * skips the gates and verification entirely and resumes only that
+ * transaction; retry params conflicting with the persisted message or
+ * `--done` value are refused, not silently ignored.
  */
 export const commitWorkflow = (
   params: CommitParams,
@@ -43,6 +64,16 @@ export const commitWorkflow = (
       return yield* allowed.failure
     }
 
+    if (state.pending_commit) {
+      return yield* resumePendingCommit({
+        params,
+        root,
+        state,
+        store,
+        vcs,
+      })
+    }
+
     const reviewRel = state.current_code_review
     if (!reviewRel) {
       return yield* new GateRefused({
@@ -52,10 +83,18 @@ export const commitWorkflow = (
     }
 
     const reviewAbs = abs(reviewRel, root)
-    const reviewPresent = yield* fs.exists(reviewAbs)
+    const reviewPresent = yield* fs.projectPathExists(root, reviewAbs)
     let fm: ReturnType<typeof parseFrontMatter> = null
     if (reviewPresent) {
-      const reviewText = yield* fs.readFile(reviewAbs)
+      const reviewText = yield* fs.readProjectFile(root, reviewAbs).pipe(
+        Effect.mapError(
+          (error) =>
+            new ArtifactInvalid({
+              artifact: reviewRel,
+              message: error.message,
+            }),
+        ),
+      )
       fm = parseFrontMatter(reviewText)
     }
     const verdict = asVerdict(fm?.verdict)
@@ -77,7 +116,7 @@ export const commitWorkflow = (
         root,
       )
     const pkgAbs = abs(pkgRel, root)
-    const pkgPresent = yield* fs.exists(pkgAbs)
+    const pkgPresent = yield* fs.projectPathExists(root, pkgAbs)
     if (!pkgPresent) {
       return yield* new GateRefused({
         gate: "commit",
@@ -85,9 +124,16 @@ export const commitWorkflow = (
         details: { package: pkgRel },
       })
     }
-    const pkgText = yield* fs.readFile(pkgAbs)
-    const cmds = extractVerifyCommands(pkgText)
-    if (!cmds.length) {
+    const pkgText = yield* fs
+      .readProjectFile(root, pkgAbs)
+      .pipe(
+        Effect.mapError(
+          (error) =>
+            new ArtifactInvalid({ artifact: pkgRel, message: error.message }),
+        ),
+      )
+    const blocks = extractVerifyBlocks(pkgText)
+    if (!blocks.length) {
       return yield* new ArtifactInvalid({
         artifact: pkgRel,
         message: "no verify commands found in phase package (need ```sh block)",
@@ -96,15 +142,14 @@ export const commitWorkflow = (
 
     const cfg = yield* config.load(root)
     const verifyTimeout = cfg.timeouts_ms.verify ?? 900_000
-    const verify = yield* vcs.runVerify(root, cmds, verifyTimeout)
+    const verify = yield* vcs.runVerify(root, blocks, verifyTimeout)
 
     const vlog = path.join(path.dirname(reviewAbs), "verify.log")
-    yield* fs.mkdir(path.dirname(vlog), { recursive: true })
-    yield* fs.writeFile(vlog, `${verify.log}\n`)
+    yield* fs.writeProjectFile(root, vlog, `${verify.log}\n`)
 
     if (!verify.ok) {
       return yield* new VerifyFailed({
-        commands: cmds,
+        commands: blocks.map(formatVerifyCommand),
         outputs: [verify.log.slice(-2000)],
         // `outputs` is a tail — point the caller at the full log on disk.
         verify_log: rel(vlog, root),
@@ -115,9 +160,162 @@ export const commitWorkflow = (
       params.message?.trim() ||
       `feat: apnea phase ${state.phase_index} (${state.slug})`
 
-    const detail = yield* vcs.commitPhase(root, state.vcs, message)
+    const prepared = yield* vcs.prepareCommit(root, state.vcs, message)
 
-    if (params.no_remaining_phases) {
+    // Durable point. From here the transaction survives crashes and
+    // cancellation: the anchor below is everything completion needs to
+    // recognize or create the commit exactly once.
+    const noRemainingPhases = params.no_remaining_phases === true
+    const verifyLogRel = rel(vlog, root)
+    state.pending_commit =
+      prepared.backend === "git"
+        ? {
+            id: prepared.id,
+            backend: prepared.backend,
+            phase_index: state.phase_index,
+            message: prepared.message,
+            no_remaining_phases: noRemainingPhases,
+            verify_log: verifyLogRel,
+            branch: prepared.branch,
+            parent_commit: prepared.parent_commit,
+            tree_id: prepared.tree_id,
+          }
+        : {
+            id: prepared.id,
+            backend: prepared.backend,
+            phase_index: state.phase_index,
+            message: prepared.message,
+            no_remaining_phases: noRemainingPhases,
+            verify_log: verifyLogRel,
+            change_id: prepared.change_id,
+            content_fingerprint: prepared.content_fingerprint,
+          }
+    yield* store.save(state, root)
+
+    const committedId = yield* vcs.completeCommit(
+      root,
+      state.vcs,
+      state.pending_commit,
+    )
+
+    return yield* advanceAndSave({
+      state,
+      store,
+      vcs,
+      root,
+      noRemainingPhases,
+      committedId,
+      recovered: false,
+      transactionId: state.pending_commit.id,
+      verifyLog: verifyLogRel,
+    })
+  })
+
+type ResumeArgs = {
+  params: CommitParams
+  root: string
+  state: RunState
+  store: RunStoreService
+  vcs: VcsService
+}
+
+/**
+ * Resume the durable transaction only: no gates, no verification.
+ * Explicit retry params conflicting with the persisted values are refused.
+ */
+function resumePendingCommit({
+  params,
+  root,
+  state,
+  store,
+  vcs,
+}: ResumeArgs): Effect.Effect<ToolResult, AppError> {
+  return Effect.gen(function* () {
+    const pending = state.pending_commit!
+    const requestedMessage = params.message?.trim()
+    // Compare against the exact trailer-augmented form the transaction will
+    // write, not a stripped persisted message: stripping only removes the
+    // LAST trailer line, so a user message that legitimately ends with a
+    // trailer-shaped line would otherwise refuse an identical plain retry.
+    if (
+      requestedMessage !== undefined &&
+      requestedMessage !== pending.message &&
+      withTransactionTrailer(requestedMessage, pending.id) !== pending.message
+    ) {
+      return yield* new GateRefused({
+        gate: "commit",
+        message:
+          "conflicting retry: this call already has a durable commit transaction with a different message",
+        details: {
+          transaction: pending.id,
+          persisted_message: withoutTransactionTrailer(pending.message),
+          requested_message: requestedMessage,
+        },
+      })
+    }
+    if (
+      params.no_remaining_phases !== undefined &&
+      params.no_remaining_phases !== pending.no_remaining_phases
+    ) {
+      return yield* new GateRefused({
+        gate: "commit",
+        message:
+          "conflicting retry: this call already has a durable commit transaction with a different no_remaining_phases value",
+        details: {
+          transaction: pending.id,
+          persisted_no_remaining_phases: pending.no_remaining_phases,
+          requested_no_remaining_phases: params.no_remaining_phases,
+        },
+      })
+    }
+
+    const committedId = yield* vcs.completeCommit(root, state.vcs, pending)
+
+    return yield* advanceAndSave({
+      state,
+      store,
+      vcs,
+      root,
+      noRemainingPhases: pending.no_remaining_phases,
+      committedId,
+      recovered: true,
+      transactionId: pending.id,
+      verifyLog: pending.verify_log,
+    })
+  })
+}
+
+type AdvanceArgs = {
+  state: RunState
+  store: RunStoreService
+  vcs: VcsService
+  root: string
+  noRemainingPhases: boolean
+  committedId: string
+  recovered: boolean
+  transactionId: string
+  /** Repo-relative verify.log path captured before the phase advanced. */
+  verifyLog: string
+}
+
+/**
+ * Advance the run after completion. A bookmark failure propagates BEFORE any
+ * state mutation is saved, so `pending_commit` stays durable and the
+ * transaction remains resumable on the next call.
+ */
+function advanceAndSave({
+  state,
+  store,
+  vcs,
+  root,
+  noRemainingPhases,
+  committedId,
+  recovered,
+  transactionId,
+  verifyLog,
+}: AdvanceArgs): Effect.Effect<ToolResult, AppError> {
+  return Effect.gen(function* () {
+    if (noRemainingPhases) {
       state.step = "finishing"
       if (state.vcs === "jj") {
         yield* vcs.setBookmarkAtTerminus(root, state.slug)
@@ -129,13 +327,18 @@ export const commitWorkflow = (
       state.current_code_review = null
     }
     state.last_error = null
+    state.pending_commit = null
     yield* store.save(state, root)
 
+    const prefix = recovered
+      ? `committed phase (recovered transaction ${transactionId})`
+      : "committed phase"
     return ok(
-      `committed phase; step → ${state.step}`,
+      `${prefix}; step → ${state.step}`,
       {
-        vcs_detail: detail,
-        verify_log: rel(vlog, root),
+        vcs_detail: `${state.vcs} commit ${committedId}`,
+        transaction: transactionId,
+        verify_log: verifyLog,
         step: state.step,
         phase_index: state.phase_index,
         next:
@@ -146,3 +349,4 @@ export const commitWorkflow = (
       nextAfter(state.step),
     )
   })
+}