@markjaquith/agency 2.3.0 → 2.5.0

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", "done", root),
+				),
+			),
+		)
+		expect(task.data.status).toBe("done")
+		expect(task.content).toContain("status: done")
+		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")
+	})
 })

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

@@ -5,6 +5,7 @@ import { mkdir } 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,66 @@ 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("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

@@ -19,6 +19,10 @@ import {
 	canUpdateManagedWorkbaseAgents,
 	managedWorkbaseAgents,
 } from "../workbase/agents-file"
+import {
+	canUpdateManagedWorkbaseOpencode,
+	managedWorkbaseOpencode,
+} from "../workbase/opencode-file"
 
 class WorkbaseNotFoundError extends Data.TaggedError("WorkbaseNotFoundError")<{
 	readonly message: string
@@ -86,6 +90,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 +194,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 							`${existing}${prefix}${missing.join("\n")}\n`,
 						)
 					}
-					yield* ensureWorkbaseAgents(root)
+					yield* ensureWorkbaseAgentFiles(root)
 
 					return root
 				}),
@@ -221,7 +251,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 										})
 									}
 								}
-								yield* ensureWorkbaseAgents(current)
+								yield* ensureWorkbaseAgentFiles(current)
 								return current
 							}
 						}

package/src/services/WorktreeService.test.ts

@@ -1,8 +1,13 @@
 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 { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
+import {
+	captureLogs,
+	cleanupTempDir,
+	createTempDir,
+	runTestEffect,
+} from "../test-utils"
 import { TaskService } from "./TaskService"
 import { PhaseService } from "./PhaseService"
 import { WorktreeService } from "./WorktreeService"
@@ -127,6 +132,60 @@ describe("WorktreeService", () => {
 		).toBe("example\n")
 	})
 
+	test("logs the expanded configured command in verbose mode", async () => {
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({
+				version: 2,
+				worktreeCreateCommand: [
+					"sh",
+					"-c",
+					'git -C "$1" worktree add -b "$3" "$2" "$4" >/dev/null 2>&1',
+					"agency-worktree",
+					"{repo}",
+					"{worktree}",
+					"{branch}",
+					"{base}",
+				],
+			}),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "verbose-command",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							branch: "task/verbose-command",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		const logs = await captureLogs(() =>
+			runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) =>
+						service.materialize("verbose-command", undefined, root, {
+							verbose: true,
+						}),
+					),
+				),
+			),
+		)
+
+		expect(logs).toHaveLength(1)
+		expect(logs[0]).toStartWith("Running worktree command: sh -c ")
+		expect(logs[0]).toContain(join(root, "repos", "agency"))
+		expect(logs[0]).toContain(
+			join(root, "tasks", "verbose-command", "code", "agency"),
+		)
+	})
+
 	test("selects phases and rejects missing or unexpected phase IDs", async () => {
 		await runTestEffect(
 			TaskService.pipe(
@@ -541,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