@markjaquith/agency 2.14.0 → 2.16.0

package/src/test-utils.ts

@@ -16,6 +16,7 @@ import { IntegrationService } from "./services/IntegrationService"
 import { ContextService } from "./services/ContextService"
 import { GraphService } from "./services/GraphService"
 import { ClaimService } from "./services/ClaimService"
+import { SyncService } from "./services/SyncService"
 
 export const createTempDir = () => mkdtemp(join(tmpdir(), "agency-test-"))
 
@@ -36,6 +37,7 @@ const TestLayer = Layer.mergeAll(
 	ContextService.Default,
 	GraphService.Default,
 	ClaimService.Default,
+	SyncService.Default,
 )
 
 export async function runTestEffect<A, E>(

package/src/utils/chooser.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { choose, type ChooserIO } from "./chooser"
+
+const choices = [
+	{ key: "first-key", label: "\x1b[32mFirst\x1b[0m", value: 1 },
+	{ key: "second key", label: "Second", value: 2 },
+]
+
+const createIO = (
+	overrides: Partial<ChooserIO> = {},
+): ChooserIO & { readonly writes: string[]; readonly inputs: string[] } => {
+	const writes: string[] = []
+	const inputs: string[] = []
+	return {
+		inputIsTTY: true,
+		outputIsTTY: true,
+		color: false,
+		write: (message) => writes.push(message),
+		question: async () => "1",
+		run: async (_command, input) => {
+			inputs.push(input)
+			return { exitCode: 0, stdout: "first-key\n" }
+		},
+		...overrides,
+		writes,
+		inputs,
+	}
+}
+
+describe("chooser", () => {
+	test("offers a plain-text numbered chooser on a TTY", async () => {
+		const io = createIO({ question: async () => "2" })
+
+		const result = await Effect.runPromise(
+			choose("Pick one", choices, undefined, io),
+		)
+
+		expect(result).toBe(2)
+		expect(io.writes.join("")).toBe("Pick one\n  1. First\n  2. Second\n")
+	})
+
+	test("preserves colors when enabled", async () => {
+		const io = createIO({ color: true })
+
+		await Effect.runPromise(choose("Pick one", choices, undefined, io))
+
+		expect(io.writes.join("")).toContain("\x1b[32mFirst\x1b[0m")
+	})
+
+	test("passes generic records to an external argv command", async () => {
+		const io = createIO()
+
+		const result = await Effect.runPromise(
+			choose("Pick one", choices, ["custom-chooser", "--flag"], io),
+		)
+
+		expect(result).toBe(1)
+		expect(io.inputs).toEqual(["first-key\tFirst\nsecond key\tSecond\n"])
+	})
+
+	test("accepts a selected record from fzf or gum", async () => {
+		const io = createIO({
+			run: async () => ({ exitCode: 0, stdout: "second key\tSecond\n" }),
+		})
+
+		expect(
+			await Effect.runPromise(choose("Pick", choices, ["gum", "filter"], io)),
+		).toBe(2)
+	})
+
+	test("treats native and external cancellation as no selection", async () => {
+		const native = createIO({ question: async () => "q" })
+		const external = createIO({
+			run: async () => ({ exitCode: 130, stdout: "" }),
+		})
+
+		expect(
+			await Effect.runPromise(choose("Pick", choices, undefined, native)),
+		).toBeNull()
+		expect(
+			await Effect.runPromise(choose("Pick", choices, ["chooser"], external)),
+		).toBeNull()
+	})
+
+	test("uses one typed error for unavailable input and invalid keys", async () => {
+		const nonTTY = createIO({ inputIsTTY: false })
+		const unknownKey = createIO({
+			run: async () => ({ exitCode: 0, stdout: "missing\n" }),
+		})
+
+		const unavailable = await Effect.runPromise(
+			Effect.flip(choose("Pick", choices, undefined, nonTTY)),
+		)
+		const invalid = await Effect.runPromise(
+			Effect.flip(choose("Pick", choices, ["chooser"], unknownKey)),
+		)
+
+		expect(unavailable).toMatchObject({
+			name: "ChooserError",
+			reason: "input-unavailable",
+		})
+		expect(invalid).toMatchObject({
+			name: "ChooserError",
+			reason: "invalid-selection",
+		})
+	})
+})

package/src/utils/chooser.ts

@@ -0,0 +1,222 @@
+import { Effect } from "effect"
+import { createInterface } from "node:readline/promises"
+
+export interface Choice<T> {
+	readonly key: string
+	readonly label: string
+	readonly plainLabel?: string
+	readonly value: T
+}
+
+export type ChooserErrorReason =
+	| "invalid-choices"
+	| "input-unavailable"
+	| "invalid-selection"
+	| "command-failed"
+
+export class ChooserError extends Error {
+	override readonly name = "ChooserError"
+
+	constructor(
+		readonly reason: ChooserErrorReason,
+		message: string,
+		options?: ErrorOptions,
+	) {
+		super(message, options)
+	}
+}
+
+interface ExternalResult {
+	readonly exitCode: number
+	readonly stdout: string
+}
+
+export interface ChooserIO {
+	readonly inputIsTTY: boolean
+	readonly outputIsTTY: boolean
+	readonly color: boolean
+	readonly write: (message: string) => void
+	readonly question: (prompt: string) => Promise<string>
+	readonly run: (
+		command: readonly string[],
+		input: string,
+	) => Promise<ExternalResult>
+}
+
+const stripAnsi = (value: string) =>
+	value.replace(
+		/[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d/#&.:=?%@~_]+)*)?\u0007)|(?:(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g,
+		"",
+	)
+
+const defaultIO = (): ChooserIO => ({
+	inputIsTTY: Boolean(process.stdin.isTTY),
+	outputIsTTY: Boolean(process.stderr.isTTY),
+	color:
+		Boolean(process.stderr.isTTY) &&
+		process.env.NO_COLOR === undefined &&
+		process.env.TERM !== "dumb",
+	write: (message) => process.stderr.write(message),
+	question: async (prompt) => {
+		const input = createInterface({
+			input: process.stdin,
+			output: process.stderr,
+		})
+		try {
+			return await input.question(prompt)
+		} finally {
+			input.close()
+		}
+	},
+	run: async (command, input) => {
+		const child = Bun.spawn([...command], {
+			stdin: new Blob([input]),
+			stdout: "pipe",
+			stderr: "inherit",
+		})
+		const [exitCode, stdout] = await Promise.all([
+			child.exited,
+			new Response(child.stdout).text(),
+		])
+		return { exitCode, stdout }
+	},
+})
+
+const displayLabel = (choice: Choice<unknown>, color: boolean) => {
+	const normalized = (
+		color ? choice.label : (choice.plainLabel ?? choice.label)
+	).replace(/[\r\n]+/g, " ")
+	return color ? normalized : stripAnsi(normalized)
+}
+
+const validateChoices = <T>(choices: readonly Choice<T>[]) => {
+	if (choices.length === 0) {
+		throw new ChooserError(
+			"invalid-choices",
+			"Cannot choose from an empty list",
+		)
+	}
+	const keys = new Set<string>()
+	for (const choice of choices) {
+		if (!choice.key || /[\t\r\n]/.test(choice.key)) {
+			throw new ChooserError(
+				"invalid-choices",
+				"Chooser keys must be non-empty and cannot contain tabs or newlines",
+			)
+		}
+		if (keys.has(choice.key)) {
+			throw new ChooserError(
+				"invalid-choices",
+				`Duplicate chooser key: ${choice.key}`,
+			)
+		}
+		keys.add(choice.key)
+	}
+}
+
+const selectedChoice = <T>(key: string, choices: readonly Choice<T>[]) => {
+	const selected = choices.find((choice) => choice.key === key)
+	if (!selected) {
+		throw new ChooserError(
+			"invalid-selection",
+			`Chooser returned an unknown key: ${key}`,
+		)
+	}
+	return selected.value
+}
+
+const externalChoice = async <T>(
+	choices: readonly Choice<T>[],
+	command: readonly string[],
+	io: ChooserIO,
+) => {
+	let result: ExternalResult
+	try {
+		const records = `${choices
+			.map((choice) => `${choice.key}\t${displayLabel(choice, io.color)}`)
+			.join("\n")}\n`
+		result = await io.run(command, records)
+	} catch (cause) {
+		throw new ChooserError(
+			"command-failed",
+			`Failed to run chooser command: ${command.join(" ")}`,
+			{ cause },
+		)
+	}
+	if (result.exitCode === 1 || result.exitCode === 130) return null
+	if (result.exitCode !== 0) {
+		throw new ChooserError(
+			"command-failed",
+			`Chooser command exited with code ${result.exitCode}`,
+		)
+	}
+	const output = result.stdout.replace(/\r?\n$/, "")
+	if (!output) return null
+	if (/[\r\n]/.test(output)) {
+		throw new ChooserError(
+			"invalid-selection",
+			"Chooser command returned more than one key",
+		)
+	}
+	const key = output.split("\t", 1)[0] ?? ""
+	return selectedChoice(key, choices)
+}
+
+const nativeChoice = async <T>(
+	choices: readonly Choice<T>[],
+	prompt: string,
+	io: ChooserIO,
+) => {
+	if (!io.inputIsTTY || !io.outputIsTTY) {
+		throw new ChooserError(
+			"input-unavailable",
+			"Interactive selection requires a terminal; provide an explicit value or use --no-input",
+		)
+	}
+	io.write(`${prompt}\n`)
+	for (const [index, choice] of choices.entries()) {
+		io.write(`  ${index + 1}. ${displayLabel(choice, io.color)}\n`)
+	}
+	let answer: string
+	try {
+		answer = (
+			await io.question(`Select [1-${choices.length}] (q to cancel): `)
+		).trim()
+	} catch (cause) {
+		if (cause instanceof Error && cause.name === "AbortError") return null
+		throw new ChooserError("input-unavailable", "Failed to read selection", {
+			cause,
+		})
+	}
+	if (!answer || answer.toLowerCase() === "q") return null
+	if (!/^\d+$/.test(answer)) {
+		throw new ChooserError("invalid-selection", `Invalid selection: ${answer}`)
+	}
+	const selected = choices[Number.parseInt(answer, 10) - 1]
+	if (!selected) {
+		throw new ChooserError(
+			"invalid-selection",
+			`Selection must be between 1 and ${choices.length}`,
+		)
+	}
+	return selected.value
+}
+
+export const choose = <T>(
+	prompt: string,
+	choices: readonly Choice<T>[],
+	command?: readonly string[],
+	io: ChooserIO = defaultIO(),
+): Effect.Effect<T | null, ChooserError> =>
+	Effect.tryPromise({
+		try: async () => {
+			validateChoices(choices)
+			return command
+				? await externalChoice(choices, command, io)
+				: await nativeChoice(choices, prompt, io)
+		},
+		catch: (cause) =>
+			cause instanceof ChooserError
+				? cause
+				: new ChooserError("input-unavailable", "Selection failed", { cause }),
+	})

package/src/workbase/schemas.test.ts

@@ -284,4 +284,16 @@ describe("schema boundaries", () => {
 			).not.toThrow()
 		}
 	})
