@markjaquith/agency 2.4.0 → 2.6.0

package/src/services/TaskService.ts

@@ -9,6 +9,7 @@ import {
 	TaskFrontmatter,
 	type RepositoryReference,
 	type TaskFrontmatter as TaskData,
+	WorkStatus,
 } from "../workbase/schemas"
 import {
 	formatMarkdownDocument,
@@ -28,7 +29,7 @@ interface TaskRecord {
 
 export interface CreateTaskInput {
 	readonly id: string
-	readonly ticketUrl: string
+	readonly ticketUrl: string | null
 	readonly description?: string
 	readonly epic?: string
 	readonly multiPhase?: boolean
@@ -57,6 +58,13 @@ const decodeId = (id: string) => {
 		: Effect.succeed(result.right)
 }
 
+const decodeStatus = (status: string) => {
+	const result = Schema.decodeUnknownEither(WorkStatus)(status)
+	return Either.isLeft(result)
+		? Effect.fail(new TaskError({ message: `Invalid work status '${status}'` }))
+		: Effect.succeed(result.right)
+}
+
 export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 	sync: () => ({
 		create: (input: CreateTaskInput, startPath: string = process.cwd()) =>
@@ -188,5 +196,27 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 				}
 				return record
 			}),
+
+		setStatus: (
+			id: string,
+			status: string,
+			startPath: string = process.cwd(),
+		) =>
+			Effect.gen(function* () {
+				const fs = yield* FileSystemService
+				const service = yield* TaskService
+				const validStatus = yield* decodeStatus(status)
+				const record = yield* service.show(id, startPath)
+				if ("phases" in record.data) {
+					return yield* new TaskError({
+						message: `Task '${id}' has multiple phases; set status on a phase instead`,
+					})
+				}
+				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 TaskRecord
+			}),
 	}),
 }) {}

package/src/services/WorkbaseService.test.ts

