@markjaquith/agency 1.2.0 → 1.3.0

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)