@markjaquith/agency 2.74.0 → 3.1.0

package/src/services/WorktreeService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { chmod, mkdir, realpath, rename, rm, stat } from "node:fs/promises"
+import { mkdir, realpath, rename, rm } from "node:fs/promises"
 import { join, resolve } from "node:path"
 import {
 	captureErrors,
@@ -38,32 +38,6 @@ const gitOutput = async (args: string[], cwd?: string) => {
 	return stdout.trim()
 }
 
-const jj = async (args: string[], cwd?: string) => {
-	const process = Bun.spawn(["jj", ...args], {
-		cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	await process.exited
-	if (process.exitCode !== 0)
-		throw new Error(await new Response(process.stderr).text())
-}
-
-const jjOutput = async (args: string[], cwd?: string) => {
-	const process = Bun.spawn(["jj", ...args], {
-		cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	const [exitCode, stdout, stderr] = await Promise.all([
-		process.exited,
-		new Response(process.stdout).text(),
-		new Response(process.stderr).text(),
-	])
-	if (exitCode !== 0) throw new Error(stderr)
-	return stdout.trim()
-}
-
 describe("WorktreeService", () => {
 	let root: string
 	let source: string
@@ -311,579 +285,6 @@ describe("WorktreeService", () => {
 		)
 	})
 
-	test("materializes and removes a jj workspace for a jj workbase", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		await git(["clone", source, repository])
-		await jj(["git", "init", "--colocate", repository])
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({
-				version: 2,
-				vcs: "jj",
-				repositories: {
-					agency: {
-						remote: "https://example.com/agency.git",
-						postCheckoutCommand: [
-							"sh",
-							"-c",
-							'printf "%s:%s" "$AGENCY_VCS" "$AGENCY_CHECKOUT_KIND" > post-checkout',
-						],
-					},
-				},
-			}),
-		)
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							id: "jj-example",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/jj-example",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-
-		const workspace = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-example", undefined, root),
-				),
-			),
-		)
-		const jjMetadata = await stat(join(workspace.writablePath!, ".jj"))
-		expect(jjMetadata.isFile() || jjMetadata.isDirectory()).toBe(true)
-		expect(
-			await Bun.file(join(workspace.writablePath!, "post-checkout")).text(),
-		).toBe("jj:writable")
-		await jj(
-			["commit", "-m", "record post-checkout output"],
-			workspace.writablePath!,
-		)
-		const inspection = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.inspect("jj-example", undefined, root),
-				),
-			),
-		)
-		expect(inspection.conflicts).toEqual([])
-		expect(inspection.checkouts[0]).toMatchObject({
-			exists: true,
-			registered: true,
-			actualBranch: "task/jj-example",
-		})
-
-		await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.remove("jj-example", undefined, root),
-				),
-			),
-		)
-		expect(await Bun.file(workspace.writablePath!).exists()).toBe(false)
-	})
-
-	test("uses a custom jj workspace creator before the post-checkout hook", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		await git(["clone", source, repository])
-		await jj(["git", "init", "--colocate", repository])
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({
-				version: 2,
-				vcs: "jj",
-				workspaceCreateCommand: [
-					"sh",
-					"-c",
-					'jj -R "$1" workspace add --name "$3" -r "$4" "$2" && printf "%s\\n%s\\n" "$AGENCY_CHECKOUT_KIND" "$AGENCY_REQUESTED_REF" > "$2/creator-finished"',
-					"workspace-creator",
-					"{repo}",
-					"{workspace}",
-					"{name}",
-					"{revision}",
-					"{kind}",
-					"{requestedRef}",
-				],
-				repositories: {
-					agency: {
-						remote: "https://example.com/agency.git",
-						postCheckoutCommand: [
-							"sh",
-							"-c",
-							'test -f creator-finished && printf "post-checkout" > hook-finished',
-						],
-					},
-				},
-			}),
-		)
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							id: "jj-custom",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/jj-custom",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-
-		const workspace = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-custom", undefined, root),
-				),
-			),
-		)
-		expect(
-			await Bun.file(join(workspace.writablePath!, "creator-finished")).text(),
-		).toBe("writable\ntask/jj-custom\n")
-		expect(
-			await Bun.file(join(workspace.writablePath!, "hook-finished")).text(),
-		).toBe("post-checkout")
-		expect(workspace.operations[0]).toMatchObject({
-			action: "create-workspace",
-			command: expect.arrayContaining(["writable", "task/jj-custom"]),
-			status: "completed",
-		})
-	})
-
-	test("rolls back a jj workspace partially created by a custom command", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		await git(["clone", source, repository])
-		await jj(["git", "init", "--colocate", repository])
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({
-				version: 2,
-				vcs: "jj",
-				workspaceCreateCommand: [
-					"sh",
-					"-c",
-					'jj -R "$1" workspace add --name "$3" -r "$4" "$2" && echo adoption-failed >&2; exit 7',
-					"workspace-creator",
-					"{repo}",
-					"{workspace}",
-					"{name}",
-					"{revision}",
-				],
-			}),
-		)
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							id: "jj-custom-failure",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/jj-custom-failure",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-		const workspacePath = join(root, "tasks/jj-custom-failure/code/agency")
-
-		await expect(
-			runTestEffect(
-				WorktreeService.pipe(
-					Effect.flatMap((service) =>
-						service.materialize("jj-custom-failure", undefined, root),
-					),
-				),
-			),
-		).rejects.toThrow("adoption-failed")
-		expect(await Bun.file(workspacePath).exists()).toBe(false)
-		expect(
-			await jjOutput(["workspace", "list", "-T", 'name ++ "\\n"'], repository),
-		).not.toContain("agency-jj-custom-failure-task-agency")
-	})
-
-	test("rejects and rolls back a custom jj workspace at the wrong revision", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		await git(["clone", source, repository])
-		await jj(["git", "init", "--colocate", repository])
-		const hookMarker = join(root, "wrong-revision-hook")
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({
-				version: 2,
-				vcs: "jj",
-				workspaceCreateCommand: [
-					"sh",
-					"-c",
-					'jj -R "$1" workspace add --name "$3" -r "root()" "$2"',
-					"workspace-creator",
-					"{repo}",
-					"{workspace}",
-					"{name}",
-					"{revision}",
-				],
-				repositories: {
-					agency: {
-						remote: "https://example.com/agency.git",
-						postCheckoutCommand: ["sh", "-c", 'touch "$1"', "hook", hookMarker],
-					},
-				},
-			}),
-		)
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							id: "jj-custom-wrong-revision",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/jj-custom-wrong-revision",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-		const workspacePath = join(
-			root,
-			"tasks/jj-custom-wrong-revision/code/agency",
-		)
-
-		await expect(
-			runTestEffect(
-				WorktreeService.pipe(
-					Effect.flatMap((service) =>
-						service.materialize("jj-custom-wrong-revision", undefined, root),
-					),
-				),
-			),
-		).rejects.toThrow("failed validation")
-		expect(await Bun.file(workspacePath).exists()).toBe(false)
-		expect(await Bun.file(hookMarker).exists()).toBe(false)
-	})
-
-	test("suspends and resumes the exact jj working-copy target", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		await git(["clone", 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: "jj-resume",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/jj-resume",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-		const workspace = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-resume", undefined, root),
-				),
-			),
-		)
-		await jj(["new", "-m", "local-only parent"], workspace.writablePath!)
-		await Bun.write(join(workspace.writablePath!, "local.txt"), "preserve me\n")
-		await jj(
-			["describe", "-m", "local working target"],
-			workspace.writablePath!,
-		)
-		const target = await jjOutput(
-			["log", "--no-graph", "-r", "@", "-T", 'commit_id ++ "\\t" ++ change_id'],
-			workspace.writablePath!,
-		)
-		const [commitId, changeId] = target.split("\t")
-		if (!commitId || !changeId)
-			throw new Error(`Unexpected jj identity: ${target}`)
-		await jj(["new", "-m", "temporary successor"], workspace.writablePath!)
-		await jj(["edit", commitId], workspace.writablePath!)
-
-		await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.remove("jj-resume", undefined, root),
-				),
-			),
-		)
-		const resumePath = join(root, "tasks/jj-resume/.agency-jj-resume.json")
-		const resume = await Bun.file(resumePath).json()
-		expect(resume.checkouts[0]).toMatchObject({ commitId, changeId })
-		expect(
-			await jjOutput(
-				[
-					"log",
-					"--no-graph",
-					"-r",
-					resume.checkouts[0].bookmark,
-					"-T",
-					"commit_id",
-				],
-				repository,
-			),
-		).toBe(commitId)
-		expect(
-			await jjOutput(
-				["log", "--no-graph", "-r", "task/jj-resume", "-T", "commit_id"],
-				repository,
-			).catch(() => null),
-		).toBeNull()
-
-		await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-resume", undefined, root),
-				),
-			),
-		)
-		expect(
-			await jjOutput(
-				["log", "--no-graph", "-r", "@", "-T", "commit_id"],
-				workspace.writablePath!,
-			),
-		).toBe(commitId)
-		expect(
-			await Bun.file(join(workspace.writablePath!, "local.txt")).text(),
-		).toBe("preserve me\n")
-		expect(await Bun.file(resumePath).exists()).toBe(false)
-		expect(
-			await jjOutput(
-				[
-					"log",
-					"--no-graph",
-					"-r",
-					resume.checkouts[0].bookmark,
-					"-T",
-					"commit_id",
-				],
-				repository,
-			).catch(() => null),
-		).toBeNull()
-	})
-
-	test("refuses stale jj resume identity and stale registrations", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		await git(["clone", source, repository])
-		await jj(["git", "init", "--colocate", repository])
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-		for (const id of ["stale-resume", "stale-registration"]) {
-			await runTestEffect(
-				TaskService.pipe(
-					Effect.flatMap((service) =>
-						service.create(
-							{
-								id,
-								ticketUrl: null,
-								repo: "agency",
-								branch: `task/${id}`,
-								base: "main",
-							},
-							root,
-						),
-					),
-				),
-			)
-		}
-		const suspended = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("stale-resume", undefined, root),
-				),
-			),
-		)
-		await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.remove("stale-resume", undefined, root),
-				),
-			),
-		)
-		const resumePath = join(root, "tasks/stale-resume/.agency-jj-resume.json")
-		const resume = await Bun.file(resumePath).json()
-		await jj([
-			"-R",
-			repository,
-			"bookmark",
-			"delete",
-			resume.checkouts[0].bookmark,
-		])
-		await expect(
-			runTestEffect(
-				WorktreeService.pipe(
-					Effect.flatMap((service) =>
-						service.materialize("stale-resume", undefined, root),
-					),
-				),
-			),
-		).rejects.toThrow("recorded commit, change ID, path, or internal bookmark")
-		expect(await Bun.file(resumePath).exists()).toBe(true)
-		expect(await Bun.file(suspended.writablePath!).exists()).toBe(false)
-
-		const stale = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("stale-registration", undefined, root),
-				),
-			),
-		)
-		await rm(join(stale.writablePath!, ".jj"), { recursive: true, force: true })
-		await expect(
-			runTestEffect(
-				WorktreeService.pipe(
-					Effect.flatMap((service) =>
-						service.remove("stale-registration", undefined, root),
-					),
-				),
-			),
-		).rejects.toThrow("checkout cleanliness could not be verified")
-	})
-
-	test("retains jj resume state when workspace deletion and rollback fail", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		await git(["clone", 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: "jj-rollback",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/jj-rollback",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-		const workspace = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-rollback", undefined, root),
-				),
-			),
-		)
-		const fakeBin = join(root, "fake-bin")
-		await mkdir(fakeBin)
-		const fakeRm = join(fakeBin, "rm")
-		await Bun.write(
-			fakeRm,
-			`#!/bin/sh\nif [ "$1" = "-rf" ] && [ "$2" = ${JSON.stringify(workspace.writablePath!)} ]; then exit 1; fi\nexec ${JSON.stringify(Bun.which("rm")!)} "$@"\n`,
-		)
-		await chmod(fakeRm, 0o755)
-		const originalPath = process.env.PATH
-		process.env.PATH = `${fakeBin}:${originalPath}`
-		try {
-			await expect(
-				runTestEffect(
-					WorktreeService.pipe(
-						Effect.flatMap((service) =>
-							service.remove("jj-rollback", undefined, root),
-						),
-					),
-				),
-			).rejects.toThrow("requires manual recovery")
-		} finally {
-			process.env.PATH = originalPath
-		}
-		const resumePath = join(root, "tasks/jj-rollback/.agency-jj-resume.json")
-		expect(await Bun.file(resumePath).exists()).toBe(true)
-
-		await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-rollback", undefined, root),
-				),
-			),
-		)
-		expect((await stat(workspace.writablePath!)).isDirectory()).toBe(true)
-		expect(await Bun.file(resumePath).exists()).toBe(false)
-	})
-
-	test("recommends a repository fetch when jj cannot resolve a base", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		await git(["clone", 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: "jj-missing",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/jj-missing",
-							base: "absent-base",
-						},
-						root,
-					),
-				),
-			),
-		)
-
-		await expect(
-			runTestEffect(
-				WorktreeService.pipe(
-					Effect.flatMap((service) =>
-						service.materialize("jj-missing", undefined, root),
-					),
-				),
-			),
-		).rejects.toThrow("run 'agency repo fetch agency' and retry")
-	})
-
 	test("does not fetch the origin for an existing writable worktree", async () => {
 		await runTestEffect(
 			TaskService.pipe(
@@ -2424,111 +1825,6 @@ pr: null
 		).toBe(true)
 	})
 
-	test("rebuilds clean drifted jj references without discarding changes", async () => {
-		if (!Bun.which("jj")) return
-		const first = new TextDecoder()
-			.decode(
-				Bun.spawnSync(["git", "-C", source, "rev-parse", "HEAD"], {
-					stdout: "pipe",
-				}).stdout,
-			)
-			.trim()
-		await Bun.write(join(source, "README.md"), "updated\n")
-		await git(["add", "README.md"], source)
-		await git(["-c", "commit.gpgsign=false", "commit", "-m", "update"], source)
-		const second = new TextDecoder()
-			.decode(
-				Bun.spawnSync(["git", "-C", source, "rev-parse", "HEAD"], {
-					stdout: "pipe",
-				}).stdout,
-			)
-			.trim()
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		await jj(["git", "clone", "--no-colocate", source, repository])
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-		const createDriftedReview = async (id: string) => {
-			const task = await runTestEffect(
-				TaskService.pipe(
-					Effect.flatMap((service) =>
-						service.create(
-							{
-								id,
-								ticketUrl: null,
-								review: {
-									repo: "agency",
-									source: {
-										kind: "branch",
-										ref: "refs/heads/main",
-									},
-									commit: first,
-									refreshedAt: "2026-08-10T00:00:00.000Z",
-								},
-							},
-							root,
-						),
-					),
-				),
-			)
-			const workspace = await runTestEffect(
-				WorktreeService.pipe(
-					Effect.flatMap((service) => service.materialize(id, undefined, root)),
-				),
-			)
-			await Bun.write(task.path, task.content.replace(first, second))
-			return workspace
-		}
-
-		const workspace = await createDriftedReview("drifted-review")
-
-		await expect(
-			runTestEffect(
-				WorktreeService.pipe(
-					Effect.flatMap((service) =>
-						service.materialize("drifted-review", undefined, root),
-					),
-				),
-			),
-		).rejects.toThrow("does not match reference")
-		const inspection = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.inspect("drifted-review", undefined, root),
-				),
-			),
-		)
-		expect(inspection.conflicts).toEqual([
-			expect.objectContaining({ kind: "reference-drift" }),
-		])
-		await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.rebuild("drifted-review", undefined, root),
-				),
-			),
-		)
-		expect(
-			await Bun.file(join(workspace.reviewPath!, "README.md")).text(),
-		).toBe("updated\n")
-
-		const dirtyWorkspace = await createDriftedReview("dirty-drifted-review")
-		const dirtyPath = join(dirtyWorkspace.reviewPath!, "dirty.txt")
-		await Bun.write(dirtyPath, "preserve me\n")
-		await expect(
-			runTestEffect(
-				WorktreeService.pipe(
-					Effect.flatMap((service) =>
-						service.rebuild("dirty-drifted-review", undefined, root),
-					),
-				),
-			),
-		).rejects.toThrow("checkout has uncommitted changes")
-		expect(await Bun.file(dirtyPath).text()).toBe("preserve me\n")
-	})
-
 	test("restores removed worktrees when rebuild creation fails", async () => {
 		await runTestEffect(
 			TaskService.pipe(