@markjaquith/agency 3.2.14 → 3.3.0

package/src/commands/repo.test.ts

@@ -1,199 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { mkdir } from "node:fs/promises"
-import { join } from "node:path"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import { repo } from "./repo"
-
-describe("repo 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 a subcommand", async () => {
-		await expect(
-			runTestEffect(repo({ args: [], silent: true })),
-		).rejects.toThrow(
-			"Available subcommands: setup, add, link, materialize, list",
-		)
-	})
-
-	test("requires add arguments", async () => {
-		await expect(
-			runTestEffect(
-				repo({ subcommand: "add", args: ["agency"], silent: true }),
-			),
-		).rejects.toThrow("Usage: agency repo add")
-	})
-
-	test("requires a materialize alias", async () => {
-		await expect(
-			runTestEffect(
-				repo({ subcommand: "materialize", args: [], silent: true }),
-			),
-		).rejects.toThrow("Usage: agency repo materialize <alias>")
-	})
-
-	test("lists repository metadata as JSON", async () => {
-		const logs = await captureLogs(() =>
-			runTestEffect(
-				repo({ subcommand: "list", args: [], cwd: root, json: true }),
-			),
-		)
-
-		expect(JSON.parse(logs[0]!)).toEqual([
-			{
-				alias: "agency",
-				path: join(root, "repos/agency"),
-				kind: "repository",
-				remote: null,
-				declaredRemote: null,
-				target: null,
-				states: ["materialized", "invalid"],
-			},
-		])
-	})
-
-	test("shows a repository by alias as JSON", async () => {
-		const logs = await captureLogs(() =>
-			runTestEffect(
-				repo({
-					subcommand: "show",
-					args: ["agency"],
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-
-		expect(JSON.parse(logs[0]!).alias).toBe("agency")
-	})
-
-	test("outputs a linked repository as JSON", async () => {
-		const target = join(root, "source")
-		await mkdir(target)
-		const git = Bun.spawn(["git", "init", target], {
-			stdout: "ignore",
-			stderr: "ignore",
-		})
-		expect(await git.exited).toBe(0)
-		const remote = Bun.spawn(
-			[
-				"git",
-				"-C",
-				target,
-				"remote",
-				"add",
-				"origin",
-				"https://example.com/linked.git",
-			],
-			{ stdout: "ignore", stderr: "ignore" },
-		)
-		expect(await remote.exited).toBe(0)
-
-		const logs = await captureLogs(() =>
-			runTestEffect(
-				repo({
-					subcommand: "link",
-					args: ["linked", target],
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-
-		expect(JSON.parse(logs[0]!)).toEqual({
-			alias: "linked",
-			path: join(root, "repos/linked"),
-		})
-	})
-
-	test("unlinks a linked repository by alias", async () => {
-		const target = join(root, "unlink-source")
-		await mkdir(target)
-		const git = Bun.spawn(["git", "init", target], {
-			stdout: "ignore",
-			stderr: "ignore",
-		})
-		expect(await git.exited).toBe(0)
-		const remote = Bun.spawn(
-			[
-				"git",
-				"-C",
-				target,
-				"remote",
-				"add",
-				"origin",
-				"https://example.com/unlink.git",
-			],
-			{ stdout: "ignore", stderr: "ignore" },
-		)
-		expect(await remote.exited).toBe(0)
-		await runTestEffect(
-			repo({
-				subcommand: "link",
-				args: ["linked", target],
-				cwd: root,
-				silent: true,
-			}),
-		)
-
-		await runTestEffect(
-			repo({
-				subcommand: "unlink",
-				args: ["linked"],
-				cwd: root,
-				silent: true,
-			}),
-		)
-
-		expect(await Bun.file(join(target, ".git/HEAD")).exists()).toBe(true)
-		expect(await Bun.file(join(root, "repos/linked")).exists()).toBe(false)
-		const logs = await captureLogs(() =>
-			runTestEffect(
-				repo({ subcommand: "list", args: [], cwd: root, json: true }),
-			),
-		)
-		expect(
-			JSON.parse(logs[0]!).map(({ alias }: { alias: string }) => alias),
-		).toEqual(["agency", "linked"])
-	})
-
-	test("reports setup plans as JSON without mutating", async () => {
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({
-				version: 2,
-				repositories: {
-					missing: { remote: "https://example.com/missing.git" },
-				},
-			}),
-		)
-		const logs = await captureLogs(() =>
-			runTestEffect(
-				repo({ subcommand: "setup", args: [], cwd: root, json: true }),
-			),
-		)
-		const result = JSON.parse(logs[0]!)
-		expect(result.mode).toBe("dry-run")
-		expect(result.actions).toEqual([
-			{
-				kind: "materialize",
-				alias: "missing",
-				remote: "https://example.com/missing.git",
-				status: "planned",
-			},
-		])
-		expect(await Bun.file(join(root, "repos/missing")).exists()).toBe(false)
-	})
-})

package/src/commands/restore.test.ts

@@ -1,106 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { join } from "node:path"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import { archive } from "./archive"
-import { restore } from "./restore"
-import { task } from "./task"
-
-describe("restore command", () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-		const initialized = Bun.spawnSync([
-			"git",
-			"init",
-			"--bare",
-			join(root, "repos/agency"),
-		])
-		if (initialized.exitCode !== 0)
-			throw new Error(new TextDecoder().decode(initialized.stderr))
-		await runTestEffect(
-			task({
-				subcommand: "create",
-				args: ["example"],
-				repo: "agency",
-				branch: "task/example",
-				base: "main",
-				cwd: root,
-				silent: true,
-			}),
-		)
-		await runTestEffect(
-			task({
-				subcommand: "status",
-				args: ["example", "dropped"],
-				cwd: root,
-				silent: true,
-			}),
-		)
-		await runTestEffect(
-			archive({ type: "task", args: ["example"], cwd: root, silent: true }),
-		)
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	test("dry-runs then restores an archived task", async () => {
-		const preview = await captureLogs(() =>
-			runTestEffect(
-				restore({
-					type: "task",
-					args: ["example"],
-					cwd: root,
-					dryRun: true,
-				}),
-			),
-		)
-		expect(preview[0]).toContain("Would restore task 'example'")
-		expect(await Bun.file(join(root, "tasks/example/TASK.md")).exists()).toBe(
-			false,
-		)
-
-		const logs = await captureLogs(() =>
-			runTestEffect(
-				restore({ type: "task", args: ["example"], cwd: root, json: true }),
-			),
-		)
-		expect(JSON.parse(logs[0]!)).toMatchObject({
-			operation: "restore",
-			kind: "task",
-			id: "example",
-			dryRun: false,
-		})
-		expect(await Bun.file(join(root, "tasks/example/TASK.md")).exists()).toBe(
-			true,
-		)
-	})
-
-	test("lists and shows archived work", async () => {
-		const listed = await captureLogs(() =>
-			runTestEffect(
-				archive({
-					type: "list",
-					args: [],
-					kinds: ["task"],
-					repositories: ["agency"],
-					cwd: root,
-				}),
-			),
-		)
-		expect(listed).toEqual(["task\texample"])
-
-		const shown = await captureLogs(() =>
-			runTestEffect(
-				archive({ type: "show", args: ["task", "example"], cwd: root }),
-			),
-		)
-		expect(shown[0]).toContain("# Example")
-	})
-})

package/src/commands/status.test.ts

@@ -1,113 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { mkdir } from "node:fs/promises"
-import { join } from "node:path"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import { status } from "./status"
-import { task } from "./task"
-
-describe("status 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("outputs status and repository metadata as JSON", async () => {
-		const logs = await captureLogs(() =>
-			runTestEffect(status({ cwd: root, json: true })),
-		)
-		const output = JSON.parse(logs[0]!)
-
-		expect(output).toMatchObject({
-			root,
-			issues: [],
-			epicCount: 0,
-			taskCount: 0,
-			phaseCount: 0,
-			valid: true,
-		})
-		expect(output.repositories).toEqual([
-			{
-				alias: "agency",
-				path: join(root, "repos/agency"),
-				kind: "repository",
-				remote: null,
-				declaredRemote: null,
-				target: null,
-				states: ["materialized", "invalid"],
-			},
-		])
-	})
-
-	test("renders and filters the execution dashboard", async () => {
-		await runTestEffect(
-			task({
-				subcommand: "create",
-				args: ["example"],
-				repo: "agency",
-				branch: "feat/example",
-				base: "main",
-				cwd: root,
-				silent: true,
-			}),
-		)
-		await runTestEffect(
-			task({
-				subcommand: "create",
-				args: ["finished"],
-				repo: "agency",
-				branch: "feat/finished",
-				base: "main",
-				cwd: root,
-				silent: true,
-			}),
-		)
-		await runTestEffect(
-			task({
-				subcommand: "status",
-				args: ["finished", "dropped"],
-				cwd: root,
-				silent: true,
-			}),
-		)
-
-		const logs = await captureLogs(() =>
-			runTestEffect(
-				status({ cwd: root, repositories: ["agency"], ready: true, pr: false }),
-			),
-		)
-		expect(logs).toContain("Repositories: 1")
-		expect(logs.at(-1)).toContain(
-			"KIND  WORK     PARENT  STATUS  READINESS  REPOSITORIES  BRANCH",
-		)
-		expect(logs.at(-1)).toContain(
-			"task  example  -       open    ready      agency        feat/example  absent  absent",
-		)
-		expect(logs.at(-1)).not.toContain("finished")
-	})
-
-	test("reports validation issues without requiring a decodable graph", async () => {
-		await mkdir(join(root, "tasks/broken"), { recursive: true })
-		await Bun.write(
-			join(root, "tasks/broken/TASK.md"),
-			"---\nrepo: agency\nstatus: invalid\n---\n",
-		)
-
-		const logs = await captureLogs(() =>
-			runTestEffect(status({ cwd: root, json: true })),
-		)
-		const output = JSON.parse(logs[0]!)
-		expect(output.valid).toBe(false)
-		expect(output.issues.length).toBeGreaterThan(0)
-		expect(output.work).toEqual([])
-	})
-})

package/src/commands/sync.test.ts

@@ -1,200 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { chmod, mkdir } from "node:fs/promises"
-import { join } from "node:path"
-import { TaskService } from "../services/TaskService"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import type { Progress } from "../utils/progress"
-import { sync } from "./sync"
-
-const git = async (args: string[], cwd: string) => {
-	const process = Bun.spawn(["git", ...args], {
-		cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	await process.exited
-	if (process.exitCode !== 0) {
-		throw new Error(await new Response(process.stderr).text())
-	}
-}
-
-describe("sync command", () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		const source = join(root, "source")
-		await mkdir(source)
-		await git(["init", "--initial-branch=main"], source)
-		await git(["config", "user.email", "test@example.com"], source)
-		await git(["config", "user.name", "Test"], source)
-		await Bun.write(join(source, "README.md"), "example\n")
-		await git(["add", "README.md"], source)
-		await git(["-c", "commit.gpgsign=false", "commit", "-m", "initial"], source)
-		await mkdir(join(root, "repos"))
-		await git(["clone", "--bare", source, join(root, "repos/agency")], root)
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							id: "example",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/example",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	test("applies safe reconciliation by default", async () => {
-		const logs = await captureLogs(() => runTestEffect(sync({ cwd: root })))
-
-		expect(
-			await Bun.file(join(root, "tasks/example/code/agency/README.md")).text(),
-		).toBe("example\n")
-		expect(logs).toContainEqual(
-			expect.stringContaining("Applied materialize-workspace 'task:example'"),
-		)
-		expect(() => JSON.parse(logs.join("\n"))).toThrow()
-	})
-
-	test("keeps explicit dry-run observational", async () => {
-		await runTestEffect(sync({ cwd: root, dryRun: true, silent: true }))
-
-		expect(
-			await Bun.file(
-				join(root, "tasks/example/code/agency/README.md"),
-			).exists(),
-		).toBe(false)
-	})
-
-	test("scopes reconciliation to one task", async () => {
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							id: "second",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/second",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-
-		const logs = await captureLogs(() =>
-			runTestEffect(sync({ cwd: root, taskId: "example", json: true })),
-		)
-		const result = JSON.parse(logs[0]!)
-		expect(result.executions.map((execution: any) => execution.target)).toEqual(
-			["task:example"],
-		)
-		expect(
-			await Bun.file(
-				join(root, "tasks/example/code/agency/README.md"),
-			).exists(),
-		).toBe(true)
-		expect(
-			await Bun.file(join(root, "tasks/second/code/agency/README.md")).exists(),
-		).toBe(false)
-	})
-
-	test("preserves structured output behind --json", async () => {
-		const logs = await captureLogs(() =>
-			runTestEffect(sync({ cwd: root, dryRun: true, json: true })),
-		)
-
-		expect(logs).toHaveLength(1)
-		expect(JSON.parse(logs[0]!)).toMatchObject({
-			mode: "dry-run",
-			changes: [
-				expect.objectContaining({
-					kind: "materialize-workspace",
-					status: "planned",
-				}),
-			],
-		})
-	})
-
-	test("groups repeated human-readable warnings by affected target", async () => {
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							id: "second",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/second",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-		const originalPath = process.env.PATH
-		const bin = join(root, "bin")
-		await mkdir(bin)
-		await Bun.write(
-			join(bin, "gh"),
-			'#!/bin/sh\necho "provider unavailable" >&2\nexit 1\n',
-		)
-		await chmod(join(bin, "gh"), 0o755)
-		process.env.PATH = `${bin}:${originalPath}`
-		try {
-			const logs = await captureLogs(() =>
-				runTestEffect(sync({ cwd: root, dryRun: true })),
-			)
-			expect(
-				logs.filter((line) => line.includes("provider unavailable")),
-			).toEqual(["Warning 'task:example', 'task:second': provider unavailable"])
-		} finally {
-			process.env.PATH = originalPath
-		}
-	})
-
-	test("reports human-readable progress without polluting JSON output", async () => {
-		const updates: string[] = []
-		const progress: Progress = {
-			start: (message) => updates.push(`start:${message}`),
-			succeed: (message) => updates.push(`succeed:${message}`),
-			fail: (message) => updates.push(`fail:${message}`),
-		}
-
-		await captureLogs(() =>
-			runTestEffect(sync({ cwd: root, silent: false }, progress)),
-		)
-		expect(updates).toEqual([
-			"start:Validating workbase",
-			"start:Inspected 1 repositories",
-			"start:Queried pull requests 1/1 (task:example)",
-			"start:Reconciled execution units 1/1 (task:example)",
-			"succeed:Synchronized 1 execution units",
-		])
-
-		updates.length = 0
-		await captureLogs(() =>
-			runTestEffect(sync({ cwd: root, dryRun: true, json: true }, progress)),
-		)
-		expect(updates).toEqual([])
-	})
-})