@markjaquith/agency 2.4.0 → 2.6.0

package/src/services/ArchiveService.test.ts

@@ -0,0 +1,334 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
+import { ArchiveService } from "./ArchiveService"
+import { EpicService } from "./EpicService"
+import { PhaseService } from "./PhaseService"
+import { TaskService } from "./TaskService"
+import { WorkbaseService } from "./WorkbaseService"
+import { WorktreeService } from "./WorktreeService"
+
+const git = async (args: string[], cwd?: string) => {
+	const process = Bun.spawn(["git", ...args], {
+		cwd,
+		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
+
+	beforeEach(async () => {
+		root = await createTempDir()
+		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
+		const source = join(root, "source")
+		await mkdir(source, { recursive: true })
+		await git(["init", "--initial-branch=main"], source)
+		await git(["config", "user.email", "test@example.com"], source)
+		await git(["config", "user.name", "Test"], source)
+		await Bun.write(join(source, "README.md"), "example\n")
+		await git(["add", "README.md"], source)
+		await git(["-c", "commit.gpgsign=false", "commit", "-m", "initial"], source)
+		await mkdir(join(root, "repos"), { recursive: true })
+		await git(["clone", "--bare", source, join(root, "repos/agency")])
+	})
+
+	afterEach(async () => cleanupTempDir(root))
+
+	test("archives a task after removing its worktree and preserves its branch", async () => {
+		await runTestEffect(
+			EpicService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						"parent",
+						"https://example.com/epic",
+						[{ repo: "agency", ref: "main" }],
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "child",
+							ticketUrl: "https://example.com/task",
+							epic: "parent",
+							repo: "agency",
+							branch: "task/child",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("child", undefined, root),
+				),
+			),
+		)
+
+		const result = await runTestEffect(
+			ArchiveService.pipe(
+				Effect.flatMap((service) => service.archiveTask("child", root)),
+			),
+		)
+
+		expect(result.path).toBe(join(root, "archive/tasks/child"))
+		expect(await Bun.file(join(root, "tasks/child/TASK.md")).exists()).toBe(
+			false,
+		)
+		expect(await Bun.file(join(result.path, "TASK.md")).exists()).toBe(true)
+		expect(await Bun.file(join(result.path, "code")).exists()).toBe(false)
+		const epic = await runTestEffect(
+			EpicService.pipe(
+				Effect.flatMap((service) => service.show("parent", root)),
+			),
+		)
+		expect(epic.data.tasks).toEqual([])
+		const report = await runTestEffect(
+			WorkbaseService.pipe(Effect.flatMap((service) => service.validate(root))),
+		)
+		expect(report.valid).toBe(true)
+		expect(
+			Bun.spawnSync([
+				"git",
+				"-C",
+				join(root, "repos/agency"),
+				"show-ref",
+				"--verify",
+				"refs/heads/task/child",
+			]).exitCode,
+		).toBe(0)
+	})
+
+	test("archives a phase in the mirrored task hierarchy", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "multi",
+							ticketUrl: "https://example.com/task",
+							multiPhase: true,
+						},
+						root,
+					),
+				),
+			),
+		)
+		for (const id of ["first", "second"]) {
+			await runTestEffect(
+				PhaseService.pipe(
+					Effect.flatMap((service) =>
+						service.create(
+							{
+								taskId: "multi",
+								id,
+								repo: "agency",
+								branch: `task/${id}`,
+								base: "main",
+							},
+							root,
+						),
+					),
+				),
+			)
+		}
+		await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("multi", "second", root),
+				),
+			),
+		)
+
+		const result = await runTestEffect(
+			ArchiveService.pipe(
+				Effect.flatMap((service) =>
+					service.archivePhase("multi", "second", root),
+				),
+			),
+		)
+
+		expect(result.path).toBe(join(root, "archive/tasks/multi/phases/second"))
+		expect(await Bun.file(join(result.path, "PHASE.md")).exists()).toBe(true)
+		expect(await Bun.file(join(result.path, "code")).exists()).toBe(false)
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("multi", root)),
+			),
+		)
+		expect("phases" in task.data && task.data.phases).toEqual([{ id: "first" }])
+		const report = await runTestEffect(
+			WorkbaseService.pipe(Effect.flatMap((service) => service.validate(root))),
+		)
+		expect(report.valid).toBe(true)
+	})
+
+	test("archives an epic and all of its child task folders", async () => {
+		await runTestEffect(
+			EpicService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						"initiative",
+						"https://example.com/epic",
+						[{ repo: "agency", ref: "main" }],
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "delivery",
+							ticketUrl: "https://example.com/task",
+							epic: "initiative",
+							repo: "agency",
+							branch: "task/delivery",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		const result = await runTestEffect(
+			ArchiveService.pipe(
+				Effect.flatMap((service) => service.archiveEpic("initiative", root)),
+			),
+		)
+
+		expect(result.archivedPaths).toEqual([
+			join(root, "archive/tasks/delivery"),
+			join(root, "archive/epics/initiative"),
+		])
+		expect(
+			await Bun.file(join(root, "archive/epics/initiative/EPIC.md")).exists(),
+		).toBe(true)
+		expect(
+			await Bun.file(join(root, "archive/tasks/delivery/TASK.md")).exists(),
+		).toBe(true)
+		const report = await runTestEffect(
+			WorkbaseService.pipe(Effect.flatMap((service) => service.validate(root))),
+		)
+		expect(report.valid).toBe(true)
+	})
+
+	test("rejects archiving an item required by an active sibling", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "multi",
+							ticketUrl: "https://example.com/task",
+							multiPhase: true,
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							taskId: "multi",
+							id: "first",
+							repo: "agency",
+							branch: "task/first",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							taskId: "multi",
+							id: "second",
+							repo: "agency",
+							branch: "task/second",
+							base: "main",
+							dependsOn: ["first"],
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		await expect(
+			runTestEffect(
+				ArchiveService.pipe(
+					Effect.flatMap((service) =>
+						service.archivePhase("multi", "first", root),
+					),
+				),
+			),
+		).rejects.toThrow("phase 'second' depends on it")
+	})
+
+	test("does not move a task when its worktree is dirty", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "dirty",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							branch: "task/dirty",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("dirty", undefined, root),
+				),
+			),
+		)
+		await Bun.write(join(workspace.writablePath, "dirty.txt"), "keep me\n")
+
+		await expect(
+			runTestEffect(
+				ArchiveService.pipe(
+					Effect.flatMap((service) => service.archiveTask("dirty", root)),
+				),
+			),
+		).rejects.toThrow("Failed to remove worktree")
+		expect(await Bun.file(join(root, "tasks/dirty/TASK.md")).exists()).toBe(
+			true,
+		)
+		expect(await Bun.file(join(root, "archive/tasks/dirty")).exists()).toBe(
+			false,
+		)
+	})
+})

