@markjaquith/agency 2.49.0 → 2.51.0

package/src/services/PhaseService.ts

@@ -30,6 +30,7 @@ import {
 	buildNonPrCompletion,
 	type NonPrCompletionInput,
 } from "../workbase/completion"
+import { VersionControlService } from "./VersionControlService"
 
 class PhaseError extends Data.TaggedError("PhaseError")<{
 	readonly message: string
@@ -92,11 +93,18 @@ 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)
+					if ("review" in task.data) {
+						return yield* new PhaseError({
+							message: `Review task '${taskId}' cannot be converted to phases`,
+						})
+					}
 					const isMultiPhase = "phases" in task.data
 					let firstPhaseId: string | undefined
 					if (!isMultiPhase) {
@@ -263,95 +271,213 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 								firstData.repo,
 								...(firstData.repos ?? []).map((reference) => reference.repo),
 							]
-							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}'`,
+							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,
+												}),
+											)
+										}
+										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(oldCodePath, alias)
+										const checkoutPath = join(basePath, alias)
 										try {
 											await lstat(checkoutPath)
 										} catch {
 											continue
 										}
-										const listed = Bun.spawnSync([
+										const result = Bun.spawnSync([
 											"git",
 											"-C",
 											join(root, "repos", alias),
 											"worktree",
-											"list",
-											"--porcelain",
+											"repair",
+											checkoutPath,
 										])
-										if (listed.exitCode !== 0)
+										if (result.exitCode !== 0) {
 											throw new Error(
-												`Failed to inspect worktrees for '${alias}'`,
+												`Failed to repair moved worktree for '${alias}': ${new TextDecoder().decode(result.stderr)}`,
 											)
-										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) {
+								}
+								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)
+											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
+										}
+									},
+									rollback: async () => {
 										await rename(firstCodePath, oldCodePath)
 										await repair(oldCodePath)
 										await rm(firstDirectory, { recursive: true, force: true })
-										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`,
-							})
+									},
+									manualRecovery: `Move ${firstCodePath} back to ${oldCodePath} and run git worktree repair`,
+								})
+							}
 						}
 						steps.push(
 							documentWriteStep(root, [

package/src/services/PullRequestService.test.ts

@@ -353,7 +353,7 @@ process.exit(${exitCode})
 	test("blocks a dirty checkout before push or gh", async () => {
 		await createTask()
 		const workspace = await materialize()
-		await Bun.write(join(workspace.writablePath, "dirty.txt"), "dirty\n")
+		await Bun.write(join(workspace.writablePath!, "dirty.txt"), "dirty\n")
 		await writeFakeGh({ stdout: "https://github.com/example/agency/pull/45" })
 
 		await expect(createPullRequest()).rejects.toThrow(
@@ -518,7 +518,7 @@ process.stdout.write(${JSON.stringify(JSON.stringify(providerRecord))})
 	test("reports git status failure before push or gh", async () => {
 		await createTask()
 		const workspace = await materialize()
-		await rm(join(workspace.writablePath, ".git"))
+		await rm(join(workspace.writablePath!, ".git"))
 		await writeFakeGh({ stdout: "https://github.com/example/agency/pull/48" })
 
 		await expect(createPullRequest()).rejects.toThrow(

package/src/services/PullRequestService.ts

@@ -6,6 +6,7 @@ import type { BaseCommandOptions } from "../utils/command"
 import { TaskService } from "./TaskService"
 import { PhaseService } from "./PhaseService"
 import { ReadinessService } from "./ReadinessService"
+import { VersionControlService } from "./VersionControlService"
 import {
 	formatMarkdownDocument,
 	parseFrontmatter,
@@ -50,6 +51,11 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 					const phases = yield* PhaseService
 					const root = yield* workbase.discover(startPath)
 					const task = yield* tasks.show(taskId, root)
+					if ("review" in task.data) {
+						return yield* new PullRequestError({
+							message: `Review task '${taskId}' cannot record a delivery pull request`,
+						})
+					}
 					const target =
 						"phases" in task.data
 							? phaseId
@@ -105,15 +111,21 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 					const worktrees = yield* WorktreeService
 					const readiness = yield* ReadinessService
 					const workbase = yield* WorkbaseService
-					const task = yield* tasks.show(taskId, startPath)
+					const versionControl = yield* VersionControlService
+					const requestedTask = yield* tasks.show(taskId, startPath)
+					if ("review" in requestedTask.data) {
+						return yield* new PullRequestError({
+							message: `Review task '${taskId}' cannot create a delivery pull request`,
+						})
+					}
 					const target =
-						"phases" in task.data
+						"phases" in requestedTask.data
 							? phaseId
 								? yield* phases.show(taskId, phaseId, startPath)
 								: yield* new PullRequestError({
 										message: `Task '${taskId}' requires a phase ID`,
 									})
-							: task
+							: requestedTask
 					if ("completion" in target.data && target.data.completion) {
 						return yield* new PullRequestError({
 							message:
@@ -134,56 +146,48 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 						options,
 					)
 					const workspaceTask = yield* tasks.show(taskId, workspace.root)
+					if ("review" in workspaceTask.data) {
+						return yield* new PullRequestError({
+							message: `Review task '${taskId}' cannot create a delivery pull request`,
+						})
+					}
 					const execution =
 						"phases" in workspaceTask.data
 							? (yield* phases.show(taskId, phaseId!, workspace.root)).data
 							: workspaceTask.data
 					const { config } = yield* workbase.loadConfig(workspace.root)
+					const backend = yield* versionControl.forWorkbase(workspace.root)
+					if (!workspace.writablePath) {
+						return yield* new PullRequestError({
+							message: `Task '${taskId}' has no writable checkout`,
+						})
+					}
 					const remote = config.delivery?.remote ?? "origin"
 
-					const status = yield* fs.runCommand(
-						["git", "-C", workspace.writablePath, "status", "--porcelain"],
-						{ captureOutput: true },
-					)
-					if (status.exitCode !== 0) {
+					const dirty = yield* backend.workspaceDirty(workspace.writablePath)
+					if (dirty === null) {
 						return yield* new PullRequestError({
-							message: `Failed to inspect worktree status: ${status.stderr}`,
+							message: "Failed to inspect worktree status",
 						})
 					}
-					if (status.stdout) {
+					if (dirty) {
 						return yield* new PullRequestError({
 							message: "Cannot create a PR with a dirty worktree",
 						})
 					}
 
-					const push = yield* fs.runCommand(
-						[
-							"git",
-							"-C",
-							workspace.writablePath,
-							"push",
-							"--set-upstream",
-							remote,
-							execution.branch,
-						],
-						{ captureOutput: true },
-					)
-					if (push.exitCode !== 0) {
-						return yield* new PullRequestError({
-							message: `Failed to push branch: ${push.stderr}`,
-						})
-					}
+					yield* backend.push(workspace.writablePath, remote, execution.branch)
 
-					const remoteResult = yield* fs.runCommand(
-						["git", "-C", workspace.writablePath, "remote", "get-url", remote],
-						{ captureOutput: true },
+					const remoteUrl = yield* backend.remoteUrl(
+						workspace.writablePath,
+						remote,
 					)
-					if (remoteResult.exitCode !== 0) {
+					if (!remoteUrl) {
 						return yield* new PullRequestError({
-							message: `Failed to inspect delivery remote '${remote}': ${remoteResult.stderr}`,
+							message: `Failed to inspect delivery remote '${remote}'`,
 						})
 					}
-					const repository = repositoryFromRemote(remoteResult.stdout.trim())
+					const repository = repositoryFromRemote(remoteUrl)
 					const resolved = config.delivery
 						? resolveDeliveryCommand(config.delivery, "create", {
 								repository,

package/src/services/ReadinessService.ts

@@ -77,7 +77,7 @@ const itemFor = (
 			? task.data.epic
 			: undefined
 	const dependentIds = new Set(node.dependents)
-	if (node.data.phaseId) {
+	if ("phaseId" in node.data && node.data.phaseId) {
 		const siblings = graph.nodes.filter(
 			(candidate): candidate is ExecutionNode =>
 				candidate.kind === "execution-unit" &&
@@ -93,10 +93,14 @@ const itemFor = (
 		rank,
 		key: node.key,
 		taskId: node.data.taskId,
-		...(node.data.phaseId ? { phaseId: node.data.phaseId } : {}),
+		...("phaseId" in node.data && node.data.phaseId
+			? { phaseId: node.data.phaseId }
+			: {}),
 		...(node.data.description ? { description: node.data.description } : {}),
 		parent: {
-			...(node.data.phaseId ? { taskId: node.data.taskId } : {}),
+			...("phaseId" in node.data && node.data.phaseId
+				? { taskId: node.data.taskId }
+				: {}),
 			...(epicId ? { epicId } : {}),
 		},
 		status: node.status,

package/src/services/RepositoryService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { mkdir } from "node:fs/promises"
+import { mkdir, stat } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { RepositoryService } from "./RepositoryService"
@@ -98,6 +98,36 @@ describe("RepositoryService", () => {
 		])
 	})
 
+	test("initializes a managed clone with jj for a jj workbase", async () => {
+		if (!Bun.which("jj")) return
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({ version: 2, vcs: "jj" }),
+		)
+		const source = join(root, "source")
+		await runGit(["init", "--initial-branch=main", source])
+		await runGit(["-C", source, "config", "user.email", "test@example.com"])
+		await runGit(["-C", source, "config", "user.name", "Test"])
+		await Bun.write(join(source, "README.md"), "example\n")
+		await runGit(["-C", source, "add", "README.md"])
+		await runGit(["-C", source, "commit", "-m", "initial"])
+		await setPortableOrigin(source, "jj-agency")
+
+		const destination = await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.add("agency", source, root)),
+			),
+		)
+		expect((await stat(join(destination, ".jj"))).isDirectory()).toBe(true)
+		expect(
+			await runTestEffect(
+				RepositoryService.pipe(
+					Effect.flatMap((service) => service.show("agency", root)),
+				),
+			),
+		).toMatchObject({ kind: "repository" })
+	})
+
 	test("links an existing repository", async () => {
 		const target = join(root, "linked-repository")
 		await mkdir(target, { recursive: true })