+
+	test("accepts a configured chooser argv", () => {
+		expect(
+			Schema.decodeUnknownSync(WorkbaseConfig)({
+				version: 2,
+				chooserCommand: ["fzf", "--accept-nth=1"],
+			}),
+		).toEqual({
+			version: 2,
+			chooserCommand: ["fzf", "--accept-nth=1"],
+		})
+	})
 })

package/src/workbase/schemas.ts

@@ -50,6 +50,7 @@ const GitHubPullRequestUrl = NonEmptyString.pipe(
 
 export const WorkbaseConfig = Schema.Struct({
 	version: Schema.Literal(2),
+	chooserCommand: Schema.optional(Schema.NonEmptyArray(NonEmptyString)),
 	worktreeCreateCommand: Schema.optional(Schema.NonEmptyArray(NonEmptyString)),
 })
 

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

@@ -80,5 +80,15 @@ describe("work target choices", () => {
 			"task",
 			"task",
 		])
+		expect(choices.map((choice) => choice.plainLabel)).toEqual([
+			"epic delivery - Ship the release",
+			"  task multi",
+			"    [working] phase build",
+			"    [done] phase verify",
+			"    [dropped] phase unlisted",
+			"  [done] task single",
+			"[open] task standalone - Independent work",
+			"[delegated] task delegated",
+		])
 	})
 })

