@markjaquith/agency 1.11.1 → 2.1.0

package/src/commands/description.test.ts

@@ -0,0 +1,103 @@
+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/epic.test.ts

@@ -0,0 +1,103 @@
+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 { 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,
+				}),
+			),
+		)
+
+		expect(JSON.parse(logs[0]!)).toEqual({
+			id: "example",
+			path: join(root, "epics/example/EPIC.md"),
+			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 }),
+			),
+		)
+		expect(JSON.parse(listLogs[0]!)).toEqual([
+			{
+				id: "example",
+				path: join(root, "epics/example/EPIC.md"),
+				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,
+				}),
+			),
+		)
+		expect(JSON.parse(showLogs[0]!)).toEqual({
+			id: "example",
+			path: join(root, "epics/example/EPIC.md"),
+			data: {
+				ticketUrl: "https://example.com/epic",
+				repos: [{ repo: "agency", ref: "main" }],
+				tasks: [],
+			},
+		})
+	})
+})

package/src/commands/epic.ts

@@ -0,0 +1,101 @@
+import { Effect } from "effect"
+import type { BaseCommandOptions } from "../utils/command"
+import { EpicService } from "../services/EpicService"
+import { createLoggers } from "../utils/effect"
+import { parseRepositoryReferences } from "../workbase/repository-reference"
+
+interface EpicOptions extends BaseCommandOptions {
+	readonly subcommand?: string
+	readonly args: readonly string[]
+	readonly ticketUrl?: string
+	readonly description?: string
+	readonly repos?: readonly string[]
+	readonly json?: boolean
+}
+
+export const epic = (options: EpicOptions) =>
+	Effect.gen(function* () {
+		const epics = yield* EpicService
+		const { log } = createLoggers(options)
+		const cwd = options.cwd ?? process.cwd()
+
+		switch (options.subcommand) {
+			case "create": {
+				const id = options.args[0]
+				if (!id || !options.ticketUrl || !options.repos?.length) {
+					return yield* Effect.fail(
+						new Error(
+							"Usage: agency epic create <id> --ticket-url <url> --repo <alias>:<ref>",
+						),
+					)
+				}
+				const record = yield* epics.create(
+					id,
+					options.ticketUrl,
+					parseRepositoryReferences(options.repos),
+					cwd,
+					options.description,
+				)
+				const { content: _, ...output } = record
+				log(
+					options.json
+						? JSON.stringify(output, null, 2)
+						: `Created epic '${record.id}'`,
+				)
+				return
+			}
+
+			case "list": {
+				const records = yield* epics.list(cwd)
+				if (options.json) {
+					log(
+						JSON.stringify(
+							records.map(({ content: _, ...record }) => record),
+							null,
+							2,
+						),
+					)
+				} else {
+					for (const record of records) log(record.id)
+				}
+				return
+			}
+
+			case "show": {
+				const id = options.args[0]
+				if (!id) return yield* Effect.fail(new Error("Epic ID is required"))
+				const record = yield* epics.show(id, cwd)
+				const { content: _, ...output } = record
+				log(
+					options.json
+						? JSON.stringify(output, null, 2)
+						: record.content.trimEnd(),
+				)
+				return
+			}
+
+			default:
+				return yield* Effect.fail(
+					new Error(
+						"Subcommand is required. Available subcommands: create, list, show",
+					),
+				)
+		}
+	})
+
+export const help = `
+Usage: agency epic <subcommand>
+
+Subcommands:
+  create <id>           Create an epic
+  list                  List epics
+  show <id>             Show an epic
+
+Create options:
+  --ticket-url <url>    External ticket URL
+  --description <text>  Short description of the epic
+  --repo <alias>:<ref>  Read-only repository reference; repeatable
+
+Options:
+  --json                Output results as JSON
+`

package/src/commands/init.test.ts

