@markjaquith/agency 1.11.1 → 2.1.0

package/src/commands/base.test.ts

@@ -1,198 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test"
-import { base } from "./base"
-import {
-	createTempDir,
-	cleanupTempDir,
-	initGitRepo,
-	getGitConfig,
-	runTestEffect,
-} from "../test-utils"
-import { getBaseBranchFromMetadata, writeAgencyMetadata } from "../types"
-
-describe("base", () => {
-	let testDir: string
-	let originalCwd: string
-
-	beforeEach(async () => {
-		originalCwd = process.cwd()
-		testDir = await createTempDir()
-		await initGitRepo(testDir)
-		process.chdir(testDir)
-	})
-
-	afterEach(async () => {
-		process.chdir(originalCwd)
-		await cleanupTempDir(testDir)
-	})
-
-	describe("base set", () => {
-		test("sets base branch for current branch", async () => {
-			// Create a feature branch
-			await Bun.spawn(["git", "checkout", "-b", "feature"], {
-				cwd: testDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Create agency.json first
-			await writeAgencyMetadata(testDir, {
-				version: 1 as const,
-				template: "test",
-				injectedFiles: [],
-				createdAt: new Date().toISOString(),
-			} as any)
-
-			// Set base branch
-			await runTestEffect(
-				base({
-					subcommand: "set",
-					args: ["main"],
-					silent: true,
-				}),
-			)
-
-			// Verify it was saved
-			const savedBase = await getBaseBranchFromMetadata(testDir)
-			expect(savedBase).toBe("main")
-		})
-
-		test("sets repository-level default base branch", async () => {
-			// Set repo-level base branch
-			await runTestEffect(
-				base({
-					subcommand: "set",
-					args: ["main"],
-					repo: true,
-					silent: true,
-				}),
-			)
-
-			// Verify it was saved to git config
-			const savedBase = await getGitConfig("agency.baseBranch", testDir)
-			expect(savedBase).toBe("main")
-		})
-
-		test("throws error if base branch does not exist", async () => {
-			await expect(
-				runTestEffect(
-					base({
-						subcommand: "set",
-						args: ["nonexistent"],
-						silent: true,
-					}),
-				),
-			).rejects.toThrow("does not exist")
-		})
-	})
-
-	describe("base get", () => {
-		test("gets base branch for current branch", async () => {
-			// Create a feature branch
-			await Bun.spawn(["git", "checkout", "-b", "feature"], {
-				cwd: testDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Create agency.json with base branch
-			await writeAgencyMetadata(testDir, {
-				version: 1,
-				template: "test",
-				injectedFiles: [],
-				baseBranch: "main",
-				createdAt: new Date().toISOString(),
-			} as any)
-
-			// Mock console.log to capture output
-			const logs: string[] = []
-			const originalLog = console.log
-			console.log = (...args: any[]) => logs.push(args.join(" "))
-
-			try {
-				await runTestEffect(
-					base({
-						subcommand: "get",
-						args: [],
-						silent: false,
-					}),
-				)
-				expect(logs[0]).toBe("main")
-			} finally {
-				console.log = originalLog
-			}
-		})
-
-		test("throws error if no base branch configured", async () => {
-			// Create a feature branch
-			await Bun.spawn(["git", "checkout", "-b", "feature"], {
-				cwd: testDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Create agency.json without base branch
-			await writeAgencyMetadata(testDir, {
-				version: 1,
-				template: "test",
-				injectedFiles: [],
-				createdAt: new Date().toISOString(),
-			} as any)
-
-			await expect(
-				runTestEffect(
-					base({
-						subcommand: "get",
-						args: [],
-						silent: true,
-					}),
-				),
-			).rejects.toThrow("No base branch configured")
-		})
-	})
-
-	describe("base command", () => {
-		test("requires subcommand", async () => {
-			await expect(
-				runTestEffect(base({ args: [], silent: true })),
-			).rejects.toThrow("Subcommand is required")
-		})
-
-		test("handles 'set' subcommand", async () => {
-			await Bun.spawn(["git", "checkout", "-b", "feature"], {
-				cwd: testDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			await writeAgencyMetadata(testDir, {
-				version: 1,
-				template: "test",
-				injectedFiles: [],
-				createdAt: new Date().toISOString(),
-			} as any)
-
-			await runTestEffect(
-				base({
-					subcommand: "set",
-					args: ["main"],
-					silent: true,
-				}),
-			)
-
-			const savedBase = await getBaseBranchFromMetadata(testDir)
-			expect(savedBase).toBe("main")
-		})
-
-		test("throws error for unknown subcommand", async () => {
-			await expect(
-				runTestEffect(
-					base({
-						subcommand: "unknown",
-						args: [],
-						silent: true,
-					}),
-				),
-			).rejects.toThrow("Unknown subcommand")
-		})
-	})
-})

package/src/commands/base.ts

@@ -1,198 +0,0 @@
-import { Effect } from "effect"
-import { GitService } from "../services/GitService"
-import { setBaseBranchInMetadata, getBaseBranchFromMetadata } from "../types"
-import highlight, { done } from "../utils/colors"
-import {
-	createLoggers,
-	ensureGitRepo,
-	ensureBranchExists,
-} from "../utils/effect"
-
-interface BaseOptions {
-	subcommand?: string
-	args: string[]
-	repo?: boolean
-	silent?: boolean
-	verbose?: boolean
-}
-
-interface BaseSetOptions {
-	baseBranch: string
-	repo?: boolean
-	silent?: boolean
-	verbose?: boolean
-}
-
-interface BaseGetOptions {
-	repo?: boolean
-	silent?: boolean
-	verbose?: boolean
-}
-
-// Effect-based implementation
-const baseSetEffect = (options: BaseSetOptions) =>
-	Effect.gen(function* () {
-		const { baseBranch, repo = false } = options
-		const { log, verboseLog } = createLoggers(options)
-
-		const git = yield* GitService
-		const gitRoot = yield* ensureGitRepo()
-
-		// Validate that the base branch exists
-		yield* ensureBranchExists(
-			gitRoot,
-			baseBranch,
-			`Base branch ${highlight.branch(baseBranch)} does not exist. Please provide a valid branch name.`,
-		)
-
-		if (repo) {
-			// Set repository-level default base branch in git config
-			yield* git.setDefaultBaseBranchConfig(baseBranch, gitRoot)
-			log(
-				done(
-					`Set repository-level default base branch to ${highlight.branch(baseBranch)}`,
-				),
-			)
-		} else {
-			// Set branch-specific base branch in agency.json
-			const currentBranch = yield* git.getCurrentBranch(gitRoot)
-			verboseLog(`Current branch: ${highlight.branch(currentBranch)}`)
-
-			// Use Effect.tryPromise for metadata functions
-			yield* Effect.tryPromise({
-				try: () => setBaseBranchInMetadata(gitRoot, baseBranch),
-				catch: (error) =>
-					new Error(`Failed to set base branch in metadata: ${error}`),
-			})
-			log(
-				done(
-					`Set base branch to ${highlight.branch(baseBranch)} for ${highlight.branch(currentBranch)}`,
-				),
-			)
-		}
-	})
-
-// Effect-based implementation
-const baseGetEffect = (options: BaseGetOptions) =>
-	Effect.gen(function* () {
-		const { repo = false } = options
-		const { log, verboseLog } = createLoggers(options)
-
-		const git = yield* GitService
-		const gitRoot = yield* ensureGitRepo()
-
-		let currentBase: string | null
-
-		if (repo) {
-			// Get repository-level default base branch from git config
-			verboseLog("Reading repository-level default base branch from git config")
-			currentBase = yield* git.getDefaultBaseBranchConfig(gitRoot)
-
-			if (!currentBase) {
-				return yield* Effect.fail(
-					new Error(
-						"No repository-level base branch configured. Use 'agency base set --repo <branch>' to set one.",
-					),
-				)
-			}
-		} else {
-			// Get current branch
-			const currentBranch = yield* git.getCurrentBranch(gitRoot)
-			verboseLog(`Current branch: ${highlight.branch(currentBranch)}`)
-
-			// Get branch-specific base branch from agency.json
-			verboseLog("Reading branch-specific base branch from agency.json")
-			currentBase = yield* Effect.tryPromise({
-				try: () => getBaseBranchFromMetadata(gitRoot),
-				catch: (error) =>
-					new Error(`Failed to get base branch from metadata: ${error}`),
-			})
-
-			if (!currentBase) {
-				return yield* Effect.fail(
-					new Error(
-						`No base branch configured for ${highlight.branch(currentBranch)}. Use 'agency base set <branch>' to set one.`,
-					),
-				)
-			}
-		}
-
-		log(currentBase)
-	})
-
-export const base = (options: BaseOptions) =>
-	Effect.gen(function* () {
-		const {
-			subcommand,
-			args,
-			repo = false,
-			silent = false,
-			verbose = false,
-		} = options
-
-		if (!subcommand) {
-			return yield* Effect.fail(
-				new Error("Subcommand is required. Usage: agency base <subcommand>"),
-			)
-		}
-
-		switch (subcommand) {
-			case "set": {
-				if (!args[0]) {
-					return yield* Effect.fail(
-						new Error(
-							"Base branch argument is required. Usage: agency base set <branch>",
-						),
-					)
-				}
-				return yield* baseSetEffect({
-					baseBranch: args[0],
-					repo,
-					silent,
-					verbose,
-				})
-			}
-			case "get": {
-				return yield* baseGetEffect({
-					repo,
-					silent,
-					verbose,
-				})
-			}
-			default:
-				return yield* Effect.fail(
-					new Error(
-						`Unknown subcommand '${subcommand}'. Available subcommands: set, get`,
-					),
-				)
-		}
-	})
-
-export const help = `
-Usage: agency base <subcommand> [options]
-
-Get or set the base branch for the current feature branch.
-
-Subcommands:
-  set <branch>      Set the base branch for the current feature branch
-  get               Get the configured base branch
-
-Options:
-  --repo            Use repository-level default instead of branch-specific
-  -h, --help        Show this help message
-  -s, --silent      Suppress output messages
-  -v, --verbose     Show verbose output
-
-Examples:
-  agency base set origin/main          # Set base branch for current branch
-  agency base set --repo origin/main   # Set repository-level default for all branches
-  agency base get                      # Get branch-specific base branch
-  agency base get --repo               # Get repository-level default base branch
-
-Notes:
-  - The base branch must exist in the repository
-  - Branch-specific base branch is saved in agency.json (committed with the branch)
-  - Repository-level default is saved in .git/config (not committed)
-  - Branch-specific settings take precedence over repository-level defaults
-  - Base branch configuration is used by 'agency emit' when creating emit branches
-`

package/src/commands/clean.test.ts

@@ -1,299 +0,0 @@
-import { test, expect, describe, beforeEach, afterEach } from "bun:test"
-import { join } from "path"
-import { clean } from "./clean"
-import {
-	createTempDir,
-	cleanupTempDir,
-	initGitRepo,
-	initAgency,
-	getGitOutput,
-	getCurrentBranch,
-	createCommit,
-	checkoutBranch,
-	runTestEffect,
-} from "../test-utils"
-
-describe("clean 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")
-		// Set config dir to temp dir to avoid picking up user's config files
-		process.env.AGENCY_CONFIG_DIR = await createTempDir()
-
-		// Initialize git repo with main branch
-		await initGitRepo(tempDir)
-
-		// Initialize agency in main branch
-		await initAgency(tempDir, "test")
-	})
-
-	afterEach(async () => {
-		process.chdir(originalCwd)
-		delete process.env.AGENCY_CONFIG_PATH
-		if (process.env.AGENCY_CONFIG_DIR) {
-			await cleanupTempDir(process.env.AGENCY_CONFIG_DIR)
-			delete process.env.AGENCY_CONFIG_DIR
-		}
-		await cleanupTempDir(tempDir)
-	})
-
-	describe("--merged-into flag requirement", () => {
-		test("throws error when --merged-into flag is not provided", async () => {
-			expect(runTestEffect(clean({ silent: true }))).rejects.toThrow(
-				"--merged-into flag is required",
-			)
-		})
-
-		test("throws error when specified branch does not exist", async () => {
-			expect(
-				runTestEffect(clean({ mergedInto: "nonexistent", silent: true })),
-			).rejects.toThrow("does not exist")
-		})
-	})
-
-	describe("basic functionality", () => {
-		test("finds and deletes branches merged into target", async () => {
-			// Create feature branch, make commits, and merge to main
-			await checkoutBranch(tempDir, "main")
-			await Bun.spawn(["git", "checkout", "-b", "feature-1"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Feature 1 commit")
-			await checkoutBranch(tempDir, "main")
-			await Bun.spawn(["git", "merge", "--no-ff", "feature-1"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Run clean command
-			await runTestEffect(clean({ mergedInto: "main", silent: true }))
-
-			// Verify feature-1 was deleted
-			const branches = await getGitOutput(tempDir, ["branch", "--list"])
-			expect(branches).not.toContain("feature-1")
-			expect(branches).toContain("main")
-		})
-
-		test("finds source branches for merged emit branches", async () => {
-			// Create source branch with agency pattern
-			await checkoutBranch(tempDir, "main")
-			await Bun.spawn(["git", "checkout", "-b", "agency--feature-2"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Create agency.json with emitBranch
-			await Bun.write(
-				join(tempDir, "agency.json"),
-				JSON.stringify({
-					version: 1,
-					injectedFiles: ["AGENTS.md"],
-					template: "test",
-					emitBranch: "feature-2",
-					createdAt: new Date().toISOString(),
-				}),
-			)
-			await Bun.spawn(["git", "add", "agency.json"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Feature 2 commit")
-
-			// Create the emit branch manually
-			await Bun.spawn(["git", "checkout", "-b", "feature-2"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Merge emit branch to main
-			await checkoutBranch(tempDir, "main")
-			await Bun.spawn(["git", "merge", "--no-ff", "feature-2"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Run clean command
-			await runTestEffect(clean({ mergedInto: "main", silent: true }))
-
-			// Verify both emit and source branches were deleted
-			const branches = await getGitOutput(tempDir, ["branch", "--list"])
-			expect(branches).not.toContain("feature-2")
-			expect(branches).not.toContain("agency--feature-2")
-			expect(branches).toContain("main")
-		})
-
-		test("does not delete unmerged branches", async () => {
-			// Create an unmerged feature branch
-			await checkoutBranch(tempDir, "main")
-			await Bun.spawn(["git", "checkout", "-b", "feature-unmerged"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Unmerged commit")
-
-			// Run clean command
-			await checkoutBranch(tempDir, "main")
-			await runTestEffect(clean({ mergedInto: "main", silent: true }))
-
-			// Verify unmerged branch still exists
-			const branches = await getGitOutput(tempDir, ["branch", "--list"])
-			expect(branches).toContain("feature-unmerged")
-		})
-
-		test("does not delete the target branch itself", async () => {
-			// Run clean on main (nothing should happen)
-			await checkoutBranch(tempDir, "main")
-			await runTestEffect(clean({ mergedInto: "main", silent: true }))
-
-			// Verify main still exists
-			const branches = await getGitOutput(tempDir, ["branch", "--list"])
-			expect(branches).toContain("main")
-		})
-	})
-
-	describe("dry-run mode", () => {
-		test("shows branches without deleting in dry-run mode", async () => {
-			// Create and merge feature branch
-			await checkoutBranch(tempDir, "main")
-			await Bun.spawn(["git", "checkout", "-b", "feature-dry"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Feature dry commit")
-			await checkoutBranch(tempDir, "main")
-			await Bun.spawn(["git", "merge", "--no-ff", "feature-dry"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Run clean in dry-run mode
-			await runTestEffect(
-				clean({ mergedInto: "main", dryRun: true, silent: true }),
-			)
-
-			// Verify branch still exists
-			const branches = await getGitOutput(tempDir, ["branch", "--list"])
-			expect(branches).toContain("feature-dry")
-		})
-	})
-
-	describe("branch switching", () => {
-		test("switches away from branch being deleted if currently on it", async () => {
-			// Create and merge feature branch
-			await checkoutBranch(tempDir, "main")
-			await Bun.spawn(["git", "checkout", "-b", "feature-switch"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Feature switch commit")
-			await checkoutBranch(tempDir, "main")
-			await Bun.spawn(["git", "merge", "--no-ff", "feature-switch"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Checkout the branch that will be deleted
-			await checkoutBranch(tempDir, "feature-switch")
-
-			// Run clean command
-			await runTestEffect(clean({ mergedInto: "main", silent: true }))
-
-			// Verify we're now on main
-			const currentBranch = await getCurrentBranch(tempDir)
-			expect(currentBranch).toBe("main")
-
-			// Verify branch was deleted
-			const branches = await getGitOutput(tempDir, ["branch", "--list"])
-			expect(branches).not.toContain("feature-switch")
-		})
-	})
-
-	describe("multiple branches", () => {
-		test("deletes multiple merged branches at once", async () => {
-			await checkoutBranch(tempDir, "main")
-
-			// Create and merge feature-1
-			await Bun.spawn(["git", "checkout", "-b", "feature-1"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Feature 1 commit")
-			await checkoutBranch(tempDir, "main")
-			await Bun.spawn(["git", "merge", "--no-ff", "feature-1"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Create and merge feature-2
-			await Bun.spawn(["git", "checkout", "-b", "feature-2"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Feature 2 commit")
-			await checkoutBranch(tempDir, "main")
-			await Bun.spawn(["git", "merge", "--no-ff", "feature-2"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Run clean command
-			await runTestEffect(clean({ mergedInto: "main", silent: true }))
-
-			// Verify both branches were deleted
-			const branches = await getGitOutput(tempDir, ["branch", "--list"])
-			expect(branches).not.toContain("feature-1")
-			expect(branches).not.toContain("feature-2")
-			expect(branches).toContain("main")
-		})
-	})
-
-	describe("no merged branches", () => {
-		test("handles case with no merged branches gracefully", async () => {
-			// Don't create any feature branches, just run clean
-			await checkoutBranch(tempDir, "main")
-
-			// Should not throw
-			await runTestEffect(clean({ mergedInto: "main", silent: true }))
-
-			// Main should still exist
-			const branches = await getGitOutput(tempDir, ["branch", "--list"])
-			expect(branches).toContain("main")
-		})
-	})
-
-	describe("error handling", () => {
-		test("throws error when not in a git repository", async () => {
-			const nonGitDir = await createTempDir()
-			process.chdir(nonGitDir)
-
-			expect(
-				runTestEffect(clean({ mergedInto: "main", silent: true })),
-			).rejects.toThrow("Not in a git repository")
-
-			await cleanupTempDir(nonGitDir)
-		})
-	})
-})