package/src/services/ArchiveService.ts

@@ -0,0 +1,246 @@
+import { Data, Effect } from "effect"
+import { dirname, join } from "node:path"
+import { EpicService, type EpicRecord } from "./EpicService"
+import { FileSystemService } from "./FileSystemService"
+import { PhaseService } from "./PhaseService"
+import { TaskService } from "./TaskService"
+import { WorkbaseService } from "./WorkbaseService"
+import { WorktreeService } from "./WorktreeService"
+import {
+	formatMarkdownDocument,
+	parseFrontmatter,
+} from "../workbase/frontmatter"
+import type { TaskFrontmatter as TaskData } from "../workbase/schemas"
+
+class ArchiveError extends Data.TaggedError("ArchiveError")<{
+	readonly message: string
+}> {}
+
+interface ArchiveResult {
+	readonly kind: "epic" | "task" | "phase"
+	readonly id: string
+	readonly taskId?: string
+	readonly path: string
+	readonly archivedPaths: readonly string[]
+	readonly removedWorktrees: readonly string[]
+}
+
+interface TaskRecord {
+	readonly id: string
+	readonly path: string
+	readonly content: string
+	readonly data: TaskData
+}
+
+const rejectExistingDestination = (path: string) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		if (yield* fs.exists(path)) {
+			return yield* new ArchiveError({
+				message: `Archive destination already exists: ${path}`,
+			})
+		}
+	})
+
+export class ArchiveService extends Effect.Service<ArchiveService>()(
+	"ArchiveService",
+	{
+		sync: () => ({
+			archiveEpic: (id: string, startPath: string = process.cwd()) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const workbase = yield* WorkbaseService
+					const epics = yield* EpicService
+					const tasks = yield* TaskService
+					const worktrees = yield* WorktreeService
+					const root = yield* workbase.discover(startPath)
+					const epic = yield* epics.show(id, root)
+					const taskRecords: TaskRecord[] = []
+					for (const child of epic.data.tasks) {
+						const task = yield* tasks.show(child.id, root)
+						if (task.data.epic !== id) {
+							return yield* new ArchiveError({
+								message: `Task '${task.id}' does not reference epic '${id}'`,
+							})
+						}
+						taskRecords.push(task)
+					}
+
+					const epicDestination = join(root, "archive", "epics", id)
+					yield* rejectExistingDestination(epicDestination)
+					for (const task of taskRecords) {
+						yield* rejectExistingDestination(
+							join(root, "archive", "tasks", task.id),
+						)
+					}
+
+					const removedWorktrees: string[] = []
+					for (const task of taskRecords) {
+						if ("phases" in task.data) {
+							for (const phase of task.data.phases) {
+								removedWorktrees.push(
+									...(yield* worktrees.remove(task.id, phase.id, root)),
+								)
+							}
+						} else {
+							removedWorktrees.push(
+								...(yield* worktrees.remove(task.id, undefined, root)),
+							)
+						}
+					}
+
+					const archivedPaths: string[] = []
+					for (const task of taskRecords) {
+						const destination = join(root, "archive", "tasks", task.id)
+						yield* fs.createDirectory(dirname(destination))
+						yield* fs.moveDirectory(dirname(task.path), destination)
+						archivedPaths.push(destination)
+					}
+					yield* fs.createDirectory(dirname(epicDestination))
+					yield* fs.moveDirectory(dirname(epic.path), epicDestination)
+					archivedPaths.push(epicDestination)
+
+					return {
+						kind: "epic",
+						id,
+						path: epicDestination,
+						archivedPaths,
+						removedWorktrees,
+					} satisfies ArchiveResult
+				}),
+
+			archiveTask: (id: string, startPath: string = process.cwd()) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const workbase = yield* WorkbaseService
+					const epics = yield* EpicService
+					const tasks = yield* TaskService
+					const worktrees = yield* WorktreeService
+					const root = yield* workbase.discover(startPath)
+					const task = yield* tasks.show(id, root)
+					const destination = join(root, "archive", "tasks", id)
+					yield* rejectExistingDestination(destination)
+
+					let parentEpic: EpicRecord | undefined
+					if (task.data.epic) {
+						parentEpic = yield* epics.show(task.data.epic, root)
+						const dependent = parentEpic.data.tasks.find((child) =>
+							child.dependsOn?.includes(id),
+						)
+						if (dependent) {
+							return yield* new ArchiveError({
+								message: `Cannot archive task '${id}'; task '${dependent.id}' depends on it`,
+							})
+						}
+					}
+
+					const removedWorktrees: string[] = []
+					if ("phases" in task.data) {
+						for (const phase of task.data.phases) {
+							removedWorktrees.push(
+								...(yield* worktrees.remove(id, phase.id, root)),
+							)
+						}
+					} else {
+						removedWorktrees.push(
+							...(yield* worktrees.remove(id, undefined, root)),
+						)
+					}
+
+					if (parentEpic) {
+						const parsed = yield* parseFrontmatter(
+							parentEpic.content,
+							parentEpic.path,
+						)
+						yield* fs.writeFile(
+							parentEpic.path,
+							formatMarkdownDocument(
+								{
+									...parentEpic.data,
+									tasks: parentEpic.data.tasks.filter(
+										(child) => child.id !== id,
+									),
+								},
+								parsed.body,
+							),
+						)
+					}
+
+					yield* fs.createDirectory(dirname(destination))
+					yield* fs.moveDirectory(dirname(task.path), destination)
+					return {
+						kind: "task",
+						id,
+						path: destination,
+						archivedPaths: [destination],
+						removedWorktrees,
+					} satisfies ArchiveResult
+				}),
+
+			archivePhase: (
+				taskId: string,
+				id: string,
+				startPath: string = process.cwd(),
+			) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const workbase = yield* WorkbaseService
+					const tasks = yield* TaskService
+					const phases = yield* PhaseService
+					const worktrees = yield* WorktreeService
+					const root = yield* workbase.discover(startPath)
+					const task = yield* tasks.show(taskId, root)
+					if (!("phases" in task.data)) {
+						return yield* new ArchiveError({
+							message: `Task '${taskId}' is single-phase and does not contain phases`,
+						})
+					}
+					const phase = yield* phases.show(taskId, id, root)
+					const dependent = task.data.phases.find((candidate) =>
+						candidate.dependsOn?.includes(id),
+					)
+					if (dependent) {
+						return yield* new ArchiveError({
+							message: `Cannot archive phase '${id}'; phase '${dependent.id}' depends on it`,
+						})
+					}
+
+					const destination = join(
+						root,
+						"archive",
+						"tasks",
+						taskId,
+						"phases",
+						id,
+					)
+					yield* rejectExistingDestination(destination)
+					const removedWorktrees = yield* worktrees.remove(taskId, id, root)
+
+					const parsed = yield* parseFrontmatter(task.content, task.path)
+					yield* fs.writeFile(
+						task.path,
+						formatMarkdownDocument(
+							{
+								...task.data,
+								phases: task.data.phases.filter(
+									(candidate) => candidate.id !== id,
+								),
+							},
+							parsed.body,
+						),
+					)
+					yield* fs.createDirectory(dirname(destination))
+					yield* fs.moveDirectory(dirname(phase.path), destination)
+
+					return {
+						kind: "phase",
+						id,
+						taskId,
+						path: destination,
+						archivedPaths: [destination],
+						removedWorktrees,
+					} satisfies ArchiveResult
+				}),
+		}),
+	},
+) {}

