@markjaquith/agency 2.23.0 → 2.25.0

package/src/services/TaskPhaseService.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 { EpicService } from "./EpicService"
@@ -60,6 +60,52 @@ describe("task and phase services", () => {
 		expect(epic.data.tasks).toEqual([{ id: "task-one" }])
 	})
 
+	test("does not create a task when its parent update cannot start", async () => {
+		await runTestEffect(
+			EpicService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						"locked",
+						"https://example.com/epic",
+						[{ repo: "agency", ref: "main" }],
+						root,
+					),
+				),
+			),
+		)
+		const lock = join(root, ".agency-graph-mutation.lock")
+		await Bun.write(lock, "held")
+		await expect(
+			runTestEffect(
+				TaskService.pipe(
+					Effect.flatMap((service) =>
+						service.create(
+							{
+								id: "not-created",
+								ticketUrl: null,
+								epic: "locked",
+								repo: "agency",
+								branch: "task/not-created",
+								base: "main",
+							},
+							root,
+						),
+					),
+				),
+			),
+		).rejects.toThrow("Another graph mutation is in progress")
+		await rm(lock)
+		expect(
+			await Bun.file(join(root, "tasks/not-created/TASK.md")).exists(),
+		).toBe(false)
+		const epic = await runTestEffect(
+			EpicService.pipe(
+				Effect.flatMap((service) => service.show("locked", root)),
+			),
+		)
+		expect(epic.data.tasks).toEqual([])
+	})
+
 	test("creates and sequences phases on a multi-phase task", async () => {
 		await runTestEffect(
 			TaskService.pipe(

package/src/services/TaskService.ts

@@ -17,6 +17,11 @@ import {
 } from "../workbase/frontmatter"
 import { canTransitionStatus } from "../readiness"
 import { documentRevision } from "../workbase/document-revision"
+import { archivedTaskDirectory } from "../workbase/archive"
+import {
+	documentWriteStep,
+	runLifecycleTransaction,
+} from "./LifecycleTransaction"
 
 class TaskError extends Data.TaggedError("TaskError")<{
 	readonly message: string
@@ -85,6 +90,11 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 						message: `Task '${id}' already exists`,
 					})
 				}
+				if (yield* fs.exists(archivedTaskDirectory(root, id))) {
+					return yield* new TaskError({
+						message: `Task '${id}' is archived; restore it before reusing this ID`,
+					})
+				}
 
 				let data: TaskData
 				if (input.multiPhase) {
@@ -123,6 +133,12 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 								...(data.repos ?? []).map((reference) => reference.repo),
 							]
 						: []
+				if (new Set(referencedRepos).size !== referencedRepos.length) {
+					return yield* new TaskError({
+						message:
+							"Repository references must be unique and cannot include the writable repository",
+					})
+				}
 				for (const alias of referencedRepos) {
 					if (!(yield* fs.exists(join(root, "repos", alias)))) {
 						return yield* new TaskError({
@@ -134,6 +150,11 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 				let parentEpic: EpicRecord | undefined
 				if (input.epic) {
 					parentEpic = yield* epics.show(input.epic, root)
+					if (parentEpic.data.tasks.some((task) => task.id === id)) {
+						return yield* new TaskError({
+							message: `Epic '${input.epic}' already lists task '${id}'`,
+						})
+					}
 				}
 
 				const title = id
@@ -144,9 +165,11 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 					data,
 					`# ${title}\n\nDescribe the task outcome.`,
 				)
-				yield* fs.createDirectory(directory)
-				yield* fs.writeFile(path, content)
-
+				const writes: {
+					path: string
+					content: string
+					create?: boolean
+				}[] = [{ path, content, create: true }]
 				if (input.epic && parentEpic) {
 					const parsed = yield* parseFrontmatter(
 						parentEpic.content,
@@ -157,8 +180,15 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 						tasks: [...parentEpic.data.tasks, { id }],
 					}
 					const updated = formatMarkdownDocument(epicData, parsed.body)
-					yield* fs.writeFile(parentEpic.path, updated)
+					writes.push({ path: parentEpic.path, content: updated })
 				}
+				yield* runLifecycleTransaction({
+					root,
+					preconditions: parentEpic
+						? [{ path: parentEpic.path, revision: parentEpic.revision }]
+						: [],
+					steps: [documentWriteStep(root, writes)],
+				})
 
 				return {
 					id,

package/src/services/WorktreeLock.ts

@@ -0,0 +1,60 @@
+import { Data, Effect } from "effect"
+import { open, rm } from "node:fs/promises"
+import { join } from "node:path"
+
+class WorktreeLockError extends Data.TaggedError("WorktreeLockError")<{
+	readonly message: string
+	readonly cause?: unknown
+}> {}
+
+export interface WorktreeLockTarget {
+	readonly taskId: string
+	readonly phaseId?: string
+}
+
+const withWorktreeLock = <A, E, R>(
+	root: string,
+	target: WorktreeLockTarget,
+	effect: Effect.Effect<A, E, R>,
+): Effect.Effect<A, E | WorktreeLockError, R> => {
+	const key = Buffer.from(
+		`${target.taskId}:${target.phaseId ?? "task"}`,
+	).toString("hex")
+	const lockPath = join(root, `.agency-worktree-${key}.lock`)
+	return Effect.acquireUseRelease(
+		Effect.tryPromise({
+			try: () => open(lockPath, "wx"),
+			catch: (cause) =>
+				new WorktreeLockError({
+					message: `Another worktree operation is in progress for '${target.taskId}${target.phaseId ? `/${target.phaseId}` : ""}'`,
+					cause,
+				}),
+		}),
+		() => effect,
+		(lock) =>
+			Effect.promise(async () => {
+				await lock.close().catch(() => undefined)
+				await rm(lockPath, { force: true }).catch(() => undefined)
+			}),
+	)
+}
+
+export const withWorktreeLocks = <A, E, R>(
+	root: string,
+	targets: readonly WorktreeLockTarget[],
+	effect: Effect.Effect<A, E, R>,
+): Effect.Effect<A, E | WorktreeLockError, R> => {
+	const unique = new Map(
+		targets.map((target) => [
+			`${target.taskId}:${target.phaseId ?? "task"}`,
+			target,
+		]),
+	)
+	let current: Effect.Effect<A, E | WorktreeLockError, R> = effect
+	for (const [, target] of [...unique.entries()]
+		.sort(([left], [right]) => left.localeCompare(right))
+		.reverse()) {
+		current = withWorktreeLock(root, target, current)
+	}
+	return current
+}

package/src/services/WorktreeService.test.ts

@@ -427,7 +427,8 @@ describe("WorktreeService", () => {
 				repo: "agency",
 				base: "absent-base",
 				config: { version: 2 },
-				expected: "Failed to create branch 'task/bad-base'",
+				expected:
+					"Base 'absent-base' for repository 'agency' does not resolve to a commit",
 			},
 			{
 				id: "failed-command",
@@ -486,6 +487,64 @@ pr: null
 		}
 	})
 
+	test("compensates a custom command that fails after creating Git state", async () => {
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({
+				version: 2,
+				worktreeCreateCommand: [
+					"sh",
+					"-c",
+					'git -C "$1" worktree add -b "$3" "$2" "$4" >/dev/null 2>&1; exit 7',
+					"agency-worktree",
+					"{repo}",
+					"{worktree}",
+					"{branch}",
+					"{base}",
+				],
+			}),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "compensated",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							branch: "task/compensated",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		await expect(
+			runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) =>
+						service.materialize("compensated", undefined, root),
+					),
+				),
+			),
+		).rejects.toThrow("Failed to create worktree for 'agency'")
+		expect(
+			await Bun.file(join(root, "tasks/compensated/code/agency")).exists(),
+		).toBe(false)
+		expect(
+			Bun.spawnSync([
+				"git",
+				"-C",
+				join(root, "repos/agency"),
+				"show-ref",
+				"--verify",
+				"refs/heads/task/compensated",
+			]).exitCode,
+		).not.toBe(0)
+	})
+
 	test("moves and repairs an existing worktree when converting a task", async () => {
 		await runTestEffect(
 			TaskService.pipe(
@@ -554,6 +613,54 @@ pr: null
 		expect(status.exitCode).toBe(0)
 	})
 
+	test("preflights worktree registration before converting a task", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "unregistered",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/unregistered",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const checkout = join(root, "tasks/unregistered/code/agency")
+		await mkdir(checkout, { recursive: true })
+		await Bun.write(join(checkout, "keep.txt"), "keep\n")
+
+		await expect(
+			runTestEffect(
+				PhaseService.pipe(
+					Effect.flatMap((service) =>
+						service.create(
+							{
+								taskId: "unregistered",
+								id: "follow-up",
+								firstPhase: "implementation",
+								repo: "agency",
+								branch: "task/follow-up-unregistered",
+								base: "main",
+							},
+							root,
+						),
+					),
+				),
+			),
+		).rejects.toThrow("is not registered as a Git worktree")
+		expect(await Bun.file(join(checkout, "keep.txt")).text()).toBe("keep\n")
+		expect(
+			await Bun.file(
+				join(root, "tasks/unregistered/phases/implementation/PHASE.md"),
+			).exists(),
+		).toBe(false)
+	})
+
 	test("rejects a writable branch checked out in another worktree", async () => {
 		const repository = join(root, "repos/agency")
 		await git(["-C", repository, "branch", "task/shared", "main"])
@@ -733,6 +840,21 @@ pr: null
 				),
 			),
 		).rejects.toThrow("is attached to branch 'main'")
+		expect(
+			await Bun.file(
+				join(root, "tasks/attached-reference/code/agency"),
+			).exists(),
+		).toBe(false)
+		expect(
+			Bun.spawnSync([
+				"git",
+				"-C",
+				join(root, "repos/agency"),
+				"show-ref",
+				"--verify",
+				"refs/heads/task/attached-reference",
+			]).exitCode,
+		).not.toBe(0)
 	})
 
 	test("removes worktrees without deleting branches", async () => {
@@ -860,6 +982,57 @@ pr: null
 		).not.toBe(0)
 	})
 
+	test("dry-run resolves a reference that exists only on the remote", async () => {
+		await git(["checkout", "-b", "remote-only"], source)
+		await Bun.write(join(source, "remote.txt"), "remote\n")
+		await git(["add", "remote.txt"], source)
+		await git(
+			["-c", "commit.gpgsign=false", "commit", "-m", "remote branch"],
+			source,
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "remote-reference",
+							ticketUrl: null,
+							repo: "agency",
+							repos: [{ repo: "effect", ref: "remote-only" }],
+							branch: "task/remote-reference",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("remote-reference", undefined, root, {
+						dryRun: true,
+					}),
+				),
+			),
+		)
+		expect(
+			workspace.checkouts.find((checkout) => checkout.repo === "effect")
+				?.resolvedCommit,
+		).toMatch(/^[0-9a-f]{40}$/)
+		expect(
+			Bun.spawnSync([
+				"git",
+				"-C",
+				join(root, "repos/effect"),
+				"show-ref",
+				"--verify",
+				"refs/heads/remote-only",
+			]).exitCode,
+		).not.toBe(0)
+	})
+
 	test("refuses to remove a worktree with uncommitted changes", async () => {
 		await runTestEffect(
 			TaskService.pipe(