@markjaquith/agency 3.2.13 → 3.2.15

package/src/utils/process.test.ts

@@ -1,132 +0,0 @@
-import { describe, expect, spyOn, test } from "bun:test"
-import { mkdtemp, readFile, rm } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { Effect, Fiber } from "effect"
-import { spawnProcess } from "./process"
-
-const waitFor = async <A>(attempt: () => Promise<A>): Promise<A> => {
-	const deadline = Date.now() + 2_000
-	while (true) {
-		try {
-			return await attempt()
-		} catch (error) {
-			if (Date.now() >= deadline) throw error
-			await Bun.sleep(10)
-		}
-	}
-}
-
-const isProcessRunning = (pid: number): boolean => {
-	try {
-		process.kill(pid, 0)
-		return true
-	} catch (error) {
-		if (
-			typeof error === "object" &&
-			error !== null &&
-			"code" in error &&
-			error.code === "ESRCH"
-		) {
-			return false
-		}
-		throw error
-	}
-}
-
-describe("spawnProcess", () => {
-	test("forwards and captures output in tee mode", async () => {
-		const forwardedStdout: Uint8Array[] = []
-		const forwardedStderr: Uint8Array[] = []
-		const stdout = spyOn(process.stdout, "write").mockImplementation(((
-			chunk: Uint8Array,
-		) => {
-			forwardedStdout.push(chunk)
-			return true
-		}) as never)
-		const stderr = spyOn(process.stderr, "write").mockImplementation(((
-			chunk: Uint8Array,
-		) => {
-			forwardedStderr.push(chunk)
-			return true
-		}) as never)
-
-		try {
-			const result = await Effect.runPromise(
-				spawnProcess(
-					["sh", "-c", "printf 'standard output'; printf 'standard error' >&2"],
-					{ stdout: "tee", stderr: "tee" },
-				),
-			)
-
-			expect(result).toEqual({
-				stdout: "standard output",
-				stderr: "standard error",
-				exitCode: 0,
-			})
-			expect(Buffer.concat(forwardedStdout).toString()).toBe("standard output")
-			expect(Buffer.concat(forwardedStderr).toString()).toBe("standard error")
-		} finally {
-			stdout.mockRestore()
-			stderr.mockRestore()
-		}
-	})
-
-	test("captures large stdout and stderr without hanging", async () => {
-		const line = "x".repeat(4096)
-		const lineCount = 256
-		const script = [
-			`const line = ${JSON.stringify(line)}`,
-			`const indexes = Array.from({ length: ${lineCount} }, (_, i) => i)`,
-			"const stdout = indexes.map((i) => `out:${i}:${line}`).join(`\n`)",
-			"const stderr = indexes.map((i) => `err:${i}:${line}`).join(`\n`)",
-			"const write = (stream, output) => new Promise((resolve, reject) => {",
-			"stream.write(output, (error) => error ? reject(error) : resolve())",
-			"})",
-			"await Promise.all([write(process.stdout, stdout), write(process.stderr, stderr)])",
-		].join("\n")
-
-		const result = await Effect.runPromise(
-			spawnProcess([process.execPath, "-e", script]),
-		)
-
-		expect(result.exitCode).toBe(0)
-		expect(result.stdout).toContain("out:0:")
-		expect(result.stdout).toContain(`out:${lineCount - 1}:`)
-		expect(result.stderr).toContain("err:0:")
-		expect(result.stderr).toContain(`err:${lineCount - 1}:`)
-	})
-
-	test("terminates timed-out process groups", async () => {
-		const startedAt = performance.now()
-		await expect(
-			Effect.runPromise(
-				spawnProcess(["sh", "-c", "sleep 30 & wait"], { timeoutMs: 25 }),
-			),
-		).rejects.toThrow("Process timed out")
-		expect(performance.now() - startedAt).toBeLessThan(1_000)
-	})
-
-	test("terminates the subprocess when interrupted", async () => {
-		const directory = await mkdtemp(join(tmpdir(), "agency-process-"))
-		const pidPath = join(directory, "pid")
-		const script = [
-			`process.on("SIGTERM", () => {})`,
-			`await Bun.write(${JSON.stringify(pidPath)}, String(process.pid))`,
-			`setInterval(() => process.stdout.write("running\\n"), 10)`,
-		].join("\n")
-		const fiber = Effect.runFork(spawnProcess([process.execPath, "-e", script]))
-
-		try {
-			const pid = Number(await waitFor(() => readFile(pidPath, "utf8")))
-			expect(isProcessRunning(pid)).toBe(true)
-
-			await Effect.runPromise(Fiber.interrupt(fiber))
-
-			expect(isProcessRunning(pid)).toBe(false)
-		} finally {
-			await Effect.runPromise(Fiber.interrupt(fiber))
-			await rm(directory, { recursive: true, force: true })
-		}
-	})
-})

