@markjaquith/agency 2.57.0 → 2.58.1

package/src/services/ArchiveService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { mkdir } from "node:fs/promises"
+import { mkdir, rm } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { ArchiveService } from "./ArchiveService"
@@ -22,8 +22,33 @@ const git = async (args: string[], cwd?: string) => {
 	}
 }
 
+const jj = async (args: string[]) => {
+	const process = Bun.spawn(["jj", ...args], {
+		stdout: "pipe",
+		stderr: "pipe",
+	})
+	await process.exited
+	if (process.exitCode !== 0) {
+		throw new Error(await new Response(process.stderr).text())
+	}
+}
+
 describe("ArchiveService", () => {
 	let root: string
+	const dropTask = (id: string) =>
+		runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.setStatus(id, "dropped", root)),
+			),
+		)
+	const dropPhase = (taskId: string, id: string) =>
+		runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus(taskId, id, "dropped", root),
+				),
+			),
+		)
 
 	beforeEach(async () => {
 		root = await createTempDir()
@@ -42,6 +67,142 @@ describe("ArchiveService", () => {
 
 	afterEach(async () => cleanupTempDir(root))
 
+	test("requires terminal effective status for singular task archival", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "status-check",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/status-check",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await expect(
+			runTestEffect(
+				ArchiveService.pipe(
+					Effect.flatMap((service) =>
+						service.archiveTask("status-check", root),
+					),
+				),
+			),
+		).rejects.toThrow("status=open")
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus("status-check", "working", root),
+				),
+			),
+		)
+		await expect(
+			runTestEffect(
+				ArchiveService.pipe(
+					Effect.flatMap((service) =>
+						service.archiveTask("status-check", root),
+					),
+				),
+			),
+		).rejects.toThrow("status=working")
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus("status-check", "dropped", root),
+				),
+			),
+		)
+		const result = await runTestEffect(
+			ArchiveService.pipe(
+				Effect.flatMap((service) =>
+					service.archiveTask("status-check", root, { dryRun: true }),
+				),
+			),
+		)
+		expect(result.dryRun).toBe(true)
+
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "done-check",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/done-check",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const donePath = join(root, "tasks/done-check/TASK.md")
+		await Bun.write(
+			donePath,
+			(await Bun.file(donePath).text()).replace("status: open", "status: done"),
+		)
+		const doneResult = await runTestEffect(
+			ArchiveService.pipe(
+				Effect.flatMap((service) =>
+					service.archiveTask("done-check", root, { dryRun: true }),
+				),
+			),
+		)
+		expect(doneResult.dryRun).toBe(true)
+	})
+
+	test("rejects empty and partially terminal multi-phase tasks in singular archival", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{ id: "empty", ticketUrl: null, multiPhase: true },
+						root,
+					),
+				),
+			),
+		)
+		await expect(
+			runTestEffect(
+				ArchiveService.pipe(
+					Effect.flatMap((service) => service.archiveTask("empty", root)),
+				),
+			),
+		).rejects.toThrow("has no phases")
+
+		for (const id of ["terminal", "open"]) {
+			await runTestEffect(
+				PhaseService.pipe(
+					Effect.flatMap((service) =>
+						service.create(
+							{
+								taskId: "empty",
+								id,
+								repo: "agency",
+								branch: `task/empty-${id}`,
+								base: "main",
+							},
+							root,
+						),
+					),
+				),
+			)
+		}
+		await dropPhase("empty", "terminal")
+		await expect(
+			runTestEffect(
+				ArchiveService.pipe(
+					Effect.flatMap((service) => service.archiveTask("empty", root)),
+				),
+			),
+		).rejects.toThrow("phase:open:status=open")
+	})
+
 	test("archives a task after removing its worktree and preserves its branch", async () => {
 		await runTestEffect(
 			EpicService.pipe(
@@ -79,6 +240,7 @@ describe("ArchiveService", () => {
 				),
 			),
 		)
+		await dropTask("child")
 
 		const result = await runTestEffect(
 			ArchiveService.pipe(
@@ -114,6 +276,166 @@ describe("ArchiveService", () => {
 		).toBe(0)
 	})
 
+	test("retries archive after a jj workspace was forgotten but not deleted", async () => {
+		if (!Bun.which("jj")) return
+		const repository = join(root, "repos/agency")
+		await rm(repository, { recursive: true, force: true })
+		await git(["clone", join(root, "source"), repository])
+		await jj(["git", "init", "--colocate", repository])
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({ version: 2, vcs: "jj" }),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "interrupted",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/interrupted",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus("interrupted", "dropped", root),
+				),
+			),
+		)
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("interrupted", undefined, root),
+				),
+			),
+		)
+		await jj([
+			"-R",
+			repository,
+			"workspace",
+			"forget",
+			"agency-interrupted-task-agency",
+		])
+
+		const preview = await runTestEffect(
+			ArchiveService.pipe(
+				Effect.flatMap((service) =>
+					service.archiveTask("interrupted", root, { dryRun: true }),
+				),
+			),
+		)
+		expect(preview.removedWorktrees).toEqual([workspace.writablePath!])
+
+		await runTestEffect(
+			ArchiveService.pipe(
+				Effect.flatMap((service) => service.archiveTask("interrupted", root)),
+			),
+		)
+		expect(await Bun.file(workspace.writablePath!).exists()).toBe(false)
+		expect(
+			await Bun.file(join(root, "archive/tasks/interrupted/TASK.md")).exists(),
+		).toBe(true)
+	})
+
+	test("refuses a modified residual jj checkout after workspace removal", async () => {
+		if (!Bun.which("jj")) return
+		const repository = join(root, "repos/agency")
+		await rm(repository, { recursive: true, force: true })
+		await git(["clone", join(root, "source"), repository])
+		await jj(["git", "init", "--colocate", repository])
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({ version: 2, vcs: "jj" }),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "modified-residual",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/modified-residual",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus("modified-residual", "dropped", root),
+				),
+			),
+		)
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("modified-residual", undefined, root),
+				),
+			),
+		)
+		await jj([
+			"-R",
+			repository,
+			"workspace",
+			"forget",
+			"agency-modified-residual-task-agency",
+		])
+		await Bun.write(join(workspace.writablePath!, "keep.txt"), "keep me\n")
+
+		await expect(
+			runTestEffect(
+				ArchiveService.pipe(
+					Effect.flatMap((service) =>
+						service.archiveTask("modified-residual", root),
+					),
+				),
+			),
+		).rejects.toThrow("contents do not match expected revision")
+		expect(
+			await Bun.file(join(workspace.writablePath!, "keep.txt")).text(),
+		).toBe("keep me\n")
+		expect(
+			await Bun.file(join(root, "tasks/modified-residual/TASK.md")).exists(),
+		).toBe(true)
+		expect(
+			await Bun.file(
+				join(
+					root,
+					`.agency-worktree-${Buffer.from("modified-residual:task").toString("hex")}.lock`,
+				),
+			).exists(),
+		).toBe(false)
+
+		await rm(join(workspace.writablePath!, "keep.txt"))
+		await rm(join(workspace.writablePath!, ".jj"), {
+			recursive: true,
+			force: true,
+		})
+		await expect(
+			runTestEffect(
+				ArchiveService.pipe(
+					Effect.flatMap((service) =>
+						service.archiveTask("modified-residual", root),
+					),
+				),
+			),
+		).rejects.toThrow("is not registered as a jj workspace")
+		expect(
+			await Bun.file(join(workspace.writablePath!, "README.md")).exists(),
+		).toBe(true)
+	})
+
 	test("archives a phase in the mirrored task hierarchy", async () => {
 		await runTestEffect(
 			TaskService.pipe(
@@ -316,6 +638,7 @@ describe("ArchiveService", () => {
 			),
 		)
 		await Bun.write(join(workspace.writablePath!, "dirty.txt"), "keep me\n")
+		await dropTask("dirty")
 
 		await expect(
 			runTestEffect(
@@ -349,6 +672,7 @@ describe("ArchiveService", () => {
 				),
 			),
 		)
+		await dropTask("preview")
 
 		const archivePreview = await runTestEffect(
 			ArchiveService.pipe(
@@ -416,6 +740,7 @@ describe("ArchiveService", () => {
 				),
 			),
 		)
+		await dropTask("child")
 		await runTestEffect(
 			ArchiveService.pipe(
 				Effect.flatMap((service) => service.archiveTask("child", root)),
@@ -426,7 +751,11 @@ describe("ArchiveService", () => {
 			ArchiveService.pipe(
 				Effect.flatMap((service) =>
 					service.list(
-						{ kinds: ["task"], repositories: ["agency"], statuses: ["open"] },
+						{
+							kinds: ["task"],
+							repositories: ["agency"],
+							statuses: ["dropped"],
+						},
 						root,
 					),
 				),
@@ -688,6 +1017,7 @@ describe("ArchiveService", () => {
 				),
 			),
 		)
+		await dropTask("reserved")
 		await runTestEffect(
 			ArchiveService.pipe(
 				Effect.flatMap((service) => service.archiveTask("reserved", root)),
@@ -737,6 +1067,7 @@ describe("ArchiveService", () => {
 				),
 			),
 		)
+		await dropTask("locked")
 		await Bun.write(join(root, ".agency-archive.lock"), "held\n")
 
 		await expect(
@@ -784,6 +1115,7 @@ describe("ArchiveService", () => {
 				),
 			),
 		)
+		await dropTask("child")
 		await runTestEffect(
 			ArchiveService.pipe(
 				Effect.flatMap((service) => service.archiveTask("child", root)),
@@ -895,6 +1227,8 @@ describe("ArchiveService", () => {
 			join(root, "tasks/multi-dirty/phases/dirty/code/agency/dirty.txt"),
 			"keep me\n",
 		)
+		await dropPhase("multi-dirty", "clean")
+		await dropPhase("multi-dirty", "dirty")
 
 		await expect(
 			runTestEffect(