@markjaquith/agency 2.4.0 → 2.6.0

package/src/commands/task-phase.test.ts

@@ -95,6 +95,7 @@ describe("task and phase command JSON output", () => {
 					branch: "task/first",
 					base: "main",
 					pr: null,
+					status: "open",
 				},
 			},
 		])
@@ -118,6 +119,7 @@ describe("task and phase command JSON output", () => {
 				branch: "task/first",
 				base: "main",
 				pr: null,
+				status: "open",
 			},
 		})
 	})
@@ -156,10 +158,53 @@ describe("task and phase command JSON output", () => {
 		expect(JSON.parse(phaseLogs[0]!)).toMatchObject({
 			taskId: "another",
 			id: "first",
-			data: { repo: "agency", branch: "task/another-first", base: "main" },
+			data: {
+				repo: "agency",
+				branch: "task/another-first",
+				base: "main",
+				status: "open",
+			},
 		})
 	})
 
+	test("sets task and phase status", async () => {
+		const phaseLogs = await captureLogs(() =>
+			runTestEffect(
+				phase({
+					subcommand: "status",
+					args: ["multi", "first", "delegated"],
+					cwd: root,
+					json: true,
+				}),
+			),
+		)
+		expect(JSON.parse(phaseLogs[0]!).data.status).toBe("delegated")
+
+		await runTestEffect(
+			task({
+				subcommand: "create",
+				args: ["single-status"],
+				ticketUrl: "https://example.com/task",
+				repo: "agency",
+				branch: "task/single-status",
+				base: "main",
+				cwd: root,
+				silent: true,
+			}),
+		)
+		const taskLogs = await captureLogs(() =>
+			runTestEffect(
+				task({
+					subcommand: "status",
+					args: ["single-status", "delegated"],
+					cwd: root,
+					json: true,
+				}),
+			),
+		)
+		expect(JSON.parse(taskLogs[0]!).data.status).toBe("delegated")
+	})
+
 	test("converts a single-phase task with an explicit first phase ID", async () => {
 		await runTestEffect(
 			task({

package/src/commands/task.test.ts

@@ -0,0 +1,94 @@
+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 { task, type TaskInteraction } from "./task"
+
+describe("task creation input", () => {
+	let root: string
+
+	beforeEach(async () => {
+		root = await createTempDir()
+		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
+		await mkdir(join(root, "repos/agency"), { recursive: true })
+	})
+
+	afterEach(async () => cleanupTempDir(root))
+
+	test("guides task creation and defaults branch metadata", async () => {
+		await mkdir(join(root, "epics/delivery"), { recursive: true })
+		await Bun.write(
+			join(root, "epics/delivery/EPIC.md"),
+			"---\nticketUrl: https://example.com/delivery\nrepos:\n  - repo: agency\n    ref: main\ntasks: []\n---\n\n# Delivery\n",
+		)
+		const textAnswers = ["guided-task", "", ""]
+		const prompts: string[] = []
+		const interaction: TaskInteraction = {
+			text: (prompt) => {
+				prompts.push(prompt)
+				return Effect.succeed(textAnswers.shift() ?? "")
+			},
+			select: (prompt, choices) => {
+				prompts.push(`${prompt}: ${choices.join(",")}`)
+				return Effect.succeed(
+					prompt === "Parent epic"
+						? "(none)"
+						: prompt === "Task type"
+							? "single-phase"
+							: "agency",
+				)
+			},
+		}
+
+		await runTestEffect(
+			task(
+				{ subcommand: "new", args: [], cwd: root, silent: true },
+				interaction,
+			),
+		)
+
+		const content = await Bun.file(
+			join(root, "tasks/guided-task/TASK.md"),
+		).text()
+		expect(content).toContain("ticketUrl: null")
+		expect(content).toContain("repo: agency")
+		expect(content).toContain("branch: task/guided-task")
+		expect(content).toContain("base: main")
+		expect(prompts).toEqual([
+			"Task ID: ",
+			"Ticket URL (optional): ",
+			"Description (optional): ",
+			"Parent epic: (none),delivery",
+			"Task type: single-phase,multi-phase",
+			"Writable repository: agency",
+		])
+	})
+
+	test("keeps scripted creation non-interactive and permits no ticket URL", async () => {
+		const interaction: TaskInteraction = {
+			text: () => Effect.fail(new Error("unexpected text prompt")),
+			select: () => Effect.fail(new Error("unexpected selection prompt")),
+		}
+
+		await runTestEffect(
+			task(
+				{
+					subcommand: "create",
+					args: ["scripted-task"],
+					repo: "agency",
+					cwd: root,
+					silent: true,
+				},
+				interaction,
+			),
+		)
+
+		const content = await Bun.file(
+			join(root, "tasks/scripted-task/TASK.md"),
+		).text()
+		expect(content).toContain("ticketUrl: null")
+		expect(content).toContain("branch: task/scripted-task")
+		expect(content).toContain("base: main")
+	})
+})

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, delegated, 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/validate.test.ts

@@ -1,4 +1,5 @@
 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 {
@@ -7,6 +8,9 @@ import {
 	createTempDir,
 	runTestEffect,
 } from "../test-utils"
+import { FileSystemService } from "../services/FileSystemService"
+import { WorkbaseService } from "../services/WorkbaseService"
+import type { PickWorkbase } from "../workbase/workbase-choice"
 import { validate } from "./validate"
 
 describe("validate command", () => {
@@ -43,6 +47,67 @@ pr: null
 		).resolves.toBeUndefined()
 	})
 
+	test("validates an explicit workbase path", async () => {
+		await Bun.write(
+			join(root, "tasks/example/TASK.md"),
+			`---
+ticketUrl: null
+repo: agency
+branch: task/example
+base: main
+pr: null
+---
+`,
+		)
+
+		await expect(
+			runTestEffect(
+				validate({ path: root, cwd: join(root, "outside"), silent: true }),
+			),
+		).resolves.toBeUndefined()
+	})
+
+	test("selects a registered workbase when local discovery fails", async () => {
+		const discovered: string[] = []
+		const workbase = {
+			discover: (path: string) => {
+				discovered.push(path)
+				return path === "/outside"
+					? Effect.fail({
+							_tag: "WorkbaseNotFoundError" as const,
+							message: "No Agency workbase found from /outside",
+						})
+					: Effect.succeed(path)
+			},
+			listRegistered: () => Effect.succeed(["/first", "/selected"]),
+			validate: (path: string) =>
+				Effect.succeed({
+					root: path,
+					issues: [],
+					epicCount: 0,
+					taskCount: 0,
+					phaseCount: 0,
+					valid: true,
+				}),
+		}
+		const fs = {
+			runCommand: () => Effect.succeed({ exitCode: 0, stdout: "", stderr: "" }),
+		}
+		const pick: PickWorkbase = (workbases) => {
+			expect(workbases).toEqual(["/first", "/selected"])
+			return Effect.succeed("/selected")
+		}
+
+		await Effect.runPromise(
+			validate({ cwd: "/outside", silent: true }, pick).pipe(
+				Effect.provideService(WorkbaseService, workbase as never),
+				Effect.provideService(FileSystemService, fs as never),
+			) as Effect.Effect<void, unknown, never>,
+		)
+
+		expect(discovered).toEqual(["/outside", "/selected"])
+	})
+
 	test("outputs the validation report as JSON", async () => {
 		await Bun.write(
 			join(root, "tasks/example/TASK.md"),

package/src/commands/validate.ts

@@ -2,8 +2,14 @@ import { Data, Effect } from "effect"
 import type { BaseCommandOptions } from "../utils/command"
 import { WorkbaseService } from "../services/WorkbaseService"
 import { createLoggers } from "../utils/effect"
+import {
+	pickWorkbase,
+	resolveWorkbase,
+	type PickWorkbase,
+} from "../workbase/workbase-choice"
 
 interface ValidateOptions extends BaseCommandOptions {
+	readonly path?: string
 	readonly json?: boolean
 }
 
@@ -11,11 +17,19 @@ class ValidationFailedError extends Data.TaggedError("ValidationFailedError")<{
 	readonly message: string
 }> {}
 
-export const validate = (options: ValidateOptions = {}) =>
+export const validate = (
+	options: ValidateOptions = {},
+	pick: PickWorkbase = pickWorkbase,
+) =>
 	Effect.gen(function* () {
 		const workbase = yield* WorkbaseService
 		const { log } = createLoggers(options)
-		const report = yield* workbase.validate(options.cwd ?? process.cwd())
+		const startPath = options.path ?? options.cwd ?? process.cwd()
+		const root = options.path
+			? yield* workbase.discover(startPath)
+			: yield* resolveWorkbase(startPath, log, pick)
+		if (!root) return
+		const report = yield* workbase.validate(root)
 
 		if (options.json) {
 			log(JSON.stringify(report, null, 2))
@@ -40,10 +54,10 @@ export const validate = (options: ValidateOptions = {}) =>
 	})
 
 export const help = `
-Usage: agency validate [options]
+Usage: agency validate [path] [options]
 
-Validate the current workbase configuration, frontmatter, references, and
-dependency graphs.
+Validate a workbase's configuration, frontmatter, references, and dependency
+graphs. The current or selected registered workbase is used when path is omitted.
 
 Options:
   --json              Output the validation report as JSON