@@ -1,10 +1,11 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import { createHash } from "node:crypto"
-import { mkdir } from "node:fs/promises"
+import { mkdir, realpath } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { managedWorkbaseAgents } from "../workbase/agents-file"
+import { managedWorkbaseOpencode } from "../workbase/opencode-file"
 import { WorkbaseService } from "./WorkbaseService"
 
 const write = async (root: string, path: string, content: string) => {
@@ -18,6 +19,11 @@ const managedAgents = (body: string) => {
 	return `<!-- agency-managed: sha256=${checksum} -->\n\n${body}`
 }
 
+const managedOpencode = (body: string) => {
+	const checksum = createHash("sha256").update(body).digest("hex")
+	return `// agency-managed: sha256=${checksum}\n\n${body}`
+}
+
 describe("WorkbaseService", () => {
 	let root: string
 
@@ -45,6 +51,98 @@ describe("WorkbaseService", () => {
 		expect(await Bun.file(join(root, "AGENTS.md")).text()).toBe(
 			managedWorkbaseAgents,
 		)
+		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
+			managedWorkbaseOpencode,
+		)
+	})
+
+	test("registers canonical workbase paths without duplicates", async () => {
+		const workbaseRoot = join(root, "workbase")
+		const nested = join(workbaseRoot, "nested")
+		const configDirectory = join(root, "config")
+		await write(workbaseRoot, "agency.json", '{"version":2}\n')
+		await mkdir(nested, { recursive: true })
+
+		const first = await runTestEffect(
+			WorkbaseService.pipe(
+				Effect.flatMap((service) => service.register(nested, configDirectory)),
+			),
+		)
+		await runTestEffect(
+			WorkbaseService.pipe(
+				Effect.flatMap((service) =>
+					service.register(workbaseRoot, configDirectory),
+				),
+			),
+		)
+		const registered = await runTestEffect(
+			WorkbaseService.pipe(
+				Effect.flatMap((service) => service.listRegistered(configDirectory)),
+			),
+		)
+
+		expect(first).toBe(await realpath(workbaseRoot))
+		expect(registered).toEqual([first])
+		expect(
+			await Bun.file(join(configDirectory, "agency/workbases.json")).json(),
+		).toEqual({ version: 1, workbases: [first] })
+	})
+
+	test("preserves an unmanaged workbase OpenCode config", async () => {
+		await write(root, "agency.json", '{"version":2}\n')
+		await write(root, ".opencode/opencode.jsonc", '{"model":"test/model"}\n')
+
+		await runTestEffect(
+			WorkbaseService.pipe(Effect.flatMap((service) => service.discover(root))),
+		)
+
+		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
+			'{"model":"test/model"}\n',
+		)
+	})
+
+	test("does not override an existing JSON OpenCode config", async () => {
+		await write(root, "agency.json", '{"version":2}\n')
+		await write(root, ".opencode/opencode.json", '{"model":"test/model"}\n')
+
+		await runTestEffect(
+			WorkbaseService.pipe(Effect.flatMap((service) => service.discover(root))),
+		)
+
+		expect(
+			await Bun.file(join(root, ".opencode/opencode.jsonc")).exists(),
+		).toBe(false)
+	})
+
+	test("updates an unmodified managed workbase OpenCode config", async () => {
+		await write(root, "agency.json", '{"version":2}\n')
+		await write(
+			root,
+			".opencode/opencode.jsonc",
+			managedOpencode('{"references":{}}\n'),
+		)
+
+		await runTestEffect(
+			WorkbaseService.pipe(Effect.flatMap((service) => service.discover(root))),
+		)
+
+		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
+			managedWorkbaseOpencode,
+		)
+	})
+
+	test("preserves a modified managed workbase OpenCode config", async () => {
+		await write(root, "agency.json", '{"version":2}\n')
+		const content = `${managedOpencode('{"references":{}}\n')}\n// User edit\n`
+		await write(root, ".opencode/opencode.jsonc", content)
+
+		await runTestEffect(
+			WorkbaseService.pipe(Effect.flatMap((service) => service.discover(root))),
+		)
+
+		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
+			content,
+		)
 	})
 
 	test("preserves an unmanaged workbase AGENTS.md", async () => {

package/src/services/WorkbaseService.ts

@@ -1,6 +1,7 @@
 import { Schema } from "@effect/schema"
 import { TreeFormatter } from "@effect/schema"
 import { Data, Effect, Either } from "effect"
+import { homedir } from "node:os"
 import { dirname, join, relative, resolve } from "node:path"
 import { FileSystemService } from "./FileSystemService"
 import { parseFrontmatter } from "../workbase/frontmatter"
@@ -9,6 +10,7 @@ import {
 	PhaseFrontmatter,
 	TaskFrontmatter,
 	WorkbaseConfig,
+	WorkbaseRegistry,
 	type Dependency,
 	type EpicFrontmatter as EpicData,
 	type PhaseFrontmatter as PhaseData,
@@ -19,6 +21,10 @@ import {
 	canUpdateManagedWorkbaseAgents,
 	managedWorkbaseAgents,
 } from "../workbase/agents-file"
+import {
+	canUpdateManagedWorkbaseOpencode,
+	managedWorkbaseOpencode,
+} from "../workbase/opencode-file"
 
 class WorkbaseNotFoundError extends Data.TaggedError("WorkbaseNotFoundError")<{
 	readonly message: string
@@ -30,6 +36,12 @@ class WorkbaseConfigError extends Data.TaggedError("WorkbaseConfigError")<{
 	readonly cause?: unknown
 }> {}
 
+class WorkbaseRegistryError extends Data.TaggedError("WorkbaseRegistryError")<{
+	readonly message: string
+	readonly path: string
+	readonly cause?: unknown
+}> {}
+
 interface ValidationIssue {
 	readonly path: string
 	readonly message: string
@@ -68,6 +80,45 @@ const decode = <S extends Schema.Schema.AnyNoContext>(
 		: { success: true, value: result.right }
 }
 
+const registryPath = (configDirectory?: string) =>
+	join(
+		configDirectory ||
+			process.env.XDG_CONFIG_HOME ||
+			join(homedir(), ".config"),
+		"agency",
+		"workbases.json",
+	)
+
+const readRegistry = (configDirectory?: string) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		const path = registryPath(configDirectory)
+		if (!(yield* fs.exists(path))) {
+			return { path, registry: { version: 1, workbases: [] } as const }
+		}
+
+		const content = yield* fs.readFile(path)
+		let input: unknown
+		try {
+			input = JSON.parse(content)
+		} catch (cause) {
+			return yield* new WorkbaseRegistryError({
+				path,
+				message: `Invalid JSON in workbase registry ${path}`,
+				cause,
+			})
+		}
+
+		const decoded = decode(WorkbaseRegistry, input)
+		if (!decoded.success) {
+			return yield* new WorkbaseRegistryError({
+				path,
+				message: `Invalid workbase registry in ${path}:\n${decoded.error}`,
+			})
+		}
+		return { path, registry: decoded.value }
+	})
+
 const ensureWorkbaseAgents = (root: string) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
@@ -86,6 +137,32 @@ const ensureWorkbaseAgents = (root: string) =>
 		}
 	})
 
