@markjaquith/agency 3.2.13 → 3.2.15

package/src/test-utils.ts

@@ -1,110 +0,0 @@
-import { spyOn } from "bun:test"
-import { Effect, Layer } from "effect"
-import { mkdtemp, rm } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { FileSystemService } from "./services/FileSystemService"
-import { WorkbaseService } from "./services/WorkbaseService"
-import { RepositoryService } from "./services/RepositoryService"
-import { EpicService } from "./services/EpicService"
-import { TaskService } from "./services/TaskService"
-import { PhaseService } from "./services/PhaseService"
-import { WorktreeService } from "./services/WorktreeService"
-import { PullRequestService } from "./services/PullRequestService"
-import { PushService } from "./services/PushService"
-import { ArchiveService } from "./services/ArchiveService"
-import { IntegrationService } from "./services/IntegrationService"
-import { ContextService } from "./services/ContextService"
-import { GraphService } from "./services/GraphService"
-import { SyncService } from "./services/SyncService"
-import { ReadinessService } from "./services/ReadinessService"
-import { GraphMutationService } from "./services/GraphMutationService"
-import { DoctorService } from "./services/DoctorService"
-import { ReviewService } from "./services/ReviewService"
-import {
-	GitVersionControlService,
-	VersionControlService,
-} from "./services/VersionControlService"
-
-export const createTempDir = () => mkdtemp(join(tmpdir(), "agency-test-"))
-
-export const cleanupTempDir = (path: string) =>
-	rm(path, { recursive: true, force: true })
-
-export const trackDocumentReadConcurrency = (fs: FileSystemService) => {
-	let active = 0
-	let maximum = 0
-	return {
-		fs: {
-			...fs,
-			readFile: (path: string) => {
-				if (!/(?:EPIC|TASK|PHASE)\.md$/.test(path)) return fs.readFile(path)
-				return Effect.gen(function* () {
-					active += 1
-					maximum = Math.max(maximum, active)
-					yield* Effect.sleep(5)
-					return yield* fs.readFile(path)
-				}).pipe(Effect.ensuring(Effect.sync(() => (active -= 1))))
-			},
-		} satisfies FileSystemService,
-		maximum: () => maximum,
-	}
-}
-
-const TestLayer = Layer.mergeAll(
-	FileSystemService.Default,
-	WorkbaseService.Default,
-	GitVersionControlService.Default,
-	VersionControlService.Default,
-	RepositoryService.Default,
-	EpicService.Default,
-	TaskService.Default,
-	PhaseService.Default,
-	WorktreeService.Default,
-	PullRequestService.Default,
-	PushService.Default,
-	ArchiveService.Default,
-	IntegrationService.Default,
-	ContextService.Default,
-	GraphService.Default,
-	SyncService.Default,
-	ReadinessService.Default,
-	GraphMutationService.Default,
-	DoctorService.Default,
-	ReviewService.Default,
-)
-
-export async function runTestEffect<A, E>(
-	effect: Effect.Effect<A, E, any>,
-): Promise<A> {
-	const program = effect.pipe(
-		Effect.provide(TestLayer),
-		Effect.catchAllDefect((defect) =>
-			Effect.fail(defect instanceof Error ? defect : new Error(String(defect))),
-		),
-	) as Effect.Effect<A, E | Error, never>
-
-	return Effect.runPromise(program)
-}
-
-async function captureConsole(
-	method: "log" | "error",
-	run: () => Promise<unknown>,
-): Promise<string[]> {
-	const logs: string[] = []
-	const output = spyOn(console, method).mockImplementation((...args) => {
-		logs.push(args.join(" "))
-	})
-	try {
-		await run()
-		return logs
-	} finally {
-		output.mockRestore()
-	}
-}
-
-export const captureLogs = (run: () => Promise<unknown>) =>
-	captureConsole("log", run)
-
-export const captureErrors = (run: () => Promise<unknown>) =>
-	captureConsole("error", run)

package/src/usage-log.test.ts

