@naxodev/apnea 0.1.0

package/extension/services/run-store.ts

@@ -0,0 +1,99 @@
+import * as path from "node:path"
+import { Clock, Context, Effect, Layer, Result } from "effect"
+import {
+  apneaRoot,
+  artifactsDir,
+  statePath,
+  tasksDir,
+} from "../domain/paths.ts"
+import { NoRunState, StateCorrupt } from "../errors.ts"
+import type { RunState } from "../domain/types.ts"
+import { decodeRunState } from "../schema/state.ts"
+import { FileSystem, type FileSystemService } from "./file-system.ts"
+
+export interface RunStoreService {
+  readonly load: (root: string) => Effect.Effect<RunState | null, StateCorrupt>
+  readonly save: (state: RunState, root: string) => Effect.Effect<void>
+  readonly require: (
+    root: string,
+  ) => Effect.Effect<RunState, NoRunState | StateCorrupt>
+  readonly abandon: (root: string) => Effect.Effect<string, NoRunState>
+}
+
+export class RunStore extends Context.Service<RunStore, RunStoreService>()(
+  "apnea/RunStore",
+) {}
+
+function ensureApneaDirs(
+  fs: FileSystemService,
+  root: string,
+): Effect.Effect<void> {
+  const dirs = [
+    apneaRoot(root),
+    artifactsDir(root),
+    tasksDir(root),
+    path.join(artifactsDir(root), "plan-review"),
+  ]
+  return Effect.forEach(dirs, (d) => fs.mkdir(d, { recursive: true }), {
+    discard: true,
+  })
+}
+
+export const RunStoreLive = Layer.effect(
+  RunStore,
+  Effect.gen(function* () {
+    const fs = yield* FileSystem
+
+    const load = (root: string): Effect.Effect<RunState | null, StateCorrupt> =>
+      Effect.gen(function* () {
+        const p = statePath(root)
+        const present = yield* fs.exists(p)
+        if (!present) return null
+        const text = yield* fs.readFile(p)
+        let json: unknown
+        try {
+          json = JSON.parse(text)
+        } catch (e) {
+          return yield* new StateCorrupt({
+            path: p,
+            message: e instanceof Error ? e.message : String(e),
+          })
+        }
+        const decoded = decodeRunState(json, p)
+        if (Result.isFailure(decoded)) {
+          return yield* decoded.failure
+        }
+        return decoded.success
+      })
+
+    const save = (state: RunState, root: string): Effect.Effect<void> =>
+      Effect.gen(function* () {
+        yield* ensureApneaDirs(fs, root)
+        const p = statePath(root)
+        const body = `${JSON.stringify(state, null, 2)}\n`
+        yield* fs.writeFile(p, body)
+      })
+
+    const require = (
+      root: string,
+    ): Effect.Effect<RunState, NoRunState | StateCorrupt> =>
+      Effect.gen(function* () {
+        const s = yield* load(root)
+        if (!s) return yield* new NoRunState({})
+        return s
+      })
+
+    const abandon = (root: string): Effect.Effect<string, NoRunState> =>
+      Effect.gen(function* () {
+        const p = statePath(root)
+        const present = yield* fs.exists(p)
+        if (!present) return yield* new NoRunState({})
+        const millis = yield* Clock.currentTimeMillis
+        const bak = `${p}.abandoned.${millis}`
+        yield* fs.rename(p, bak)
+        return bak
+      })
+
+    return RunStore.of({ load, save, require, abandon })
+  }),
+)

package/extension/services/vcs.ts