+const ensureWorkbaseOpencode = (root: string) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		const directory = join(root, ".opencode")
+		const path = join(directory, "opencode.jsonc")
+		if (!(yield* fs.exists(path))) {
+			if (yield* fs.exists(join(directory, "opencode.json"))) return
+			yield* fs.createDirectory(directory)
+			yield* fs.writeFile(path, managedWorkbaseOpencode)
+			return
+		}
+
+		const content = yield* fs.readFile(path)
+		if (
+			content !== managedWorkbaseOpencode &&
+			canUpdateManagedWorkbaseOpencode(content)
+		) {
+			yield* fs.writeFile(path, managedWorkbaseOpencode)
+		}
+	})
+
+const ensureWorkbaseAgentFiles = (root: string) =>
+	Effect.all([ensureWorkbaseAgents(root), ensureWorkbaseOpencode(root)], {
+		concurrency: "unbounded",
+	})
+
 const findCycles = (nodes: readonly Dependency[]): readonly string[] => {
 	const dependencies = new Map(
 		nodes.map((node) => [node.id, [...(node.dependsOn ?? [])]]),
@@ -164,7 +241,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 							`${existing}${prefix}${missing.join("\n")}\n`,
 						)
 					}
-					yield* ensureWorkbaseAgents(root)
+					yield* ensureWorkbaseAgentFiles(root)
 
 					return root
 				}),
@@ -221,7 +298,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 										})
 									}
 								}
-								yield* ensureWorkbaseAgents(current)
+								yield* ensureWorkbaseAgentFiles(current)
 								return current
 							}
 						}
@@ -263,6 +340,28 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 					return { root, config: decoded.value }
 				}),
 
+			register: (startPath: string, configDirectory?: string) =>
+				Effect.gen(function* () {
+					const service = yield* WorkbaseService
+					const fs = yield* FileSystemService
+					const discovered = yield* service.discover(startPath)
+					const root = yield* fs.realPath(discovered)
+					const { path, registry } = yield* readRegistry(configDirectory)
+					if (registry.workbases.includes(root)) return root
+
+					yield* fs.createDirectory(dirname(path))
+					yield* fs.writeJSON(path, {
+						version: 1,
+						workbases: [...registry.workbases, root],
+					})
+					return root
+				}),
+
+			listRegistered: (configDirectory?: string) =>
+				readRegistry(configDirectory).pipe(
+					Effect.map(({ registry }) => registry.workbases),
+				),
+
 			validate: (startPath: string = process.cwd()) =>
 				Effect.gen(function* () {
 					const service = yield* WorkbaseService

package/src/services/WorktreeService.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, rm } from "node:fs/promises"
 import { join } from "node:path"
 import {
 	captureLogs,
@@ -600,6 +600,155 @@ pr: null
 		).rejects.toThrow("is attached to branch 'main'")
 	})
 
