@markjaquith/agency 1.1.1 → 1.3.0

package/src/services/GitService.ts

@@ -874,5 +874,201 @@ export class GitService extends Effect.Service<GitService>()("GitService", {
 				),
 				Effect.catchAll(() => Effect.succeed(false)),
 			),
+
+		/**
+		 * Get all local branch names.
+		 * @param gitRoot - The git repository root
+		 * @returns Array of local branch names
+		 */
+		getAllLocalBranches: (gitRoot: string) =>
+			pipe(
+				runGitCommand(["git", "branch", "--format=%(refname:short)"], gitRoot),
+				Effect.map((result) => {
+					if (result.exitCode === 0 && result.stdout.trim()) {
+						return result.stdout.trim().split("\n") as readonly string[]
+					}
+					return [] as readonly string[]
+				}),
+				Effect.mapError(
+					() => new GitError({ message: "Failed to get local branches" }),
+				),
+			),
+
+		/**
+		 * Get branches that have been merged into a target branch.
+		 * @param gitRoot - The git repository root
+		 * @param targetBranch - The branch to check merges against
+		 * @returns Array of merged branch names
+		 */
+		getMergedBranches: (gitRoot: string, targetBranch: string) =>
+			pipe(
+				runGitCommand(
+					[
+						"git",
+						"branch",
+						"--merged",
+						targetBranch,
+						"--format=%(refname:short)",
+					],
+					gitRoot,
+				),
+				Effect.map((result) => {
+					if (result.exitCode === 0 && result.stdout.trim()) {
+						return result.stdout.trim().split("\n") as readonly string[]
+					}
+					return [] as readonly string[]
+				}),
+				Effect.mapError(
+					() =>
+						new GitError({
+							message: `Failed to get branches merged into ${targetBranch}`,
+						}),
+				),
+			),
+
+		/**
+		 * Push a branch to a remote.
+		 * @param gitRoot - The git repository root
+		 * @param remote - Remote name (e.g., "origin")
+		 * @param branch - Branch name to push
+		 * @param options - Push options
+		 * @returns Object with exitCode, stdout, stderr
+		 */
+		push: (
+			gitRoot: string,
+			remote: string,
+			branch: string,
+			options?: {
+				readonly setUpstream?: boolean
+				readonly force?: boolean
+			},
+		) => {
+			const args = ["git", "push"]
+			if (options?.setUpstream) {
+				args.push("-u")
+			}
+			if (options?.force) {
+				args.push("--force")
+			}
+			args.push(remote, branch)
+
+			return pipe(
+				runGitCommand(args, gitRoot),
+				Effect.mapError(
+					(error) =>
+						new GitError({
+							message: `Failed to push ${branch} to ${remote}`,
+							cause: error,
+						}),
+				),
+			)
+		},
+
+		/**
+		 * Merge a branch into the current branch.
+		 * @param gitRoot - The git repository root
+		 * @param branch - Branch to merge
+		 * @param options - Merge options
+		 * @returns Object with exitCode, stdout, stderr
+		 */
+		merge: (
+			gitRoot: string,
+			branch: string,
+			options?: {
+				readonly squash?: boolean
+				readonly noCommit?: boolean
+				readonly message?: string
+			},
+		) => {
+			const args = ["git", "merge"]
+			if (options?.squash) {
+				args.push("--squash")
+			}
+			if (options?.noCommit) {
+				args.push("--no-commit")
+			}
+			if (options?.message) {
+				args.push("-m", options.message)
+			}
+			args.push(branch)
+
+			return pipe(
+				runGitCommand(args, gitRoot),
+				Effect.mapError(
+					(error) =>
+						new GitError({
+							message: `Failed to merge ${branch}`,
+							cause: error,
+						}),
+				),
+			)
+		},
+
+		/**
+		 * Rebase current branch onto a base branch.
+		 * @param gitRoot - The git repository root
+		 * @param baseBranch - Branch to rebase onto
+		 * @returns Object with exitCode, stdout, stderr
+		 */
+		rebase: (gitRoot: string, baseBranch: string) =>
+			pipe(
+				runGitCommand(["git", "rebase", baseBranch], gitRoot),
+				Effect.mapError(
+					(error) =>
+						new GitError({
+							message: `Failed to rebase onto ${baseBranch}`,
+							cause: error,
+						}),
+				),
+			),
+
+		/**
+		 * Get the working tree status (porcelain format).
+		 * @param gitRoot - The git repository root
+		 * @returns Status output string
+		 */
+		getStatus: (gitRoot: string) =>
+			pipe(
+				runGitCommand(["git", "status", "--porcelain"], gitRoot),
+				Effect.map((result) => result.stdout),
+				Effect.mapError(
+					() => new GitError({ message: "Failed to get git status" }),
+				),
+			),
+
+		/**
+		 * Check if one commit is an ancestor of another.
+		 * @param gitRoot - The git repository root
+		 * @param potentialAncestor - The commit that might be an ancestor
+		 * @param commit - The commit to check against
+		 * @returns true if potentialAncestor is an ancestor of commit
+		 */
+		isAncestor: (gitRoot: string, potentialAncestor: string, commit: string) =>
+			pipe(
+				runGitCommand(
+					["git", "merge-base", "--is-ancestor", potentialAncestor, commit],
+					gitRoot,
+				),
+				Effect.map((result) => result.exitCode === 0),
+				Effect.catchAll(() => Effect.succeed(false)),
+			),
+
+		/**
+		 * Create or reset a branch to point to a specific commit/branch.
+		 * Uses `git checkout -B` which creates the branch if it doesn't exist
+		 * or resets it if it does.
+		 * @param gitRoot - The git repository root
+		 * @param branchName - Name of the branch to create/reset
+		 * @param startPoint - Commit or branch to start from
+		 */
+		createOrResetBranch: (
+			gitRoot: string,
+			branchName: string,
+			startPoint: string,
+		) =>
+			runGitCommandVoid(
+				["git", "checkout", "-q", "-B", branchName, startPoint],
+				gitRoot,
+			),
 	}),
 }) {}