package/src/services/PhaseService.ts

@@ -9,6 +9,7 @@ import {
 	PhaseFrontmatter,
 	type PhaseFrontmatter as PhaseData,
 	type RepositoryReference,
+	WorkStatus,
 } from "../workbase/schemas"
 import {
 	formatMarkdownDocument,
@@ -58,6 +59,15 @@ const decodePhase = (input: unknown) => {
 		: Effect.succeed(result.right)
 }
 
+const decodeStatus = (status: string) => {
+	const result = Schema.decodeUnknownEither(WorkStatus)(status)
+	return Either.isLeft(result)
+		? Effect.fail(
+				new PhaseError({ message: `Invalid work status '${status}'` }),
+			)
+		: Effect.succeed(result.right)
+}
+
 export class PhaseService extends Effect.Service<PhaseService>()(
 	"PhaseService",
 	{
@@ -318,6 +328,24 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 					}
 					return record
 				}),
+
+			setStatus: (
+				taskId: string,
+				id: string,
+				status: string,
+				startPath: string = process.cwd(),
+			) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const service = yield* PhaseService
+					const validStatus = yield* decodeStatus(status)
+					const record = yield* service.show(taskId, id, startPath)
+					const parsed = yield* parseFrontmatter(record.content, record.path)
+					const data = { ...record.data, status: validStatus }
+					const content = formatMarkdownDocument(data, parsed.body)
+					yield* fs.writeFile(record.path, content)
+					return { ...record, content, data } satisfies PhaseRecord
+				}),
 		}),
 	},
 ) {}