+	test("removes worktrees without deleting branches", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "removable",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							repos: [{ repo: "effect", ref: "main" }],
+							branch: "task/removable",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("removable", undefined, root),
+				),
+			),
+		)
+
+		const removed = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.remove("removable", undefined, root),
+				),
+			),
+		)
+
+		expect(removed.sort()).toEqual(
+			[
+				join(workspace.codePath, "agency"),
+				join(workspace.codePath, "effect"),
+			].sort(),
+		)
+		expect(await Bun.file(workspace.codePath).exists()).toBe(false)
+		const branch = Bun.spawnSync([
+			"git",
+			"-C",
+			join(root, "repos/agency"),
+			"show-ref",
+			"--verify",
+			"refs/heads/task/removable",
+		])
+		expect(branch.exitCode).toBe(0)
+	})
+
+	test("refuses to remove a worktree with uncommitted changes", 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, "uncommitted.txt"),
+			"keep me\n",
+		)
+
+		await expect(
+			runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) => service.remove("dirty", undefined, root)),
+				),
+			),
+		).rejects.toThrow("Failed to remove worktree for 'agency'")
+		expect(
+			await Bun.file(join(workspace.writablePath, "uncommitted.txt")).text(),
+		).toBe("keep me\n")
+	})
+
+	test("handles a missing checkout without deleting its branch", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "stale",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							branch: "task/stale",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("stale", undefined, root),
+				),
+			),
+		)
+		await rm(workspace.codePath, { recursive: true })
+
+		const removed = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) => service.remove("stale", undefined, root)),
+			),
+		)
+
+		expect(removed).toEqual([])
+		const worktrees = Bun.spawnSync([
+			"git",
+			"-C",
+			join(root, "repos/agency"),
+			"worktree",
+			"list",
+			"--porcelain",
+		])
+		expect(new TextDecoder().decode(worktrees.stdout)).not.toContain(
+			workspace.writablePath,
+		)
+		expect(
+			Bun.spawnSync([
+				"git",
+				"-C",
+				join(root, "repos/agency"),
+				"show-ref",
+				"--verify",
+				"refs/heads/task/stale",
+			]).exitCode,
+		).toBe(0)
+	})
+
 	test("supports Worktrunk as the configured command", async () => {
 		if (Bun.spawnSync(["which", "wt"], { stdout: "ignore" }).exitCode !== 0) {
 			return

package/src/services/WorktreeService.ts

@@ -1,5 +1,5 @@
 import { Data, Effect } from "effect"
-import { dirname, join, resolve } from "node:path"
+import { basename, dirname, join, resolve } from "node:path"
 import { FileSystemService } from "./FileSystemService"
 import { WorkbaseService } from "./WorkbaseService"
 import { TaskService } from "./TaskService"
@@ -372,6 +372,128 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 						repos: execution.repos ?? [],
 					} satisfies ExecutionWorkspace
 				}),
