@markjaquith/agency 3.2.13 → 3.2.15

package/src/commands/description.test.ts

@@ -1,103 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { mkdir } from "node:fs/promises"
-import { join } from "node:path"
-import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
-import { epic } from "./epic"
-import { phase } from "./phase"
-import { task } from "./task"
-
-describe("create command descriptions", () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-		await mkdir(join(root, "repos/agency"), { recursive: true })
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	test("persists and exposes descriptions for every body-of-work shape", async () => {
-		await runTestEffect(
-			epic({
-				subcommand: "create",
-				args: ["rollout"],
-				ticketUrl: "https://example.com/epic",
-				description: "Coordinate the rollout.",
-				repos: ["agency:main"],
-				cwd: root,
-				silent: true,
-			}),
-		)
-		await runTestEffect(
-			task({
-				subcommand: "create",
-				args: ["delivery"],
-				ticketUrl: "https://example.com/task",
-				description: "Deliver the rollout.",
-				multiPhase: true,
-				cwd: root,
-				silent: true,
-			}),
-		)
-		await runTestEffect(
-			phase({
-				subcommand: "create",
-				args: ["delivery", "contract"],
-				description: "Introduce the service contract.",
-				repo: "agency",
-				branch: "task/contract",
-				base: "main",
-				cwd: root,
-				silent: true,
-			}),
-		)
-
-		expect(
-			await Bun.file(join(root, "epics/rollout/EPIC.md")).text(),
-		).toContain("description: Coordinate the rollout.")
-		expect(
-			await Bun.file(join(root, "tasks/delivery/TASK.md")).text(),
-		).toContain("description: Deliver the rollout.")
-		expect(
-			await Bun.file(
-				join(root, "tasks/delivery/phases/contract/PHASE.md"),
-			).text(),
-		).toContain("description: Introduce the service contract.")
-
-		const output: string[] = []
-		const originalLog = console.log
-		console.log = (message?: unknown) => output.push(String(message))
-		try {
-			await runTestEffect(
-				epic({ subcommand: "list", args: [], cwd: root, json: true }),
-			)
-			await runTestEffect(
-				task({
-					subcommand: "show",
-					args: ["delivery"],
-					cwd: root,
-					json: true,
-				}),
-			)
-			await runTestEffect(
-				phase({
-					subcommand: "show",
-					args: ["delivery", "contract"],
-					cwd: root,
-					json: true,
-				}),
-			)
-		} finally {
-			console.log = originalLog
-		}
-
-		expect(JSON.parse(output[0]!)[0].data.description).toBe(
-			"Coordinate the rollout.",
-		)
-		expect(JSON.parse(output[1]!).data.description).toBe("Deliver the rollout.")
-		expect(JSON.parse(output[2]!).data.description).toBe(
-			"Introduce the service contract.",
-		)
-	})
-})

package/src/commands/doctor.test.ts

