@markjaquith/agency 0.5.0

package/src/commands/clean.test.ts

@@ -0,0 +1,299 @@
+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)
+		})
+	})
+})

package/src/commands/clean.ts

@@ -0,0 +1,320 @@
+import { Effect } from "effect"
+import { Schema } from "@effect/schema"
+import type { BaseCommandOptions } from "../utils/command"
+import { GitService } from "../services/GitService"
+import { ConfigService } from "../services/ConfigService"
+import { AgencyMetadata } from "../schemas"
+import highlight, { done } from "../utils/colors"
+import { createLoggers, ensureGitRepo } from "../utils/effect"
+import { extractCleanBranch, makeSourceBranchName } from "../utils/pr-branch"
+
+interface CleanOptions extends BaseCommandOptions {
+	dryRun?: boolean
+	mergedInto?: string
+}
+
+/**
+ * Read agency.json metadata from a specific branch without checking it out.
+ * Uses `git show` to read the file contents directly.
+ */
+const readAgencyMetadata = (gitRoot: string, branch: string) =>
+	Effect.gen(function* () {
+		const git = yield* GitService
+
+		// Use git show to read agency.json from the branch without checking out
+		const content = yield* git.getFileAtRef(gitRoot, branch, "agency.json")
+
+		if (!content) {
+			return null
+		}
+
+		const data = yield* Effect.try({
+			try: () => JSON.parse(content),
+			catch: () => new Error("Failed to parse agency.json"),
+		})
+
+		// Validate version
+		if (typeof data.version !== "number" || data.version !== 1) {
+			return null
+		}
+
+		// Parse and validate using Effect schema
+		const metadata: AgencyMetadata | null = yield* Effect.try({
+			try: () => Schema.decodeUnknownSync(AgencyMetadata)(data),
+			catch: () => new Error("Invalid agency.json format"),
+		}).pipe(Effect.catchAll(() => Effect.succeed(null)))
+
+		return metadata
+	}).pipe(Effect.catchAll(() => Effect.succeed(null)))
+
+/**
+ * Get all local branches
+ */
+const getAllLocalBranches = (gitRoot: string) =>
+	Effect.gen(function* () {
+		const git = yield* GitService
+
+		// Get all local branches using git branch --format
+		const result = yield* git.runGitCommand(
+			["git", "branch", "--format=%(refname:short)"],
+			gitRoot,
+			{ captureOutput: true },
+		)
+
+		if (result.exitCode !== 0) {
+			return []
+		}
+
+		return result.stdout
+			.split("\n")
+			.map((line) => line.trim())
+			.filter((line) => line.length > 0)
+	}).pipe(Effect.catchAll(() => Effect.succeed([])))
+
+/**
+ * Get all branches that have been fully merged into the specified branch
+ */
+const getBranchesMergedInto = (
+	gitRoot: string,
+	targetBranch: string,
+	options: BaseCommandOptions,
+) =>
+	Effect.gen(function* () {
+		const git = yield* GitService
+		const { verboseLog } = createLoggers(options)
+
+		verboseLog(
+			`Finding branches merged into ${highlight.branch(targetBranch)}...`,
+		)
+
+		// Use git branch --merged to find all merged branches
+		const result = yield* git.runGitCommand(
+			["git", "branch", "--merged", targetBranch, "--format=%(refname:short)"],
+			gitRoot,
+			{ captureOutput: true },
+		)
+
+		if (result.exitCode !== 0) {
+			return []
+		}
+
+		const mergedBranches = result.stdout
+			.split("\n")
+			.map((line) => line.trim())
+			.filter((line) => line.length > 0)
+
+		verboseLog(`Found ${mergedBranches.length} merged branches`)
+		return mergedBranches
+	}).pipe(Effect.catchAll(() => Effect.succeed([])))
+
+/**
+ * Find source branches for the given branches (emit branches).
+ * For each branch, check if there's a corresponding source branch by:
+ * 1. Looking for branches with agency.json that has this branch as emitBranch
+ * 2. Using the source branch pattern from config
+ */
+const findSourceBranches = (
+	gitRoot: string,
+	branches: readonly string[],
+	sourcePattern: string,
+	emitPattern: string,
+	options: BaseCommandOptions,
+) =>
+	Effect.gen(function* () {
+		const git = yield* GitService
+		const { verboseLog } = createLoggers(options)
+
+		const allBranches = yield* getAllLocalBranches(gitRoot)
+		const sourceBranches: string[] = []
+
+		verboseLog(
+			`Looking for source branches for ${branches.length} emit branches...`,
+		)
+
+		// For each branch in our list, check if it's an emit branch and find its source
+		for (const branch of branches) {
+			// Strategy 1: Check all branches for agency.json with matching emitBranch
+			for (const candidateBranch of allBranches) {
+				if (candidateBranch === branch) continue
+
+				const metadata = yield* readAgencyMetadata(gitRoot, candidateBranch)
+
+				if (metadata?.emitBranch === branch) {
+					verboseLog(
+						`Found source branch ${highlight.branch(candidateBranch)} for emit branch ${highlight.branch(branch)}`,
+					)
+					if (!sourceBranches.includes(candidateBranch)) {
+						sourceBranches.push(candidateBranch)
+					}
+				}
+			}
+
+			// Strategy 2: Try using the source pattern
+			// If emitPattern is "%branch%", the branch name itself is the clean name
+			const cleanBranch =
+				emitPattern === "%branch%"
+					? branch
+					: extractCleanBranch(branch, emitPattern)
+
+			if (cleanBranch) {
+				const possibleSourceBranch = makeSourceBranchName(
+					cleanBranch,
+					sourcePattern,
+				)
+				const sourceExists = yield* git
+					.branchExists(gitRoot, possibleSourceBranch)
+					.pipe(Effect.catchAll(() => Effect.succeed(false)))
+
+				if (sourceExists && !sourceBranches.includes(possibleSourceBranch)) {
+					verboseLog(
+						`Found source branch ${highlight.branch(possibleSourceBranch)} via pattern matching`,
+					)
+					sourceBranches.push(possibleSourceBranch)
+				}
+			}
+		}
+
+		verboseLog(`Found ${sourceBranches.length} source branches`)
+		return sourceBranches
+	})
+
+export const clean = (options: CleanOptions = {}) =>
+	Effect.gen(function* () {
+		const { dryRun = false, mergedInto } = options
+		const { log, verboseLog } = createLoggers(options)
+
+		const git = yield* GitService
+		const configService = yield* ConfigService
+		const gitRoot = yield* ensureGitRepo()
+
+		// Require --merged-into flag
+		if (!mergedInto) {
+			return yield* Effect.fail(
+				new Error(
+					"The --merged-into flag is required. Specify which branch to check for merged branches (e.g., --merged-into main)",
+				),
+			)
+		}
+
+		// Verify the target branch exists
+		const targetExists = yield* git.branchExists(gitRoot, mergedInto)
+		if (!targetExists) {
+			return yield* Effect.fail(
+				new Error(
+					`Branch ${highlight.branch(mergedInto)} does not exist. Please specify a valid branch.`,
+				),
+			)
+		}
+
+		// Load config to get source and emit patterns
+		const config = yield* configService.loadConfig()
+		const sourcePattern = config.sourceBranchPattern || "agency/%branch%"
+		const emitPattern = config.emitBranch || "%branch%"
+
+		verboseLog(
+			`Using source pattern: ${sourcePattern}, emit pattern: ${emitPattern}`,
+		)
+
+		// Get all branches merged into target
+		const mergedBranches = yield* getBranchesMergedInto(
+			gitRoot,
+			mergedInto,
+			options,
+		)
+		verboseLog(
+			`Found ${mergedBranches.length} branches merged into ${highlight.branch(mergedInto)}`,
+		)
+
+		// Find source branches for the merged branches
+		const sourceBranches = yield* findSourceBranches(
+			gitRoot,
+			mergedBranches,
+			sourcePattern,
+			emitPattern,
+			options,
+		)
+
+		// Combine merged branches and their source branches
+		const branchesToDelete = [
+			...new Set([...mergedBranches, ...sourceBranches]),
+		]
+
+		// Filter out the target branch itself (we don't want to delete it)
+		const filteredBranches = branchesToDelete.filter(
+			(branch) => branch !== mergedInto,
+		)
+
+		if (filteredBranches.length === 0) {
+			log(
+				`No branches found that are merged into ${highlight.branch(mergedInto)}`,
+			)
+			return
+		}
+
+		// Show what will be deleted
+		const branchWord = filteredBranches.length === 1 ? "branch" : "branches"
+		log(
+			`Found ${filteredBranches.length} ${branchWord} to delete (merged into ${highlight.branch(mergedInto)}):`,
+		)
+		for (const branch of filteredBranches) {
+			log(`  ${highlight.branch(branch)}`)
+		}
+
+		if (dryRun) {
+			log("")
+			log("Dry-run mode: no branches were deleted")
+			return
+		}
+
+		// Get current branch to avoid deleting it
+		const currentBranch = yield* git.getCurrentBranch(gitRoot)
+
+		// Delete all branches
+		log("")
+		for (const branch of filteredBranches) {
+			// If we're currently on the branch, switch away first
+			if (currentBranch === branch) {
+				verboseLog(
+					`Currently on ${highlight.branch(branch)}, switching to ${highlight.branch(mergedInto)}`,
+				)
+				yield* git.checkoutBranch(gitRoot, mergedInto)
+			}
+
+			verboseLog(`Deleting ${highlight.branch(branch)}...`)
+			yield* git.deleteBranch(gitRoot, branch, true)
+		}
+
+		const deletedBranchWord =
+			filteredBranches.length === 1 ? "branch" : "branches"
+		log(done(`Deleted ${filteredBranches.length} ${deletedBranchWord}`))
+	})
+
+export const help = `
+Usage: agency clean --merged-into <branch> [options]
+
+Delete all branches that have been fully merged into a specified branch, 
+along with their corresponding source branches.
+
+This command is useful for cleaning up branches after they've been merged.
+It will:
+1. Find all branches fully merged into the specified branch
+2. Find the corresponding source branches (which won't show as merged due to emit filtering)
+3. Delete both the merged branches and their source branches
+
+The --merged-into flag is REQUIRED to prevent accidental deletion of branches.
+
+Options:
+  --merged-into <branch>  Branch to check against (e.g., main, origin/main) [REQUIRED]
+  --dry-run              Show what would be deleted without actually deleting
+
+Safety:
+  - By default, this command deletes branches
+  - Use --dry-run to preview what would be deleted without making changes
+  - If currently on a branch that will be deleted, switches to the target branch first
+  - Uses force delete (git branch -D) to ensure branches are deleted
+
+Examples:
+  agency clean --merged-into main           # Delete branches merged into main
+  agency clean --merged-into main --dry-run # Preview what would be deleted
+  agency clean --merged-into origin/main    # Delete branches merged into origin/main
+`