+
+			remove: (
+				taskId: string,
+				phaseId?: 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 root = yield* workbase.discover(startPath)
+					const task = yield* tasks.show(taskId, root)
+
+					let execution: {
+						repo: string
+						repos?: readonly RepositoryReference[]
+					}
+					let codePath: string
+					if ("phases" in task.data) {
+						if (!phaseId) {
+							return yield* new WorktreeError({
+								message: `Task '${taskId}' has multiple phases; phase ID is required`,
+							})
+						}
+						const phase = yield* phases.show(taskId, phaseId, root)
+						execution = phase.data
+						codePath = join(dirname(phase.path), "code")
+					} else {
+						if (phaseId) {
+							return yield* new WorktreeError({
+								message: `Task '${taskId}' is single-phase and does not accept a phase ID`,
+							})
+						}
+						execution = task.data
+						codePath = join(dirname(task.path), "code")
+					}
+
+					const codeDirectoryExists = yield* fs.isDirectory(codePath)
+					const removed: string[] = []
+					for (const alias of [
+						execution.repo,
+						...(execution.repos ?? []).map((reference) => reference.repo),
+					]) {
+						const repositoryPath = join(root, "repos", alias)
+						const checkoutPath = join(codePath, alias)
+						const listed = yield* fs.runCommand(
+							[
+								"git",
+								"-C",
+								repositoryPath,
+								"worktree",
+								"list",
+								"--porcelain",
+								"-z",
+							],
+							{ captureOutput: true },
+						)
+						if (listed.exitCode !== 0) {
+							return yield* new WorktreeError({
+								message: `Failed to inspect worktrees for '${alias}': ${listed.stderr}`,
+							})
+						}
+
+						const checkoutExists = yield* fs.isDirectory(checkoutPath)
+						const canonicalCheckoutPath = checkoutExists
+							? yield* fs.realPath(checkoutPath)
+							: join(
+									yield* fs.realPath(dirname(codePath)),
+									basename(codePath),
+									alias,
+								)
+						let registeredPath: string | undefined
+						for (const worktree of parseWorktreeList(listed.stdout)) {
+							const worktreePath = (yield* fs.exists(worktree.path))
+								? yield* fs.realPath(worktree.path)
+								: resolve(worktree.path)
+							if (worktreePath === canonicalCheckoutPath) {
+								registeredPath = worktreePath
+								break
+							}
+						}
+						if (!registeredPath) {
+							if (checkoutExists) {
+								return yield* new WorktreeError({
+									message: `Existing checkout ${checkoutPath} is not registered as a Git worktree`,
+								})
+							}
+							continue
+						}
+
+						const result = yield* fs.runCommand(
+							[
+								"git",
+								"-C",
+								repositoryPath,
+								"worktree",
+								"remove",
+								...(!checkoutExists ? ["--force"] : []),
+								checkoutExists ? checkoutPath : registeredPath,
+							],
+							{ captureOutput: true },
+						)
+						if (result.exitCode !== 0) {
+							return yield* new WorktreeError({
+								message: `Failed to remove worktree for '${alias}': ${result.stderr}`,
+							})
+						}
+						if (checkoutExists) removed.push(checkoutPath)
+					}
+
+					if (codeDirectoryExists && (yield* fs.isDirectory(codePath))) {
+						const remaining = yield* fs.readDirectory(codePath)
+						if (remaining.length > 0) {
+							return yield* new WorktreeError({
+								message: `Cannot remove ${codePath}; it contains unmanaged entries: ${remaining.map((entry) => entry.name).join(", ")}`,
+							})
+						}
+						yield* fs.deleteDirectory(codePath)
+					}
+					return removed
+				}),
 		}),
 	},
 ) {}

package/src/test-utils.ts

@@ -11,6 +11,7 @@ import { TaskService } from "./services/TaskService"
 import { PhaseService } from "./services/PhaseService"
 import { WorktreeService } from "./services/WorktreeService"
 import { PullRequestService } from "./services/PullRequestService"
+import { ArchiveService } from "./services/ArchiveService"
 
 export const createTempDir = () => mkdtemp(join(tmpdir(), "agency-test-"))
 
@@ -26,6 +27,7 @@ const TestLayer = Layer.mergeAll(
 	PhaseService.Default,
 	WorktreeService.Default,
 	PullRequestService.Default,
+	ArchiveService.Default,
 )
 
 export async function runTestEffect<A, E>(

package/src/utils/progress.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test"
+import { createProgress } from "./progress"
+
+describe("progress", () => {
+	test("replaces an active TTY line with its completed state", () => {
+		const output: string[] = []
+		const progress = createProgress(
+			{},
+			{ isTTY: true, write: (text) => output.push(text) },
+		)
+
+		progress.start("Preparing workspace...")
+		progress.succeed("Workspace ready")
+
+		expect(output).toEqual([
+			"\r\x1b[2K\x1b[2m○\x1b[0m Preparing workspace...",
+			"\r\x1b[2K\x1b[32m✓\x1b[0m Workspace ready\n",
+		])
+	})
+
+	test("stays quiet for silent or non-TTY output", () => {
+		const output: string[] = []
+		for (const [silent, isTTY] of [
+			[true, true],
+			[false, false],
+		] as const) {
+			const progress = createProgress(
+				{ silent },
+				{ isTTY, write: (text) => output.push(text) },
+			)
+			progress.start("Preparing workspace...")
+			progress.fail("Workspace preparation failed")
+		}
+
+		expect(output).toEqual([])
+	})
+})