@@ -1,185 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { createHash } from "node:crypto"
-import { chmod, mkdir } from "node:fs/promises"
-import { dirname, join } from "node:path"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import { doctor } from "./doctor"
-
-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)
-}
-
-const managedAgents = (body: string) =>
-	`<!-- agency-managed: sha256=${createHash("sha256").update(body).digest("hex")} -->\n\n${body}`
-
-describe("doctor command", () => {
-	let root: string
-	let repository: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		repository = join(root, "source")
-		await mkdir(repository)
-		await Bun.$`git init -q -b main ${repository}`
-		await Bun.$`git -C ${repository} config user.email test@example.com`
-		await Bun.$`git -C ${repository} config user.name Test`
-		await write(repository, "README.md", "test\n")
-		await Bun.$`git -C ${repository} add README.md`
-		await Bun.$`git -C ${repository} commit -q -m initial`
-		await Bun.$`git -C ${repository} remote add origin https://example.com/agency.git`
-		await write(
-			root,
-			"agency.json",
-			JSON.stringify({
-				version: 2,
-				agents: {
-					missing: {
-						command: ["definitely-not-installed"],
-						autoCommand: ["also-not-installed", "{prompt}"],
-					},
-				},
-			}),
-		)
-		await mkdir(join(root, "repos"), { recursive: true })
-		await Bun.$`ln -s ${repository} ${join(root, "repos/agency")}`
-		await write(
-			root,
-			"tasks/example/TASK.md",
-			`---
-ticketUrl: null
-repo: agency
-branch: feat/example
-base: main
-pr: null
-status: open
----
-
-# Example
-`,
-		)
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	test("returns stable checks, severities, and remediation in JSON", async () => {
-		const logs = await captureLogs(() =>
-			runTestEffect(doctor({ cwd: root, json: true })),
-		)
-		const report = JSON.parse(logs[0]!)
-
-		expect(report).toMatchObject({
-			version: 1,
-			root,
-			healthy: false,
-		})
-		expect(report.checks).toEqual(
-			expect.arrayContaining([
-				expect.objectContaining({
-					id: "tool.git",
-					level: "error",
-					status: "pass",
-				}),
-				expect.objectContaining({
-					id: "integration.agent.missing",
-					level: "error",
-					status: "fail",
-				}),
-				expect.objectContaining({
-					id: "integration.agent.missing.auto",
-					level: "error",
-					status: "fail",
-				}),
-				expect.objectContaining({
-					id: "ref.agency.main",
-					status: "pass",
-				}),
-			]),
-		)
-		for (const check of report.checks) {
-			if (check.status === "fail") expect(check.remediation).toBeTruthy()
-		}
-	})
-
-	test("reports repository, ref, remote, and managed-file failures", async () => {
-		await Bun.$`git -C ${repository} remote remove origin`
-		await Bun.$`git -C ${repository} branch -m other`
-		await write(root, ".agency/AGENTS.md", managedAgents("old\n"))
-
-		const logs = await captureLogs(() =>
-			runTestEffect(doctor({ cwd: root, json: true })),
-		)
-		const checks = JSON.parse(logs[0]!).checks
-
-		expect(checks).toEqual(
-			expect.arrayContaining([
-				expect.objectContaining({
-					id: "repository.agency.remote",
-					status: "fail",
-				}),
-				expect.objectContaining({
-					id: "ref.agency.main",
-					status: "fail",
-				}),
-				expect.objectContaining({
-					id: "integration.file.agents",
-					status: "fail",
-				}),
-			]),
-		)
-	})
-
-	test("warns when customized OpenCode config cannot guarantee access", async () => {
-		const custom = '{"references":{}}\n'
-		await write(root, ".opencode/opencode.jsonc", custom)
-
-		const logs = await captureLogs(() =>
-			runTestEffect(doctor({ cwd: root, json: true })),
-		)
-		const check = JSON.parse(logs[0]!).checks.find(
-			(value: { id: string }) => value.id === "integration.file.opencode",
-		)
-
-		expect(check).toMatchObject({
-			level: "warning",
-			status: "fail",
-			message: expect.stringContaining("cannot guarantee its instructions"),
-			remediation: expect.stringContaining("global config"),
-		})
-		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
-			custom,
-		)
-	})
-
-	test("is safe when the workbase is read-only", async () => {
-		for (const path of [
-			join(root, "agency.json"),
-			join(root, "tasks/example/TASK.md"),
-		]) {
-			await chmod(path, 0o444)
-		}
-		await chmod(join(root, "tasks/example"), 0o555)
-		await chmod(join(root, "tasks"), 0o555)
-		await chmod(root, 0o555)
-
-		try {
-			await runTestEffect(doctor({ cwd: root, silent: true }))
-		} finally {
-			await chmod(root, 0o755)
-			await chmod(join(root, "tasks"), 0o755)
-			await chmod(join(root, "tasks/example"), 0o755)
-		}
-
-		expect(await Bun.file(join(root, "AGENTS.md")).exists()).toBe(false)
-		expect(await Bun.file(join(root, ".agency/AGENTS.md")).exists()).toBe(false)
-		expect(
-			await Bun.file(join(root, ".opencode/opencode.jsonc")).exists(),
-		).toBe(false)
-	})
-})

package/src/commands/epic.test.ts