@@ -0,0 +1,246 @@
+import { spawnSync } from "node:child_process"
+import * as path from "node:path"
+import { Context, Effect, Layer } from "effect"
+import { VcsError } from "../errors.ts"
+import type { VcsBackend } from "../domain/types.ts"
+import { FileSystem } from "./file-system.ts"
+
+export interface VcsService {
+  readonly detect: (root: string) => Effect.Effect<VcsBackend | null>
+  readonly isDirty: (root: string, vcs: VcsBackend) => Effect.Effect<boolean>
+  readonly treeFingerprint: (
+    root: string,
+    vcs: VcsBackend,
+  ) => Effect.Effect<string>
+  readonly ensureGitBranch: (
+    root: string,
+    slug: string,
+  ) => Effect.Effect<string, VcsError>
+  readonly commitPhase: (
+    root: string,
+    vcs: VcsBackend,
+    message: string,
+  ) => Effect.Effect<string, VcsError>
+  readonly setBookmarkAtTerminus: (
+    root: string,
+    slug: string,
+  ) => Effect.Effect<void>
+  readonly runVerify: (
+    root: string,
+    commands: readonly string[],
+    timeoutMs: number,
+  ) => Effect.Effect<{ ok: boolean; log: string }>
+}
+
+export class Vcs extends Context.Service<Vcs, VcsService>()("apnea/Vcs") {}
+
+function run(
+  cmd: string,
+  args: string[],
+  cwd: string,
+): { ok: boolean; stdout: string; stderr: string; code: number } {
+  const r = spawnSync(cmd, args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024,
+  })
+  return {
+    ok: r.status === 0,
+    stdout: (r.stdout ?? "").toString(),
+    stderr: (r.stderr ?? "").toString(),
+    code: r.status ?? 1,
+  }
+}
+
+/** Drop .apnea/ runtime paths from VCS summaries (artifacts are allowed). */
+export function filterAppPaths(summary: string): string {
+  return summary
+    .split(/\r?\n/)
+    .filter((line) => {
+      const t = line.trim()
+      if (!t) return false
+      // git porcelain: XY path
+      if (/^.. /.test(line)) {
+        const p = line.slice(3).replace(/^"|"$/g, "")
+        return !p.startsWith(".apnea/") && !p.includes("/.apnea/")
+      }
+      // jj summary often: M path / A path
+      const m = t.match(/^[A-Z]+\s+(.+)$/)
+      if (m) {
+        const p = m[1]!
+        return !p.startsWith(".apnea/") && !p.includes("/.apnea/")
+      }
+      return !t.includes(".apnea/")
+    })
+    .join("\n")
+}
+
+export const VcsLive = Layer.effect(
+  Vcs,
+  Effect.gen(function* () {
+    const fs = yield* FileSystem
+
+    const detect = (root: string): Effect.Effect<VcsBackend | null> =>
+      Effect.gen(function* () {
+        if (yield* fs.exists(path.join(root, ".jj"))) return "jj"
+        if (yield* fs.exists(path.join(root, ".git"))) return "git"
+        return null
+      })
+
+    const treeFingerprint = (
+      root: string,
+      vcs: VcsBackend,
+    ): Effect.Effect<string> =>
+      Effect.sync(() => {
+        if (vcs === "jj") {
+          const r = run("jj", ["diff", "--summary"], root)
+          return filterAppPaths(r.stdout)
+        }
+        const r = run("git", ["status", "--porcelain"], root)
+        return filterAppPaths(r.stdout)
+      })
+
+    const isDirty = (root: string, vcs: VcsBackend): Effect.Effect<boolean> =>
+      Effect.gen(function* () {
+        const fp = yield* treeFingerprint(root, vcs)
+        return fp.trim().length > 0
+      })
+
+    const ensureGitBranch = (
+      root: string,
+      slug: string,
+    ): Effect.Effect<string, VcsError> =>
+      Effect.gen(function* () {
+        const branch = `apnea/${slug}`
+        const cur = yield* Effect.sync(() =>
+          run("git", ["rev-parse", "--abbrev-ref", "HEAD"], root),
+        )
+        if (cur.stdout.trim() === branch) return branch
+        const exists = yield* Effect.sync(() =>
+          run(
+            "git",
+            ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`],
+            root,
+          ),
+        )
+        if (exists.ok) {
+          const co = yield* Effect.sync(() =>
+            run("git", ["checkout", branch], root),
+          )
+          if (!co.ok) {
+            return yield* new VcsError({
+              message: `git checkout ${branch}: ${co.stderr}`,
+              command: `git checkout ${branch}`,
+            })
+          }
+          return branch
+        }
+        const cr = yield* Effect.sync(() =>
+          run("git", ["checkout", "-b", branch], root),
+        )
+        if (!cr.ok) {
+          return yield* new VcsError({
+            message: `git checkout -b ${branch}: ${cr.stderr}`,
+            command: `git checkout -b ${branch}`,
+          })
+        }
+        return branch
+      })
+
+    const commitPhase = (
+      root: string,
+      vcs: VcsBackend,
+      message: string,
+    ): Effect.Effect<string, VcsError> =>
+      Effect.gen(function* () {
+        if (vcs === "jj") {
+          const d = yield* Effect.sync(() =>
+            run("jj", ["describe", "-m", message], root),
+          )
+          if (!d.ok) {
+            return yield* new VcsError({
+              message: d.stderr || d.stdout,
+              command: "jj describe",
+            })
+          }
+          const n = yield* Effect.sync(() => run("jj", ["new"], root))
+          if (!n.ok) {
+            return yield* new VcsError({
+              message: n.stderr || n.stdout,
+              command: "jj new",
+            })
+          }
+          return "jj describe + new"
+        }
+        const add = yield* Effect.sync(() => run("git", ["add", "-A"], root))
+        if (!add.ok) {
+          return yield* new VcsError({
+            message: add.stderr,
+            command: "git add -A",
+          })
+        }
+        const c = yield* Effect.sync(() =>
+          run("git", ["commit", "-m", message], root),
+        )
+        if (!c.ok) {
+          return yield* new VcsError({
+            message: c.stderr || c.stdout,
+            command: "git commit",
+          })
+        }
+        return "git commit"
+      })
+
+    const setBookmarkAtTerminus = (
+      root: string,
+      slug: string,
+    ): Effect.Effect<void> =>
+      Effect.sync(() => {
+        const name = `apnea/${slug}`
+        const r = run("jj", ["bookmark", "set", name, "-r", "@-"], root)
+        if (!r.ok) {
+          run("jj", ["bookmark", "create", name, "-r", "@-"], root)
+        }
+      })
+
+    const runVerify = (
+      root: string,
+      commands: readonly string[],
+      timeoutMs: number,
+    ): Effect.Effect<{ ok: boolean; log: string }> =>
+      Effect.sync(() => {
+        const lines: string[] = []
+        for (const cmd of commands) {
+          lines.push(`$ ${cmd}`)
+          const r = spawnSync("bash", ["-lc", cmd], {
+            cwd: root,
+            encoding: "utf8",
+            timeout: timeoutMs,
+            maxBuffer: 10 * 1024 * 1024,
+          })
+          const out = `${r.stdout ?? ""}${r.stderr ?? ""}`.trimEnd()
+          if (out) lines.push(out)
+          lines.push(`exit=${r.status ?? 1}`)
+          if (r.error) {
+            lines.push(String(r.error))
+            return { ok: false, log: lines.join("\n") }
+          }
+          if (r.status !== 0) {
+            return { ok: false, log: lines.join("\n") }
+          }
+          lines.push("")
+        }
+        return { ok: true, log: lines.join("\n") }
+      })
+
+    return Vcs.of({
+      detect,
+      isDirty,
+      treeFingerprint,
+      ensureGitBranch,
+      commitPhase,
+      setBookmarkAtTerminus,
+      runVerify,
+    })
+  }),
+)

package/extension/workflows/commit.ts

@@ -0,0 +1,148 @@
+import * as path from "node:path"
+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 {
+  ArtifactInvalid,
+  GateRefused,
+  VerifyFailed,
+  type AppError,
+} from "../errors.ts"
+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"
+
+export type CommitParams = {
+  message?: string
+  /** When true and no more phases, advance to finishing instead of phase_packaging */
+  no_remaining_phases?: boolean
+}
+
+/**
+ * Require APPROVED code review, run phase package verify commands,
+ * jj/git commit, advance phase. Refusals are tagged failures only.
+ */
+export const commitWorkflow = (
+  params: CommitParams,
+  root: string,
+): Effect.Effect<ToolResult, AppError, FileSystem | RunStore | Config | Vcs> =>
+  Effect.gen(function* () {
+    const store = yield* RunStore
+    const fs = yield* FileSystem
+    const config = yield* Config
+    const vcs = yield* Vcs
+
+    const state = yield* store.require(root)
+
+    const allowed = toolAllowed(state.step, "workflow_commit_phase")
+    if (Result.isFailure(allowed)) {
+      return yield* allowed.failure
+    }
+
+    const reviewRel = state.current_code_review
+    if (!reviewRel) {
+      return yield* new GateRefused({
+        gate: "commit",
+        message: "current_code_review not set — complete code_review first",
+      })
+    }
+
+    const reviewAbs = abs(reviewRel, root)
+    const reviewPresent = yield* fs.exists(reviewAbs)
+    let fm: ReturnType<typeof parseFrontMatter> = null
+    if (reviewPresent) {
+      const reviewText = yield* fs.readFile(reviewAbs)
+      fm = parseFrontMatter(reviewText)
+    }
+    const verdict = asVerdict(fm?.verdict)
+    if (verdict !== "APPROVED") {
+      return yield* new GateRefused({
+        gate: "commit",
+        message: `commit refused: code review verdict is ${fm?.verdict ?? "missing"} (need APPROVED)`,
+        details: {
+          review: reviewRel,
+          verdict: fm?.verdict ?? "missing",
+        },
+      })
+    }
+
+    const pkgRel =
+      state.current_phase_package ??
+      rel(
+        path.join(phaseDir(state.phase_index, 1, root), "phase-package.md"),
+        root,
+      )
+    const pkgAbs = abs(pkgRel, root)
+    const pkgPresent = yield* fs.exists(pkgAbs)
+    if (!pkgPresent) {
+      return yield* new GateRefused({
+        gate: "commit",
+        message: `phase package missing: ${pkgRel}`,
+        details: { package: pkgRel },
+      })
+    }
+    const pkgText = yield* fs.readFile(pkgAbs)
+    const cmds = extractVerifyCommands(pkgText)
+    if (!cmds.length) {
+      return yield* new ArtifactInvalid({
+        artifact: pkgRel,
+        message: "no verify commands found in phase package (need ```sh block)",
+      })
+    }
+
+    const cfg = yield* config.load(root)
+    const verifyTimeout = cfg.timeouts_ms.verify ?? 900_000
+    const verify = yield* vcs.runVerify(root, cmds, 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`)
+
+    if (!verify.ok) {
+      return yield* new VerifyFailed({
+        commands: cmds,
+        outputs: [verify.log.slice(-2000)],
+        // `outputs` is a tail — point the caller at the full log on disk.
+        verify_log: rel(vlog, root),
+      })
+    }
+
+    const message =
+      params.message?.trim() ||
+      `feat: apnea phase ${state.phase_index} (${state.slug})`
+
+    const detail = yield* vcs.commitPhase(root, state.vcs, message)
+
+    if (params.no_remaining_phases) {
+      state.step = "finishing"
+      if (state.vcs === "jj") {
+        yield* vcs.setBookmarkAtTerminus(root, state.slug)
+      }
+    } else {
+      state.phase_index += 1
+      state.step = "phase_packaging"
+      state.current_phase_package = null
+      state.current_code_review = null
+    }
+    state.last_error = null
+    yield* store.save(state, root)
+
+    return ok(
+      `committed phase; step → ${state.step}`,
+      {
+        vcs_detail: detail,
+        verify_log: rel(vlog, root),
+        step: state.step,
+        phase_index: state.phase_index,
+        next:
+          state.step === "finishing"
+            ? ["dispatch_role kind=pr_description"]
+            : ["dispatch_role kind=phase_package"],
+      },
+      nextAfter(state.step),
+    )
+  })