package/src/utils/progress.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { createProgress } from "./progress"
-
-describe("progress", () => {
-	test("replaces an active TTY line with its completed state", () => {
-		const output: string[] = []
-		const progress = createProgress(
-			{},
-			{ isTTY: true, write: (text) => output.push(text) },
-		)
-
-		progress.start("Preparing workspace...")
-		progress.succeed("Workspace ready")
-
-		expect(output).toEqual([
-			"\r\x1b[2K\x1b[2m○\x1b[0m Preparing workspace...",
-			"\r\x1b[2K\x1b[32m✓\x1b[0m Workspace ready\n",
-		])
-	})
-
-	test("stays quiet for silent or non-TTY output", () => {
-		const output: string[] = []
-		for (const [silent, isTTY] of [
-			[true, true],
-			[false, false],
-		] as const) {
-			const progress = createProgress(
-				{ silent },
-				{ isTTY, write: (text) => output.push(text) },
-			)
-			progress.start("Preparing workspace...")
-			progress.fail("Workspace preparation failed")
-		}
-
-		expect(output).toEqual([])
-	})
-})

package/src/work-view.test.ts

@@ -1,151 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { mkdir } from "node:fs/promises"
-import { dirname, join } from "node:path"
-import { cleanupTempDir, createTempDir, runTestEffect } from "./test-utils"
-import { getWorkViews } from "./work-view"
-
-const write = async (root: string, path: string, content: string) => {
-	const fullPath = join(root, path)
-	await mkdir(dirname(fullPath), { recursive: true })
-	await Bun.write(fullPath, content)
-}
-
-describe("work views", () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		await write(root, "agency.json", '{"version":2}\n')
-		await mkdir(join(root, "repos/agency"), { recursive: true })
-		await write(
-			root,
-			"epics/delivery/EPIC.md",
-			`---
-ticketUrl: https://example.com/delivery
-repos:
-  - repo: agency
-    ref: main
-tasks:
-  - id: zeta
-  - id: alpha
----
-`,
-		)
-		await write(
-			root,
-			"tasks/zeta/TASK.md",
-			`---
-ticketUrl: null
-epic: delivery
-phases:
-  - id: verify
-    dependsOn: [implement]
-  - id: implement
----
-`,
-		)
-		await write(
-			root,
-			"tasks/zeta/phases/verify/PHASE.md",
-			`---
-repo: agency
-branch: feat/verify
-base: main
-pr: null
-status: open
----
-`,
-		)
-		await write(
-			root,
-			"tasks/zeta/phases/implement/PHASE.md",
-			`---
-repo: agency
-branch: feat/implement
-base: main
-pr: https://github.com/example/agency/pull/1
-status: dropped
----
-`,
-		)
-		await mkdir(join(root, "tasks/zeta/phases/implement/code/agency"), {
-			recursive: true,
-		})
-		await write(
-			root,
-			"tasks/alpha/TASK.md",
-			`---
-ticketUrl: null
-epic: delivery
-repo: agency
-branch: feat/alpha
-base: main
-pr: null
-status: open
----
-`,
-		)
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	const views = (options: Record<string, unknown> = {}) =>
-		runTestEffect(Effect.suspend(() => getWorkViews({ cwd: root, ...options })))
-
-	test("uses declared graph order and exposes operational state", async () => {
-		const result = await views()
-
-		expect(result.taskRows.map((row) => row.id)).toEqual(["zeta", "alpha"])
-		expect(result.phaseRows.map((row) => row.id)).toEqual([
-			"verify",
-			"implement",
-		])
-		expect(result.executionRows.map((row) => row.key)).toEqual([
-			"zeta/verify",
-			"zeta/implement",
-			"alpha",
-		])
-		expect(result.phaseRows[0]).toMatchObject({
-			parent: "zeta",
-			status: "open",
-			readiness: "blocked",
-			repositories: "agency",
-			branch: "feat/verify",
-			pr: "absent",
-			worktree: "absent",
-		})
-		expect(result.phaseRows[1]).toMatchObject({
-			readiness: "terminal",
-			pr: "present",
-			worktree: "materialized",
-		})
-		expect(result.taskRows[0]).toMatchObject({
-			parent: "delivery",
-			branch: "multiple",
-			pr: "1/2 present",
-			worktree: "1/2 materialized",
-		})
-	})
-
-	test("composes lifecycle, repository, readiness, and PR filters", async () => {
-		expect(
-			(await views({ statuses: ["dropped"] })).executionRows.map(
-				(row) => row.key,
-			),
-		).toEqual(["zeta/implement"])
-		expect(
-			(await views({ repositories: ["agency"], blocked: true })).phaseRows.map(
-				(row) => row.id,
-			),
-		).toEqual(["verify"])
-		expect(
-			(await views({ ready: true, pr: false })).executionRows.map(
-				(row) => row.key,
-			),
-		).toEqual(["alpha"])
-		expect((await views({ pr: true })).phaseRows.map((row) => row.id)).toEqual([
-			"implement",
-		])
-	})
-})