@@ -1,311 +1,63 @@
-import { test, expect, describe } from "bun:test"
-import { mkdtemp, rm } from "fs/promises"
-import { tmpdir } from "os"
-import { join } from "path"
+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"
-import { initGitRepo, getGitConfig, runTestEffect } from "../test-utils"
 
 describe("init command", () => {
-	test("initializes with template flag", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await runTestEffect(
-				init({ template: "test-template", silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe(
-				"test-template",
-			)
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
-	})
-
-	test("saves template name to git config", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await runTestEffect(
-				init({ template: "my-template", silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe("my-template")
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
-	})
+	let parent: string
 
-	test("accepts template names with hyphens", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await runTestEffect(
-				init({ template: "my-work-template", silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe(
-				"my-work-template",
-			)
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
+	beforeEach(async () => {
+		parent = await createTempDir()
 	})
 
-	test("accepts template names with underscores", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await runTestEffect(
-				init({ template: "my_work_template", silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe(
-				"my_work_template",
-			)
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
-	})
-
-	test("throws error when not in git repository", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await expect(
-				runTestEffect(init({ template: "test", silent: true, cwd: tempDir })),
-			).rejects.toThrow("Not in a git repository")
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
+	afterEach(async () => {
+		await cleanupTempDir(parent)
 	})
 
-	test("throws error when already initialized without template flag", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await runTestEffect(
-				init({ template: "first-template", silent: true, cwd: tempDir }),
-			)
-			await expect(
-				runTestEffect(init({ silent: true, cwd: tempDir })),
-			).rejects.toThrow("Already initialized")
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
-	})
+	test("creates a workbase and required directories", async () => {
+		const root = join(parent, "workbase")
+		await runTestEffect(init({ path: root, silent: true }))
 
-	test("allows re-initialization with different template", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await runTestEffect(
-				init({ template: "first-template", silent: true, cwd: tempDir }),
-			)
-			await runTestEffect(
-				init({ template: "second-template", silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe(
-				"second-template",
-			)
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
+		expect(await Bun.file(join(root, "agency.json")).json()).toEqual({
+			version: 2,
+		})
+		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",
+		)
 	})
 
-	test("requires template name in silent mode", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await expect(
-				runTestEffect(init({ silent: true, cwd: tempDir })),
-			).rejects.toThrow("Template name required")
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
-	})
+	test("preserves existing gitignore entries", async () => {
+		await Bun.write(join(parent, ".gitignore"), "custom\n")
+		await runTestEffect(init({ path: parent, silent: true }))
 
-	test("sets config even if template directory does not exist", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await runTestEffect(
-				init({ template: "nonexistent", silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe("nonexistent")
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
+		expect(await Bun.file(join(parent, ".gitignore")).text()).toStartWith(
+			"custom\n",
+		)
 	})
 
-	test("works without output in silent mode", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await runTestEffect(
-				init({ template: "silent-test", silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe("silent-test")
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
-	})
+	test("outputs the initialized workbase as JSON", async () => {
+		const root = join(parent, "json-workbase")
+		const logs = await captureLogs(() =>
+			runTestEffect(init({ path: root, json: true })),
+		)
 
-	test("fails in silent mode without template", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await expect(
-				runTestEffect(init({ silent: true, cwd: tempDir })),
-			).rejects.toThrow("Template name required")
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
+		expect(JSON.parse(logs[0]!)).toEqual({ root })
 	})
 
-	test("works in verbose mode", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			const originalLog = console.log
-			console.log = () => {}
-			try {
-				await runTestEffect(
-					init({
-						template: "verbose-test",
-						verbose: true,
-						silent: false,
-						cwd: tempDir,
-					}),
-				)
-				expect(await getGitConfig("agency.template", tempDir)).toBe(
-					"verbose-test",
-				)
-			} finally {
-				console.log = originalLog
-			}
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
-	})
+	test("rejects an existing Agency configuration", async () => {
+		await Bun.write(join(parent, "agency.json"), '{"version":2}\n')
 
-	test("handles empty template name", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await expect(
-				runTestEffect(init({ template: "", silent: true, cwd: tempDir })),
-			).rejects.toThrow("Template name required")
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
-	})
-
-	test("handles template name with special characters", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await runTestEffect(
-				init({ template: "test.template", silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe(
-				"test.template",
-			)
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
-	})
-
-	test("handles very long template names", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			const longName = "a".repeat(100)
-			await runTestEffect(
-				init({ template: longName, silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe(longName)
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
-	})
-
-	test("changing template updates git config", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await runTestEffect(
-				init({ template: "template-a", silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe("template-a")
-			await runTestEffect(
-				init({ template: "template-b", silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe("template-b")
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
-	})
-
-	test("preserves template name across command runs", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		try {
-			await initGitRepo(tempDir)
-			await runTestEffect(
-				init({ template: "persistent", silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe("persistent")
-			expect(await getGitConfig("agency.template", tempDir)).toBe("persistent")
-		} finally {
-			await rm(tempDir, { recursive: true, force: true })
-		}
-	})
-
-	test("does not create template directory during init", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		const configDir = await mkdtemp(join(tmpdir(), "agency-config-"))
-		const originalConfigDir = process.env.AGENCY_CONFIG_DIR
-		try {
-			await initGitRepo(tempDir)
-			process.env.AGENCY_CONFIG_DIR = configDir
-			await runTestEffect(
-				init({ template: "test-template", silent: true, cwd: tempDir }),
-			)
-			expect(
-				await Bun.file(
-					`${configDir}/templates/test-template/AGENTS.md`,
-				).exists(),
-			).toBe(false)
-		} finally {
-			if (originalConfigDir !== undefined) {
-				process.env.AGENCY_CONFIG_DIR = originalConfigDir
-			} else {
-				delete process.env.AGENCY_CONFIG_DIR
-			}
-			await rm(tempDir, { recursive: true, force: true })
-			await rm(configDir, { recursive: true, force: true })
-		}
-	})
-
-	test("works when templates directory does not exist", async () => {
-		const tempDir = await mkdtemp(join(tmpdir(), "agency-test-"))
-		const originalConfigDir = process.env.AGENCY_CONFIG_DIR
-		try {
-			await initGitRepo(tempDir)
-			// Point to a non-existent config directory
-			const configDir = join(tmpdir(), `agency-config-${Date.now()}`)
-			process.env.AGENCY_CONFIG_DIR = configDir
-			// Verify templates directory doesn't exist
-			expect(await Bun.file(join(configDir, "templates")).exists()).toBe(false)
-			// Init should work even without templates directory
-			await runTestEffect(
-				init({ template: "new-template", silent: true, cwd: tempDir }),
-			)
-			expect(await getGitConfig("agency.template", tempDir)).toBe(
-				"new-template",
-			)
-		} finally {
-			if (originalConfigDir !== undefined) {
-				process.env.AGENCY_CONFIG_DIR = originalConfigDir
-			} else {
-				delete process.env.AGENCY_CONFIG_DIR
-			}
-			await rm(tempDir, { recursive: true, force: true })
-		}
+		await expect(
+			runTestEffect(init({ path: parent, silent: true })),
+		).rejects.toThrow("already exists")
 	})
 })