@markjaquith/agency 0.5.0

package/src/commands/emitted.test.ts

@@ -0,0 +1,226 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import { join } from "path"
+import { emitted } from "./emitted"
+import {
+	createTempDir,
+	cleanupTempDir,
+	initGitRepo,
+	getCurrentBranch,
+	createCommit,
+	checkoutBranch,
+	runTestEffect,
+} from "../test-utils"
+
+async function createBranch(cwd: string, branchName: string): Promise<void> {
+	await Bun.spawn(["git", "checkout", "-b", branchName], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	}).exited
+}
+
+describe("emitted command", () => {
+	let tempDir: string
+	let originalCwd: 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)
+	})
+
+	describe("basic functionality", () => {
+		test("returns emit branch name when on source branch", async () => {
+			// Create source branch (agency/main)
+			await createBranch(tempDir, "agency/main")
+			await createCommit(tempDir, "Work on source")
+
+			// Capture output
+			const originalLog = console.log
+			let capturedOutput = ""
+			console.log = (msg: string) => {
+				capturedOutput = msg
+			}
+
+			await runTestEffect(emitted({ silent: false }))
+
+			console.log = originalLog
+			expect(capturedOutput).toBe("main")
+		})
+
+		test("returns emit branch name when on emit branch", async () => {
+			// Create source branch
+			await createBranch(tempDir, "agency/main")
+			await createCommit(tempDir, "Work on source")
+
+			// Switch to emit branch (main)
+			await checkoutBranch(tempDir, "main")
+
+			// Capture output
+			const originalLog = console.log
+			let capturedOutput = ""
+			console.log = (msg: string) => {
+				capturedOutput = msg
+			}
+
+			await runTestEffect(emitted({ silent: false }))
+
+			console.log = originalLog
+			expect(capturedOutput).toBe("main")
+		})
+
+		test("returns emit branch with custom pattern", async () => {
+			// Create custom config
+			const configPath = join(tempDir, "custom-config.json")
+			await Bun.write(
+				configPath,
+				JSON.stringify({
+					sourceBranchPattern: "agency/%branch%",
+					emitBranch: "%branch%--PR",
+				}),
+			)
+			process.env.AGENCY_CONFIG_PATH = configPath
+
+			// Create source branch
+			await createBranch(tempDir, "agency/feature")
+			await createCommit(tempDir, "Feature work")
+
+			// Capture output
+			const originalLog = console.log
+			let capturedOutput = ""
+			console.log = (msg: string) => {
+				capturedOutput = msg
+			}
+
+			await runTestEffect(emitted({ silent: false }))
+
+			console.log = originalLog
+			expect(capturedOutput).toBe("feature--PR")
+		})
+
+		test("returns emit branch from agency.json when present", async () => {
+			// Create source branch
+			await createBranch(tempDir, "agency/feature")
+
+			// Create agency.json with custom emitBranch
+			const agencyJsonPath = join(tempDir, "agency.json")
+			await Bun.write(
+				agencyJsonPath,
+				JSON.stringify({
+					version: 1,
+					injectedFiles: [],
+					template: "test-template",
+					createdAt: new Date().toISOString(),
+					emitBranch: "custom-emit-name",
+				}),
+			)
+
+			// Commit the agency.json file so it's available on the branch
+			await Bun.spawn(["git", "add", "agency.json"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+			await createCommit(tempDir, "Add agency.json")
+
+			// Capture output
+			const originalLog = console.log
+			let capturedOutput = ""
+			console.log = (msg: string) => {
+				capturedOutput = msg
+			}
+
+			await runTestEffect(emitted({ silent: false }))
+
+			console.log = originalLog
+			expect(capturedOutput).toBe("custom-emit-name")
+		})
+
+		test("works with legacy branch names", async () => {
+			// On a branch that doesn't match the source pattern
+			// Should treat it as a legacy branch and apply emit pattern
+			await createBranch(tempDir, "feature-foo")
+
+			// Capture output
+			const originalLog = console.log
+			let capturedOutput = ""
+			console.log = (msg: string) => {
+				capturedOutput = msg
+			}
+
+			await runTestEffect(emitted({ silent: false }))
+
+			console.log = originalLog
+			// With default pattern "%branch%", emit should be the same as clean branch
+			expect(capturedOutput).toBe("feature-foo")
+		})
+	})
+
+	describe("silent mode", () => {
+		test("still outputs when not in silent mode", async () => {
+			await createBranch(tempDir, "agency/main")
+
+			const originalLog = console.log
+			let logCalled = false
+			console.log = () => {
+				logCalled = true
+			}
+
+			await runTestEffect(emitted({ silent: false }))
+
+			console.log = originalLog
+			expect(logCalled).toBe(true)
+		})
+
+		test("silent flag suppresses output", async () => {
+			await createBranch(tempDir, "agency/main")
+
+			const originalLog = console.log
+			let logCalled = false
+			console.log = () => {
+				logCalled = true
+			}
+
+			await runTestEffect(emitted({ silent: true }))
+
+			console.log = originalLog
+			expect(logCalled).toBe(false)
+		})
+	})
+
+	describe("error handling", () => {
+		test("throws error when not in a git repository", async () => {
+			const nonGitDir = await createTempDir()
+			process.chdir(nonGitDir)
+
+			await expect(runTestEffect(emitted({ silent: true }))).rejects.toThrow(
+				"Not in a git repository",
+			)
+
+			await cleanupTempDir(nonGitDir)
+		})
+	})
+})

