@markjaquith/agency 2.73.2 → 3.0.0

package/src/commands/pr.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { chmod, mkdir, realpath, rm } from "node:fs/promises"
+import { chmod, mkdir, realpath } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { PullRequestService } from "../services/PullRequestService"
 import {
@@ -31,7 +31,6 @@ describe("pr command", () => {
 			join(bin, "gh"),
 			`#!/bin/sh
 printf '%s\n' "$PWD" "$@" > "$GH_CAPTURE"
-if [ -n "$GIT_DIR" ]; then printf 'GIT_DIR=%s\n' "$GIT_DIR" >> "$GH_CAPTURE"; fi
 exit "\${GH_EXIT:-0}"
 `,
 		)
@@ -51,14 +50,13 @@ exit "\${GH_EXIT:-0}"
 	const captured = async () =>
 		(await Bun.file(capturePath).text()).trim().split("\n")
 
-	const createExecutionWorkbase = async (vcs: "git" | "jj" = "git") => {
+	const createExecutionWorkbase = async () => {
 		const root = join(tempRoot, "workbase")
 		await write(
 			root,
 			"agency.json",
 			`${JSON.stringify({
 				version: 2,
-				vcs,
 				repositories: {
 					agency: { remote: "https://github.com/example/agency.git" },
 				},
@@ -110,41 +108,6 @@ status: open
 # Build
 `,
 		)
-		if (vcs === "jj") {
-			const repository = join(root, "repos/agency")
-			await rm(join(root, "tasks/single/code/agency"), { recursive: true })
-			await rm(join(root, "tasks/multi/phases/build/code/agency"), {
-				recursive: true,
-			})
-			const initialized = Bun.spawn(
-				["jj", "git", "init", "--no-colocate", repository],
-				{ stdout: "pipe", stderr: "pipe" },
-			)
-			if ((await initialized.exited) !== 0)
-				throw new Error(await new Response(initialized.stderr).text())
-			for (const [name, path] of [
-				["single", join(root, "tasks/single/code/agency")],
-				["build", join(root, "tasks/multi/phases/build/code/agency")],
-			] as const) {
-				const workspace = Bun.spawn(
-					[
-						"jj",
-						"-R",
-						repository,
-						"workspace",
-						"add",
-						"--name",
-						name,
-						"-r",
-						"root()",
-						path,
-					],
-					{ stdout: "pipe", stderr: "pipe" },
-				)
-				if ((await workspace.exited) !== 0)
-					throw new Error(await new Response(workspace.stderr).text())
-			}
-		}
 		return root
 	}
 
@@ -261,54 +224,6 @@ status: working
 		])
 	})
 
-	test("injects the execution branch and repository for jj targets", async () => {
-		const root = await createExecutionWorkbase("jj")
-		const task = join(root, "tasks/single")
-		const phase = join(root, "tasks/multi/phases/build")
-
-		expect(await runTestEffect(pr(["view", "--web"], task))).toBe(0)
-		expect(await captured()).toEqual([
-			await realpath(join(task, "code/agency")),
-			"pr",
-			"view",
-			"feat/single",
-			"--repo",
-			"example/agency",
-			"--web",
-			expect.stringMatching(/^GIT_DIR=.*\.jj/),
-		])
-
-		expect(
-			await runTestEffect(pr(["create", "--title", "Example"], phase)),
-		).toBe(0)
-		expect(await captured()).toEqual([
-			await realpath(join(phase, "code/agency")),
-			"pr",
-			"create",
-			"--head",
-			"feat/build",
-			"--repo",
-			"example/agency",
-			"--title",
-			"Example",
-			expect.stringMatching(/^GIT_DIR=.*\.jj/),
-		])
-	})
-
-	test("preserves explicit jj PR and repository targets", async () => {
-		const root = await createExecutionWorkbase("jj")
-		const task = join(root, "tasks/single")
-		const args = ["view", "123", "--repo", "other/repository"]
-
-		expect(await runTestEffect(pr(args, task))).toBe(0)
-		expect(await captured()).toEqual([
-			await realpath(join(task, "code/agency")),
-			"pr",
-			...args,
-			expect.stringMatching(/^GIT_DIR=.*\.jj/),
-		])
-	})
-
 	test("falls back to the invocation directory without execution authority", async () => {
 		const root = await createExecutionWorkbase()
 		const orchestration = join(root, "tasks/multi")

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(