package/src/services/MockFilterRepoService.ts

@@ -0,0 +1,133 @@
+import { Effect, Layer } from "effect"
+import { FilterRepoService } from "./FilterRepoService"
+
+/**
+ * Captured filter-repo call for verification in tests.
+ */
+export interface CapturedFilterRepoCall {
+	gitRoot: string
+	args: readonly string[]
+	env?: Record<string, string>
+}
+
+/**
+ * Global state for captured filter-repo calls.
+ * Tests can inspect this to verify correct commands were constructed.
+ */
+let capturedCalls: CapturedFilterRepoCall[] = []
+
+/**
+ * Clear all captured filter-repo calls.
+ * Call this in beforeEach() to reset state between tests.
+ */
+export function clearCapturedFilterRepoCalls(): void {
+	capturedCalls = []
+}
+
+/**
+ * Get all captured filter-repo calls.
+ * @returns Array of captured calls
+ */
+export function getCapturedFilterRepoCalls(): readonly CapturedFilterRepoCall[] {
+	return capturedCalls
+}
+
+/**
+ * Get the last captured filter-repo call.
+ * @returns The last captured call, or undefined if none
+ */
+export function getLastCapturedFilterRepoCall():
+	| CapturedFilterRepoCall
+	| undefined {
+	return capturedCalls[capturedCalls.length - 1]
+}
+
+/**
+ * Mock implementation of FilterRepoService.
+ *
+ * This mock:
+ * - Always returns true for isInstalled()
+ * - Captures the arguments passed to run() without executing
+ * - Returns a successful result with exit code 0
+ *
+ * Use getCapturedFilterRepoCalls() to verify the correct commands were constructed.
+ */
+export class MockFilterRepoService extends Effect.Service<MockFilterRepoService>()(
+	"FilterRepoService", // Same tag as the real service to replace it
+	{
+		sync: () => ({
+			isInstalled: () => Effect.succeed(true),
+
+			run: (
+				gitRoot: string,
+				args: readonly string[],
+				options?: {
+					readonly env?: Record<string, string>
+				},
+			) => {
+				// Capture the call
+				capturedCalls.push({
+					gitRoot,
+					args,
+					env: options?.env,
+				})
+
+				// Return a successful result
+				return Effect.succeed({
+					exitCode: 0,
+					stdout: "",
+					stderr: "",
+				})
+			},
+
+			filterFiles: (
+				gitRoot: string,
+				options: {
+					readonly refs?: string
+					readonly pathsToRemove?: readonly string[]
+					readonly pathRenames?: readonly { from: string; to: string }[]
+					readonly force?: boolean
+				},
+			) => {
+				// Build the args like the real implementation would
+				const args: string[] = []
+
+				if (options.refs) {
+					args.push("--refs", options.refs)
+				}
+
+				if (options.pathsToRemove) {
+					for (const path of options.pathsToRemove) {
+						args.push("--invert-paths", "--path", path)
+					}
+				}
+
+				if (options.pathRenames) {
+					for (const rename of options.pathRenames) {
+						args.push("--path-rename", `${rename.from}:${rename.to}`)
+					}
+				}
+
+				if (options.force) {
+					args.push("--force")
+				}
+
+				args.push("--prune-empty=always")
+
+				// Capture the call
+				capturedCalls.push({
+					gitRoot,
+					args,
+					env: { GIT_CONFIG_GLOBAL: "" },
+				})
+
+				// Return a successful result
+				return Effect.succeed({
+					exitCode: 0,
+					stdout: "",
+					stderr: "",
+				})
+			},
+		}),
+	},
+) {}

package/src/test-utils.ts

@@ -235,6 +235,47 @@ export async function deleteBranch(
 	await gitRun(cwd, ["branch", flag, branchName])
 }
 
