@markjaquith/agency 2.35.0 → 2.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.35.0",
+  "version": "2.36.0",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",

package/src/utils/interactive.pty.test.ts

@@ -0,0 +1,128 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { join } from "node:path"
+import { cleanupTempDir, createTempDir } from "../test-utils"
+
+const projectRoot = join(import.meta.dir, "../..")
+const cliPath = join(projectRoot, "cli.ts")
+const tempDirs: string[] = []
+
+afterEach(() => Promise.all(tempDirs.splice(0).map(cleanupTempDir)))
+
+const modes = (terminal: Bun.Terminal) => ({
+	input: terminal.inputFlags,
+	output: terminal.outputFlags,
+	local: terminal.localFlags,
+	control: terminal.controlFlags,
+})
+
+const waitFor = async (condition: () => boolean, output: () => string) => {
+	const deadline = Date.now() + 8_000
+	while (!condition()) {
+		if (Date.now() >= deadline) {
+			throw new Error(`Timed out waiting for terminal output:\n${output()}`)
+		}
+		await Bun.sleep(10)
+	}
+}
+
+const waitForExit = (subprocess: Bun.Subprocess, output: () => string) =>
+	new Promise<number>((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			reject(new Error(`Timed out waiting for CLI exit:\n${output()}`))
+		}, 8_000)
+		subprocess.exited.then(
+			(exitCode) => {
+				clearTimeout(timeout)
+				resolve(exitCode)
+			},
+			(error) => {
+				clearTimeout(timeout)
+				reject(error)
+			},
+		)
+	})
+
+const createWorkbase = async () => {
+	const root = await createTempDir()
+	tempDirs.push(root)
+	const initialized = Bun.spawnSync(
+		[process.execPath, cliPath, "init", root, "--silent"],
+		{ stdout: "pipe", stderr: "pipe" },
+	)
+	if (initialized.exitCode !== 0) {
+		throw new Error(new TextDecoder().decode(initialized.stderr))
+	}
+	return root
+}
+
+const runPrompt = async (
+	drive: (terminal: Bun.Terminal, output: () => string) => Promise<void>,
+) => {
+	const root = await createWorkbase()
+	const decoder = new TextDecoder()
+	let output = ""
+	const terminal = new Bun.Terminal({
+		cols: 80,
+		rows: 24,
+		data: (_terminal, bytes) => {
+			output += decoder.decode(bytes, { stream: true })
+		},
+	})
+	const initialModes = modes(terminal)
+	const subprocess = Bun.spawn([process.execPath, cliPath, "task", "new"], {
+		cwd: root,
+		env: { ...process.env, TERM: "xterm-256color" },
+		terminal,
+	})
+
+	try {
+		await waitFor(
+			() => output.includes("Task ID:"),
+			() => output,
+		)
+		const activeModes = modes(terminal)
+		expect(activeModes).not.toEqual(initialModes)
+		await drive(terminal, () => output)
+		const exitCode = await waitForExit(subprocess, () => output)
+		output += decoder.decode()
+		expect(exitCode).toBe(1)
+		expect(modes(terminal)).toEqual(initialModes)
+		expect(output.lastIndexOf("\x1b[?25h")).toBeGreaterThan(
+			output.lastIndexOf("\x1b[?25l"),
+		)
+		expect(output.lastIndexOf("\x1b[?2004l")).toBeGreaterThan(
+			output.lastIndexOf("\x1b[?2004h"),
+		)
+		return output
+	} finally {
+		if (subprocess.exitCode === null) {
+			subprocess.kill("SIGKILL")
+			await subprocess.exited
+		}
+		terminal.close()
+	}
+}
+
+describe("interactive CLI terminal restoration", () => {
+	test("restores terminal state after submission, resize, and escape", async () => {
+		const output = await runPrompt(async (terminal, currentOutput) => {
+			terminal.resize(30, 8)
+			terminal.write("pty-contract\r")
+			await waitFor(
+				() => currentOutput().includes("Ticket URL (optional):"),
+				currentOutput,
+			)
+			terminal.write("\x1b")
+		})
+
+		expect(output).toContain("Failed to read task input")
+	}, 12_000)
+
+	test("restores terminal state after ctrl-c", async () => {
+		const output = await runPrompt(async (terminal) => {
+			terminal.write("\x03")
+		})
+
+		expect(output).toContain("Failed to read task input")
+	}, 12_000)
+})

package/src/utils/interactive.test.tsx

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test"
+import { KeyCodes, type MockInput } from "@opentui/core/testing"
 import { testRender } from "@opentui/solid"
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises"
 import { tmpdir } from "node:os"
@@ -10,6 +11,34 @@ import {
 	interactiveRendererConfig,
 } from "./interactive"
 
