@markjaquith/agency 1.11.0 → 2.0.0

package/src/commands/repo.test.ts

@@ -0,0 +1,80 @@
+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: add, link, list")
+	})
+
+	test("requires add arguments", async () => {
+		await expect(
+			runTestEffect(
+				repo({ subcommand: "add", args: ["agency"], silent: true }),
+			),
+		).rejects.toThrow("Usage: agency repo add")
+	})
+
+	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,
+				target: null,
+			},
+		])
+	})
+
+	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 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"),
+		})
+	})
+})

package/src/commands/repo.ts

@@ -0,0 +1,83 @@
+import { Effect } from "effect"
+import type { BaseCommandOptions } from "../utils/command"
+import { RepositoryService } from "../services/RepositoryService"
+import { createLoggers } from "../utils/effect"
+
+interface RepoOptions extends BaseCommandOptions {
+	readonly subcommand?: string
+	readonly args: readonly string[]
+	readonly json?: boolean
+}
+
+export const repo = (options: RepoOptions) =>
+	Effect.gen(function* () {
+		const repositories = yield* RepositoryService
+		const { log } = createLoggers(options)
+		const cwd = options.cwd ?? process.cwd()
+
+		switch (options.subcommand) {
+			case "add": {
+				const [alias, remote] = options.args
+				if (!alias || !remote) {
+					return yield* Effect.fail(
+						new Error("Usage: agency repo add <alias> <remote>"),
+					)
+				}
+				const path = yield* repositories.add(alias, remote, cwd)
+				log(
+					options.json
+						? JSON.stringify({ alias, path }, null, 2)
+						: `Added repository '${alias}'`,
+				)
+				return
+			}
+
+			case "link": {
+				const [alias, path] = options.args
+				if (!alias || !path) {
+					return yield* Effect.fail(
+						new Error("Usage: agency repo link <alias> <path>"),
+					)
+				}
+				const destination = yield* repositories.link(alias, path, cwd)
+				log(
+					options.json
+						? JSON.stringify({ alias, path: destination }, null, 2)
+						: `Linked repository '${alias}'`,
+				)
+				return
+			}
+
+			case "list": {
+				const items = yield* repositories.list(cwd)
+				if (options.json) {
+					log(JSON.stringify(items, null, 2))
+					return
+				}
+				for (const item of items) {
+					const detail = item.target ?? item.remote ?? item.path
+					log(`${item.alias}\t${item.kind}\t${detail}`)
+				}
+				return
+			}
+
+			default:
+				return yield* Effect.fail(
+					new Error(
+						"Subcommand is required. Available subcommands: add, link, list",
+					),
+				)
+		}
+	})
+
+export const help = `
+Usage: agency repo <subcommand>
+
+Subcommands:
+  add <alias> <remote>  Create a bare clone
+  link <alias> <path>   Link an existing Git repository
+  list                  List repository aliases
+
+Options:
+  --json                Output repository aliases as JSON
+`

package/src/commands/status.test.ts

@@ -1,489 +1,47 @@
-import { test, expect, describe, beforeEach, afterEach } from "bun:test"
-import { join } from "path"
-import { status } from "./status"
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { mkdir } from "node:fs/promises"
+import { join } from "node:path"
 import {
-	createTempDir,
+	captureLogs,
 	cleanupTempDir,
-	initGitRepo,
-	getCurrentBranch,
-	createCommit,
-	initAgency,
+	createTempDir,
 	runTestEffect,
 } from "../test-utils"
