@markjaquith/agency 2.5.0 → 2.7.0

package/src/services/WorktreeService.ts

@@ -136,11 +136,13 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 							})
 						}
 
-						const remote = yield* fs.runCommand(
-							["git", "-C", repositoryPath, "remote", "get-url", "origin"],
-							{ captureOutput: true },
-						)
-						if (remote.exitCode === 0) {
+						const fetchOrigin = Effect.gen(function* () {
+							const remote = yield* fs.runCommand(
+								["git", "-C", repositoryPath, "remote", "get-url", "origin"],
+								{ captureOutput: true },
+							)
+							if (remote.exitCode !== 0) return
+
 							const fetch = yield* fs.runCommand(
 								["git", "-C", repositoryPath, "fetch", "origin"],
 								{ captureOutput: true },
@@ -150,7 +152,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 									message: `Failed to fetch '${alias}': ${fetch.stderr}`,
 								})
 							}
-						}
+						})
 
 						const listed = yield* fs.runCommand(
 							[
@@ -208,6 +210,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 									message: `Worktree registry contains a missing checkout at ${checkoutPath}`,
 								})
 							}
+							yield* fetchOrigin
 
 							let args: string[]
 							let env: Record<string, string> | undefined
@@ -341,6 +344,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 									message: `Worktree registry contains a missing checkout at ${checkoutPath}`,
 								})
 							}