package/src/commands/emitted.ts

@@ -0,0 +1,57 @@
+import { Effect } from "effect"
+import type { BaseCommandOptions } from "../utils/command"
+import { GitService } from "../services/GitService"
+import { ConfigService } from "../services/ConfigService"
+import {
+	resolveBranchPairWithAgencyJson,
+	type BranchPair,
+} from "../utils/pr-branch"
+import { createLoggers, ensureGitRepo } from "../utils/effect"
+
+interface EmittedOptions extends BaseCommandOptions {}
+
+export const emitted = (options: EmittedOptions = {}) =>
+	Effect.gen(function* () {
+		const { log } = createLoggers(options)
+
+		const git = yield* GitService
+		const configService = yield* ConfigService
+
+		const gitRoot = yield* ensureGitRepo()
+
+		// Load config
+		const config = yield* configService.loadConfig()
+
+		// Get current branch and resolve the branch pair
+		const currentBranch = yield* git.getCurrentBranch(gitRoot)
+		const branches: BranchPair = yield* resolveBranchPairWithAgencyJson(
+			gitRoot,
+			currentBranch,
+			config.sourceBranchPattern,
+			config.emitBranch,
+		)
+
+		// Return the emit branch name (whether we're on it or not)
+		log(branches.emitBranch)
+	})
+
+export const help = `
+Usage: agency emitted [options]
+
+Get the name of the emitted branch (or what it would be).
+
+This command shows the emit branch name corresponding to your current branch:
+  - If on a source branch (e.g., agency/main), shows the emit branch (e.g., main)
+  - If on an emit branch (e.g., main), shows the current branch name
+
+This is useful for scripting and automation where you need to know
+the emit branch name without actually creating or switching to it.
+
+Example:
+  agency emitted                  # Show the emit branch name
+
+Notes:
+  - Does not require the emit branch to exist
+  - Uses source and emit patterns from ~/.config/agency/agency.json
+  - Respects emitBranch field in agency.json when present
+`

package/src/commands/init.test.ts

@@ -0,0 +1,311 @@
+import { test, expect, describe } from "bun:test"
+import { mkdtemp, rm } from "fs/promises"
+import { tmpdir } from "os"
+import { join } from "path"
+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 })
+		}
+	})
+
+	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 })
+		}
+	})
+
+	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 })
+		}
+	})
+
+	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("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 })
+		}
+	})
+
+	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("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 })
+		}
+	})
+
+	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("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 })
+		}
+	})
+
+	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("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 })
+		}
+	})
+})