-import { writeAgencyMetadata } from "../types"
-
-async function createBranch(cwd: string, branchName: string): Promise<void> {
-	await Bun.spawn(["git", "checkout", "-b", branchName], {
-		cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-	}).exited
-}
-
-async function checkoutBranch(cwd: string, branchName: string): Promise<void> {
-	await Bun.spawn(["git", "checkout", branchName], {
-		cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-	}).exited
-}
+import { status } from "./status"
 
 describe("status command", () => {
-	let tempDir: string
-	let originalCwd: string
+	let root: string
 
 	beforeEach(async () => {
-		tempDir = await createTempDir()
-		originalCwd = process.cwd()
-		process.chdir(tempDir)
-
-		// Set config path to non-existent file to use defaults
-		process.env.AGENCY_CONFIG_PATH = join(tempDir, "non-existent-config.json")
-
-		// Initialize git repo
-		await initGitRepo(tempDir)
-		await createCommit(tempDir, "Initial commit")
-
-		// Rename to main if needed
-		const currentBranch = await getCurrentBranch(tempDir)
-		if (currentBranch === "master") {
-			await Bun.spawn(["git", "branch", "-m", "main"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-		}
-	})
-
-	afterEach(async () => {
-		process.chdir(originalCwd)
-		delete process.env.AGENCY_CONFIG_PATH
-		await cleanupTempDir(tempDir)
+		root = await createTempDir()
+		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
+		await mkdir(join(root, "repos/agency"), { recursive: true })
 	})
 
-	describe("basic functionality", () => {
-		test("shows not initialized when agency.json is missing", async () => {
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({}))
-
-			console.log = originalLog
-			expect(output).toContain("Not initialized")
-			expect(output).toContain("agency task")
-		})
-
-		test("shows initialized when agency.json exists", async () => {
-			// Initialize agency
-			await initAgency(tempDir, "test-template")
-
-			// Create feature branch with agency.json
-			await createBranch(tempDir, "feature")
-			await writeAgencyMetadata(tempDir, {
-				version: 1,
-				injectedFiles: ["AGENTS.md"],
-				template: "test-template",
-				createdAt: new Date().toISOString(),
-			} as any)
-
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({}))
-
-			console.log = originalLog
-			expect(output).toContain("Current branch:")
-			expect(output).toContain("Branch type: Source branch")
-			expect(output).toContain("Template:")
-		})
-
-		test("shows source branch type when on source branch", async () => {
-			await initAgency(tempDir, "test-template")
-			await createBranch(tempDir, "feature")
-			await writeAgencyMetadata(tempDir, {
-				version: 1,
-				injectedFiles: [],
-				template: "test-template",
-				createdAt: new Date().toISOString(),
-			} as any)
-
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({}))
-
-			console.log = originalLog
-			expect(output).toContain("Branch type:")
-			expect(output).toContain("Source branch")
-		})
-
-		test("shows emit branch type when on emit branch", async () => {
-			await initAgency(tempDir, "test-template")
-
-			// Create source branch with agency.json
-			await createBranch(tempDir, "agency--feature")
-			await writeAgencyMetadata(tempDir, {
-				version: 1,
-				injectedFiles: [],
-				template: "test-template",
-				emitBranch: "feature",
-				createdAt: new Date().toISOString(),
-			} as any)
-			// Stage and commit agency.json
-			await Bun.spawn(["git", "add", "agency.json"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Feature work")
-
-			// Create and switch to emit branch
-			await createBranch(tempDir, "feature")
-
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({}))
-
-			console.log = originalLog
-			expect(output).toContain("Branch type:")
-			expect(output).toContain("Emit branch")
-		})
-
-		test("shows corresponding branch when it exists", async () => {
-			await initAgency(tempDir, "test-template")
-			await createBranch(tempDir, "agency--feature")
-			await writeAgencyMetadata(tempDir, {
-				version: 1,
-				injectedFiles: [],
-				template: "test-template",
-				emitBranch: "feature",
-				createdAt: new Date().toISOString(),
-			} as any)
-
-			// Stage and commit agency.json
-			await Bun.spawn(["git", "add", "agency.json"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Set up branch")
-
-			// Create emit branch
-			await createBranch(tempDir, "feature")
-			await checkoutBranch(tempDir, "agency--feature")
-
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({}))
-
-			console.log = originalLog
-			expect(output).toContain("Emit branch: ")
-			expect(output).toContain("feature")
-		})
-
-		test("shows backpack files", async () => {
-			await initAgency(tempDir, "test-template")
-			await createBranch(tempDir, "feature")
-			await writeAgencyMetadata(tempDir, {
-				version: 1,
-				injectedFiles: ["AGENTS.md", "opencode.json"],
-				template: "test-template",
-				createdAt: new Date().toISOString(),
-			} as any)
-
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({}))
-
-			console.log = originalLog
-			expect(output).toContain("Backpack:")
-			// Base backpack files (TASK.md, AGENCY.md, agency.json) + injected files (AGENTS.md, opencode.json)
-			expect(output).toContain("TASK.md")
-			expect(output).toContain("AGENCY.md")
-			expect(output).toContain("agency.json")
-			expect(output).toContain("AGENTS.md")
-			expect(output).toContain("opencode.json")
-		})
-
-		test("shows base branch when set", async () => {
-			await initAgency(tempDir, "test-template")
-			await createBranch(tempDir, "feature")
-			await writeAgencyMetadata(tempDir, {
-				version: 1,
-				injectedFiles: [],
-				template: "test-template",
-				baseBranch: "main",
-				createdAt: new Date().toISOString(),
-			} as any)
-
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({}))
-
-			console.log = originalLog
-			expect(output).toContain("Base branch:")
-			expect(output).toContain("main")
-		})
-
-		test("shows template name", async () => {
-			await initAgency(tempDir, "my-custom-template")
-			await createBranch(tempDir, "feature")
-			await writeAgencyMetadata(tempDir, {
-				version: 1,
-				injectedFiles: [],
-				template: "my-custom-template",
-				createdAt: new Date().toISOString(),
-			} as any)
-
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({}))
-
-			console.log = originalLog
-			expect(output).toContain("Template:")
-			expect(output).toContain("my-custom-template")
-		})
-	})
-
-	describe("JSON output", () => {
-		test("outputs valid JSON with --json flag", async () => {
-			await initAgency(tempDir, "test-template")
-			await createBranch(tempDir, "feature")
-			await writeAgencyMetadata(tempDir, {
-				version: 1,
-				injectedFiles: ["AGENTS.md"],
-				baseBranch: "main",
-				template: "test-template",
-				createdAt: new Date().toISOString(),
-			} as any)
-
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({ json: true }))
-
-			console.log = originalLog
-
-			const data = JSON.parse(output.trim())
-			expect(data.initialized).toBe(true)
-			expect(data.branchType).toBe("source")
-			expect(data.currentBranch).toBe("feature")
-			expect(data.template).toBe("test-template")
-			// managedFiles includes base backpack files + injected files
-			expect(data.managedFiles).toContain("TASK.md")
-			expect(data.managedFiles).toContain("AGENCY.md")
-			expect(data.managedFiles).toContain("agency.json")
-			expect(data.managedFiles).toContain("AGENTS.md")
-			expect(data.baseBranch).toBe("main")
-		})
-
-		test("JSON output contains all expected fields", async () => {
-			await initAgency(tempDir, "test-template")
-			await createBranch(tempDir, "feature")
-			await writeAgencyMetadata(tempDir, {
-				version: 1,
-				injectedFiles: [],
-				template: "test-template",
-				createdAt: new Date().toISOString(),
-			} as any)
-
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({ json: true }))
-
-			console.log = originalLog
-
-			const data = JSON.parse(output.trim())
-			expect(data).toHaveProperty("initialized")
-			expect(data).toHaveProperty("branchType")
-			expect(data).toHaveProperty("currentBranch")
-			expect(data).toHaveProperty("sourceBranch")
-			expect(data).toHaveProperty("emitBranch")
-			expect(data).toHaveProperty("correspondingBranchExists")
-			expect(data).toHaveProperty("template")
-			expect(data).toHaveProperty("managedFiles")
-			expect(data).toHaveProperty("baseBranch")
-			expect(data).toHaveProperty("createdAt")
-		})
-
-		test("JSON output shows not initialized state", async () => {
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({ json: true }))
-
-			console.log = originalLog
-
-			const data = JSON.parse(output.trim())
-			expect(data.initialized).toBe(false)
-			expect(data.branchType).toBe("neither")
-		})
-	})
-
-	describe("error handling", () => {
-		test("throws error when not in a git repository", async () => {
-			const nonGitDir = await createTempDir()
-			process.chdir(nonGitDir)
-
-			await expect(runTestEffect(status({}))).rejects.toThrow(
-				"Not in a git repository",
-			)
-
-			await cleanupTempDir(nonGitDir)
-		})
-	})
-
-	describe("silent mode", () => {
-		test("silent flag suppresses output", async () => {
-			const originalLog = console.log
-			let logCalled = false
-			console.log = () => {
-				logCalled = true
-			}
-
-			await runTestEffect(status({ silent: true }))
-
-			console.log = originalLog
-			expect(logCalled).toBe(false)
-		})
-	})
-
-	describe("emit branch behavior", () => {
-		test("reads metadata from source branch when on emit branch without agency.json on disk", async () => {
-			await initAgency(tempDir, "test-template")
-
-			// Create source branch (agency--feature) with agency.json committed
-			await createBranch(tempDir, "agency--feature")
-			await writeAgencyMetadata(tempDir, {
-				version: 1,
-				injectedFiles: ["AGENTS.md", "opencode.json"],
-				template: "test-template",
-				baseBranch: "main",
-				emitBranch: "feature",
-				createdAt: new Date().toISOString(),
-			} as any)
-			// Stage and commit agency.json
-			await Bun.spawn(["git", "add", "agency.json"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Feature work")
-
-			// Create emit branch and remove agency.json from working tree
-			await createBranch(tempDir, "feature")
-			await Bun.spawn(["rm", "agency.json"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({ json: true }))
-
-			console.log = originalLog
-
-			const data = JSON.parse(output.trim())
-			// Verify that we're recognized as on an emit branch
-			expect(data.branchType).toBe("emit")
-			expect(data.initialized).toBe(true)
-			// Verify metadata is correctly read from source branch
-			expect(data.baseBranch).toBe("main")
-			expect(data.managedFiles).toContain("AGENTS.md")
-			expect(data.managedFiles).toContain("opencode.json")
-			expect(data.sourceBranch).toBe("agency--feature")
-		})
-
-		test("shows correct backpack when on emit branch", async () => {
-			await initAgency(tempDir, "test-template")
-
-			// Create source branch (agency--feature) with agency.json committed
-			await createBranch(tempDir, "agency--feature")
-			await writeAgencyMetadata(tempDir, {
-				version: 1,
-				injectedFiles: ["AGENTS.md"],
-				template: "test-template",
-				emitBranch: "feature",
-				createdAt: new Date().toISOString(),
-			} as any)
-			// Stage and commit agency.json
-			await Bun.spawn(["git", "add", "agency.json"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Feature work")
-
-			// Create emit branch and remove agency.json from disk to simulate clean emit branch
-			await createBranch(tempDir, "feature")
-			await Bun.spawn(["rm", "agency.json"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			let output = ""
-			const originalLog = console.log
-			console.log = (msg: string) => {
-				output += msg + "\n"
-			}
-
-			await runTestEffect(status({ json: true }))
-
-			console.log = originalLog
-
-			const data = JSON.parse(output.trim())
-			expect(data.branchType).toBe("emit")
-			expect(data.initialized).toBe(true)
-			// Backpack should include injected files from source branch
-			expect(data.managedFiles).toContain("AGENTS.md")
-			expect(data.managedFiles).toContain("TASK.md")
-			expect(data.managedFiles).toContain("AGENCY.md")
-			expect(data.managedFiles).toContain("agency.json")
-		})
+	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,
+				target: null,
+			},
+		])
 	})
 })