@markjaquith/agency 3.2.13 → 3.2.15

package/src/services/WorktreeLock.test.ts

@@ -1,205 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { mkdtemp, readdir, rm, utimes } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { withWorktreeLocks } from "./WorktreeLock"
-
-const createTempDir = () => mkdtemp(join(tmpdir(), "agency-lock-test-"))
-const cleanupTempDir = (path: string) =>
-	rm(path, { recursive: true, force: true })
-
-describe("withWorktreeLocks", () => {
-	const tempDirs: string[] = []
-
-	afterEach(async () => {
-		await Promise.all(tempDirs.splice(0).map(cleanupTempDir))
-	})
-
-	test("rejects a concurrent operation for the same target", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		let entered!: () => void
-		let release!: () => void
-		const enteredPromise = new Promise<void>((resolve) => {
-			entered = resolve
-		})
-		const releasePromise = new Promise<void>((resolve) => {
-			release = resolve
-		})
-		const held = Effect.runPromise(
-			withWorktreeLocks(
-				root,
-				[{ taskId: "alpha" }],
-				Effect.promise(async () => {
-					entered()
-					await releasePromise
-				}),
-			),
-		)
-		await enteredPromise
-
-		const conflict = await Effect.runPromise(
-			Effect.either(
-				withWorktreeLocks(root, [{ taskId: "alpha" }], Effect.void),
-			),
-		)
-		release()
-		await held
-		const lockPath = join(
-			root,
-			`.agency-worktree-${Buffer.from("alpha:task").toString("hex")}.lock`,
-		)
-		expect(conflict).toMatchObject({
-			_tag: "Left",
-			left: {
-				_tag: "WorktreeLockError",
-				message: `Another worktree operation is in progress for 'alpha'. Retry with --force or remove the stale sentinel with: rm '${lockPath}'`,
-			},
-		})
-	})
-
-	test("removes stale locks before acquiring them", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		const lockPath = join(
-			root,
-			`.agency-worktree-${Buffer.from("alpha:task").toString("hex")}.lock`,
-		)
-		await Bun.write(lockPath, "")
-		const staleAt = new Date(Date.now() - 11 * 60 * 1000)
-		await utimes(lockPath, staleAt, staleAt)
-
-		await expect(
-			Effect.runPromise(
-				withWorktreeLocks(root, [{ taskId: "alpha" }], Effect.void),
-			),
-		).resolves.toBeUndefined()
-	})
-
-	test("force overrides an active lock", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		let firstEntered!: () => void
-		let firstRelease!: () => void
-		const firstEnteredPromise = new Promise<void>((resolve) => {
-			firstEntered = resolve
-		})
-		const firstReleasePromise = new Promise<void>((resolve) => {
-			firstRelease = resolve
-		})
-		const first = Effect.runPromise(
-			withWorktreeLocks(
-				root,
-				[{ taskId: "alpha" }],
-				Effect.promise(async () => {
-					firstEntered()
-					await firstReleasePromise
-				}),
-			),
-		)
-		await firstEnteredPromise
-
-		let forcedEntered!: () => void
-		let forcedRelease!: () => void
-		const forcedEnteredPromise = new Promise<void>((resolve) => {
-			forcedEntered = resolve
-		})
-		const forcedReleasePromise = new Promise<void>((resolve) => {
-			forcedRelease = resolve
-		})
-		const forced = Effect.runPromise(
-			withWorktreeLocks(
-				root,
-				[{ taskId: "alpha" }],
-				Effect.promise(async () => {
-					forcedEntered()
-					await forcedReleasePromise
-				}),
-				{ force: true },
-			),
-		)
-		await forcedEnteredPromise
-
-		firstRelease()
-		await first
-
-		const conflict = await Effect.runPromise(
-			Effect.either(
-				withWorktreeLocks(root, [{ taskId: "alpha" }], Effect.void),
-			),
-		)
-		expect(conflict).toMatchObject({
-			_tag: "Left",
-			left: { _tag: "WorktreeLockError" },
-		})
-
-		forcedRelease()
-		await forced
-	})
-
-	test("releases locks when the protected operation fails", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		const failure = new Error("operation failed")
-
-		const result = await Effect.runPromise(
-			Effect.either(
-				withWorktreeLocks(
-					root,
-					[{ taskId: "alpha", phaseId: "build" }],
-					Effect.fail(failure),
-				),
-			),
-		)
-		expect(result._tag).toBe("Left")
-		if (result._tag === "Left") expect(result.left).toBe(failure)
-		await expect(
-			Effect.runPromise(
-				withWorktreeLocks(
-					root,
-					[{ taskId: "alpha", phaseId: "build" }],
-					Effect.succeed("reacquired"),
-				),
-			),
-		).resolves.toBe("reacquired")
-	})
-
-	test("deduplicates targets while keeping task and phase locks distinct", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		let entered!: () => void
-		let release!: () => void
-		const enteredPromise = new Promise<void>((resolve) => {
-			entered = resolve
-		})
-		const releasePromise = new Promise<void>((resolve) => {
-			release = resolve
-		})
-		const held = Effect.runPromise(
-			withWorktreeLocks(
-				root,
-				[
-					{ taskId: "alpha" },
-					{ taskId: "alpha" },
-					{ taskId: "alpha", phaseId: "build" },
-				],
-				Effect.promise(async () => {
-					entered()
-					await releasePromise
-				}),
-			),
-		)
-		await enteredPromise
-
-		expect(
-			(await readdir(root)).filter((path) => path.endsWith(".lock")),
-		).toHaveLength(2)
-
-		release()
-		await held
-		expect(
-			(await readdir(root)).filter((path) => path.endsWith(".lock")),
-		).toEqual([])
-	})
-})

package/src/services/WorktreePerformance.test.ts

@@ -1,71 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { mkdir } from "node:fs/promises"
-import { join } from "node:path"
-import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
-import { PhaseService } from "./PhaseService"
-import { TaskService } from "./TaskService"
-
-const taskDocument = (id: string) => `---
-ticketUrl: null
-repo: agency
-branch: task/${id}
-base: main
-pr: null
-status: open
----
-
-# ${id}
-`
-
-describe("worktree document loading", () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	test("shows a task without parsing sibling task documents", async () => {
-		await mkdir(join(root, "tasks/target"), { recursive: true })
-		await mkdir(join(root, "tasks/broken"), { recursive: true })
-		await Bun.write(join(root, "tasks/target/TASK.md"), taskDocument("target"))
-		await Bun.write(join(root, "tasks/broken/TASK.md"), "invalid frontmatter")
-
-		const task = await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) => service.show("target", root)),
-			),
-		)
-
-		expect(task.id).toBe("target")
-	})
-
-	test("lists phases from a preloaded task without rereading its parent", async () => {
-		const phasePath = join(root, "tasks/multi/phases/build")
-		await mkdir(phasePath, { recursive: true })
-		await Bun.write(
-			join(phasePath, "PHASE.md"),
-			`---
-repo: agency
-branch: task/multi-build
-base: main
-pr: null
-status: open
----
-
-# Build
-`,
-		)
-
-		const phases = await runTestEffect(
-			PhaseService.pipe(
-				Effect.flatMap((service) => service.list("multi", root, true)),
-			),
-		)
-
-		expect(phases.map(({ id }) => id)).toEqual(["build"])
-	})
-})