@markjaquith/agency 2.74.0 → 3.0.0

package/src/commands/pr.ts

@@ -3,11 +3,8 @@ import { resolve } from "node:path"
 import { ContextService } from "../services/ContextService"
 import { FileSystemService } from "../services/FileSystemService"
 import { PullRequestService } from "../services/PullRequestService"
-import { VersionControlService } from "../services/VersionControlService"
-import { WorkbaseService } from "../services/WorkbaseService"
 import type { BaseCommandOptions } from "../utils/command"
 import { createLoggers } from "../utils/effect"
-import { repositoryFromRemote } from "../workbase/delivery-command"
 
 interface PrCreateOptions extends BaseCommandOptions {
 	readonly taskId: string
@@ -20,56 +17,6 @@ interface PrCreateOptions extends BaseCommandOptions {
 	readonly labels?: readonly string[]
 }
 
-const branchTargetCommands = new Set([
-	"checkout",
-	"checks",
-	"close",
-	"comment",
-	"diff",
-	"edit",
-	"lock",
-	"merge",
-	"ready",
-	"reopen",
-	"revert",
-	"review",
-	"unlock",
-	"update-branch",
-	"view",
-])
-
-const hasOption = (args: readonly string[], short: string, long: string) =>
-	args.some(
-		(argument) =>
-			argument === short ||
-			argument.startsWith(`${short}=`) ||
-			argument === long ||
-			argument.startsWith(`${long}=`),
-	)
-
-const withJjContext = (
-	args: readonly string[],
-	branch: string,
-	repository: string,
-) => {
-	const [command, ...rest] = args
-	if (!command) return args
-
-	const branchArgs =
-		(command === "create" || command === "new") &&
-		!hasOption(rest, "-H", "--head")
-			? ["--head", branch]
-			: branchTargetCommands.has(command) &&
-				  (rest.length === 0 || rest[0]?.startsWith("-"))
-				? [branch]
-				: []
-	const repositoryArgs = hasOption(rest, "-R", "--repo")
-		? []
-		: ["--repo", repository]
-
-	return [command, ...branchArgs, ...repositoryArgs, ...rest]
-}
-
 export const prCreate = (options: PrCreateOptions) =>
 	Effect.gen(function* () {
 		const pullRequests = yield* PullRequestService
@@ -88,8 +35,6 @@ export const pr = (args: readonly string[], cwd: string = process.cwd()) =>
 	Effect.gen(function* () {
 		const contexts = yield* ContextService
 		const fs = yield* FileSystemService
-		const workbase = yield* WorkbaseService
-		const versionControl = yield* VersionControlService
 		const invocationCwd = resolve(cwd)
 		const context = yield* contexts
 			.get({ cwd: invocationCwd, target: ".", compact: true })
@@ -104,30 +49,9 @@ export const pr = (args: readonly string[], cwd: string = process.cwd()) =>
 				: null
 		const focusedCheckout = writableCheckout ?? reviewCheckout
 		const focusedCwd = focusedCheckout ?? invocationCwd
-		let forwardedArgs = args
-		let environment: Record<string, string> = {}
-		if (focusedCheckout && context?.workbase.vcs === "jj") {
-			if (writableCheckout && context.authority.writable) {
-				const execution =
-					context.documents?.phase?.data ?? context.documents?.task?.data
-				const { config } = yield* workbase.loadConfig(context.workbase.root)
-				const remote =
-					config.repositories?.[context.authority.writable.repo]?.remote
-				if (execution && "branch" in execution && remote) {
-					forwardedArgs = withJjContext(
-						args,
-						execution.branch,
-						repositoryFromRemote(remote),
-					)
-				}
-			}
-			const backend = yield* versionControl.forWorkbase(context.workbase.root)
-			environment = yield* backend.gitEnvironment(focusedCheckout)
-		}
-		const result = yield* fs.runCommand(["gh", "pr", ...forwardedArgs], {
+		const result = yield* fs.runCommand(["gh", "pr", ...args], {
 			cwd: focusedCwd,
 			passthrough: true,
-			env: environment,
 		})
 		return result.exitCode
 	})
@@ -139,8 +63,7 @@ Usage: agency pr create <task-id> [phase-id] [options]
 Create records a pull request for an Agency execution unit and accepts the
 options listed below. Invocations without an Agency task target run gh pr
 unchanged, focusing the writable repository checkout when invoked from
-an Agency execution task or phase. In jj workbases, Agency supplies the declared
-branch and repository to gh subcommands that would otherwise infer Git context.
+an Agency execution task or phase.
 
 Options:
   --draft                   Create the pull request as a draft

package/src/commands/push.test.ts

@@ -14,13 +14,12 @@ describe("push command", () => {
 			fail: (message) => updates.push(`fail:${message}`),
 		}
 		const result = {
-			vcs: "jj" as const,
+			vcs: "git" as const,
 			taskId: "example",
 			branch: "task/example",
 			base: "main",
 			remote: "origin",
 			tip: "abc123",
-			changeId: "change",
 		}
 		const logs = await captureLogs(() =>
 			Effect.runPromise(

package/src/graph-schema.ts

@@ -57,7 +57,7 @@ export const GraphReadiness = Schema.Struct({
 
 export const GraphWorkbase = Schema.Struct({
 	version: Schema.Literal(2),
-	vcs: Schema.optional(Schema.Literal("git", "jj")),
+	vcs: Schema.optional(Schema.Literal("git")),
 	root: Schema.optional(Schema.String),
 })
 

package/src/services/ArchiveBulkService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { chmod, mkdir, rm } from "node:fs/promises"
+import { chmod, mkdir } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { ArchiveService } from "./ArchiveService"
@@ -17,13 +17,6 @@ const git = (args: readonly string[], cwd?: string) => {
 	}
 }
 
-const jj = (args: readonly string[], cwd?: string) => {
-	const result = Bun.spawnSync(["jj", ...args], { cwd })
-	if (result.exitCode !== 0) {
-		throw new Error(new TextDecoder().decode(result.stderr))
-	}
-}
-
 describe("ArchiveService bulk task archive", () => {
 	let root: string
 	let source: string
@@ -430,140 +423,6 @@ claim:
 		])
 	})
 
-	test("skips a dirty jj workspace", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		git(["clone", source, repository])
-		const initialized = Bun.spawnSync([
-			"jj",
-			"git",
-			"init",
-			"--colocate",
-			repository,
-		])
-		if (initialized.exitCode !== 0) {
-			throw new Error(new TextDecoder().decode(initialized.stderr))
-		}
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-		await createTask("jj-dirty")
-		await dropTask("jj-dirty")
-		const workspace = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-dirty", undefined, root),
-				),
-			),
-		)
-		await Bun.write(join(workspace.writablePath!, "dirty.txt"), "keep\n")
-
-		const result = await archiveTasks()
-
-		expect(result.tasks[0]).toMatchObject({
-			id: "jj-dirty",
-			disposition: "skipped",
-			reason: { code: "dirty-worktree" },
-		})
-		expect(
-			await Bun.file(join(workspace.writablePath!, "dirty.txt")).exists(),
-		).toBe(true)
-	})
-
-	test("archives a jj working-copy commit preserved by its task bookmark", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		git(["clone", source, repository])
-		jj(["git", "init", "--colocate", repository])
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-		await createTask("jj-bookmarked")
-		await dropTask("jj-bookmarked")
-		const workspace = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-bookmarked", undefined, root),
-				),
-			),
-		)
-		await Bun.write(join(workspace.writablePath!, "preserved.txt"), "keep\n")
-		jj(
-			["bookmark", "set", "task/jj-bookmarked", "-r", "@"],
-			workspace.writablePath!,
-		)
-
-		const preview = await archiveTasks(true)
-		expect(preview.tasks[0]).toMatchObject({
-			id: "jj-bookmarked",
-			disposition: "planned",
-			removedWorktrees: [workspace.writablePath!],
-		})
-		expect(
-			await Bun.file(join(workspace.writablePath!, "preserved.txt")).text(),
-		).toBe("keep\n")
-
-		const result = await archiveTasks()
-		expect(result.tasks[0]).toMatchObject({
-			id: "jj-bookmarked",
-			disposition: "archived",
-		})
-		expect(await Bun.file(workspace.writablePath!).exists()).toBe(false)
-		const preserved = Bun.spawnSync([
-			"jj",
-			"-R",
-			repository,
-			"file",
-			"show",
-			"-r",
-			"task/jj-bookmarked",
-			'root:"preserved.txt"',
-		])
-		if (preserved.exitCode !== 0) {
-			throw new Error(preserved.stderr.toString())
-		}
-		expect(preserved.stdout.toString()).toBe("keep\n")
-	})
-
-	test("archives a forgotten jj workspace preserved by its task bookmark", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		git(["clone", source, repository])
-		jj(["git", "init", "--colocate", repository])
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-		await createTask("jj-stale")
-		await dropTask("jj-stale")
-		const workspace = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-stale", undefined, root),
-				),
-			),
-		)
-		await Bun.write(join(workspace.writablePath!, "preserved.txt"), "keep\n")
-		jj(["bookmark", "set", "task/jj-stale", "-r", "@"], workspace.writablePath!)
-		jj(["-R", repository, "workspace", "forget", "agency-jj-stale-task-agency"])
-
-		const result = await archiveTasks(true)
-
-		expect(result.tasks[0]).toMatchObject({
-			id: "jj-stale",
-			disposition: "planned",
-			removedWorktrees: [workspace.writablePath!],
-		})
-		expect(
-			await Bun.file(join(workspace.writablePath!, "preserved.txt")).text(),
-		).toBe("keep\n")
-	})
-
 	test("rolls back the entire cohort when application fails", async () => {
 		await runTestEffect(
 			EpicService.pipe(

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, rm } from "node:fs/promises"
+import { mkdir } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { ArchiveService } from "./ArchiveService"
@@ -22,17 +22,6 @@ 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) =>
@@ -276,166 +265,6 @@ 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(

package/src/services/ArchiveService.ts

@@ -13,7 +13,6 @@ import {
 } from "./WorktreeService"
 import {
 	GitVersionControlService,
-	JjVersionControlService,
 	VersionControlService,
 } from "./VersionControlService"
 import {
@@ -368,7 +367,6 @@ const WorktreeLayer = Layer.mergeAll(
 	FileSystemService.Default,
 	WorkbaseService.Default,
 	GitVersionControlService.Default,
-	JjVersionControlService.Default,
 	VersionControlService.Default,
 	TaskService.Default,
 	PhaseService.Default,
@@ -400,22 +398,6 @@ const restoreWorktreeSnapshots = async (
 			continue
 		} catch {}
 		await mkdir(dirname(snapshot.path), { recursive: true })
-		if (snapshot.vcs === "jj") {
-			await runGit([
-				"jj",
-				"-R",
-				snapshot.repositoryPath,
-				"workspace",
-				"add",
-				"--name",
-				snapshot.workspaceName!,
-				"-r",
-				snapshot.head,
-				snapshot.path,
-			])
-			await runGit(["jj", "-R", snapshot.path, "edit", snapshot.head])
-			continue
-		}
 		await runGit(
 			snapshot.branch
 				? [
@@ -724,7 +706,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 						removedWorktrees.push(
 							...(yield* worktrees.remove(unit.taskId, unit.phaseId, root, {
 								dryRun: true,
-								persistResume: false,
 							})),
 						)
 					}
@@ -783,7 +764,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 												worktrees.remove(unit.taskId, unit.phaseId, root, {
 													snapshots,
 													lockHeld: true,
-													persistResume: false,
 												}),
 											)
 									} catch (cause) {
@@ -897,7 +877,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 							const result = yield* worktrees
 								.remove(unit.taskId, executionPhaseId(unit), root, {
 									dryRun: true,
-									persistResume: false,
 									task: context.task,
 									phase: unit.phaseId
 										? context.phases.find((phase) => phase.id === unit.phaseId)
@@ -1075,7 +1054,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 												worktrees.remove(unit.taskId, unit.phaseId, root, {
 													snapshots,
 													lockHeld: true,
-													persistResume: false,
 													task: contexts.get(unit.taskId)!.task,
 													phase: unit.phaseId
 														? contexts
@@ -1232,7 +1210,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 								root,
 								{
 									dryRun: true,
-									persistResume: false,
 								},
 							)),
 						)
@@ -1288,7 +1265,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 													{
 														snapshots,
 														lockHeld: true,
-														persistResume: false,
 													},
 												),
 											)
@@ -1381,7 +1357,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 					yield* rejectExistingDestination(destination, "Archive")
 					const removedWorktrees = yield* worktrees.remove(taskId, id, root, {
 						dryRun: true,
-						persistResume: false,
 					})
 					const at = new Date().toISOString()
 					const content = yield* declarationContent(task, {
@@ -1430,7 +1405,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 													worktrees.remove(taskId, id, root, {
 														snapshots,
 														lockHeld: true,
-														persistResume: false,
 													}),
 												)
 											},

package/src/services/ContextService.ts

@@ -350,7 +350,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 								root,
 								configPath: join(root, "agency.json"),
 								version: config.version,
-								vcs: config.vcs ?? "git",
+								vcs: "git",
 							},
 							target: { kind: "workbase", path: root },
 							hint: compact
@@ -1025,51 +1025,9 @@ export class ContextService extends Effect.Service<ContextService>()(
 					const inspectCheckout = (
 						repositoryPath: string,
 						checkoutPath: string,
-						expectedBranch: string | null = null,
-						branchCommit: string | null = null,
 					) =>
 						Effect.gen(function* (): Generator<any, CheckoutInspection, any> {
 							const materialized = yield* fs.isDirectory(checkoutPath)
-							if (backend.kind === "jj") {
-								const listed = yield* Effect.either(
-									backend.listWorkspaces(repositoryPath),
-								)
-								const workspaces = Either.isRight(listed) ? listed.right : []
-								if (Either.isLeft(listed)) {
-									inspectionWarnings.push(
-										`Unable to inspect jj workspace registrations for ${repositoryPath}`,
-									)
-								}
-								const canonicalCheckoutPath = materialized
-									? yield* fs.realPath(checkoutPath)
-									: resolve(checkoutPath)
-								const workspace = workspaces.find(
-									(workspace) => workspace.path === canonicalCheckoutPath,
-								)
-								const registered = workspace !== undefined
-								if (!materialized) {
-									return {
-										materialized: false,
-										registered,
-										checkoutCommit: null,
-										checkoutBranch: null,
-										detached: null,
-										dirty: null,
-									}
-								}
-								return {
-									materialized: true,
-									registered,
-									checkoutCommit: workspace?.commit ?? null,
-									checkoutBranch:
-										expectedBranch && branchCommit === workspace?.commit
-											? expectedBranch
-											: null,
-									detached:
-										!expectedBranch || branchCommit !== workspace?.commit,
-									dirty: workspace ? false : null,
-								}
-							}
 							const listed = yield* runGit(fs, repositoryPath, [
 								"worktree",
 								"list",
@@ -1136,7 +1094,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 								const repositoryPath =
 									repository?.path ?? join(root, "repos", executionData.repo)
 								const checkoutPath = join(codePath, executionData.repo)
-								let branchCommit = yield* backend.resolveRevision(
+								const branchCommit = yield* backend.resolveRevision(
 									repositoryPath,
 									executionData.branch,
 								)
@@ -1147,8 +1105,6 @@ export class ContextService extends Effect.Service<ContextService>()(
 								const checkout = yield* inspectCheckout(
 									repositoryPath,
 									checkoutPath,
-									executionData.branch,
-									branchCommit,
 								)
 								if (branchCommit === null) {
 									inspectionWarnings.push(
@@ -1261,7 +1217,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 							root,
 							configPath: join(root, "agency.json"),
 							version: config.version,
-							vcs: config.vcs ?? "git",
+							vcs: "git",
 						},
 						target,
 						documents: {