@@ -1,196 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { mkdir } from "node:fs/promises"
-import { join } from "node:path"
-import { Effect } from "effect"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import { epic } from "./epic"
-
-describe("epic command", () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-		await mkdir(join(root, "repos/agency"), { recursive: true })
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	test("requires create arguments", async () => {
-		await expect(
-			runTestEffect(epic({ subcommand: "create", args: [], silent: true })),
-		).rejects.toThrow("Usage: agency epic create")
-	})
-
-	test("outputs the created epic as JSON", async () => {
-		const logs = await captureLogs(() =>
-			runTestEffect(
-				epic({
-					subcommand: "create",
-					args: ["example"],
-					ticketUrl: "https://example.com/epic",
-					repos: ["agency:main"],
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-
-		const created = JSON.parse(logs[0]!)
-		expect(created.revision).toMatch(/^[a-f0-9]{64}$/)
-		expect(created).toEqual({
-			id: "example",
-			path: join(root, "epics/example/EPIC.md"),
-			revision: created.revision,
-			data: {
-				ticketUrl: "https://example.com/epic",
-				repos: [{ repo: "agency", ref: "main" }],
-				tasks: [],
-			},
-		})
-	})
-
-	test("lists and shows stable epic JSON records", async () => {
-		await runTestEffect(
-			epic({
-				subcommand: "create",
-				args: ["example"],
-				ticketUrl: "https://example.com/epic",
-				repos: ["agency:main"],
-				cwd: root,
-				silent: true,
-			}),
-		)
-
-		const listLogs = await captureLogs(() =>
-			runTestEffect(
-				epic({ subcommand: "list", args: [], cwd: root, json: true }),
-			),
-		)
-		const listed = JSON.parse(listLogs[0]!)
-		expect(listed[0].revision).toMatch(/^[a-f0-9]{64}$/)
-		expect(listed).toEqual([
-			{
-				id: "example",
-				path: join(root, "epics/example/EPIC.md"),
-				revision: listed[0].revision,
-				data: {
-					ticketUrl: "https://example.com/epic",
-					repos: [{ repo: "agency", ref: "main" }],
-					tasks: [],
-				},
-			},
-		])
-
-		const showLogs = await captureLogs(() =>
-			runTestEffect(
-				epic({
-					subcommand: "show",
-					args: ["example"],
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-		const shown = JSON.parse(showLogs[0]!)
-		expect(shown.revision).toBe(listed[0].revision)
-		expect(shown).toEqual({
-			id: "example",
-			path: join(root, "epics/example/EPIC.md"),
-			revision: shown.revision,
-			data: {
-				ticketUrl: "https://example.com/epic",
-				repos: [{ repo: "agency", ref: "main" }],
-				tasks: [],
-			},
-		})
-	})
-
-	test("reads each epic document once when listing JSON", async () => {
-		await runTestEffect(
-			epic({
-				subcommand: "create",
-				args: ["example"],
-				ticketUrl: "https://example.com/epic",
-				repos: ["agency:main"],
-				cwd: root,
-				silent: true,
-			}),
-		)
-		const original = Bun.file
-		let reads = 0
-		Bun.file = ((path: Parameters<typeof Bun.file>[0], ...args: never[]) => {
-			if (String(path).endsWith("/epics/example/EPIC.md")) reads += 1
-			return original(path as unknown as string, ...args)
-		}) as typeof Bun.file
-		try {
-			await captureLogs(() =>
-				runTestEffect(
-					epic({ subcommand: "list", args: [], cwd: root, json: true }),
-				),
-			)
-		} finally {
-			Bun.file = original
-		}
-		expect(reads).toBe(2)
-	})
-
-	test("renders a readable operational table", async () => {
-		await runTestEffect(
-			epic({
-				subcommand: "create",
-				args: ["example"],
-				ticketUrl: "https://example.com/epic",
-				repos: ["agency:main"],
-				cwd: root,
-				silent: true,
-			}),
-		)
-
-		const logs = await captureLogs(() =>
-			runTestEffect(epic({ subcommand: "list", args: [], cwd: root })),
-		)
-		expect(logs[0]).toContain(
-			"EPIC     STATUS  READINESS  REPOSITORIES  PR  WORKTREE",
-		)
-		expect(logs[0]).toContain("example  open    waiting    agency")
-		expect(logs[0]).not.toMatch(/[\u{e000}-\u{f8ff}]/u)
-	})
-
-	test("starts work on a newly created epic", async () => {
-		const launches: unknown[] = []
-
-		await runTestEffect(
-			epic(
-				{
-					subcommand: "new",
-					args: ["immediate"],
-					ticketUrl: "https://example.com/immediate",
-					repos: ["agency:main"],
-					work: true,
-					auto: true,
-					cwd: root,
-					silent: true,
-				},
-				(options) =>
-					Effect.sync(() => {
-						launches.push(options)
-						return undefined
-					}),
-			),
-		)
-
-		expect(launches).toEqual([
-			expect.objectContaining({
-				epicId: "immediate",
-				auto: true,
-				cwd: root,
-			}),
-		])
-	})
-})

package/src/commands/init.test.ts

@@ -1,117 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { stat } from "node:fs/promises"
-import { join } from "node:path"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import { init } from "./init"
-
-describe("init command", () => {
-	let parent: string
-
-	beforeEach(async () => {
-		parent = await createTempDir()
-	})
-
-	afterEach(async () => {
-		await cleanupTempDir(parent)
-	})
-
-	test("creates a workbase and required directories", async () => {
-		const root = join(parent, "workbase")
-		await runTestEffect(init({ path: root, silent: true }))
-
-		expect(await Bun.file(join(root, "agency.json")).json()).toEqual({
-			version: 2,
-			vcs: "git",
-		})
-		for (const directory of ["repos", "epics", "tasks"]) {
-			expect((await stat(join(root, directory))).isDirectory()).toBe(true)
-		}
-		expect(await Bun.file(join(root, ".gitignore")).text()).toBe(
-			"/repos/\n/tasks/*/code/\n/tasks/*/phases/*/code/\n",
-		)
-		expect(await Bun.file(join(root, "AGENTS.md")).exists()).toBe(false)
-		const agents = await Bun.file(join(root, ".agency/AGENTS.md")).text()
-		expect(agents).toContain("agency context . --json")
-		expect(agents).toContain("## Consent Boundaries")
-		expect(agents).toContain("## Execution")
-		expect(agents).not.toContain("SKILL.md")
-		const opencode = await Bun.file(
-			join(root, ".opencode/opencode.jsonc"),
-		).text()
-		const config = JSON.parse(opencode.slice(opencode.indexOf("\n\n") + 2))
-		expect(config.instructions).toEqual([".agency/AGENTS.md"])
-		expect(config.agent.agency).toBeUndefined()
-		expect(config.agent.plan).toEqual({ disable: true })
-		expect(config.agent["agency-plan"]).toMatchObject({
-			mode: "primary",
-			permission: {
-				bash: {
-					"agency *": "allow",
-				},
-				edit: {
-					"*": "deny",
-					"tasks/*/TASK.md": "allow",
-					"tasks/*/phases/*/PHASE.md": "allow",
-					"epics/*/EPIC.md": "allow",
-				},
-			},
-		})
-		expect(config.references).toEqual({
-			workbase: expect.objectContaining({ path: ".." }),
-		})
-		expect(config.permission).toBeUndefined()
-		expect(
-			await Bun.file(join(root, ".opencode/command/agency.md")).exists(),
-		).toBe(false)
-		const plugin = await Bun.file(
-			join(root, ".opencode/plugins/agency-repository-skills.ts"),
-		).text()
-		expect(plugin).toContain("AGENCY_WRITABLE_CHECKOUT")
-		expect(plugin).toContain("config.skills.paths")
-		const tui = await Bun.file(join(root, ".opencode/tui.jsonc")).text()
-		expect(JSON.parse(tui.slice(tui.indexOf("\n\n") + 2))).toEqual({
-			$schema: "https://opencode.ai/tui.json",
-			plugin: ["./tui/agency-debug.ts"],
-		})
-		const tuiPlugin = await Bun.file(
-			join(root, ".opencode/tui/agency-debug.ts"),
-		).text()
-		expect(tuiPlugin).toContain('slashName: "agency-debug"')
-		expect(tuiPlugin).toContain("api.ui.toast")
-		expect(tuiPlugin).not.toContain("chat.message")
-		expect(
-			await Bun.file(join(root, ".pi/extensions/agency-workbase.ts")).exists(),
-		).toBe(false)
-	})
-
-	test("preserves existing gitignore entries", async () => {
-		await Bun.write(join(parent, ".gitignore"), "custom\n")
-		await runTestEffect(init({ path: parent, silent: true }))
-
-		expect(await Bun.file(join(parent, ".gitignore")).text()).toStartWith(
-			"custom\n",
-		)
-	})
-
-	test("outputs the initialized workbase as JSON", async () => {
-		const root = join(parent, "json-workbase")
-		const logs = await captureLogs(() =>
-			runTestEffect(init({ path: root, json: true })),
-		)
-
-		expect(JSON.parse(logs[0]!)).toEqual({ root })
-	})
-
-	test("rejects an existing Agency configuration", async () => {
-		await Bun.write(join(parent, "agency.json"), '{"version":2}\n')
-
-		await expect(
-			runTestEffect(init({ path: parent, silent: true })),
-		).rejects.toThrow("already exists")
-	})
-})