@markjaquith/agency 1.1.1 → 1.3.0

package/src/commands/emit.test.ts

@@ -15,8 +15,10 @@ import {
 	createBranch,
 	addAndCommit,
 	setupRemote,
-	renameBranch,
 	runTestEffect,
+	runTestEffectWithMockFilterRepo,
+	clearCapturedFilterRepoCalls,
+	getLastCapturedFilterRepoCall,
 } from "../test-utils"
 
 // Cache the git-filter-repo availability check (it doesn't change during test run)
@@ -36,7 +38,6 @@ async function checkGitFilterRepo(): Promise<boolean> {
 describe("emit command", () => {
 	let tempDir: string
 	let originalCwd: string
-	let hasGitFilterRepo: boolean
 
 	beforeEach(async () => {
 		tempDir = await createTempDir()
@@ -48,9 +49,6 @@ describe("emit command", () => {
 		// Set config dir to temp dir to avoid picking up user's config files
 		process.env.AGENCY_CONFIG_DIR = await createTempDir()
 
-		// Check if git-filter-repo is available (cached)
-		hasGitFilterRepo = await checkGitFilterRepo()
-
 		// Initialize git repo with main branch (already includes initial commit)
 		await initGitRepo(tempDir)
 
@@ -79,6 +77,7 @@ describe("emit command", () => {
 
 	describe("basic functionality", () => {
 		test("throws error when git-filter-repo is not installed", async () => {
+			const hasGitFilterRepo = await checkGitFilterRepo()
 			if (hasGitFilterRepo) {
 				// Skip this test if git-filter-repo IS installed
 				return
@@ -245,159 +244,48 @@ describe("emit command", () => {
 		})
 	})
 
-	// Integration tests that actually run git-filter-repo to verify filtering behavior
-	// These are slower but ensure the filtering logic works correctly
-	describe("filtering integration (requires git-filter-repo)", () => {
-		test("filters AGENTS.md from emit branch", async () => {
-			if (!hasGitFilterRepo) {
-				console.log("Skipping test: git-filter-repo not installed")
-				return
-			}
+	describe("error handling", () => {
+		test("throws error when not in a git repository", async () => {
+			const nonGitDir = await createTempDir()
+			process.chdir(nonGitDir)
 
-			// Go back to main and create a fresh source branch
-			await checkoutBranch(tempDir, "main")
-			await createBranch(tempDir, "agency/feature")
-			// Create agency.json with AGENTS.md as managed file
-			await Bun.write(
-				join(tempDir, "agency.json"),
-				JSON.stringify({
-					version: 1,
-					injectedFiles: ["AGENTS.md"],
-					template: "test",
-					createdAt: new Date().toISOString(),
-				}),
+			expect(runTestEffect(emit({ silent: true }))).rejects.toThrow(
+				"Not in a git repository",
 			)
-			await Bun.write(join(tempDir, "AGENTS.md"), "# Test AGENTS\n")
-			await addAndCommit(tempDir, "agency.json AGENTS.md", "Add agency files")
-			// Also create a test.txt file via createCommit
-			await createCommit(tempDir, "Feature commit")
-
-			// Create emit branch (this runs git-filter-repo)
-			await runTestEffect(emit({ silent: true }))
 
-			// Should still be on feature branch
-			const currentBranch = await getCurrentBranch(tempDir)
-			expect(currentBranch).toBe("agency/feature")
-
-			// Switch to emit branch to verify files
-			await checkoutBranch(tempDir, "feature")
-
-			// AGENTS.md should be filtered out
-			const files = await getGitOutput(tempDir, ["ls-files"])
-			expect(files).not.toContain("AGENTS.md")
-			expect(files).not.toContain("AGENCY.md")
-
-			// But test.txt should still exist
-			expect(files).toContain("test.txt")
+			await cleanupTempDir(nonGitDir)
 		})
+	})
 
-		test("handles emit branch recreation after source branch rebase", async () => {
-			if (!hasGitFilterRepo) {
-				console.log("Skipping test: git-filter-repo not installed")
-				return
-			}
-
-			// We're on test-feature which has AGENTS.md
-			// Add a feature-specific file to avoid conflicts
-			await Bun.write(join(tempDir, "feature.txt"), "feature content\n")
-			await addAndCommit(tempDir, "feature.txt", "Add feature file")
-
-			// Store merge-base before advancing main
-			const initialMergeBase = await getGitOutput(tempDir, [
-				"merge-base",
-				"agency/test-feature",
-				"main",
-			])
-
-			// Create initial emit branch
-			await runTestEffect(emit({ silent: true, baseBranch: "main" }))
-
-			// Should still be on test-feature branch
-			let currentBranch = await getCurrentBranch(tempDir)
-			expect(currentBranch).toBe("agency/test-feature")
-
-			// Switch to emit branch to verify AGENTS.md is filtered
-			await checkoutBranch(tempDir, "test-feature")
-
-			let files = await getGitOutput(tempDir, ["ls-files"])
-			expect(files).not.toContain("AGENTS.md")
-			expect(files).toContain("feature.txt")
-
-			// Switch back to source branch
-			await checkoutBranch(tempDir, "agency/test-feature")
-
-			// Simulate advancing main branch with a different file
-			await checkoutBranch(tempDir, "main")
-			await Bun.write(join(tempDir, "main-file.txt"), "main content\n")
-			await addAndCommit(tempDir, "main-file.txt", "Main branch advancement")
-
-			// Rebase test-feature onto new main
-			await checkoutBranch(tempDir, "agency/test-feature")
-			const rebaseProc = Bun.spawn(["git", "rebase", "main"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			})
-			await rebaseProc.exited
-			if (rebaseProc.exitCode !== 0) {
-				const stderr = await new Response(rebaseProc.stderr).text()
-				throw new Error(`Rebase failed: ${stderr}`)
-			}
-
-			// Verify merge-base has changed after rebase
-			const newMergeBase = await getGitOutput(tempDir, [
-				"merge-base",
-				"agency/test-feature",
-				"main",
-			])
-			expect(newMergeBase.trim()).not.toBe(initialMergeBase.trim())
-
-			// Recreate emit branch after rebase (this is where the bug would manifest)
-			await runTestEffect(emit({ silent: true, baseBranch: "main" }))
+	describe("silent mode", () => {
+		test("silent flag suppresses output", async () => {
+			await createBranch(tempDir, "agency/feature")
+			await createCommit(tempDir, "Feature commit")
 
-			// Should still be on test-feature branch
-			currentBranch = await getCurrentBranch(tempDir)
-			expect(currentBranch).toBe("agency/test-feature")
+			const logs: string[] = []
+			const originalLog = console.log
+			console.log = (...args: any[]) => logs.push(args.join(" "))
 
-			// Switch to emit branch to verify files
-			await checkoutBranch(tempDir, "test-feature")
+			// Skip filter for speed
+			await runTestEffect(emit({ silent: true, skipFilter: true }))
 
-			// Verify AGENTS.md is still filtered and no extraneous changes
-			files = await getGitOutput(tempDir, ["ls-files"])
-			expect(files).not.toContain("AGENTS.md")
-			expect(files).toContain("feature.txt")
-			expect(files).toContain("main-file.txt") // Should have main's file after rebase
+			console.log = originalLog
 
-			// Verify that our feature commits exist but AGENTS.md commit is filtered
-			const logOutput = await getGitOutput(tempDir, [
-				"log",
-				"--oneline",
-				"main..test-feature",
-			])
-			expect(logOutput).toContain("Add feature file")
-			expect(logOutput).not.toContain("Add AGENTS.md")
+			expect(logs.length).toBe(0)
 		})
+	})
 
-		test("filters pre-existing CLAUDE.md that gets edited by agency", async () => {
-			if (!hasGitFilterRepo) {
-				console.log("Skipping test: git-filter-repo not installed")
-				return
-			}
+	describe("filter-repo command construction (with mock)", () => {
+		beforeEach(() => {
+			clearCapturedFilterRepoCalls()
+		})
 
-			// Start fresh on main branch
+		test("constructs correct filter-repo arguments", async () => {
+			// Set up fresh branch with agency.json
 			await checkoutBranch(tempDir, "main")
+			await createBranch(tempDir, "agency/filter-test")
 
-			// Create CLAUDE.md on main branch (simulating pre-existing file)
-			await Bun.write(
-				join(tempDir, "CLAUDE.md"),
-				"# Original Claude Instructions\n\nSome content here.\n",
-			)
-			await addAndCommit(tempDir, "CLAUDE.md", "Add CLAUDE.md")
-
-			// Create a new feature branch
-			await createBranch(tempDir, "agency/claude-test")
-
-			// Initialize agency on this branch (this will modify CLAUDE.md)
+			// Create agency.json with injected files
 			await Bun.write(
 				join(tempDir, "agency.json"),
 				JSON.stringify({
@@ -407,76 +295,33 @@ describe("emit command", () => {
 					createdAt: new Date().toISOString(),
 				}),
 			)
-			await Bun.write(join(tempDir, "AGENTS.md"), "# Test AGENTS\n")
-
-			// Simulate what agency task does - inject into CLAUDE.md
-			const originalClaude = await Bun.file(join(tempDir, "CLAUDE.md")).text()
-			const modifiedClaude = `${originalClaude}\n# Agency References\n@AGENTS.md\n@TASK.md\n`
-			await Bun.write(join(tempDir, "CLAUDE.md"), modifiedClaude)
-
-			await addAndCommit(
-				tempDir,
-				"agency.json AGENTS.md CLAUDE.md",
-				"Initialize agency files",
-			)
-
-			// Add a feature file
-			await createCommit(tempDir, "Feature commit")
-
-			// Create emit branch (this should filter CLAUDE.md)
-			await runTestEffect(emit({ silent: true, baseBranch: "main" }))
-
-			// Should still be on source branch
-			const currentBranch = await getCurrentBranch(tempDir)
-			expect(currentBranch).toBe("agency/claude-test")
-
-			// Switch to emit branch to verify CLAUDE.md is reverted to main's version
-			await checkoutBranch(tempDir, "claude-test")
-
-			const files = await getGitOutput(tempDir, ["ls-files"])
-			expect(files).toContain("CLAUDE.md") // File should exist (from main)
-			expect(files).not.toContain("AGENTS.md") // Should be filtered
-			expect(files).not.toContain("TASK.md") // Should be filtered
-			expect(files).toContain("test.txt") // Feature file should exist
-
-			// Verify CLAUDE.md was reverted to original (no agency references)
-			const claudeContent = await Bun.file(join(tempDir, "CLAUDE.md")).text()
-			expect(claudeContent).toBe(
-				"# Original Claude Instructions\n\nSome content here.\n",
-			)
-			expect(claudeContent).not.toContain("@AGENTS.md")
-			expect(claudeContent).not.toContain("@TASK.md")
-		})
-	})
+			await addAndCommit(tempDir, "agency.json", "Add agency.json")
 
-	describe("error handling", () => {
-		test("throws error when not in a git repository", async () => {
-			const nonGitDir = await createTempDir()
-			process.chdir(nonGitDir)
-
-			expect(runTestEffect(emit({ silent: true }))).rejects.toThrow(
-				"Not in a git repository",
-			)
-
-			await cleanupTempDir(nonGitDir)
-		})
-	})
+			// Run emit with mock filter-repo (not skipFilter!)
+			await runTestEffectWithMockFilterRepo(emit({ silent: true }))
 
-	describe("silent mode", () => {
-		test("silent flag suppresses output", async () => {
-			await createBranch(tempDir, "agency/feature")
-			await createCommit(tempDir, "Feature commit")
+			// Verify filter-repo was called with correct arguments
+			const lastCall = getLastCapturedFilterRepoCall()
+			expect(lastCall).toBeDefined()
 
-			const logs: string[] = []
-			const originalLog = console.log
-			console.log = (...args: any[]) => logs.push(args.join(" "))
+			// Should include paths for base files (TASK.md, AGENCY.md, CLAUDE.md, agency.json)
+			// and injected files (AGENTS.md)
+			expect(lastCall!.args).toContain("--path")
+			expect(lastCall!.args).toContain("TASK.md")
+			expect(lastCall!.args).toContain("AGENCY.md")
+			expect(lastCall!.args).toContain("CLAUDE.md")
+			expect(lastCall!.args).toContain("agency.json")
+			expect(lastCall!.args).toContain("AGENTS.md")
 
-			// Skip filter for speed
-			await runTestEffect(emit({ silent: true, skipFilter: true }))
+			// Should include invert-paths and force flags
+			expect(lastCall!.args).toContain("--invert-paths")
+			expect(lastCall!.args).toContain("--force")
 
-			console.log = originalLog
+			// Should include refs for the commit range
+			expect(lastCall!.args).toContain("--refs")
 
-			expect(logs.length).toBe(0)
+			// Should have GIT_CONFIG_GLOBAL env set
+			expect(lastCall!.env?.GIT_CONFIG_GLOBAL).toBe("")
 		})
 	})
 })

package/src/commands/emit.ts

@@ -3,6 +3,7 @@ import type { BaseCommandOptions } from "../utils/command"
 import { GitService } from "../services/GitService"
 import { ConfigService } from "../services/ConfigService"
 import { FileSystemService } from "../services/FileSystemService"
+import { FilterRepoService } from "../services/FilterRepoService"
 import {
 	makeEmitBranchName,
 	makeSourceBranchName,
@@ -49,9 +50,10 @@ const emitCore = (gitRoot: string, options: EmitOptions) =>
 		const git = yield* GitService
 		const configService = yield* ConfigService
 		const fs = yield* FileSystemService
+		const filterRepo = yield* FilterRepoService
 
 		// Check if git-filter-repo is installed
-		const hasFilterRepo = yield* git.checkCommandExists("git-filter-repo")
+		const hasFilterRepo = yield* filterRepo.isInstalled()
 		if (!hasFilterRepo) {
 			const isMac = process.platform === "darwin"
 			const installInstructions = isMac
@@ -197,8 +199,6 @@ const emitCore = (gitRoot: string, options: EmitOptions) =>
 
 			// Run git-filter-repo
 			const filterRepoArgs = [
-				"git",
-				"filter-repo",
 				...filesToFilter.flatMap((f) => ["--path", f]),
 				"--invert-paths",
 				"--force",
@@ -206,19 +206,12 @@ const emitCore = (gitRoot: string, options: EmitOptions) =>
 				`${forkPoint}..${emitBranchName}`,
 			]
 
-			const result = yield* git.runGitCommand(filterRepoArgs, gitRoot, {
+			yield* filterRepo.run(gitRoot, filterRepoArgs, {
 				env: { GIT_CONFIG_GLOBAL: "" },
-				captureOutput: true,
 			})
 
 			verboseLog("git-filter-repo completed")
 
-			if (result.exitCode !== 0) {
-				return yield* Effect.fail(
-					new Error(`git-filter-repo failed: ${result.stderr}`),
-				)
-			}
-
 			// Switch back to source branch (git-filter-repo may have checked out the emit branch)
 			yield* git.checkoutBranch(gitRoot, currentBranch)
 		})
@@ -326,26 +319,6 @@ const getRemoteTrackingBranch = (
 		return null
 	})
 
-/**
- * Check if one commit is an ancestor of another.
- */
-const isAncestor = (
-	git: GitService,
-	gitRoot: string,
-	potentialAncestor: string,
-	commit: string,
-) =>
-	git
-		.runGitCommand(
-			["git", "merge-base", "--is-ancestor", potentialAncestor, commit],
-			gitRoot,
-			{},
-		)
-		.pipe(
-			Effect.map((result) => result.exitCode === 0),
-			Effect.catchAll(() => Effect.succeed(false)),
-		)
-
 /**
  * Find the best fork point by checking both local and remote tracking branches.
  *
@@ -399,8 +372,7 @@ const findBestForkPoint = (
 
 		// Strategy 3: Choose the more recent fork point
 		// If local fork point is an ancestor of remote, prefer remote (it's more recent)
-		const localIsAncestorOfRemote = yield* isAncestor(
-			git,
+		const localIsAncestorOfRemote = yield* git.isAncestor(
 			gitRoot,
 			localForkPoint,
 			remoteForkPoint,

package/src/commands/merge.integration.test.ts

@@ -0,0 +1,195 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import { join } from "path"
+import { merge } from "./merge"
+import { emit } from "./emit"
+import { task } from "./task"
+import {
+	createTempDir,
+	cleanupTempDir,
+	initGitRepo,
+	initAgency,
+	getGitOutput,
+	getCurrentBranch,
+	createCommit,
+	branchExists,
+	checkoutBranch,
+	createBranch,
+	addAndCommit,
+	setupRemote,
+	deleteBranch,
+	runTestEffect,
+} from "../test-utils"
+
+// Cache the git-filter-repo availability check (it doesn't change during test run)
+let hasGitFilterRepoCache: boolean | null = null
+async function checkGitFilterRepo(): Promise<boolean> {
+	if (hasGitFilterRepoCache === null) {
+		const proc = Bun.spawn(["which", "git-filter-repo"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		})
+		await proc.exited
+		hasGitFilterRepoCache = proc.exitCode === 0
+	}
+	return hasGitFilterRepoCache
+}
+
+describe("merge command - integration tests (requires git-filter-repo)", () => {
+	let tempDir: string
+	let originalCwd: string
+	let hasGitFilterRepo: boolean
+
+	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()
+
+		// Check if git-filter-repo is available (cached)
+		hasGitFilterRepo = await checkGitFilterRepo()
+
+		// Initialize git repo with main branch (already includes initial commit)
+		await initGitRepo(tempDir)
+
+		// Set up origin for git-filter-repo
+		await setupRemote(tempDir, "origin", tempDir)
+
+		// Create a source branch (with agency/ prefix per new default config)
+		await createBranch(tempDir, "agency/feature")
+
+		// Initialize AGENTS.md on feature branch
+		await initAgency(tempDir, "test")
+
+		await runTestEffect(task({ silent: true, fromCurrent: true }))
+
+		// Ensure agency.json has baseBranch set (task should auto-detect it, but ensure it's there)
+		const agencyJsonPath = join(tempDir, "agency.json")
+		const agencyJson = await Bun.file(agencyJsonPath).json()
+		if (!agencyJson.baseBranch) {
+			agencyJson.baseBranch = "origin/main"
+			await Bun.write(
+				agencyJsonPath,
+				JSON.stringify(agencyJson, null, 2) + "\n",
+			)
+		}
+
+		await addAndCommit(tempDir, "AGENTS.md agency.json", "Add AGENTS.md")
+
+		// Create another commit on feature branch
+		await createCommit(tempDir, "Feature work")
+	})
+
+	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("merge from source branch", () => {
+		test("creates emit branch and merges when run from source branch", async () => {
+			if (!hasGitFilterRepo) {
+				console.log("Skipping test: git-filter-repo not installed")
+				return
+			}
+
+			// We're on feature branch (source)
+			const currentBranch = await getCurrentBranch(tempDir)
+			expect(currentBranch).toBe("agency/feature")
+
+			// Run merge - should create feature--PR and merge it to main
+			await runTestEffect(merge({ silent: true }))
+
+			// Should be on main branch after merge
+			const afterMergeBranch = await getCurrentBranch(tempDir)
+			expect(afterMergeBranch).toBe("main")
+
+			// emit branch should exist
+			const prExists = await branchExists(tempDir, "feature")
+			expect(prExists).toBe(true)
+
+			// Main should have the feature work but not AGENTS.md
+			const files = await getGitOutput(tempDir, ["ls-files"])
+			expect(files).not.toContain("AGENTS.md")
+		})
+
+		test("recreates emit branch if it already exists", async () => {
+			if (!hasGitFilterRepo) {
+				console.log("Skipping test: git-filter-repo not installed")
+				return
+			}
+
+			// Create emit branch first
+			await runTestEffect(emit({ silent: true }))
+
+			// Go back to feature branch
+			await checkoutBranch(tempDir, "agency/feature")
+
+			// Make additional changes
+			await createCommit(tempDir, "More feature work")
+
+			// Run merge - should recreate emit branch with new changes
+			await runTestEffect(merge({ silent: true }))
+
+			// Should be on main after merge
+			const currentBranch = await getCurrentBranch(tempDir)
+			expect(currentBranch).toBe("main")
+		})
+	})
+
+	describe("merge from emit branch", () => {
+		test("merges emit branch directly when run from emit branch", async () => {
+			if (!hasGitFilterRepo) {
+				console.log("Skipping test: git-filter-repo not installed")
+				return
+			}
+
+			// Create emit branch
+			await runTestEffect(emit({ silent: true }))
+
+			// emit() now stays on source branch, so we need to checkout to emit branch
+			await checkoutBranch(tempDir, "feature")
+
+			// We're on feature--PR now
+			const currentBranch = await getCurrentBranch(tempDir)
+			expect(currentBranch).toBe("feature")
+
+			// Run merge - should merge feature--PR to main
+			await runTestEffect(merge({ silent: true }))
+
+			// Should be on main after merge
+			const afterMergeBranch = await getCurrentBranch(tempDir)
+			expect(afterMergeBranch).toBe("main")
+
+			// Main should have the feature work but not AGENTS.md
+			const files = await getGitOutput(tempDir, ["ls-files"])
+			expect(files).not.toContain("AGENTS.md")
+		})
+
+		test("throws error if emit branch has no corresponding source branch", async () => {
+			if (!hasGitFilterRepo) {
+				console.log("Skipping test: git-filter-repo not installed")
+				return
+			}
+
+			// Create emit branch
+			await runTestEffect(emit({ silent: true }))
+
+			// pr() now stays on source branch, so checkout to emit branch
+			await checkoutBranch(tempDir, "feature")
+
+			// Delete the source branch
+			await deleteBranch(tempDir, "agency/feature", true)
+
+			// Try to merge - should fail (error message may vary since source branch is deleted)
+			await expect(runTestEffect(merge({ silent: true }))).rejects.toThrow()
+		})
+	})
+})