@markjaquith/agency 2.74.0 → 3.1.0

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

@@ -1,7 +1,7 @@
 import { Schema, TreeFormatter } from "@effect/schema"
 import { Data, Effect, Either, Layer } from "effect"
 import { lstat, mkdir, open, rename, rm } from "node:fs/promises"
-import { dirname, join, relative } from "node:path"
+import { dirname, join, relative, resolve, sep } from "node:path"
 import { EpicService, type EpicRecord } from "./EpicService"
 import { FileSystemService } from "./FileSystemService"
 import { PhaseService, type PhaseRecord } from "./PhaseService"
@@ -13,7 +13,6 @@ import {
 } from "./WorktreeService"
 import {
 	GitVersionControlService,
-	JjVersionControlService,
 	VersionControlService,
 } from "./VersionControlService"
 import {
@@ -53,6 +52,11 @@ class ArchiveError extends Data.TaggedError("ArchiveError")<{
 
 export type ArchiveKind = "epic" | "task" | "phase"
 
+interface ArchivePathTarget {
+	readonly kind: "epic" | "task"
+	readonly id: string
+}
+
 const LifecycleEventSchema = Schema.Struct({
 	operation: Schema.Literal("archive", "restore"),
 	at: Schema.String,
@@ -368,7 +372,6 @@ const WorktreeLayer = Layer.mergeAll(
 	FileSystemService.Default,
 	WorkbaseService.Default,
 	GitVersionControlService.Default,
-	JjVersionControlService.Default,
 	VersionControlService.Default,
 	TaskService.Default,
 	PhaseService.Default,
@@ -400,22 +403,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
 				? [
@@ -496,6 +483,59 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 	"ArchiveService",
 	{
 		sync: () => ({
+			resolvePathTarget: (path: string, cwd: string = process.cwd()) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const workbase = yield* WorkbaseService
+					const candidate = resolve(cwd, path)
+					if (!(yield* fs.exists(candidate))) {
+						return yield* new ArchiveError({
+							message: `Archive path does not exist: ${candidate}`,
+						})
+					}
+
+					const canonicalPath = yield* fs.realPath(candidate)
+					const root = yield* workbase.discover(canonicalPath)
+					const child = relative(root, canonicalPath)
+					const parts = child.split(sep)
+					if (child === "" || parts.length === 1) {
+						return yield* new ArchiveError({
+							message: `Archive path is ambiguous; it does not identify a single epic or task: ${canonicalPath}`,
+						})
+					}
+
+					const [collection, id] = parts
+					const kind =
+						collection === "epics"
+							? "epic"
+							: collection === "tasks"
+								? "task"
+								: undefined
+					if (!kind || !id) {
+						return yield* new ArchiveError({
+							message: `Archive path must be within an active epic or task: ${canonicalPath}`,
+						})
+					}
+					if (kind === "task" && parts[2] === "phases") {
+						return yield* new ArchiveError({
+							message: `Archive path identifies a phase; use 'agency archive phase <task-id> <phase-id>': ${canonicalPath}`,
+						})
+					}
+
+					const document = join(
+						root,
+						kind === "epic" ? "epics" : "tasks",
+						id,
+						kind === "epic" ? "EPIC.md" : "TASK.md",
+					)
+					if (!(yield* fs.exists(document))) {
+						return yield* new ArchiveError({
+							message: `Archive path does not identify an active ${kind}: ${canonicalPath}`,
+						})
+					}
+					return { kind, id } satisfies ArchivePathTarget
+				}),
+
 			list: (filters: ArchiveFilters = {}, startPath: string = process.cwd()) =>
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
@@ -724,7 +764,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 						removedWorktrees.push(
 							...(yield* worktrees.remove(unit.taskId, unit.phaseId, root, {
 								dryRun: true,
-								persistResume: false,
 							})),
 						)
 					}
@@ -783,7 +822,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 												worktrees.remove(unit.taskId, unit.phaseId, root, {
 													snapshots,
 													lockHeld: true,
-													persistResume: false,
 												}),
 											)
 									} catch (cause) {
@@ -897,7 +935,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 +1112,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 +1268,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 								root,
 								{
 									dryRun: true,
-									persistResume: false,
 								},
 							)),
 						)
@@ -1288,7 +1323,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 													{
 														snapshots,
 														lockHeld: true,
-														persistResume: false,
 													},
 												),
 											)
@@ -1381,7 +1415,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 +1463,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: {

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,