package/src/workbase/agent-command.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-	printableEnvironment,
-	resolveAgentCommand,
-	agentEnvironment,
-	validateAgents,
-} from "./agent-command"
-
-const variables = {
-	prompt: "Read the task.",
-	workbase: "/workbase",
-	target: "execution-unit:phase/task/build",
-	task: "task",
-	phase: "build",
-	sessionId: "session-1",
-}
-
-describe("agent commands", () => {
-	test("uses promptless interactive commands for built-in presets", () => {
-		expect(
-			resolveAgentCommand("opencode2", undefined, variables, false).argv,
-		).toEqual(["opencode2"])
-		expect(
-			resolveAgentCommand("opencode2", undefined, variables, true).argv,
-		).toEqual(["opencode2", "--continue"])
-		expect(
-			resolveAgentCommand("opencode", undefined, variables, false).argv,
-		).toEqual(["opencode"])
-		expect(
-			resolveAgentCommand("opencode", undefined, variables, true).argv,
-		).toEqual(["opencode", "--continue"])
-		expect(resolveAgentCommand("pi", undefined, variables, false).argv).toEqual(
-			["pi"],
-		)
-		expect(resolveAgentCommand("pi", undefined, variables, true).argv).toEqual([
-			"pi",
-			"--continue",
-		])
-		expect(
-			resolveAgentCommand("claude", undefined, variables, true).argv,
-		).toEqual(["claude", "--continue"])
-	})
-
-	test("uses autonomous commands when a prompt is requested", () => {
-		expect(
-			resolveAgentCommand("opencode2", undefined, variables, false, true).argv,
-		).toEqual(["opencode2", "--prompt", "Read the task."])
-		expect(
-			resolveAgentCommand("opencode2", undefined, variables, true, true).argv,
-		).toEqual(["opencode2", "--continue", "--prompt", "Read the task."])
-		expect(
-			resolveAgentCommand("opencode", undefined, variables, false, true).argv,
-		).toEqual(["opencode", "--prompt", "Read the task."])
-		expect(
-			resolveAgentCommand("opencode", undefined, variables, true, true).argv,
-		).toEqual(["opencode", "--continue", "--prompt", "Read the task."])
-		expect(
-			resolveAgentCommand("pi", undefined, variables, false, true).argv,
-		).toEqual(["pi", "Read the task."])
-		expect(
-			resolveAgentCommand("claude", undefined, variables, true, true).argv,
-		).toEqual(["claude", "--continue", "Read the task."])
-	})
-
-	test("expands configured argv and environment without a shell", () => {
-		const resolved = resolveAgentCommand(
-			"custom",
-			{
-				custom: {
-					command: ["agent"],
-					autoCommand: ["agent", "--target={target}", "{prompt}"],
-					environment: { CUSTOM_SESSION: "{sessionId}" },
-				},
-			},
-			variables,
-			false,
-			true,
-		)
-
-		expect(resolved).toEqual({
-			argv: [
-				"agent",
-				"--target=execution-unit:phase/task/build",
-				"Read the task.",
-			],
-			environment: { CUSTOM_SESSION: "session-1" },
-		})
-	})
-
-	test("rejects --auto for configured agents without an auto command", () => {
-		expect(() =>
-			resolveAgentCommand(
-				"custom",
-				{ custom: { command: ["agent"] } },
-				variables,
-				false,
-				true,
-			),
-		).toThrow("Agent 'custom' does not support --auto")
-	})
-
-	test("rejects unknown placeholders", () => {
-		expect(() =>
-			validateAgents({ custom: { command: ["agent", "{unknown}"] } }),
-		).toThrow("Unknown agent 'custom' placeholder: {unknown}")
-	})
-
-	test("provides normalized Agency environment and filters secret values", () => {
-		const environment = {
-			...agentEnvironment("custom", variables),
-			VISIBLE: "yes",
-			ACCESS_TOKEN: "secret",
-		}
-
-		expect(environment).toMatchObject({
-			AGENCY_AGENT: "custom",
-			AGENCY_INVOCATION_SOURCE: "agent",
-			AGENCY_SESSION_ID: "session-1",
-			AGENCY_WORKBASE: "/workbase",
-			AGENCY_TARGET: "execution-unit:phase/task/build",
-			AGENCY_TASK_ID: "task",
-			AGENCY_PHASE_ID: "build",
-			AGENCY_PROMPT: "Read the task.",
-		})
-		expect(printableEnvironment(environment).VISIBLE).toBe("yes")
-		expect(printableEnvironment(environment).ACCESS_TOKEN).toBeUndefined()
-	})
-})