+/**
+ * Reset a git repo to clean state for test reuse.
+ * This is much faster than creating a new repo from scratch.
+ * - Checks out main branch
+ * - Removes all other branches
+ * - Resets to initial commit
+ * - Cleans untracked files
+ * - Removes agency git config
+ */
+export async function resetGitRepo(cwd: string): Promise<void> {
+	// Checkout main
+	await gitRun(cwd, ["checkout", "-q", "main"])
+
+	// Delete all branches except main
+	const branchOutput = await getGitOutput(cwd, ["branch", "--list"])
+	const branches = branchOutput
+		.split("\n")
+		.map((b) => b.replace(/^\*?\s*/, "").trim())
+		.filter((b) => b && b !== "main")
+
+	for (const branch of branches) {
+		await gitRun(cwd, ["branch", "-D", branch])
+	}
+
+	// Reset to first commit (the initial commit from template)
+	const firstCommit = (
+		await getGitOutput(cwd, ["rev-list", "--max-parents=0", "HEAD"])
+	).trim()
+	await gitRun(cwd, ["reset", "--hard", firstCommit])
+
+	// Clean untracked files and directories
+	await gitRun(cwd, ["clean", "-fdx"])
+
+	// Remove agency config
+	try {
+		await gitRun(cwd, ["config", "--unset", "agency.template"])
+	} catch {
+		// Ignore if not set
+	}
+}
+
 /**
  * Rename current branch
  */
@@ -340,8 +381,18 @@ import { PromptService } from "./services/PromptService"
 import { TemplateService } from "./services/TemplateService"
 import { OpencodeService } from "./services/OpencodeService"
 import { ClaudeService } from "./services/ClaudeService"
-
-// Create test layer with all services
+import { FilterRepoService } from "./services/FilterRepoService"
+import { MockFilterRepoService } from "./services/MockFilterRepoService"
+
+// Re-export mock utilities for tests
+export {
+	clearCapturedFilterRepoCalls,
+	getCapturedFilterRepoCalls,
+	getLastCapturedFilterRepoCall,
+} from "./services/MockFilterRepoService"
+export type { CapturedFilterRepoCall } from "./services/MockFilterRepoService"
+
+// Create test layer with all services (real filter-repo)
 const TestLayer = Layer.mergeAll(
 	GitService.Default,
 	ConfigService.Default,
@@ -350,6 +401,19 @@ const TestLayer = Layer.mergeAll(
 	TemplateService.Default,
 	OpencodeService.Default,
 	ClaudeService.Default,
+	FilterRepoService.Default,
+)
+
+// Create test layer with mock filter-repo (for tests that don't need real filtering)
+const TestLayerWithMockFilterRepo = Layer.mergeAll(
+	GitService.Default,
+	ConfigService.Default,
+	FileSystemService.Default,
+	PromptService.Default,
+	TemplateService.Default,
+	OpencodeService.Default,
+	ClaudeService.Default,
+	MockFilterRepoService.Default,
 )
 
 export async function runTestEffect<A, E>(
@@ -366,3 +430,22 @@ export async function runTestEffect<A, E>(
 
 	return await Effect.runPromise(program)
 }
+
+/**
+ * Run a test effect with MockFilterRepoService instead of the real one.
+ * Use this for tests that need to verify filter-repo command construction
+ * without actually running git-filter-repo.
+ */
+export async function runTestEffectWithMockFilterRepo<A, E>(
+	effect: Effect.Effect<A, E, any>,
+): Promise<A> {
+	const providedEffect = Effect.provide(
+		effect,
+		TestLayerWithMockFilterRepo,
+	) as Effect.Effect<A, E, never>
+	const program = Effect.catchAllDefect(providedEffect, (defect) =>
+		Effect.fail(defect instanceof Error ? defect : new Error(String(defect))),
+	) as Effect.Effect<A, E | Error, never>
+
+	return await Effect.runPromise(program)
+}

package/src/utils/pr-branch.ts

@@ -278,26 +278,18 @@ const findSourceBranchByEmitBranch = (
 		const git = yield* GitService
 
 		// Get all local branches
-		const branchesResult = yield* pipe(
-			git.runGitCommand(
-				["git", "branch", "--format=%(refname:short)"],
-				gitRoot,
-				{
-					captureOutput: true,
-				},
+		const branches = yield* pipe(
+			git.getAllLocalBranches(gitRoot),
+			Effect.map((allBranches) =>
+				allBranches.filter((b) => b !== currentBranch),
 			),
-			Effect.catchAll(() => Effect.succeed({ exitCode: 1, stdout: "" })),
+			Effect.catchAll(() => Effect.succeed([] as readonly string[])),
 		)
 
-		if (branchesResult.exitCode !== 0 || !branchesResult.stdout) {
+		if (branches.length === 0) {
 			return null
 		}
 
-		const branches = branchesResult.stdout
-			.split("\n")
-			.map((b) => b.trim())
-			.filter((b) => b.length > 0 && b !== currentBranch)
-
 		// Search each branch for agency.json with matching emitBranch
 		for (const branch of branches) {
 			const metadata = yield* readAgencyJsonFromBranch(gitRoot, branch)