+							yield* fetchOrigin
 							const result = yield* fs.runCommand(
 								[
 									"git",

package/src/workbase/opencode-file.ts

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto"
+import { join } from "node:path"
 
 const managedHeaderPattern =
 	/^\/\/ agency-managed: sha256=([a-f0-9]{64})\r?\n\r?\n/
@@ -6,28 +7,36 @@ const managedHeaderPattern =
 const checksum = (content: string) =>
 	createHash("sha256").update(content).digest("hex")
 
-const body = `${JSON.stringify(
-	{
-		$schema: "https://opencode.ai/config.json",
-		references: {
-			tasks: {
-				path: "../tasks",
-				description: "Agency task definitions and execution context",
+const body = (root: string) =>
+	`${JSON.stringify(
+		{
+			$schema: "https://opencode.ai/config.json",
+			references: {
+				tasks: {
+					path: "../tasks",
+					description: "Agency task definitions and execution context",
+				},
+				epics: {
+					path: "../epics",
+					description: "Agency epic definitions and orchestration context",
+				},
 			},
-			epics: {
-				path: "../epics",
-				description: "Agency epic definitions and orchestration context",
+			permission: {
+				external_directory: {
+					[`${join(root, "tasks")}/*`]: "allow",
+					[`${join(root, "epics")}/*`]: "allow",
+				},
 			},
 		},
-	},
-	null,
-	2,
-)}\n`
+		null,
+		2,
+	)}\n`
 
-const renderManagedWorkbaseOpencode = (content: string = body) =>
+const renderManagedWorkbaseOpencode = (content: string) =>
 	`// agency-managed: sha256=${checksum(content)}\n\n${content}`
 
-export const managedWorkbaseOpencode = renderManagedWorkbaseOpencode()
+export const managedWorkbaseOpencode = (root: string) =>
+	renderManagedWorkbaseOpencode(body(root))
 
 export const canUpdateManagedWorkbaseOpencode = (content: string) => {
 	const match = content.match(managedHeaderPattern)

package/src/workbase/schemas.test.ts

@@ -5,7 +5,9 @@ import {
 	EpicFrontmatter,
 	PhaseFrontmatter,
 	TaskFrontmatter,
+	WorkStatus,
 	WorkbaseConfig,
+	WorkbaseRegistry,
 } from "./schemas"
 
 describe("body-of-work descriptions", () => {
@@ -76,6 +78,14 @@ describe("body-of-work descriptions", () => {
 })
 
 describe("work status", () => {
+	const supportedStatuses: Record<WorkStatus, true> = {
+		open: true,
+		working: true,
+		delegated: true,
+		done: true,
+		dropped: true,
+	}
+
 	test("defaults execution units to open", () => {
 		const task = Schema.decodeUnknownSync(TaskFrontmatter)({
 			ticketUrl: "https://example.com/task",
@@ -95,17 +105,36 @@ describe("work status", () => {
 		expect(phase.status).toBe("open")
 	})
 
-	test("accepts supported statuses and rejects other values", () => {
-		const phase = Schema.decodeUnknownSync(PhaseFrontmatter)({
-			repo: "agency",
-			branch: "task/done",
-			base: "main",
-			pr: null,
-			status: "done",
-		})
-		expect(phase.status).toBe("done")
+	test("accepts every supported status on tasks and phases", () => {
+		for (const status of Object.keys(supportedStatuses) as WorkStatus[]) {
+			expect(Schema.decodeUnknownSync(WorkStatus)(status)).toBe(status)
+
+			const task = Schema.decodeUnknownSync(TaskFrontmatter)({
+				ticketUrl: null,
+				repo: "agency",
+				branch: `task/${status}`,
+				base: "main",
+				pr: null,
+				status,
+			})
+			const phase = Schema.decodeUnknownSync(PhaseFrontmatter)({
+				repo: "agency",
+				branch: `phase/${status}`,
+				base: "main",
+				pr: null,
+				status,
+			})
+
+			expect("status" in task && task.status).toBe(status)
+			expect(phase.status).toBe(status)
+		}
+	})
+
+	test("rejects unsupported statuses on tasks and phases", () => {
+		expect(() => Schema.decodeUnknownSync(WorkStatus)("blocked")).toThrow()
 		expect(() =>
-			Schema.decodeUnknownSync(PhaseFrontmatter)({
+			Schema.decodeUnknownSync(TaskFrontmatter)({
+				ticketUrl: null,
 				repo: "agency",
 				branch: "task/invalid",
 				base: "main",
@@ -113,6 +142,41 @@ describe("work status", () => {
 				status: "blocked",
 			}),
 		).toThrow()
+		expect(() =>
+			Schema.decodeUnknownSync(PhaseFrontmatter)({
+				repo: "agency",
+				branch: "phase/invalid",
+				base: "main",
+				pr: null,
+				status: "blocked",
+			}),
+		).toThrow()
+	})
+})
+
+describe("workbase registry", () => {
+	test("accepts registered paths", () => {
+		expect(
+			Schema.decodeUnknownSync(WorkbaseRegistry)({
+				version: 1,
+				workbases: ["/work/one", "/work/two"],
+			}),
+		).toEqual({ version: 1, workbases: ["/work/one", "/work/two"] })
+	})
+
+	test("rejects invalid versions and empty paths", () => {
+		expect(() =>
+			Schema.decodeUnknownSync(WorkbaseRegistry)({
+				version: 2,
+				workbases: [],
+			}),
+		).toThrow()
+		expect(() =>
+			Schema.decodeUnknownSync(WorkbaseRegistry)({
+				version: 1,
+				workbases: [""],
+			}),
+		).toThrow()
 	})
 })
 

package/src/workbase/schemas.ts

@@ -15,7 +15,13 @@ export const RepositoryReference = Schema.Struct({
 	ref: NonEmptyString,
 })
 
-export const WorkStatus = Schema.Literal("open", "working", "done", "dropped")
+export const WorkStatus = Schema.Literal(
+	"open",
+	"working",
+	"delegated",
+	"done",
+	"dropped",
+)
 
 const Url = NonEmptyString.pipe(Schema.pattern(/^[a-zA-Z][a-zA-Z0-9+.-]*:/))
 
@@ -28,6 +34,11 @@ export const WorkbaseConfig = Schema.Struct({
 	worktreeCreateCommand: Schema.optional(Schema.NonEmptyArray(NonEmptyString)),
 })
 
+export const WorkbaseRegistry = Schema.Struct({
+	version: Schema.Literal(1),
+	workbases: Schema.Array(NonEmptyString),
+})
+
 export const Dependency = Schema.Struct({
 	id: EntityId,
 	dependsOn: Schema.optional(Schema.Array(EntityId)),
@@ -74,6 +85,7 @@ export const PhaseFrontmatter = Schema.Struct({
 })
 
 export type WorkbaseConfig = Schema.Schema.Type<typeof WorkbaseConfig>
+export type WorkbaseRegistry = Schema.Schema.Type<typeof WorkbaseRegistry>
 export type Dependency = Schema.Schema.Type<typeof Dependency>
 export type RepositoryReference = Schema.Schema.Type<typeof RepositoryReference>
 export type WorkStatus = Schema.Schema.Type<typeof WorkStatus>

package/src/workbase/work-target.test.ts

@@ -32,6 +32,11 @@ describe("work target choices", () => {
 					path: "/workbase/tasks/standalone/TASK.md",
 					data: { description: "Independent work" },
 				},
+				{
+					id: "delegated",
+					path: "/workbase/tasks/delegated/TASK.md",
+					data: { status: "delegated" },
+				},
 			],
 			[
 				{
@@ -63,6 +68,7 @@ describe("work target choices", () => {
 			"    \x1b[31m⊘\x1b[0m \x1b[33m󰔚\x1b[0m unlisted",
 			"  \x1b[32m✓\x1b[0m \x1b[36m󰗡\x1b[0m single",
 			"\x1b[2m○\x1b[0m \x1b[36m󰗡\x1b[0m standalone\x1b[2m - Independent work\x1b[0m",
+			"\x1b[35m↗\x1b[0m \x1b[36m󰗡\x1b[0m delegated",
 		])
 		expect(choices.map((choice) => choice.target.kind)).toEqual([
 			"epic",
@@ -72,6 +78,7 @@ describe("work target choices", () => {
 			"phase",
 			"task",
 			"task",
+			"task",
 		])
 	})
 })

package/src/workbase/work-target.ts

@@ -58,6 +58,7 @@ export interface WorkTargetChoice {
 const statusIcons: Record<WorkStatus, string> = {
 	open: "\x1b[2m○\x1b[0m",
 	working: "\x1b[34m◐\x1b[0m",
+	delegated: "\x1b[35m↗\x1b[0m",
 	done: "\x1b[32m✓\x1b[0m",
 	dropped: "\x1b[31m⊘\x1b[0m",
 }

package/src/workbase/workbase-choice.ts

@@ -0,0 +1,71 @@
+import { Effect } from "effect"
+import { resolve } from "node:path"
+import { FileSystemService } from "../services/FileSystemService"
+import { WorkbaseService } from "../services/WorkbaseService"
+
+export type PickWorkbase = (
+	workbases: readonly string[],
+) => Effect.Effect<string | null, Error>
+
+export const pickWorkbase: PickWorkbase = (workbases) =>
+	Effect.tryPromise({
+		try: async () => {
+			const input = workbases
+				.map((workbase, index) => `${index}\t${workbase}`)
+				.join("\n")
+			const process = Bun.spawn(
+				["fzf", "--delimiter=\t", "--with-nth=2..", "--prompt=Workbase> "],
+				{ stdin: new Blob([input]), stdout: "pipe", stderr: "inherit" },
+			)
+			const [exitCode, output] = await Promise.all([
+				process.exited,
+				new Response(process.stdout).text(),
+			])
+			if (exitCode === 1 || exitCode === 130) return null
+			if (exitCode !== 0) throw new Error(`fzf exited with code ${exitCode}`)
+			const index = Number.parseInt(output.split("\t", 1)[0] ?? "", 10)
+			return workbases[index] ?? null
+		},
+		catch: (cause) =>
+			new Error("Failed to select a workbase with fzf", { cause }),
+	})
+
+export const resolveWorkbase = (
+	startPath: string,
+	log: (message: string) => void,
+	pick: PickWorkbase = pickWorkbase,
+) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		const workbase = yield* WorkbaseService
+
+		return yield* workbase.discover(startPath).pipe(
+			Effect.catchTag("WorkbaseNotFoundError", () =>
+				Effect.gen(function* () {
+					const registered = yield* workbase.listRegistered()
+					if (registered.length === 0) {
+						return yield* Effect.fail(
+							new Error(
+								`No Agency workbase found from ${resolve(startPath)}. Register one with 'agency workbase add <path>'.`,
+							),
+						)
+					}
+
+					const fzf = yield* fs.runCommand(["which", "fzf"], {
+						captureOutput: true,
+					})
+					if (fzf.exitCode !== 0) {
+						for (const path of registered) log(path)
+						return yield* Effect.fail(
+							new Error(
+								"fzf is required to select a workbase; install fzf or run Agency from a registered workbase",
+							),
+						)
+					}
+
+					const selected = yield* pick(registered)
+					return selected ? yield* workbase.discover(selected) : null
+				}),
+			),
+		)
+	})