@markjaquith/agency 2.3.0 → 2.5.0

package/src/commands/task.ts

@@ -1,6 +1,9 @@
 import { Effect } from "effect"
+import { createInterface } from "node:readline/promises"
 import type { BaseCommandOptions } from "../utils/command"
 import { TaskService } from "../services/TaskService"
+import { EpicService } from "../services/EpicService"
+import { RepositoryService } from "../services/RepositoryService"
 import { createLoggers } from "../utils/effect"
 import { parseRepositoryReferences } from "../workbase/repository-reference"
 
@@ -18,31 +21,151 @@ interface TaskOptions extends BaseCommandOptions {
 	readonly json?: boolean
 }
 
-export const task = (options: TaskOptions) =>
+export interface TaskInteraction {
+	readonly text: (prompt: string) => Effect.Effect<string, Error>
+	readonly select: (
+		prompt: string,
+		choices: readonly string[],
+	) => Effect.Effect<string | null, Error>
+}
+
+const defaultInteraction: TaskInteraction = {
+	text: (prompt) =>
+		Effect.tryPromise({
+			try: async () => {
+				const input = createInterface({
+					input: process.stdin,
+					output: process.stderr,
+				})
+				try {
+					return await input.question(prompt)
+				} finally {
+					input.close()
+				}
+			},
+			catch: (cause) => new Error("Failed to read task input", { cause }),
+		}),
+	select: (prompt, choices) =>
+		Effect.tryPromise({
+			try: async () => {
+				const process = Bun.spawn(
+					["fzf", `--prompt=${prompt}> `, "--height=~40%", "--reverse"],
+					{
+						stdin: new Blob([choices.join("\n")]),
+						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}`)
+				return output.trim() || null
+			},
+			catch: (cause) =>
+				new Error("Failed to select task input with fzf", { cause }),
+		}),
+}
+
+export const task = (
+	options: TaskOptions,
+	interaction: TaskInteraction = defaultInteraction,
+) =>
 	Effect.gen(function* () {
 		const tasks = yield* TaskService
+		const epics = yield* EpicService
+		const repositories = yield* RepositoryService
 		const { log } = createLoggers(options)
 		const cwd = options.cwd ?? process.cwd()
 
 		switch (options.subcommand) {
+			case "new":
 			case "create": {
-				const id = options.args[0]
-				if (!id || !options.ticketUrl) {
-					return yield* Effect.fail(
-						new Error("Usage: agency task create <id> --ticket-url <url>"),
+				const interactive = options.subcommand === "new" || !options.args[0]
+				const id =
+					options.args[0] ??
+					(interactive
+						? (yield* interaction.text("Task ID: ")).trim()
+						: undefined)
+				if (!id) {
+					return yield* Effect.fail(new Error("Task ID is required"))
+				}
+
+				let ticketUrl = options.ticketUrl?.trim() || null
+				let description = options.description?.trim() || undefined
+				let epic = options.epic
+				let multiPhase = options.multiPhase ?? false
+				let repo = options.repo
+
+				if (interactive) {
+					if (options.ticketUrl === undefined) {
+						ticketUrl =
+							(yield* interaction.text("Ticket URL (optional): ")).trim() ||
+							null
+					}
+					if (options.description === undefined) {
+						description =
+							(yield* interaction.text("Description (optional): ")).trim() ||
+							undefined
+					}
+					if (options.epic === undefined) {
+						const epicRecords = yield* epics.list(cwd)
+						if (epicRecords.length > 0) {
+							const none = "(none)"
+							const selected = yield* interaction.select("Parent epic", [
+								none,
+								...epicRecords.map((record) => record.id),
+							])
+							if (selected === null) {
+								return yield* Effect.fail(new Error("Task creation cancelled"))
+							}
+							epic = selected === none ? undefined : selected
+						}
+					}
+					if (options.multiPhase === undefined) {
+						const selected = yield* interaction.select("Task type", [
+							"single-phase",
+							"multi-phase",
+						])
+						if (selected === null) {
+							return yield* Effect.fail(new Error("Task creation cancelled"))
+						}
+						multiPhase = selected === "multi-phase"
+					}
+				}
+
+				if (!multiPhase && !repo) {
+					const records = yield* repositories.list(cwd)
+					if (records.length === 0) {
+						return yield* Effect.fail(
+							new Error(
+								"No repositories found; add or link a repository first",
+							),
+						)
+					}
+					const selected = yield* interaction.select(
+						"Writable repository",
+						records.map((record) => record.alias),
 					)
+					if (!selected) {
+						return yield* Effect.fail(new Error("Task creation cancelled"))
+					}
+					repo = selected
 				}
+
 				const record = yield* tasks.create(
 					{
 						id,
-						ticketUrl: options.ticketUrl,
-						description: options.description,
-						epic: options.epic,
-						multiPhase: options.multiPhase,
-						repo: options.repo,
+						ticketUrl,
+						description,
+						epic,
+						multiPhase,
+						repo,
 						repos: parseRepositoryReferences(options.references),
-						branch: options.branch,
-						base: options.base,
+						branch: multiPhase ? undefined : (options.branch ?? `task/${id}`),
+						base: multiPhase ? undefined : (options.base ?? "main"),
 					},
 					cwd,
 				)
@@ -81,9 +204,27 @@ export const task = (options: TaskOptions) =>
 				)
 				return
 			}
+			case "status": {
+				const [id, status] = options.args
+				if (!id || !status) {
+					return yield* Effect.fail(
+						new Error("Usage: agency task status <id> <status>"),
+					)
+				}
+				const record = yield* tasks.setStatus(id, status, cwd)
+				const { content: _, ...output } = record
+				log(
+					options.json
+						? JSON.stringify(output, null, 2)
+						: `Marked task '${id}' as ${record.data.status}`,
+				)
+				return
+			}
 			default:
 				return yield* Effect.fail(
-					new Error("Subcommand is required. Available: create, list, show"),
+					new Error(
+						"Subcommand is required. Available: new, create, list, show, status",
+					),
 				)
 		}
 	})
@@ -92,19 +233,21 @@ export const help = `
 Usage: agency task <subcommand>
 
 Subcommands:
-  create <id>           Create a task
+  new [id]              Create a task with guided input
+  create <id>           Create a task; omitted metadata uses defaults
   list                  List tasks
   show <id>             Show a task
+  status <id> <status>  Set open, working, done, or dropped
 
 Create options:
-  --ticket-url <url>    External ticket URL
+  --ticket-url <url>    External ticket URL (optional)
   --description <text>  Short description of the task
   --epic <id>           Parent epic
   --repo <alias>        Writable repository
   --reference <alias>:<ref>
                         Read-only repository reference; repeatable
-  --branch <name>       Working branch
-  --base <name>         Base branch
+  --branch <name>       Working branch (default: task/<id>)
+  --base <name>         Base branch (default: main)
   --multi-phase         Create a task container for phases
 
 Options:

package/src/commands/work.test.ts

@@ -9,6 +9,7 @@ import { WorktreeService } from "../services/WorktreeService"
 import { captureLogs } from "../test-utils"
 import { work } from "./work"
 import type { PickWorkTarget } from "../workbase/work-target"
+import type { Progress } from "../utils/progress"
 
 type ExecutionWorkspace = Effect.Effect.Success<
 	ReturnType<WorktreeService["materialize"]>
@@ -47,14 +48,25 @@ interface HarnessOptions {
 const createHarness = (options: HarnessOptions = {}) => {
 	const events: string[] = []
 	const probes: string[] = []
+	const statusUpdates: string[] = []
+	const progressUpdates: string[] = []
 	const launches: Array<{
 		cli: string
 		args: readonly string[]
 		cwd: string
 	}> = []
+	const materializeOptions: Array<
+		Parameters<WorktreeService["materialize"]>[3]
+	> = []
 	const worktrees = {
-		materialize: () => {
+		materialize: (
+			_taskId: string,
+			_phaseId?: string,
+			_root?: string,
+			commandOptions?: Parameters<WorktreeService["materialize"]>[3],
+		) => {
 			events.push("materialize")
+			materializeOptions.push(commandOptions)
 			return options.materializeError
 				? Effect.fail(options.materializeError)
 				: Effect.succeed(options.workspace ?? singlePhaseWorkspace)
@@ -82,6 +94,10 @@ const createHarness = (options: HarnessOptions = {}) => {
 					: { repo: "agency", branch: `task/${id}`, base: "main" },
 			}),
 		list: () => Effect.succeed(options.taskRecords ?? []),
+		setStatus: (id: string, status: string) => {
+			statusUpdates.push(`task:${id}:${status}`)
+			return Effect.void
+		},
 	}
 	const phases = {
 		show: (taskId: string, id: string) =>
@@ -92,6 +108,10 @@ const createHarness = (options: HarnessOptions = {}) => {
 				data: { repo: "agency", branch: `task/${id}`, base: "main" },
 			}),
 		list: () => Effect.succeed(options.phaseRecords ?? []),
+		setStatus: (taskId: string, id: string, status: string) => {
+			statusUpdates.push(`phase:${taskId}:${id}:${status}`)
+			return Effect.void
+		},
 	}
 	const fs = {
 		runCommand: (args: readonly string[]) => {
@@ -110,12 +130,17 @@ const createHarness = (options: HarnessOptions = {}) => {
 		launches.push({ cli, args, cwd })
 	}
 	const defaultPick: PickWorkTarget = () => Effect.succeed(null)
+	const progress: Progress = {
+		start: (message) => progressUpdates.push(`start:${message}`),
+		succeed: (message) => progressUpdates.push(`succeed:${message}`),
+		fail: (message) => progressUpdates.push(`fail:${message}`),
+	}
 	const run = (
 		commandOptions: Parameters<typeof work>[0],
 		pick: PickWorkTarget = defaultPick,
 	) =>
 		Effect.runPromise(
-			work(commandOptions, launch, pick).pipe(
+			work(commandOptions, launch, pick, progress).pipe(
 				Effect.provideService(WorktreeService, worktrees as never),
 				Effect.provideService(FileSystemService, fs as never),
 				Effect.provideService(WorkbaseService, workbase as never),
@@ -125,7 +150,15 @@ const createHarness = (options: HarnessOptions = {}) => {
 			) as Effect.Effect<void, unknown, never>,
 		)
 
-	return { events, probes, launches, run }
+	return {
+		events,
+		probes,
+		launches,
+		materializeOptions,
+		statusUpdates,
+		progressUpdates,
+		run,
+	}
 }
 
 describe("work command", () => {
@@ -137,11 +170,7 @@ describe("work command", () => {
 		expect(harness.events).toEqual(["probe:opencode", "launch:opencode"])
 		expect(harness.launches[0]).toEqual({
 			cli: "opencode",
-			args: [
-				"opencode",
-				"--prompt",
-				"Work on the epic. Read /workbase/epics/delivery/EPIC.md.",
-			],
+			args: ["opencode", "--continue"],
 			cwd: "/workbase/epics/delivery",
 		})
 	})
@@ -154,11 +183,7 @@ describe("work command", () => {
 		expect(harness.events).toEqual(["probe:opencode", "launch:opencode"])
 		expect(harness.launches[0]).toEqual({
 			cli: "opencode",
-			args: [
-				"opencode",
-				"--prompt",
-				"Work on the task. Read /workbase/tasks/delivery/TASK.md.",
-			],
+			args: ["opencode", "--continue"],
 			cwd: "/workbase/tasks/delivery",
 		})
 	})
@@ -176,9 +201,10 @@ describe("work command", () => {
 			"probe:opencode",
 			"launch:opencode",
 		])
-		expect(harness.launches[0]?.args).toContain(
-			"Start the task. Read /workbase/tasks/example/TASK.md and /workbase/tasks/example/phases/implementation/PHASE.md.",
-		)
+		expect(harness.launches[0]?.args).toEqual(["opencode", "--continue"])
+		expect(harness.statusUpdates).toEqual([
+			"phase:example:implementation:working",
+		])
 	})
 
 	test("infers a single-phase task from a nested checkout directory", async () => {
@@ -190,7 +216,7 @@ describe("work command", () => {
 		})
 
 		expect(harness.events[0]).toBe("materialize")
-		expect(harness.launches[0]?.cwd).toBe("/workbase/tasks/example/code/agency")
+		expect(harness.launches[0]?.cwd).toBe("/workbase/tasks/example")
 	})
 
 	test("selects a target with fzf outside an entity directory", async () => {
@@ -225,7 +251,7 @@ describe("work command", () => {
 			"launch:opencode",
 		])
 		expect(harness.launches[0]?.cwd).toBe(
-			"/workbase/tasks/example/phases/implementation/code/agency",
+			"/workbase/tasks/delivery/phases/build",
 		)
 	})
 
@@ -269,7 +295,7 @@ describe("work command", () => {
 		expect(harness.events).toEqual([])
 	})
 
-	test("launches OpenCode in the writable checkout with the single-phase prompt", async () => {
+	test("launches OpenCode in the task directory and continues its session", async () => {
 		const harness = createHarness()
 
 		await harness.run({ taskId: "example", opencode: true })
@@ -282,17 +308,18 @@ describe("work command", () => {
 		expect(harness.launches).toEqual([
 			{
 				cli: "opencode",
-				args: [
-					"opencode",
-					"--prompt",
-					"Start the task. Read /workbase/tasks/example/TASK.md.",
-				],
-				cwd: "/workbase/tasks/example/code/agency",
+				args: ["opencode", "--continue"],
+				cwd: "/workbase/tasks/example",
 			},
 		])
+		expect(harness.statusUpdates).toEqual(["task:example:working"])
+		expect(harness.progressUpdates).toEqual([
+			"start:Preparing workspace...",
+			"succeed:Workspace ready",
+		])
 	})
 
-	test("includes absolute task and phase paths in a multi-phase prompt", async () => {
+	test("continues OpenCode for a multi-phase task", async () => {
 		const harness = createHarness({ workspace: multiPhaseWorkspace })
 
 		await harness.run({
@@ -301,11 +328,7 @@ describe("work command", () => {
 			opencode: true,
 		})
 
-		expect(harness.launches[0]?.args).toEqual([
-			"opencode",
-			"--prompt",
-			"Start the task. Read /workbase/tasks/example/TASK.md and /workbase/tasks/example/phases/implementation/PHASE.md.",
-		])
+		expect(harness.launches[0]?.args).toEqual(["opencode", "--continue"])
 	})
 
 	test("automatically falls back to Claude", async () => {
@@ -317,7 +340,7 @@ describe("work command", () => {
 		expect(harness.launches[0]).toEqual({
 			cli: "claude",
 			args: ["claude", "Start the task. Read /workbase/tasks/example/TASK.md."],
-			cwd: "/workbase/tasks/example/code/agency",
+			cwd: "/workbase/tasks/example",
 		})
 	})
 
@@ -329,6 +352,7 @@ describe("work command", () => {
 		).rejects.toThrow("opencode CLI tool not found")
 		expect(harness.probes).toEqual(["opencode"])
 		expect(harness.launches).toEqual([])
+		expect(harness.statusUpdates).toEqual([])
 	})
 
 	test("launches explicitly requested Claude", async () => {
@@ -340,7 +364,7 @@ describe("work command", () => {
 		expect(harness.launches[0]).toEqual({
 			cli: "claude",
 			args: ["claude", "Start the task. Read /workbase/tasks/example/TASK.md."],
-			cwd: "/workbase/tasks/example/code/agency",
+			cwd: "/workbase/tasks/example",
 		})
 	})
 
@@ -365,6 +389,10 @@ describe("work command", () => {
 			"materialization failed",
 		)
 		expect(harness.events).toEqual(["materialize"])
+		expect(harness.progressUpdates).toEqual([
+			"start:Preparing workspace...",
+			"fail:Workspace preparation failed",
+		])
 	})
 
 	test("respects silent and verbose logging options", async () => {
@@ -373,8 +401,9 @@ describe("work command", () => {
 			verboseHarness.run({ taskId: "example", verbose: true }),
 		)
 		expect(verboseLogs).toEqual([
-			"Launching opencode in /workbase/tasks/example/code/agency",
+			"Launching opencode in /workbase/tasks/example",
 		])
+		expect(verboseHarness.materializeOptions[0]?.verbose).toBe(true)
 
 		const silentHarness = createHarness()
 		const silentLogs = await captureLogs(() =>

package/src/commands/work.ts

@@ -9,6 +9,7 @@ import { TaskService } from "../services/TaskService"
 import { PhaseService } from "../services/PhaseService"
 import { createLoggers } from "../utils/effect"
 import { execvp } from "../utils/exec"
+import { createProgress, type Progress } from "../utils/progress"
 import {
 	buildWorkTargetChoices,
 	pickWorkTarget,
@@ -35,6 +36,7 @@ export const work = (
 	options: WorkOptions = {},
 	launch: LaunchAgent = launchAgent,
 	pick: PickWorkTarget = pickWorkTarget,
+	progress: Progress = createProgress(options),
 ) =>
 	Effect.gen(function* () {
 		if (options.opencode && options.claude) {
@@ -155,11 +157,21 @@ export const work = (
 		} else {
 			const taskId = target.taskId
 			const phaseId = target.kind === "phase" ? target.phaseId : undefined
-			const workspace = yield* worktrees.materialize(taskId, phaseId, root)
+			progress.start("Preparing workspace...")
+			const workspace = yield* worktrees
+				.materialize(taskId, phaseId, root, options)
+				.pipe(
+					Effect.tap(() =>
+						Effect.sync(() => progress.succeed("Workspace ready")),
+					),
+					Effect.tapError(() =>
+						Effect.sync(() => progress.fail("Workspace preparation failed")),
+					),
+				)
 			prompt = workspace.phasePath
 				? `Start the task. Read ${workspace.taskPath} and ${workspace.phasePath}.`
 				: `Start the task. Read ${workspace.taskPath}.`
-			launchPath = workspace.writablePath
+			launchPath = dirname(target.path)
 		}
 
 		const requested = options.claude ? "claude" : "opencode"
@@ -174,9 +186,14 @@ export const work = (
 		if (available.exitCode !== 0) {
 			return yield* Effect.fail(new Error(`${cli} CLI tool not found`))
 		}
+		if (target.kind === "phase") {
+			yield* phases.setStatus(target.taskId, target.phaseId, "working", root)
+		} else if (target.kind === "task" && !target.multiPhase) {
+			yield* tasks.setStatus(target.taskId, "working", root)
+		}
 
 		verboseLog(`Launching ${cli} in ${launchPath}`)
-		const args = cli === "opencode" ? ["--prompt", prompt] : [prompt]
+		const args = cli === "opencode" ? ["--continue"] : [prompt]
 		launch(cli, [cli, ...args], launchPath)
 	})