@markjaquith/agency 2.74.0 → 3.0.0

package/src/services/DoctorService.ts

@@ -125,20 +125,12 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 							return available
 						})
 
-					const [gitAvailable, jjAvailable] = yield* Effect.all(
-						[
-							tool("tool.git", "git", "error", "Git"),
-							tool(
-								"tool.jj",
-								"jj",
-								config.vcs === "jj" ? "error" : "optional",
-								"Jujutsu",
-							),
-						],
-						{ concurrency: "unbounded", batching: true },
+					const versionControlAvailable = yield* tool(
+						"tool.git",
+						"git",
+						"error",
+						"Git",
 					)
-					const versionControlAvailable =
-						gitAvailable && (config.vcs !== "jj" || jjAvailable)
 					yield* Effect.all(
 						[
 							tool(
@@ -180,15 +172,6 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 									] as const,
 								]
 							: []),
-						...(config.workspaceCreateCommand
-							? [
-									[
-										"integration.workspace-create",
-										config.workspaceCreateCommand,
-										"Workspace creator",
-									] as const,
-								]
-							: []),
 						...Object.entries(config.repositories ?? {}).flatMap(
 							([alias, repository]) =>
 								repository.postCheckoutCommand
@@ -384,8 +367,9 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 							category: "repository",
 							level: "warning",
 							status: "fail",
-							message: `Repository, ref, remote, and workspace checks were skipped because the ${config.vcs ?? "git"} backend is unavailable`,
-							remediation: `Install '${config.vcs === "jj" ? "jj" : "git"}' and rerun 'agency doctor'.`,
+							message:
+								"Repository, ref, remote, and workspace checks were skipped because Git is unavailable",
+							remediation: "Install 'git' and rerun 'agency doctor'.",
 						})
 					}
 					for (const repository of repositoryList) {

package/src/services/GraphService.test.ts

@@ -121,6 +121,7 @@ describe("GraphService", () => {
 		const graph = await getGraph(root)
 
 		expect(Schema.decodeUnknownSync(AgencyGraph)(graph)).toEqual(graph)
+		expect(graph.workbase.vcs).toBe("git")
 		expect(graph.nodes.map((node) => node.id)).toEqual([
 			"epic:delivery",
 			"execution-unit:phase/ship/implement",

package/src/services/GraphService.ts

@@ -821,10 +821,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 												checkoutCommit: materialized
 													? yield* backend.workspaceHead(checkoutPath)
 													: null,
-												checkoutBranch:
-													backend.kind === "jj" && materialized
-														? data.branch
-														: actualBranch,
+												checkoutBranch: actualBranch,
 												dirty: materialized
 													? yield* backend.workspaceDirty(checkoutPath)
 													: null,
@@ -1022,7 +1019,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 						version: GRAPH_VERSION,
 						workbase: {
 							version: config.version,
-							vcs: config.vcs ?? "git",
+							vcs: "git",
 							...(include.has("workspace") ? { root } : {}),
 						},
 						filters,

package/src/services/PhaseService.ts

@@ -30,7 +30,6 @@ import {
 	buildNonPrCompletion,
 	type NonPrCompletionInput,
 } from "../workbase/completion"
-import { VersionControlService } from "./VersionControlService"
 
 class PhaseError extends Data.TaggedError("PhaseError")<{
 	readonly message: string
@@ -93,10 +92,8 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
 					const workbase = yield* WorkbaseService
-					const versionControl = yield* VersionControlService
 					const tasks = yield* TaskService
 					const root = yield* workbase.discover(startPath)
-					const backend = yield* versionControl.forWorkbase(root)
 					const taskId = yield* decodeId(input.taskId, "task")
 					const id = yield* decodeId(input.id, "phase")
 					const task = yield* tasks.show(taskId, root)
@@ -274,213 +271,95 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 								firstData.repo,
 								...(firstData.repos ?? []).map((reference) => reference.repo),
 							]
-							if (backend.kind === "jj") {
-								const workspaces: {
-									alias: string
-									name: string
-									head: string
-									oldPath: string
-									newPath: string
-								}[] = []
-								const runBackend = <A>(
-									effect: Effect.Effect<A, unknown, any>,
-								) =>
-									Effect.runPromise(
-										effect.pipe(
-											Effect.provideService(FileSystemService, fs),
-										) as Effect.Effect<A, unknown, never>,
-									)
-								steps.push({
-									label: `move jj workspaces for ${taskId}/${firstPhaseId}`,
-									preflight: async () => {
-										for (const entry of await readdir(oldCodePath)) {
-											if (!checkoutAliases.includes(entry))
-												throw new Error(
-													`Cannot convert task '${taskId}'; code contains unmanaged entry '${entry}'`,
-												)
-										}
-										for (const alias of checkoutAliases) {
-											const oldPath = join(oldCodePath, alias)
-											try {
-												await lstat(oldPath)
-											} catch {
-												continue
-											}
-											const expected = await realpath(oldPath)
-											const registered = (
-												await runBackend(
-													backend.listWorkspaces(join(root, "repos", alias)),
-												)
-											).find((workspace) => workspace.path === expected)
-											if (!registered?.name)
-												throw new Error(
-													`Cannot convert task '${taskId}'; checkout '${alias}' is not registered as a jj workspace`,
-												)
-											if (await runBackend(backend.workspaceDirty(oldPath)))
-												throw new Error(
-													`Cannot convert task '${taskId}'; jj workspace '${alias}' has uncommitted changes`,
-												)
-											const head = await runBackend(
-												backend.workspaceHead(oldPath),
-											)
-											if (!head)
-												throw new Error(
-													`Cannot resolve jj workspace '${alias}' before conversion`,
-												)
-											workspaces.push({
-												alias,
-												name: registered.name,
-												head,
-												oldPath,
-												newPath: join(firstCodePath, alias),
-											})
-										}
-									},
-									apply: async () => {
-										await mkdir(firstCodePath, { recursive: true })
-										for (const workspace of workspaces) {
-											const repositoryPath = join(
-												root,
-												"repos",
-												workspace.alias,
-											)
-											await runBackend(
-												backend.removeWorkspace({
-													repositoryPath,
-													workspacePath: workspace.oldPath,
-													workspaceName: workspace.name,
-												}),
-											)
-											await runBackend(
-												backend.createWorkspace({
-													repositoryPath,
-													workspacePath: workspace.newPath,
-													workspaceName: workspace.name,
-													revision: workspace.head,
-												}),
-											)
-										}
-										await rm(oldCodePath, { recursive: true, force: true })
-									},
-									rollback: async () => {
-										await mkdir(oldCodePath, { recursive: true })
-										for (const workspace of [...workspaces].reverse()) {
-											const repositoryPath = join(
-												root,
-												"repos",
-												workspace.alias,
-											)
-											await runBackend(
-												backend.removeWorkspace({
-													repositoryPath,
-													workspacePath: workspace.newPath,
-													workspaceName: workspace.name,
-												}),
-											)
-											await runBackend(
-												backend.createWorkspace({
-													repositoryPath,
-													workspacePath: workspace.oldPath,
-													workspaceName: workspace.name,
-													revision: workspace.head,
-												}),
+							const repair = async (basePath: string) => {
+								for (const alias of checkoutAliases) {
+									const checkoutPath = join(basePath, alias)
+									try {
+										await lstat(checkoutPath)
+									} catch {
+										continue
+									}
+									const result = Bun.spawnSync([
+										"git",
+										"-C",
+										join(root, "repos", alias),
+										"worktree",
+										"repair",
+										checkoutPath,
+									])
+									if (result.exitCode !== 0) {
+										throw new Error(
+											`Failed to repair moved worktree for '${alias}': ${new TextDecoder().decode(result.stderr)}`,
+										)
+									}
+								}
+							}
+							steps.push({
+								label: `move and repair code for ${taskId}/${firstPhaseId}`,
+								preflight: async () => {
+									for (const entry of await readdir(oldCodePath)) {
+										if (!checkoutAliases.includes(entry))
+											throw new Error(
+												`Cannot convert task '${taskId}'; code contains unmanaged entry '${entry}'`,
 											)
-										}
-										await rm(firstDirectory, { recursive: true, force: true })
-									},
-									manualRecovery: `Restore jj workspaces from ${firstCodePath} to ${oldCodePath}`,
-								})
-							} else {
-								const repair = async (basePath: string) => {
+									}
 									for (const alias of checkoutAliases) {
-										const checkoutPath = join(basePath, alias)
+										const checkoutPath = join(oldCodePath, alias)
 										try {
 											await lstat(checkoutPath)
 										} catch {
 											continue
 										}
-										const result = Bun.spawnSync([
+										const listed = Bun.spawnSync([
 											"git",
 											"-C",
 											join(root, "repos", alias),
 											"worktree",
-											"repair",
-											checkoutPath,
+											"list",
+											"--porcelain",
 										])
-										if (result.exitCode !== 0) {
+										if (listed.exitCode !== 0)
 											throw new Error(
-												`Failed to repair moved worktree for '${alias}': ${new TextDecoder().decode(result.stderr)}`,
+												`Failed to inspect worktrees for '${alias}'`,
 											)
-										}
-									}
-								}
-								steps.push({
-									label: `move and repair code for ${taskId}/${firstPhaseId}`,
-									preflight: async () => {
-										for (const entry of await readdir(oldCodePath)) {
-											if (!checkoutAliases.includes(entry))
-												throw new Error(
-													`Cannot convert task '${taskId}'; code contains unmanaged entry '${entry}'`,
-												)
-										}
-										for (const alias of checkoutAliases) {
-											const checkoutPath = join(oldCodePath, alias)
+										const expected = await realpath(checkoutPath)
+										let registered = false
+										for (const line of new TextDecoder()
+											.decode(listed.stdout)
+											.split("\n")) {
+											if (!line.startsWith("worktree ")) continue
 											try {
-												await lstat(checkoutPath)
-											} catch {
-												continue
-											}
-											const listed = Bun.spawnSync([
-												"git",
-												"-C",
-												join(root, "repos", alias),
-												"worktree",
-												"list",
-												"--porcelain",
-											])
-											if (listed.exitCode !== 0)
-												throw new Error(
-													`Failed to inspect worktrees for '${alias}'`,
-												)
-											const expected = await realpath(checkoutPath)
-											let registered = false
-											for (const line of new TextDecoder()
-												.decode(listed.stdout)
-												.split("\n")) {
-												if (!line.startsWith("worktree ")) continue
-												try {
-													if ((await realpath(line.slice(9))) === expected) {
-														registered = true
-														break
-													}
-												} catch {}
-											}
-											if (!registered)
-												throw new Error(
-													`Cannot convert task '${taskId}'; checkout '${alias}' is not registered as a Git worktree`,
-												)
-										}
-									},
-									apply: async () => {
-										await mkdir(firstDirectory, { recursive: true })
-										await rename(oldCodePath, firstCodePath)
-										try {
-											await repair(firstCodePath)
-										} catch (cause) {
-											await rename(firstCodePath, oldCodePath)
-											await repair(oldCodePath)
-											await rm(firstDirectory, { recursive: true, force: true })
-											throw cause
+												if ((await realpath(line.slice(9))) === expected) {
+													registered = true
+													break
+												}
+											} catch {}
 										}
-									},
-									rollback: async () => {
+										if (!registered)
+											throw new Error(
+												`Cannot convert task '${taskId}'; checkout '${alias}' is not registered as a Git worktree`,
+											)
+									}
+								},
+								apply: async () => {
+									await mkdir(firstDirectory, { recursive: true })
+									await rename(oldCodePath, firstCodePath)
+									try {
+										await repair(firstCodePath)
+									} catch (cause) {
 										await rename(firstCodePath, oldCodePath)
 										await repair(oldCodePath)
 										await rm(firstDirectory, { recursive: true, force: true })
-									},
-									manualRecovery: `Move ${firstCodePath} back to ${oldCodePath} and run git worktree repair`,
-								})
-							}
+										throw cause
+									}
+								},
+								rollback: async () => {
+									await rename(firstCodePath, oldCodePath)
+									await repair(oldCodePath)
+									await rm(firstDirectory, { recursive: true, force: true })
+								},
+								manualRecovery: `Move ${firstCodePath} back to ${oldCodePath} and run git worktree repair`,
+							})
 						}
 						steps.push(
 							documentWriteStep(root, [

package/src/services/PullRequestService.test.ts

@@ -98,7 +98,7 @@ describe("PullRequestService", () => {
 		await Bun.write(
 			path,
 			`#!/usr/bin/env bun
-await Bun.write(${JSON.stringify(ghCallPath)}, JSON.stringify({ args: Bun.argv.slice(2), cwd: process.cwd(), ...(process.env.GIT_DIR ? { gitDir: process.env.GIT_DIR } : {}) }))
+await Bun.write(${JSON.stringify(ghCallPath)}, JSON.stringify({ args: Bun.argv.slice(2), cwd: process.cwd() }))
 process.stdout.write(${JSON.stringify(stdout)})
 process.stderr.write(${JSON.stringify(stderr)})
 process.exit(${exitCode})
@@ -111,7 +111,6 @@ process.exit(${exitCode})
 		(await Bun.file(ghCallPath).json()) as {
 			args: string[]
 			cwd: string
-			gitDir?: string
 		}
 
 	const expectRemoteBranch = async (branch: string, exists = true) => {
@@ -243,49 +242,6 @@ process.exit(${exitCode})
 		expect(updated.endsWith(`${body}\n`)).toBe(true)
 	})
 
-	test("creates a PR from a non-colocated jj workspace with backing Git context", async () => {
-		if (!Bun.which("jj")) return
-		await rm(join(root, "repos/agency"), { recursive: true, force: true })
-		await requireCommand([
-			"jj",
-			"git",
-			"clone",
-			"--no-colocate",
-			remotePath,
-			join(root, "repos/agency"),
-		])
-		await requireCommand(
-			["jj", "config", "set", "--repo", "user.name", "Agency Test"],
-			join(root, "repos/agency"),
-		)
-		await requireCommand(
-			["jj", "config", "set", "--repo", "user.email", "agency@example.com"],
-			join(root, "repos/agency"),
-		)
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-		await createTask("jj-example", "task/jj-example")
-		const workspace = await materialize("jj-example")
-		await Bun.write(join(workspace.writablePath!, "CHANGE.md"), "jj change\n")
-		await requireCommand(
-			["jj", "describe", "-m", "feat: add jj example"],
-			workspace.writablePath!,
-		)
-		await requireCommand(["jj", "new"], workspace.writablePath!)
-		const url = "https://github.com/example/agency/pull/44"
-		await writeFakeGh({ stdout: `${url}\n` })
-
-		expect(await createPullRequest("jj-example")).toBe(url)
-		await expectRemoteBranch("task/jj-example")
-		const ghCall = await readGhCall()
-		expect(ghCall.args).toContain("--head")
-		expect(ghCall.args).toContain("--repo")
-		expect(ghCall.gitDir).toContain(".jj")
-		expect(await Bun.file(join(root, "repos/agency/.git")).exists()).toBe(false)
-	})
-
 	test("passes --draft to gh", async () => {
 		await createTask()
 		await writeFakeGh({

package/src/services/PullRequestService.ts

@@ -195,20 +195,6 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 					}
 
 					yield* backend.push(workspace.writablePath, remote, execution.branch)
-					const defaults =
-						backend.kind === "jj"
-							? yield* backend.pullRequestDefaults(
-									workspace.writablePath,
-									execution.base,
-								)
-							: null
-					if (backend.kind === "jj" && !defaults) {
-						return yield* new PullRequestError({
-							message:
-								"Failed to derive pull request title and body from jj commits",
-						})
-					}
-
 					const remoteUrl = yield* backend.remoteUrl(
 						workspace.writablePath,
 						remote,
@@ -230,22 +216,15 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 							})
 						: resolveGitHubCreateCommand({
 								base: execution.base,
-								branch: execution.branch,
-								repository,
 								draft,
-								vcs: config.vcs ?? "git",
 								title: options.title,
 								head: options.head,
 								labels: options.labels,
-								...(defaults ? { defaults } : {}),
 							})
-					const gitEnvironment = config.delivery
-						? {}
-						: yield* backend.gitEnvironment(workspace.writablePath)
 					const created = yield* fs.runCommand(resolved.argv, {
 						cwd: workspace.writablePath,
 						captureOutput: true,
-						env: { ...gitEnvironment, ...resolved.environment },
+						env: resolved.environment,
 					})
 					if (created.exitCode !== 0) {
 						return yield* new PullRequestError({