@@ -1,188 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Database } from "bun:sqlite"
-import { rm } from "node:fs/promises"
-import { join } from "node:path"
-import { cleanupTempDir, createTempDir } from "./test-utils"
-import {
-	exportUsageEvents,
-	recordUsageEvent,
-	usageOutcomeCode,
-} from "./usage-log"
-
-describe("usage logging", () => {
-	const tempDirs: string[] = []
-
-	afterEach(() => Promise.all(tempDirs.splice(0).map(cleanupTempDir)))
-
-	test("maps only reviewed failure categories", () => {
-		expect(usageOutcomeCode({ _tag: "WorkbaseNotFoundError" })).toBe(
-			"WORKBASE_NOT_FOUND",
-		)
-		expect(usageOutcomeCode({ _tag: "private-customer-id" })).toBe(
-			"COMMAND_FAILED",
-		)
-	})
-
-	test("stores versioned privacy-safe events in session order", async () => {
-		const state = await createTempDir()
-		tempDirs.push(state)
-		const env = {
-			XDG_STATE_HOME: state,
-			AGENCY_SESSION_ID: "session-1",
-			AGENCY_INVOCATION_SOURCE: "automation",
-			AGENCY_USAGE_TEST: "1",
-		} as NodeJS.ProcessEnv
-		for (const commandPath of ["worktree/prepare", "context"]) {
-			await recordUsageEvent(
-				{
-					commandPath,
-					flagNames: ["json", "task", "json"],
-					durationMs: 12.4,
-					outcome: "success",
-					outcomeCode: "SUCCESS",
-					exitStatus: 0,
-					...(commandPath === "context"
-						? {
-								vcs: "git" as const,
-								terminalStage: "publish",
-								category: "success",
-							}
-						: {}),
-				},
-				"1.2.3",
-				env,
-			)
-		}
-
-		expect(await Bun.file(join(state, "agency/usage.sqlite3")).exists()).toBe(
-			true,
-		)
-		const events = await exportUsageEvents(env)
-		expect(events).toEqual([
-			expect.objectContaining({
-				version: 2,
-				journeyId: expect.stringMatching(/^sha256:[a-f0-9]{64}$/),
-				journeySequence: 1,
-				invocationSource: "automation",
-				isTest: true,
-				agencyVersion: "1.2.3",
-				commandPath: "worktree/prepare",
-				flagNames: ["json", "task"],
-				durationMs: 12,
-				outcome: "success",
-				outcomeCode: "SUCCESS",
-				exitStatus: 0,
-			}),
-			expect.objectContaining({
-				journeySequence: 2,
-				commandPath: "context",
-				vcs: "git",
-				terminalStage: "publish",
-				category: "success",
-			}),
-		])
-		expect(JSON.stringify(events)).not.toContain("session-1")
-	})
-
-	test("supports opt-out and ignores unavailable storage", async () => {
-		const state = await createTempDir()
-		tempDirs.push(state)
-		const disabled = {
-			XDG_STATE_HOME: state,
-			AGENCY_NO_USAGE_LOG: "true",
-		} as NodeJS.ProcessEnv
-		await recordUsageEvent(
-			{
-				commandPath: "status",
-				flagNames: [],
-				durationMs: 1,
-				outcome: "failure",
-				outcomeCode: "COMMAND_FAILED",
-				exitStatus: 1,
-			},
-			"1.2.3",
-			disabled,
-		)
-		expect(await Bun.file(join(state, "agency/usage.sqlite3")).exists()).toBe(
-			false,
-		)
-
-		const blocked = join(state, "blocked")
-		await Bun.write(blocked, "not a directory")
-		await expect(
-			recordUsageEvent(
-				{
-					commandPath: "status",
-					flagNames: [],
-					durationMs: 1,
-					outcome: "failure",
-					outcomeCode: "COMMAND_FAILED",
-					exitStatus: 1,
-				},
-				"1.2.3",
-				{ AGENCY_USAGE_DB: join(blocked, "usage.sqlite3") },
-			),
-		).resolves.toBeUndefined()
-		await rm(blocked)
-	})
-
-	test("prunes expired events on every database access", async () => {
-		const state = await createTempDir()
-		tempDirs.push(state)
-		const env = {
-			XDG_STATE_HOME: state,
-			AGENCY_USAGE_RETENTION_DAYS: "30",
-		} as NodeJS.ProcessEnv
-		await recordUsageEvent(
-			{
-				commandPath: "status",
-				flagNames: [],
-				durationMs: 1,
-				outcome: "success",
-				outcomeCode: "SUCCESS",
-				exitStatus: 0,
-			},
-			"1.2.3",
-			env,
-		)
-		const database = new Database(join(state, "agency/usage.sqlite3"))
-		database.run(
-			"UPDATE usage_events SET occurred_at = datetime('now', '-31 days')",
-		)
-		database.close()
-
-		expect(await exportUsageEvents(env)).toEqual([])
-	})
-
-	test("removes legacy events that may contain positional values", async () => {
-		const state = await createTempDir()
-		tempDirs.push(state)
-		const path = join(state, "usage.sqlite3")
-		const database = new Database(path, { create: true })
-		database.run(
-			"CREATE TABLE usage_events (id INTEGER PRIMARY KEY, command_path TEXT NOT NULL)",
-		)
-		database.run("INSERT INTO usage_events (command_path) VALUES (?)", [
-			"task/private-customer-id",
-		])
-		database.close()
-		const env = { AGENCY_USAGE_DB: path } as NodeJS.ProcessEnv
-
-		await recordUsageEvent(
-			{
-				commandPath: "task/show",
-				flagNames: [],
-				durationMs: 1,
-				outcome: "success",
-				outcomeCode: "SUCCESS",
-				exitStatus: 0,
-			},
-			"1.2.3",
-			env,
-		)
-
-		expect(await exportUsageEvents(env)).toEqual([
-			expect.objectContaining({ commandPath: "task/show", version: 2 }),
-		])
-	})
-})