+const submitEditedText = async (
+	edit: (input: MockInput) => void | Promise<void>,
+) => {
+	let submitted: string | null | undefined
+	const setup = await testRender(
+		() => (
+			<InteractiveTextPrompt
+				prompt="Text"
+				onDone={(value) => {
+					submitted = value
+				}}
+			/>
+		),
+		{ width: 60, height: 4 },
+	)
+	try {
+		await setup.renderer.setupTerminal()
+		await setup.renderOnce()
+		await Bun.sleep(0)
+		await edit(setup.mockInput)
+		setup.mockInput.pressEnter()
+		await setup.waitFor(() => submitted !== undefined)
+		return submitted
+	} finally {
+		setup.renderer.destroy()
+	}
+}
+
 describe("OpenTUI interaction", () => {
 	test("selects the Solid JSX runtime without the project preload", async () => {
 		const source = await Bun.file(
@@ -109,8 +138,8 @@ describe("OpenTUI interaction", () => {
 		expect(await selectAfter("down")).toBe("web")
 	})
 
-	test("uses printable j, k, and q characters as the fuzzy query", async () => {
-		for (const query of ["j", "k", "q"]) {
+	test("uses printable j, k, q, and ? characters as the fuzzy query", async () => {
+		for (const query of ["j", "k", "q", "?"]) {
 			let selected: string | null | undefined
 			const setup = await testRender(
 				() => (
@@ -141,6 +170,163 @@ describe("OpenTUI interaction", () => {
 		}
 	})
 
+	test("supports the readline movement and deletion contract", async () => {
+		const cases = [
+			{
+				name: "left arrow",
+				expected: "aXb",
+				edit: async (input: MockInput) => {
+					await input.typeText("ab")
+					input.pressArrow("left")
+					await input.typeText("X")
+				},
+			},
+			{
+				name: "home and end",
+				expected: "XabY",
+				edit: async (input: MockInput) => {
+					await input.typeText("ab")
+					input.pressKey(KeyCodes.HOME)
+					await input.typeText("X")
+					input.pressKey(KeyCodes.END)
+					await input.typeText("Y")
+				},
+			},
+			{
+				name: "backspace and delete",
+				expected: "a",
+				edit: async (input: MockInput) => {
+					await input.typeText("abc")
+					input.pressBackspace()
+					input.pressArrow("left")
+					input.pressKey(KeyCodes.DELETE)
+				},
+			},
+			{
+				name: "ctrl-a and ctrl-e",
+				expected: "XabY",
+				edit: async (input: MockInput) => {
+					await input.typeText("ab")
+					input.pressKey("a", { ctrl: true })
+					await input.typeText("X")
+					input.pressKey("e", { ctrl: true })
+					await input.typeText("Y")
+				},
+			},
+			{
+				name: "ctrl-b and ctrl-f",
+				expected: "aXb",
+				edit: async (input: MockInput) => {
+					await input.typeText("ab")
+					input.pressKey("b", { ctrl: true })
+					input.pressKey("b", { ctrl: true })
+					input.pressKey("f", { ctrl: true })
+					await input.typeText("X")
+				},
+			},
+			{
+				name: "meta-b and meta-f",
+				expected: "one Xtwo",
+				edit: async (input: MockInput) => {
+					await input.typeText("one two")
+					input.pressKey("b", { meta: true })
+					input.pressKey("b", { meta: true })
+					input.pressKey("f", { meta: true })
+					await input.typeText("X")
+				},
+			},
+			{
+				name: "ctrl-u",
+				expected: "c",
+				edit: async (input: MockInput) => {
+					await input.typeText("abc")
+					input.pressArrow("left")
+					input.pressKey("u", { ctrl: true })
+				},
+			},
+			{
+				name: "ctrl-k",
+				expected: "ab",
+				edit: async (input: MockInput) => {
+					await input.typeText("abc")
+					input.pressArrow("left")
+					input.pressKey("k", { ctrl: true })
+				},
+			},
+			{
+				name: "ctrl-w",
+				expected: "one ",
+				edit: async (input: MockInput) => {
+					await input.typeText("one two")
+					input.pressKey("w", { ctrl: true })
+				},
+			},
+			{
+				name: "ctrl-d",
+				expected: "ab",
+				edit: async (input: MockInput) => {
+					await input.typeText("abc")
+					input.pressArrow("left")
+					input.pressKey("d", { ctrl: true })
+				},
+			},
+			{
+				name: "ctrl-h",
+				expected: "ab",
+				edit: async (input: MockInput) => {
+					await input.typeText("abc")
+					input.pressKey("h", { ctrl: true })
+				},
+			},
+		]
+
+		for (const contract of cases) {
+			expect(await submitEditedText(contract.edit), contract.name).toBe(
+				contract.expected,
+			)
+		}
+	})
+
+	test("yanks the most recently killed text in both prompt inputs", async () => {
+		expect(
+			await submitEditedText(async (input) => {
+				await input.typeText("one two")
+				input.pressKey("w", { ctrl: true })
+				input.pressKey("y", { ctrl: true })
+			}),
+		).toBe("one two")
+
+		let selected: string | null | undefined
+		const setup = await testRender(
+			() => (
+				<InteractiveSelectPrompt
+					prompt="Repository"
+					choices={[
+						{ key: "agency", label: "agency" },
+						{ key: "web", label: "web" },
+					]}
+					onDone={(value) => {
+						selected = value
+					}}
+				/>
+			),
+			{ width: 60, height: 4 },
+		)
+		try {
+			await setup.renderer.setupTerminal()
+			await setup.renderOnce()
+			await Bun.sleep(0)
+			await setup.mockInput.typeText("web")
+			setup.mockInput.pressKey("u", { ctrl: true })
+			setup.mockInput.pressKey("y", { ctrl: true })
+			setup.mockInput.pressEnter()
+			await setup.waitFor(() => selected !== undefined)
+			expect(selected).toBe("web")
+		} finally {
+			setup.renderer.destroy()
+		}
+	})
+
 	test("does not select an empty result and supports ctrl-u editing", async () => {
 		let selected: string | null | undefined
 		const setup = await testRender(
@@ -232,6 +418,98 @@ describe("OpenTUI interaction", () => {
 		}
 	})
 
+	test("keeps empty and single-item list boundaries safe", async () => {
+		let emptyResult: string | null | undefined
+		const empty = await testRender(
+			() => (
+				<InteractiveSelectPrompt
+					prompt="Empty"
+					choices={[]}
+					onDone={(value) => {
+						emptyResult = value
+					}}
+				/>
+			),
+			{ width: 60, height: 4 },
+		)
+		try {
+			await empty.renderer.setupTerminal()
+			await empty.renderOnce()
+			await Bun.sleep(0)
+			empty.mockInput.pressArrow("up")
+			empty.mockInput.pressArrow("down")
+			empty.mockInput.pressKey("p", { ctrl: true })
+			empty.mockInput.pressKey("n", { ctrl: true })
+			empty.mockInput.pressEnter()
+			await Bun.sleep(0)
+			expect(emptyResult).toBeUndefined()
+			expect(empty.captureCharFrame()).toContain("No matches")
+		} finally {
+			empty.renderer.destroy()
+		}
+
+		for (const move of ["up", "down"] as const) {
+			let singleResult: string | null | undefined
+			const single = await testRender(
+				() => (
+					<InteractiveSelectPrompt
+						prompt="Single"
+						choices={[{ key: "one", label: "One" }]}
+						onDone={(value) => {
+							singleResult = value
+						}}
+					/>
+				),
+				{ width: 60, height: 4 },
+			)
+			try {
+				await single.renderer.setupTerminal()
+				await single.renderOnce()
+				await Bun.sleep(0)
+				single.mockInput.pressArrow(move)
+				single.mockInput.pressEnter()
+				await single.waitFor(() => singleResult !== undefined)
+				expect(singleResult).toBe("one")
+			} finally {
+				single.renderer.destroy()
+			}
+		}
+	})
+
+	test("remains usable after a narrow terminal resize", async () => {
+		let selected: string | null | undefined
+		const setup = await testRender(
+			() => (
+				<InteractiveSelectPrompt
+					prompt="Repository with a long prompt"
+					choices={[
+						{ key: "agency", label: "agency" },
+						{ key: "docs", label: "docs" },
+					]}
+					onDone={(value) => {
+						selected = value
+					}}
+				/>
+			),
+			{ width: 60, height: 4 },
+		)
+		try {
+			await setup.renderer.setupTerminal()
+			await setup.renderOnce()
+			await Bun.sleep(0)
+			setup.resize(18, 4)
+			await setup.renderOnce()
+			await setup.mockInput.typeText("docs")
+			await setup.renderOnce()
+			expect(setup.captureCharFrame()).toContain("> docs")
+			setup.mockInput.pressEnter()
+			await setup.waitFor(() => selected !== undefined)
+			expect(selected).toBe("docs")
+		} finally {
+			setup.renderer.destroy()
+		}
+	})
+
 	test("submits text and cancels with ctrl-c or escape", async () => {
 		let submitted: string | null | undefined
 		const input = await testRender(

package/src/utils/interactive.tsx

@@ -34,9 +34,77 @@ interface PromptProps<T> {
 const isCancel = (key: { name: string; ctrl: boolean }) =>
 	key.name === "escape" || (key.ctrl && key.name === "c")
 
+interface PromptKey {
+	readonly name: string
+	readonly ctrl: boolean
+	preventDefault(): void
+	stopPropagation(): void
+}
+
+const removedText = (before: string, after: string) => {
+	let start = 0
+	while (
+		start < before.length &&
+		start < after.length &&
+		before[start] === after[start]
+	) {
+		start++
+	}
+
+	let end = 0
+	while (
+		before[before.length - end - 1] === after[after.length - end - 1] &&
+		end < before.length - start &&
+		end < after.length - start
+	) {
+		end++
+	}
+
+	return before.slice(start, before.length - end)
+}
+
+const createReadlineEditing = (
+	getInput: () => TextareaRenderable | undefined,
+	onInput?: (value: string) => void,
+) => {
+	let value = ""
+	let killBuffer = ""
+	let beforeKill: string | undefined
+
+	return {
+		get value() {
+			return value
+		},
+		handleInput(next: string) {
+			if (beforeKill !== undefined) {
+				const killed = removedText(beforeKill, next)
+				if (killed) killBuffer = killed
+				beforeKill = undefined
+			}
+			value = next
+			onInput?.(next)
+		},
+		handleKey(key: PromptKey) {
+			const current = getInput()?.plainText
+			if (current !== undefined && current !== value) this.handleInput(current)
+			if (!key.ctrl) return false
+			if (key.name === "y") {
+				key.preventDefault()
+				key.stopPropagation()
+				if (killBuffer) getInput()?.insertText(killBuffer)
+				return true
+			}
+			if (key.name === "u" || key.name === "k" || key.name === "w") {
+				beforeKill = value
+			}
+			return false
+		},
+	}
+}
+
 export const InteractiveTextPrompt = (props: PromptProps<string>) => {
 	let input: TextareaRenderable | undefined
-	let value = ""
+	const editing = createReadlineEditing(() => input)
 	useKeyboard((key) => {
 		if (isCancel(key)) {
 			key.preventDefault()
@@ -44,10 +112,11 @@ export const InteractiveTextPrompt = (props: PromptProps<string>) => {
 			props.onDone(null)
 			return
 		}
+		if (editing.handleKey(key)) return
 		if (key.name !== "return") return
 		key.preventDefault()
 		key.stopPropagation()
-		props.onDone(value)
+		props.onDone(editing.value)
 	})
 
 	return (
@@ -59,7 +128,7 @@ export const InteractiveTextPrompt = (props: PromptProps<string>) => {
 				wrapMode="word"
 				keyBindings={[{ name: "return", action: "submit" }]}
 				onContentChange={() => {
-					value = input?.plainText ?? ""
+					editing.handleInput(input?.plainText ?? "")
 				}}
 				ref={(next) => {
 					input = next
@@ -68,7 +137,9 @@ export const InteractiveTextPrompt = (props: PromptProps<string>) => {
 					})
 				}}
 			/>
-			<text fg="#6c7086">enter submit | esc cancel</text>
+			<text fg="#6c7086" wrapMode="none">
+				enter submit | esc cancel | ctrl-y yank
+			</text>
 		</box>
 	)
 }
@@ -145,6 +216,7 @@ export const fuzzyChoices = (
 export const InteractiveSelectPrompt = (props: SelectPromptProps) => {
 	let input: TextareaRenderable | undefined
 	const [query, setQuery] = createSignal("")
+	const editing = createReadlineEditing(() => input, setQuery)
 	const [selected, setSelected] = createSignal(0)
 	const choices = createMemo(() => fuzzyChoices(props.choices, query()))
 	const move = (offset: -1 | 1) => {
@@ -171,6 +243,7 @@ export const InteractiveSelectPrompt = (props: SelectPromptProps) => {
 			move(1)
 			return
 		}
+		if (editing.handleKey(key)) return
 		if (key.name !== "return") return
 		key.preventDefault()
 		key.stopPropagation()
@@ -207,7 +280,7 @@ export const InteractiveSelectPrompt = (props: SelectPromptProps) => {
 					placeholder="filter"
 					keyBindings={[{ name: "return", action: "submit" }]}
 					onContentChange={() => {
-						setQuery(input?.plainText ?? "")
+						editing.handleInput(input?.plainText ?? "")
 						setSelected(0)
 					}}
 					ref={(next) => {
@@ -232,7 +305,7 @@ export const InteractiveSelectPrompt = (props: SelectPromptProps) => {
 				</For>
 			</box>
 			<text fg="#6c7086" wrapMode="none">
-				enter select | esc cancel | ctrl-n/p or arrows
+				enter select | esc cancel | arrows/ctrl-n/p | ctrl-y yank
 			</text>
 		</box>
 	)