package/src/services/TaskPhaseService.test.ts

@@ -212,6 +212,85 @@ describe("task and phase services", () => {
 			branch: "task/single",
 			base: "main",
 			pr: "https://github.com/example/agency/pull/42",
+			status: "open",
 		})
 	})
+
+	test("updates status on execution units", async () => {
+		const createdTask = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "single-status",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							branch: "task/single-status",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		expect(createdTask.content).toContain("status: open")
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus("single-status", "delegated", root),
+				),
+			),
+		)
+		expect(task.data.status).toBe("delegated")
+		expect(task.content).toContain("status: delegated")
+		expect(task.content).toContain("Describe the task outcome.")
+
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "multi-status",
+							ticketUrl: "https://example.com/task",
+							multiPhase: true,
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							taskId: "multi-status",
+							id: "implementation",
+							repo: "agency",
+							branch: "task/multi-status",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const phase = await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus("multi-status", "implementation", "dropped", root),
+				),
+			),
+		)
+		expect(phase.data.status).toBe("dropped")
+		await expect(
+			runTestEffect(
+				TaskService.pipe(
+					Effect.flatMap((service) =>
+						service.setStatus("multi-status", "done", root),
+					),
+				),
+			),
+		).rejects.toThrow("set status on a phase instead")
+	})
 })