@markjaquith/agency 2.7.2 → 2.7.3

package/src/commands/task.ts

@@ -81,14 +81,16 @@ export const task = (
 		const cwd = options.cwd ?? process.cwd()
 
 		switch (options.subcommand) {
-			case "new":
-			case "create": {
-				const interactive = options.subcommand === "new" || !options.args[0]
+			case "new": {
+				if (options.inputAllowed === false) {
+					return yield* Effect.fail(
+						new Error(
+							"task new requires interactive input; use 'agency task create <id> --repo <alias>' for automation",
+						),
+					)
+				}
 				const id =
-					options.args[0] ??
-					(interactive
-						? (yield* interaction.text("Task ID: ")).trim()
-						: undefined)
+					options.args[0] ?? (yield* interaction.text("Task ID: ")).trim()
 				if (!id) {
 					return yield* Effect.fail(new Error("Task ID is required"))
 				}
@@ -99,42 +101,39 @@ export const task = (
 				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 (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"))
 						}
-						multiPhase = selected === "multi-phase"
+						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)
@@ -177,6 +176,39 @@ export const task = (
 				)
 				return
 			}
+			case "create": {
+				const id = options.args[0]
+				if (!id) {
+					return yield* Effect.fail(new Error("Task ID is required"))
+				}
+				const multiPhase = options.multiPhase ?? false
+				if (!multiPhase && !options.repo) {
+					return yield* Effect.fail(
+						new Error("Writable repository is required for task create"),
+					)
+				}
+				const record = yield* tasks.create(
+					{
+						id,
+						ticketUrl: options.ticketUrl?.trim() || null,
+						description: options.description?.trim() || undefined,
+						epic: options.epic,
+						multiPhase,
+						repo: options.repo,
+						repos: parseRepositoryReferences(options.references),
+						branch: multiPhase ? undefined : (options.branch ?? `task/${id}`),
+						base: multiPhase ? undefined : (options.base ?? "main"),
+					},
+					cwd,
+				)
+				const { content: _, ...output } = record
+				log(
+					options.json
+						? JSON.stringify(output, null, 2)
+						: `Created task '${record.id}'`,
+				)
+				return
+			}
 			case "list": {
 				const records = yield* tasks.list(cwd)
 				if (options.json) {
@@ -234,7 +266,7 @@ Usage: agency task <subcommand>
 
 Subcommands:
   new [id]              Create a task with guided input
-  create <id>           Create a task; omitted metadata uses defaults
+  create <id>           Create a task without prompting
   list                  List tasks
   show <id>             Show a task
   status <id> <status>  Set open, working, delegated, done, or dropped
@@ -250,6 +282,11 @@ Create options:
   --base <name>         Base branch (default: main)
   --multi-phase         Create a task container for phases
 
+Task creation is noninteractive. Single-phase tasks require --repo; use
+--multi-phase instead for a task container. Guided input is available only
+through task new, which fails when --no-input is set or no TTY is available.
+
 Options:
   --json                Output results as JSON
+  --no-input            Never open interactive task creation
 `

package/src/commands/validate.test.ts

@@ -108,6 +108,34 @@ pr: null
 		expect(discovered).toEqual(["/outside", "/selected"])
 	})
 
+	test("does not select a registered workbase when input is disabled", async () => {
+		const workbase = {
+			discover: () =>
+				Effect.fail({
+					_tag: "WorkbaseNotFoundError" as const,
+					message: "No Agency workbase found from /outside",
+				}),
+			listRegistered: () => Effect.succeed(["/selected"]),
+		}
+		const fs = {
+			runCommand: () => Effect.fail(new Error("unexpected fzf probe")),
+		}
+		const pick: PickWorkbase = () =>
+			Effect.fail(new Error("unexpected workbase selection"))
+
+		await expect(
+			Effect.runPromise(
+				validate(
+					{ cwd: "/outside", silent: true, inputAllowed: false },
+					pick,
+				).pipe(
+					Effect.provideService(WorkbaseService, workbase as never),
+					Effect.provideService(FileSystemService, fs as never),
+				) as Effect.Effect<void, unknown, never>,
+			),
+		).rejects.toThrow("provide an explicit path or run Agency from a workbase")
+	})
+
 	test("outputs the validation report as JSON", async () => {
 		await Bun.write(
 			join(root, "tasks/example/TASK.md"),

package/src/commands/validate.ts

@@ -27,7 +27,12 @@ export const validate = (
 		const startPath = options.path ?? options.cwd ?? process.cwd()
 		const root = options.path
 			? yield* workbase.discover(startPath)
-			: yield* resolveWorkbase(startPath, log, pick)
+			: yield* resolveWorkbase(
+					startPath,
+					log,
+					pick,
+					options.inputAllowed ?? true,
+				)
 		if (!root) return
 		const report = yield* workbase.validate(root)
 
@@ -61,4 +66,8 @@ graphs. The current or selected registered workbase is used when path is omitted
 
 Options:
   --json              Output the validation report as JSON
+  --no-input          Never open an interactive workbase selector
+
+When interactive input is unavailable, pass a path or run this command from a
+workbase. Registered-workbase selection otherwise fails.
 `

package/src/commands/work.test.ts

@@ -329,6 +329,36 @@ describe("work command", () => {
 		expect(harness.launches[0]?.cwd).toBe(multiPhaseWorkspace.writablePath)
 	})
 
+	test("requires an explicit target when input is disabled", async () => {
+		const harness = createHarness()
+
+		await expect(
+			harness.run({
+				cwd: "/workbase",
+				opencode: true,
+				inputAllowed: false,
+			}),
+		).rejects.toThrow("provide a directory, task ID, or --epic")
+		expect(harness.events).toEqual([])
+	})
+
+	test("runs an explicit target when input is disabled", async () => {
+		const harness = createHarness({ existingDirectories: [] })
+
+		await harness.run({
+			cwd: "/workbase",
+			directory: "example",
+			opencode: true,
+			inputAllowed: false,
+		})
+
+		expect(harness.events).toEqual([
+			"materialize",
+			"probe:opencode",
+			"launch:opencode",
+		])
+	})
+
 	test("selects a registered workbase when local discovery fails", async () => {
 		const harness = createHarness({
 			outsideWorkbase: true,
@@ -355,6 +385,24 @@ describe("work command", () => {
 		])
 	})
 
+	test("does not select a registered workbase when input is disabled", async () => {
+		const harness = createHarness({
+			outsideWorkbase: true,
+			registeredWorkbases: ["/workbase"],
+			existingDirectories: [],
+		})
+
+		await expect(
+			harness.run({
+				cwd: "/outside",
+				directory: "example",
+				opencode: true,
+				inputAllowed: false,
+			}),
+		).rejects.toThrow("provide an explicit path or run Agency from a workbase")
+		expect(harness.events).toEqual([])
+	})
+
 	test("explains how to register a workbase when none are known", async () => {
 		const harness = createHarness({ outsideWorkbase: true })
 

package/src/commands/work.ts

@@ -84,7 +84,8 @@ export const work = (
 			? yield* fs.isDirectory(directoryPath)
 			: false
 		const startPath = isDirectory && directoryPath ? directoryPath : cwd
-		const root = yield* resolveWorkbase(startPath, log, pickBase)
+		const inputAllowed = options.inputAllowed ?? true
+		const root = yield* resolveWorkbase(startPath, log, pickBase, inputAllowed)
 		if (!root) return
 
 		let target: WorkTarget | null = null
@@ -148,6 +149,13 @@ export const work = (
 		}
 
 		if (!target) {
+			if (!inputAllowed) {
+				return yield* Effect.fail(
+					new Error(
+						"Work target selection requires interactive input; provide a directory, task ID, or --epic <id>",
+					),
+				)
+			}
 			const epicRecords = yield* epics.list(root)
 			const taskRecords = yield* tasks.list(root)
 			const phaseRecords = []
@@ -247,4 +255,8 @@ Options:
   --epic <id>         Work on an epic
   --opencode           Require OpenCode
   --claude             Require Claude Code
+  --no-input          Never open an interactive selector
+
+Without interactive input, provide a directory, task ID, or --epic and run the
+command from a workbase. Workbase and target selection otherwise fail.
 `

package/src/utils/command.ts

@@ -5,6 +5,8 @@ export interface BaseCommandOptions {
 	readonly silent?: boolean
 	readonly verbose?: boolean
 	readonly json?: boolean
+	/** Whether this invocation may open prompts or selectors. */
+	readonly inputAllowed?: boolean
 	/**
 	 * Working directory to use instead of process.cwd().
 	 * Primarily used for testing to enable concurrent test execution.

package/src/workbase/workbase-choice.ts

@@ -34,6 +34,7 @@ export const resolveWorkbase = (
 	startPath: string,
 	log: (message: string) => void,
 	pick: PickWorkbase = pickWorkbase,
+	inputAllowed = true,
 ) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
@@ -50,6 +51,13 @@ export const resolveWorkbase = (
 							),
 						)
 					}
+					if (!inputAllowed) {
+						return yield* Effect.fail(
+							new Error(
+								"Workbase selection requires interactive input; provide an explicit path or run Agency from a workbase",
+							),
+						)
+					}
 
 					const fzf = yield* fs.runCommand(["which", "fzf"], {
 						captureOutput: true,