package/src/utils/chooser.test.ts

@@ -1,192 +0,0 @@
-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 selections: Array<{
-		readonly prompt: string
-		readonly choices: readonly {
-			readonly key: string
-			readonly label: string
-		}[]
-	}>
-	readonly inputs: string[]
-} => {
-	const selections: Array<{
-		readonly prompt: string
-		readonly choices: readonly {
-			readonly key: string
-			readonly label: string
-		}[]
-	}> = []
-	const inputs: string[] = []
-	return {
-		inputIsTTY: true,
-		outputIsTTY: true,
-		color: false,
-		select: async (prompt, choices) => {
-			selections.push({ prompt, choices })
-			return choices[0]?.key ?? null
-		},
-		run: async (_command, input) => {
-			inputs.push(input)
-			return { exitCode: 0, stdout: "first-key\n" }
-		},
-		...overrides,
-		selections,
-		inputs,
-	}
-}
-
-describe("chooser", () => {
-	test("offers plain choices to the native interactive renderer", async () => {
-		let offered:
-			| {
-					readonly prompt: string
-					readonly choices: readonly {
-						readonly key: string
-						readonly label: string
-					}[]
-			  }
-			| undefined
-		const io = createIO({
-			select: async (prompt, offeredChoices) => {
-				offered = { prompt, choices: offeredChoices }
-				return offeredChoices[1]!.key
-			},
-		})
-
-		const result = await Effect.runPromise(
-			choose("Pick one", choices, undefined, io),
-		)
-
-		expect(result).toBe(2)
-		expect(offered).toEqual({
-			prompt: "Pick one",
-			choices: [
-				{ key: "first-key", label: "First" },
-				{ key: "second key", label: "Second" },
-			],
-		})
-	})
-
-	test("passes hierarchy depth only to the native renderer", async () => {
-		let offered: readonly {
-			readonly key: string
-			readonly label: string
-			readonly depth?: number
-			readonly segments?: readonly {
-				readonly text: string
-				readonly color?: string
-			}[]
-		}[] = []
-		const io = createIO({
-			select: async (_prompt, choices) => {
-				offered = choices
-				return choices[0]!.key
-			},
-		})
-
-		await Effect.runPromise(
-			choose(
-				"Pick one",
-				[
-					{
-						key: "parent",
-						label: "Parent",
-						depth: 0,
-						segments: [{ text: "P", color: "#c6a0f6" }],
-						value: 1,
-					},
-					{ key: "child", label: "Child", depth: 1, value: 2 },
-				],
-				undefined,
-				io,
-			),
-		)
-
-		expect(offered).toEqual([
-			{
-				key: "parent",
-				label: "Parent",
-				depth: 0,
-				segments: [{ text: "P", color: "#c6a0f6" }],
-			},
-			{ key: "child", label: "Child", depth: 1 },
-		])
-		expect(io.inputs).toEqual([])
-	})
-
-	test("preserves colors for configured external choosers", async () => {
-		const io = createIO({ color: true })
-
-		await Effect.runPromise(choose("Pick one", choices, ["chooser"], io))
-
-		expect(io.inputs[0]).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({ select: async () => null })
-		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/effect.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, spyOn, test } from "bun:test"
-import { captureLogs } from "../test-utils"
-import { createLoggers } from "./effect"
-
-describe("createLoggers", () => {
-	test("keeps JSON output machine-readable when verbose is enabled", async () => {
-		const errors: string[] = []
-		const error = spyOn(console, "error").mockImplementation((...args) => {
-			errors.push(args.join(" "))
-		})
-		const logs = await captureLogs(async () => {
-			const { log, verboseLog } = createLoggers({ json: true, verbose: true })
-			verboseLog("debug")
-			log('{"ok":true}')
-		})
-		error.mockRestore()
-
-		expect(logs).toEqual(['{"ok":true}'])
-		expect(errors).toEqual(["debug"])
-	})
-
-	test("lets JSON output override silent", async () => {
-		const logs = await captureLogs(async () => {
-			const { log } = createLoggers({ json: true, silent: true })
-			log('{"ok":true}')
-		})
-
-		expect(logs).toEqual(['{"ok":true}'])
-	})
-})

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

@@ -1,128 +0,0 @@
-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)
-})