@markjaquith/agency 2.49.0 → 2.51.0

package/src/services/SyncService.ts

@@ -25,6 +25,7 @@ import {
 	RepositoryService,
 	type RepositorySetupResult,
 } from "./RepositoryService"
+import { VersionControlService } from "./VersionControlService"
 
 class SyncError extends Data.TaggedError("SyncError")<{
 	readonly message: string
@@ -83,11 +84,16 @@ interface CheckoutState {
 interface ExecutionSyncState {
 	readonly target: string
 	readonly status: WorkStatus
-	readonly branch: string
-	readonly base: string
+	readonly branch: string | null
+	readonly base: string | null
 	readonly claim: ClaimRecord | null
 	readonly checkouts: readonly CheckoutState[]
 	readonly pr: Record<string, unknown>
+	readonly review?: {
+		readonly pinnedCommit: string
+		readonly sourceCommit: string | null
+		readonly sourceAvailable: boolean
+	}
 }
 
 interface SyncResult {
@@ -156,7 +162,9 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 				const worktrees = yield* WorktreeService
 				const claims = yield* ClaimService
 				const repositories = yield* RepositoryService
+				const versionControl = yield* VersionControlService
 				const { root, config } = yield* workbase.loadConfig(options.cwd)
+				const backend = yield* versionControl.forWorkbase(root)
 				const validation = yield* workbase.validate(root)
 				if (!validation.valid) {
 					return yield* new SyncError({
@@ -219,7 +227,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 								data: phase.data,
 							})
 						}
-					} else {
+					} else if (!("review" in task.data)) {
 						records.push({
 							key: `task:${task.id}`,
 							taskId: task.id,
@@ -263,33 +271,27 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							workspaceConflict = true
 							continue
 						}
-						const listed = yield* fs.runCommand(
-							[
-								"git",
-								"-C",
-								repositoryPath,
-								"worktree",
-								"list",
-								"--porcelain",
-								"-z",
-							],
-							{ captureOutput: true },
+						const listed = yield* Effect.either(
+							backend.listWorkspaces(repositoryPath),
 						)
-						if (listed.exitCode !== 0) {
+						if (Either.isLeft(listed)) {
 							unresolved.push({
 								kind: "worktree-inspection-failed",
 								target: record.key,
-								message:
-									listed.stderr.trim() || `Cannot inspect '${checkout.repo}'`,
+								message: `Cannot inspect '${checkout.repo}'`,
 							})
 							workspaceConflict = true
 							continue
 						}
 						const exists = yield* fs.isDirectory(checkoutPath)
 						const registered: RegisteredWorktree[] = []
-						for (const item of parseWorktrees(listed.stdout)) {
+						for (const item of listed.right) {
 							registered.push({
-								...item,
+								head: item.commit,
+								branch:
+									backend.kind === "jj" && "branch" in checkout
+										? checkout.branch
+										: item.branch,
 								path: (yield* fs.exists(item.path))
 									? yield* fs.realPath(item.path)
 									: resolve(item.path),
@@ -301,39 +303,36 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 								? join(yield* fs.realPath(codePath), checkout.repo)
 								: resolve(checkoutPath)
 						let atPath = registered.find((item) => item.path === expectedPath)
+						if (backend.kind === "jj" && atPath && exists) {
+							atPath = {
+								...atPath,
+								head: yield* backend.workspaceHead(checkoutPath),
+							}
+						}
 						const branchRef =
-							"branch" in checkout ? `refs/heads/${checkout.branch}` : null
-						const branchElsewhere = branchRef
-							? registered.find(
-									(item) =>
-										item.branch === branchRef && item.path !== expectedPath,
-								)
-							: undefined
+							"branch" in checkout
+								? backend.kind === "jj"
+									? checkout.branch
+									: `refs/heads/${checkout.branch}`
+								: null
+						const branchElsewhere =
+							branchRef && backend.kind !== "jj"
+								? registered.find(
+										(item) =>
+											item.branch === branchRef && item.path !== expectedPath,
+									)
+								: undefined
 						if ("branch" in checkout && !exists && !branchElsewhere) {
-							const branch = yield* fs.runCommand(
-								[
-									"git",
-									"-C",
-									repositoryPath,
-									"rev-parse",
-									"--verify",
-									`${checkout.branch}^{commit}`,
-								],
-								{ captureOutput: true },
+							const branch = yield* backend.resolveRevision(
+								repositoryPath,
+								checkout.branch,
 							)
-							if (branch.exitCode !== 0) {
-								const base = yield* fs.runCommand(
-									[
-										"git",
-										"-C",
-										repositoryPath,
-										"rev-parse",
-										"--verify",
-										`${data.base}^{commit}`,
-									],
-									{ captureOutput: true },
+							if (!branch) {
+								const base = yield* backend.resolveRevision(
+									repositoryPath,
+									data.base,
 								)
-								if (base.exitCode !== 0) {
+								if (!base) {
 									unresolved.push({
 										kind: "unresolved-base",
 										target: record.key,
@@ -399,22 +398,10 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 									})
 								}
 							}
-							const resolvedRef = resolvedCommit
-								? null
-								: yield* fs.runCommand(
-										[
-											"git",
-											"-C",
-											repositoryPath,
-											"rev-parse",
-											"--verify",
-											`${checkout.ref}^{commit}`,
-										],
-										{ captureOutput: true },
-									)
-							if (resolvedRef?.exitCode === 0) {
-								resolvedCommit = resolvedRef.stdout.trim()
-							}
+							resolvedCommit ??= yield* backend.resolveRevision(
+								repositoryPath,
+								checkout.ref,
+							)
 							if (!resolvedCommit) {
 								unresolved.push({
 									kind: "unresolved-reference",
@@ -426,23 +413,15 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							}
 						}
 
-						const dirtyResult =
+						const dirty =
 							exists && atPath
-								? yield* fs.runCommand(
-										["git", "-C", checkoutPath, "status", "--porcelain"],
-										{ captureOutput: true },
-									)
+								? yield* backend.workspaceDirty(checkoutPath)
 								: null
-						const dirty = dirtyResult
-							? dirtyResult.exitCode === 0
-								? dirtyResult.stdout.length > 0
-								: null
-							: null
-						if (dirtyResult && dirtyResult.exitCode !== 0) {
+						if (exists && atPath && dirty === null) {
 							warnings.push({
 								kind: "status-inspection-failed",
 								target: record.key,
-								message: `Could not inspect dirtiness for ${checkoutPath}: ${dirtyResult.stderr.trim()}`,
+								message: `Could not inspect dirtiness for ${checkoutPath}`,
 								action: "Inspect the checkout manually before changing it",
 							})
 						}
@@ -551,7 +530,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 								},
 								root,
 							)
-							data = expired.data
+							data = expired.data as ExecutionData
 							revision = expired.revision
 						} else {
 							const claim: ClaimRecord = {
@@ -602,15 +581,8 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 					let prConflict = false
 					const repositoryPath = join(root, "repos", data.repo)
 					const remoteName = config.delivery?.remote ?? "origin"
-					const remote = yield* runExternal([
-						"git",
-						"-C",
-						repositoryPath,
-						"remote",
-						"get-url",
-						remoteName,
-					])
-					const remoteRepository = remote.stdout
+					const remoteUrl = yield* backend.remoteUrl(repositoryPath, remoteName)
+					const remoteRepository = (remoteUrl ?? "")
 						.trim()
 						.replace(/^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?[^/]+\//i, "")
 						.replace(/^[^:]+:/, "")
@@ -630,11 +602,11 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						})
 					}
 
-					if (config.delivery && remote.exitCode !== 0) {
+					if (config.delivery && !remoteUrl) {
 						warnings.push({
 							kind: "delivery-remote-unavailable",
 							target: record.key,
-							message: `Could not inspect delivery remote '${remoteName}': ${remote.stderr.trim()}`,
+							message: `Could not inspect delivery remote '${remoteName}'`,
 						})
 					} else if (config.delivery) {
 						const resolved = resolveDeliveryCommand(config.delivery, "query", {
@@ -787,7 +759,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 								},
 								root,
 							)
-							data = recorded.data
+							data = recorded.data as ExecutionData
 							revision = recorded.revision
 						}
 						changes.push({
@@ -823,7 +795,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 									},
 									root,
 								)
-								data = completed.data
+								data = completed.data as ExecutionData
 								revision = completed.revision
 							}
 							changes.push({
@@ -846,6 +818,105 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 					})
 				}
 
+				for (const task of (yield* tasks.list(root)).filter(
+					(task) => "review" in task.data,
+				)) {
+					if (!("review" in task.data)) continue
+					let data = task.data
+					let revision = task.revision
+					if (
+						isExpired(data.claim, now) &&
+						(data.status === "working" || data.status === "delegated")
+					) {
+						if (apply) {
+							const expired = yield* claims.expire(
+								{ taskId: task.id, revision, now },
+								root,
+							)
+							if ("review" in expired.data) data = expired.data
+							revision = expired.revision
+						}
+						changes.push({
+							kind: "release-stale-claim",
+							target: `task:${task.id}`,
+							message: `Release expired claim '${data.claim?.sessionId ?? "unknown"}'`,
+							status: apply ? "applied" : "planned",
+						})
+					}
+					const inspection = yield* worktrees.inspect(task.id, undefined, root)
+					for (const conflict of inspection.conflicts) {
+						unresolved.push({
+							kind: conflict.kind,
+							target: `task:${task.id}`,
+							message: conflict.message,
+							action: "Repair or remove the review checkout explicitly",
+						})
+					}
+					const checkout = inspection.checkouts[0]
+					if (
+						!checkout?.exists &&
+						inspection.conflicts.length === 0 &&
+						(data.status === "working" || data.status === "delegated")
+					) {
+						if (apply) yield* worktrees.materialize(task.id, undefined, root)
+						changes.push({
+							kind: "materialize-workspace",
+							target: `task:${task.id}`,
+							message: `Materialize pinned review checkout under ${inspection.codePath}`,
+							status: apply ? "applied" : "planned",
+						})
+					}
+					const repositoryPath = join(root, "repos", data.review.repo)
+					const source = yield* runExternal([
+						"git",
+						"-C",
+						repositoryPath,
+						"ls-remote",
+						"origin",
+						data.review.source.kind === "pull-request"
+							? data.review.source.fetchRef
+							: originRef(data.review.source.ref),
+					])
+					const sourceCommit = source.stdout.trim().split(/\s+/)[0] || null
+					if (!sourceCommit) {
+						warnings.push({
+							kind: "review-source-unavailable",
+							target: `task:${task.id}`,
+							message:
+								"Review source is unavailable; the pinned commit is unchanged",
+						})
+					}
+					executions.push({
+						target: `task:${task.id}`,
+						status: data.status,
+						branch: null,
+						base: null,
+						claim: data.claim ?? null,
+						checkouts: checkout
+							? [
+									{
+										repo: checkout.repo,
+										kind: "reference",
+										path: checkout.path,
+										requestedRef: data.review.commit,
+										resolvedCommit: checkout.expectedCommit,
+										registered: checkout.registered,
+										exists: checkout.exists,
+										head: checkout.actualCommit,
+										branch: checkout.actualBranch,
+										dirty: checkout.dirty,
+									},
+								]
+							: [],
+						pr: { url: null, state: "none" },
+						review: {
+							pinnedCommit: data.review.commit,
+							sourceCommit,
+							sourceAvailable: sourceCommit !== null,
+						},
+					})
+				}
+
 				return {
 					root,
 					mode: apply ? "apply" : "dry-run",

package/src/services/TaskPhaseService.test.ts

@@ -7,6 +7,13 @@ import { EpicService } from "./EpicService"
 import { TaskService } from "./TaskService"
 import { PhaseService } from "./PhaseService"
 import { PullRequestService } from "./PullRequestService"
+import { WorktreeService } from "./WorktreeService"
+
+const run = async (args: string[], cwd?: string) => {
+	const child = Bun.spawn(args, { cwd, stdout: "pipe", stderr: "pipe" })
+	const exitCode = await child.exited
+	if (exitCode !== 0) throw new Error(await new Response(child.stderr).text())
+}
 
 describe("task and phase services", () => {
 	let root: string
@@ -283,6 +290,79 @@ describe("task and phase services", () => {
 		})
 	})
 
+	test("recreates jj workspaces when converting a task to phases", async () => {
+		if (!Bun.which("jj")) return
+		const source = join(root, "source")
+		const repository = join(root, "repos/agency")
+		await rm(repository, { recursive: true, force: true })
+		await mkdir(source)
+		await run(["git", "init", "--initial-branch=main"], source)
+		await run(["git", "config", "user.email", "test@example.com"], source)
+		await run(["git", "config", "user.name", "Test"], source)
+		await Bun.write(join(source, "README.md"), "example\n")
+		await run(["git", "add", "README.md"], source)
+		await run(["git", "commit", "-m", "initial"], source)
+		await run(["git", "clone", source, repository])
+		await run(["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-single",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/jj-single",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("jj-single", undefined, root),
+				),
+			),
+		)
+
+		await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							taskId: "jj-single",
+							id: "extra",
+							firstPhase: "implementation",
+							repo: "agency",
+							branch: "task/extra",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		const moved = join(
+			root,
+			"tasks/jj-single/phases/implementation/code/agency",
+		)
+		expect(await Bun.file(workspace.codePath).exists()).toBe(false)
+		expect(await Bun.file(join(moved, "README.md")).text()).toBe("example\n")
+		const listed = Bun.spawnSync(
+			["jj", "-R", repository, "workspace", "list", "-T", 'root ++ "\\n"'],
+			{ stdout: "pipe" },
+		)
+		expect(new TextDecoder().decode(listed.stdout)).toContain(moved)
+	})
+
 	test("preserves non-PR completion when converting a task to phases", async () => {
 		await runTestEffect(
 			TaskService.pipe(

package/src/services/TaskService.ts

@@ -8,6 +8,7 @@ import {
 	EntityId,
 	TaskFrontmatter,
 	type RepositoryReference,
+	type ReviewRecord,
 	type TaskFrontmatter as TaskData,
 	WorkStatus,
 } from "../workbase/schemas"
@@ -26,6 +27,7 @@ import {
 import {
 	documentWriteStep,
 	runLifecycleTransaction,
+	type TransactionStep,
 } from "./LifecycleTransaction"
 
 class TaskError extends Data.TaggedError("TaskError")<{
@@ -50,6 +52,7 @@ export interface CreateTaskInput {
 	readonly repos?: readonly RepositoryReference[]
 	readonly branch?: string
 	readonly base?: string
+	readonly review?: ReviewRecord
 }
 
 const decodeTask = (input: unknown) => {
@@ -78,6 +81,50 @@ const decodeStatus = (status: string) => {
 		: Effect.succeed(result.right)
 }
 
+const reviewPinRef = (taskId: string) =>
+	`refs/agency/reviews/${Buffer.from(taskId).toString("hex")}`
+
+const reviewPinStep = (
+	root: string,
+	taskId: string,
+	review: ReviewRecord,
+): TransactionStep => {
+	const repositoryPath = join(root, "repos", review.repo)
+	const ref = reviewPinRef(taskId)
+	const run = async (args: readonly string[]) => {
+		const child = Bun.spawn([...args], { stdout: "pipe", stderr: "pipe" })
+		const [exitCode, stderr] = await Promise.all([
+			child.exited,
+			new Response(child.stderr).text(),
+		])
+		if (exitCode !== 0) throw new Error(stderr.trim() || args.join(" "))
+	}
+	return {
+		label: `retain review pin for ${taskId}`,
+		apply: () =>
+			run([
+				"git",
+				"-C",
+				repositoryPath,
+				"update-ref",
+				ref,
+				review.commit,
+				"0".repeat(40),
+			]),
+		rollback: () =>
+			run([
+				"git",
+				"-C",
+				repositoryPath,
+				"update-ref",
+				"-d",
+				ref,
+				review.commit,
+			]),
+		manualRecovery: `Delete ${ref} from repository '${review.repo}'`,
+	}
+}
+
 export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 	sync: () => ({
 		create: (input: CreateTaskInput, startPath: string = process.cwd()) =>
@@ -102,7 +149,28 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 				}
 
 				let data: TaskData
-				if (input.multiPhase) {
+				if (input.review) {
+					if (
+						input.multiPhase ||
+						input.repo !== undefined ||
+						input.repos !== undefined ||
+						input.branch !== undefined ||
+						input.base !== undefined
+					) {
+						return yield* new TaskError({
+							message:
+								"Review tasks cannot include writable or multi-phase fields",
+						})
+					}
+					data = yield* decodeTask({
+						ticketUrl: input.ticketUrl,
+						...(input.description !== undefined
+							? { description: input.description }
+							: {}),
+						...(input.epic ? { epic: input.epic } : {}),
+						review: input.review,
+					})
+				} else if (input.multiPhase) {
 					data = yield* decodeTask({
 						ticketUrl: input.ticketUrl,
 						...(input.description !== undefined
@@ -132,12 +200,14 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 				}
 
 				const referencedRepos =
-					"repo" in data
-						? [
-								data.repo,
-								...(data.repos ?? []).map((reference) => reference.repo),
-							]
-						: []
+					"review" in data
+						? [data.review.repo]
+						: "repo" in data
+							? [
+									data.repo,
+									...(data.repos ?? []).map((reference) => reference.repo),
+								]
+							: []
 				if (new Set(referencedRepos).size !== referencedRepos.length) {
 					return yield* new TaskError({
 						message:
@@ -192,7 +262,10 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 					preconditions: parentEpic
 						? [{ path: parentEpic.path, revision: parentEpic.revision }]
 						: [],
-					steps: [documentWriteStep(root, writes)],
+					steps: [
+						...(input.review ? [reviewPinStep(root, id, input.review)] : []),
+						documentWriteStep(root, writes),
+					],
 				})
 
 				return {
@@ -279,7 +352,7 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 						message: "Non-PR completion is valid only with a done status",
 					})
 				}
-				if (nonPrCompletion && record.data.pr !== null) {
+				if (nonPrCompletion && "pr" in record.data && record.data.pr !== null) {
 					return yield* new TaskError({
 						message:
 							"Cannot complete without a pull request while an authoritative pull request is recorded",