package/src/workbase/checkout-command.test.ts

@@ -1,62 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-	expandPostCheckoutCommand,
-	postCheckoutCommandEnvironment,
-} from "./checkout-command"
-
-const variables = {
-	repoAlias: "app",
-	repositoryPath: "/work/repos/app",
-	checkoutPath: "/work/tasks/example/code/app",
-	checkoutKind: "reference" as const,
-	requestedRef: "main",
-	base: "",
-	vcs: "git" as const,
-	workbaseRoot: "/work",
-	taskId: "example",
-	phaseId: "",
-}
-
-describe("post-checkout command templates", () => {
-	test("expands all context placeholders without shell interpolation", () => {
-		expect(
-			expandPostCheckoutCommand(
-				[
-					"tool",
-					"{repoAlias}",
-					"{repositoryPath}",
-					"{checkoutPath}",
-					"{checkoutKind}",
-					"{requestedRef}",
-					"{base}",
-					"{vcs}",
-					"{workbaseRoot}",
-					"{taskId}",
-					"{phaseId}",
-				],
-				variables,
-			),
-		).toEqual(["tool", ...Object.values(variables)])
-	})
-
-	test("rejects unknown placeholders", () => {
-		expect(() =>
-			expandPostCheckoutCommand(["tool", "{unknown}"], variables),
-		).toThrow("{unknown}")
-	})
-
-	test("provides matching environment variables with empty optional values", () => {
-		expect(postCheckoutCommandEnvironment(variables)).toEqual({
-			AGENCY_REPO_ALIAS: variables.repoAlias,
-			AGENCY_REPOSITORY_PATH: variables.repositoryPath,
-			AGENCY_CHECKOUT_PATH: variables.checkoutPath,
-			AGENCY_CHECKOUT_KIND: variables.checkoutKind,
-			AGENCY_REQUESTED_REF: variables.requestedRef,
-			AGENCY_BASE: "",
-			AGENCY_VCS: variables.vcs,
-			AGENCY_WORKBASE_ROOT: variables.workbaseRoot,
-			AGENCY_TASK_ID: variables.taskId,
-			AGENCY_PHASE_ID: "",
-		})
-	})
-})

package/src/workbase/delivery-command.test.ts