package/src/workbase/work-target.ts

@@ -1,5 +1,6 @@
 import { Effect } from "effect"
 import type { WorkStatus } from "./schemas"
+import { choose } from "../utils/chooser"
 
 export type WorkTarget =
 	| {
@@ -52,6 +53,7 @@ interface PhaseRecord {
 
 export interface WorkTargetChoice {
 	readonly label: string
+	readonly plainLabel: string
 	readonly target: WorkTarget
 }
 
@@ -78,6 +80,15 @@ const label = (
 		}[kind]
 	} ${id}${description === undefined ? "" : `\x1b[2m - ${description}\x1b[0m`}`
 
+const plainLabel = (
+	indent: string,
+	kind: WorkTarget["kind"],
+	id: string,
+	description?: string,
+	status?: WorkStatus,
+) =>
+	`${indent}${status === undefined ? "" : `[${status}] `}${kind} ${id}${description === undefined ? "" : ` - ${description}`}`
+
 const taskChoices = (
 	task: TaskRecord,
 	phaseRecords: readonly PhaseRecord[],
@@ -93,6 +104,13 @@ const taskChoices = (
 				task.data.description,
 				multiPhase ? undefined : (task.data.status ?? "open"),
 			),
+			plainLabel: plainLabel(
+				indent,
+				"task",
+				task.id,
+				task.data.description,
+				multiPhase ? undefined : (task.data.status ?? "open"),
+			),
 			target: {
 				kind: "task",
 				taskId: task.id,
@@ -117,6 +135,13 @@ const taskChoices = (
 				record.data.description,
 				record.data.status ?? "open",
 			),
+			plainLabel: plainLabel(
+				`${indent}  `,
+				"phase",
+				record.id,
+				record.data.description,
+				record.data.status ?? "open",
+			),
 			target: {
 				kind: "phase",
 				taskId: task.id,
@@ -135,6 +160,13 @@ const taskChoices = (
 				record.data.description,
 				record.data.status ?? "open",
 			),
+			plainLabel: plainLabel(
+				`${indent}  `,
+				"phase",
+				record.id,
+				record.data.description,
+				record.data.status ?? "open",
+			),
 			target: {
 				kind: "phase",
 				taskId: task.id,
@@ -164,6 +196,7 @@ export const buildWorkTargetChoices = (
 	for (const epic of epicRecords) {
 		choices.push({
 			label: label("", "epic", epic.id, epic.data.description),
+			plainLabel: plainLabel("", "epic", epic.id, epic.data.description),
 			target: { kind: "epic", epicId: epic.id, path: epic.path },
 		})
 		for (const child of epic.data.tasks) {
@@ -184,40 +217,17 @@ export const buildWorkTargetChoices = (
 
 export type PickWorkTarget = (
 	choices: readonly WorkTargetChoice[],
+	command?: readonly string[],
 ) => Effect.Effect<WorkTarget | null, Error>
 
-const parseWorkTargetSelection = (
-	output: string,
-	choices: readonly WorkTargetChoice[],
-) => {
-	const index = Number.parseInt(output.split("\t", 1)[0] ?? "", 10)
-	return choices[index]?.target ?? null
-}
-
-export const pickWorkTarget: PickWorkTarget = (choices) =>
-	Effect.tryPromise({
-		try: async () => {
-			const input = choices
-				.map((choice, index) => `${index}\t${choice.label}`)
-				.join("\n")
-			const process = Bun.spawn(
-				[
-					"fzf",
-					"--ansi",
-					"--delimiter=\t",
-					"--with-nth=2..",
-					"--prompt=Work on> ",
-				],
-				{ 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}`)
-			return parseWorkTargetSelection(output, choices)
-		},
-		catch: (cause) =>
-			new Error("Failed to select a work target with fzf", { cause }),
-	})
+export const pickWorkTarget: PickWorkTarget = (choices, command) =>
+	choose(
+		"Work on",
+		choices.map((choice, index) => ({
+			key: String(index),
+			label: choice.label,
+			plainLabel: choice.plainLabel,
+			value: choice.target,
+		})),
+		command,
+	)

package/src/workbase/workbase-choice.ts

@@ -1,43 +1,30 @@
 import { Effect } from "effect"
 import { resolve } from "node:path"
-import { FileSystemService } from "../services/FileSystemService"
 import { WorkbaseService } from "../services/WorkbaseService"
+import { choose } from "../utils/chooser"
 
 export type PickWorkbase = (
 	workbases: readonly string[],
+	command?: 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 pickWorkbase: PickWorkbase = (workbases, command) =>
+	choose(
+		"Workbase",
+		workbases.map((workbase, index) => ({
+			key: String(index),
+			label: workbase,
+			value: workbase,
+		})),
+		command,
+	)
 
 export const resolveWorkbase = (
 	startPath: string,
-	log: (message: string) => void,
 	pick: PickWorkbase = pickWorkbase,
 	inputAllowed = true,
 ) =>
 	Effect.gen(function* () {
-		const fs = yield* FileSystemService
 		const workbase = yield* WorkbaseService
 
 		return yield* workbase.discover(startPath).pipe(
@@ -59,18 +46,6 @@ export const resolveWorkbase = (
 						)
 					}
 
-					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
 				}),