@@ -1,180 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-	parseGitHubPullRequest,
-	parseGitHubPullRequestList,
-	parsePullRequestRecord,
-	resolveDeliveryCommand,
-	resolveGitHubCreateCommand,
-	validateDelivery,
-} from "./delivery-command"
-
-const delivery = {
-	provider: "forge",
-	remote: "upstream",
-	createCommand: ["forge", "create", "{repository}", "{branch}"],
-	queryCommand: ["forge", "query", "{identifier}"],
-	environment: { FORGE_BASE: "{base}" },
-} as const
-
-const variables = {
-	repository: "example/agency",
-	branch: "feat/example",
-	base: "main",
-	draft: "false",
-	url: "",
-	identifier: "",
-}
-
-describe("delivery commands", () => {
-	test("expands argv and environment without shell evaluation", () => {
-		expect(resolveDeliveryCommand(delivery, "create", variables)).toEqual({
-			argv: ["forge", "create", "example/agency", "feat/example"],
-			environment: { FORGE_BASE: "main" },
-		})
-	})
-
-	test("builds the default GitHub create command", () => {
-		const input = {
-			repository: "example/agency",
-			base: "main",
-			draft: false,
-			head: "feat/example",
-		} as const
-		expect(resolveGitHubCreateCommand(input)).toEqual({
-			argv: [
-				"gh",
-				"pr",
-				"create",
-				"--fill",
-				"--repo",
-				"example/agency",
-				"--base",
-				"main",
-				"--head",
-				"feat/example",
-			],
-			environment: {},
-		})
-		expect(
-			resolveGitHubCreateCommand({
-				...input,
-				title: "Requested",
-				head: "feat/example",
-				labels: ["ai-assisted", "platform"],
-			}),
-		).toEqual({
-			argv: [
-				"gh",
-				"pr",
-				"create",
-				"--fill",
-				"--title",
-				"Requested",
-				"--repo",
-				"example/agency",
-				"--base",
-				"main",
-				"--head",
-				"feat/example",
-				"--label",
-				"ai-assisted",
-				"--label",
-				"platform",
-			],
-			environment: {},
-		})
-	})
-
-	test("rejects unknown placeholders", () => {
-		expect(() =>
-			validateDelivery({ ...delivery, queryCommand: ["forge", "{unknown}"] }),
-		).toThrow("Unknown delivery provider 'forge' placeholder")
-	})
-
-	test("requires complete and consistent normalized records", () => {
-		const record = {
-			provider: "forge",
-			repository: "example/agency",
-			identifier: "17",
-			url: "https://forge.example/example/agency/pulls/17",
-			state: "merged",
-			draft: false,
-			merged: true,
-		} as const
-		expect(parsePullRequestRecord(JSON.stringify(record))).toEqual(record)
-		expect(() =>
-			parsePullRequestRecord(JSON.stringify({ ...record, merged: false })),
-		).toThrow("inconsistent merge state")
-		expect(
-			parsePullRequestRecord(JSON.stringify({ ...record, mergeable: null })),
-		).toEqual({ ...record, mergeable: null })
-		expect(() =>
-			parsePullRequestRecord(JSON.stringify({ ...record, mergeable: "yes" })),
-		).toThrow("valid pull request record")
-	})
-
-	test("normalizes GitHub state and mergeability", () => {
-		const base = {
-			number: 17,
-			url: "https://github.com/example/agency/pull/17",
-			title: "Ship",
-			isDraft: false,
-			headRefName: "feat/example",
-			baseRefName: "main",
-			headRepository: { nameWithOwner: "fork/agency" },
-			mergedAt: null,
-			mergeCommit: null,
-			mergeable: "UNKNOWN",
-		}
-		expect(
-			parseGitHubPullRequest(
-				JSON.stringify({
-					...base,
-					state: "OPEN",
-					baseRepository: { nameWithOwner: "example/agency" },
-					mergeable: "MERGEABLE",
-				}),
-			),
-		).toMatchObject({
-			state: "open",
-			merged: false,
-			headRepository: "fork/agency",
-			headBranch: "feat/example",
-			baseRepository: "example/agency",
-			baseBranch: "main",
-			mergeable: true,
-		})
-		expect(
-			parseGitHubPullRequest(
-				JSON.stringify({
-					...base,
-					state: "OPEN",
-					mergeable: "CONFLICTING",
-				}),
-			),
-		).toMatchObject({ state: "open", merged: false, mergeable: false })
-		expect(
-			parseGitHubPullRequest(
-				JSON.stringify({
-					...base,
-					state: "CLOSED",
-					mergedAt: "2026-07-21T00:00:00Z",
-					mergeCommit: { oid: "abc" },
-					mergeable: "UNKNOWN",
-				}),
-			),
-		).toMatchObject({ state: "merged", merged: true, mergeable: null })
-	})
-
-	test("rejects malformed GitHub detail and list responses", () => {
-		expect(() => parseGitHubPullRequest("not-json")).toThrow(
-			"GitHub CLI did not return valid JSON for pull request",
-		)
-		expect(() => parseGitHubPullRequest("{}")).toThrow(
-			"GitHub CLI did not return a valid pull request",
-		)
-		expect(() => parseGitHubPullRequestList("{}")).toThrow(
-			"GitHub CLI did not return a valid pull request list",
-		)
-	})
-})