@markjaquith/agency 1.1.1 → 1.3.0

package/src/commands/merge.test.ts

@@ -11,7 +11,6 @@ import {
 	getGitOutput,
 	getCurrentBranch,
 	createCommit,
-	branchExists,
 	checkoutBranch,
 	createBranch,
 	addAndCommit,
@@ -20,24 +19,9 @@ import {
 	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", () => {
 	let tempDir: string
 	let originalCwd: string
-	let hasGitFilterRepo: boolean
 
 	beforeEach(async () => {
 		tempDir = await createTempDir()
@@ -49,9 +33,6 @@ describe("merge 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)
 
@@ -93,106 +74,6 @@ describe("merge command", () => {
 		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()
-		})
-	})
-
 	describe("error handling", () => {
 		test("throws error when not in a git repository", async () => {
 			const nonGitDir = await createTempDir()

package/src/commands/merge.ts

@@ -29,18 +29,13 @@ const mergeBranchEffect = (
 ) =>
 	Effect.gen(function* () {
 		const git = yield* GitService
-		const args = squash
-			? ["git", "merge", "--squash", branch]
-			: ["git", "merge", branch]
 
-		const result = yield* git.runGitCommand(args, gitRoot, {
-			captureOutput: true,
-		})
+		const result = yield* git.merge(gitRoot, branch, { squash })
 
 		if (result.exitCode !== 0) {
 			return yield* Effect.fail(
 				new GitCommandError({
-					command: args.join(" "),
+					command: `git merge${squash ? " --squash" : ""} ${branch}`,
 					exitCode: result.exitCode,
 					stderr: result.stderr,
 				}),
@@ -188,11 +183,7 @@ export const merge = (options: MergeOptions = {}) =>
 				`Pushing ${highlight.branch(baseBranchToMergeInto)} to ${highlight.remote(remote)}...`,
 			)
 
-			const pushResult = yield* git.runGitCommand(
-				["git", "push", remote, baseBranchToMergeInto],
-				gitRoot,
-				{ captureOutput: true },
-			)
+			const pushResult = yield* git.push(gitRoot, remote, baseBranchToMergeInto)
 
 			if (pushResult.exitCode !== 0) {
 				return yield* Effect.fail(

package/src/commands/pr.ts

@@ -0,0 +1,77 @@
+import { Effect } from "effect"
+import type { BaseCommandOptions } from "../utils/command"
+import { GitService } from "../services/GitService"
+import { ConfigService } from "../services/ConfigService"
+import { resolveBranchPairWithAgencyJson } from "../utils/pr-branch"
+import { ensureGitRepo } from "../utils/effect"
+
+interface PrOptions extends BaseCommandOptions {
+	/** Arguments to pass to gh pr (subcommand and flags) */
+	args: string[]
+}
+
+export const pr = (options: PrOptions) =>
+	Effect.gen(function* () {
+		const git = yield* GitService
+		const configService = yield* ConfigService
+
+		const gitRoot = yield* ensureGitRepo()
+
+		// Load config
+		const config = yield* configService.loadConfig()
+
+		// Get current branch and resolve the branch pair
+		const currentBranch = yield* git.getCurrentBranch(gitRoot)
+		const branches = yield* resolveBranchPairWithAgencyJson(
+			gitRoot,
+			currentBranch,
+			config.sourceBranchPattern,
+			config.emitBranch,
+		)
+
+		// Build the gh pr command with the emit branch
+		const ghArgs = ["gh", "pr", ...options.args, branches.emitBranch]
+
+		// Run gh pr with stdio inherited so output goes directly to terminal
+		const exitCode = yield* Effect.tryPromise({
+			try: async () => {
+				const proc = Bun.spawn(ghArgs, {
+					cwd: gitRoot,
+					stdin: "inherit",
+					stdout: "inherit",
+					stderr: "inherit",
+				})
+				return proc.exited
+			},
+			catch: (error) =>
+				new Error(
+					`Failed to run gh pr: ${error instanceof Error ? error.message : String(error)}`,
+				),
+		})
+
+		if (exitCode !== 0) {
+			return yield* Effect.fail(
+				new Error(`gh pr command exited with code ${exitCode}`),
+			)
+		}
+	})
+
+export const help = `
+Usage: agency pr <subcommand> [flags]
+
+Wrapper for 'gh pr' that automatically appends the emitted branch name.
+
+This command passes all arguments to 'gh pr' with the emitted branch name
+appended, making it easy to work with PRs for your feature branch without
+needing to remember or type the emit branch name.
+
+Examples:
+  agency pr view --web              # gh pr view --web <emit-branch>
+  agency pr checks                  # gh pr checks <emit-branch>
+  agency pr status                  # gh pr status <emit-branch>
+
+Notes:
+  - Requires gh CLI to be installed and authenticated
+  - Uses source and emit patterns from ~/.config/agency/agency.json
+  - Respects emitBranch field in agency.json when present
+`

package/src/commands/push.ts

@@ -121,10 +121,7 @@ const pushCore = (gitRoot: string, options: PushOptions) =>
 
 		// If skipFilter, we skipped emit() so we must create the emit branch manually
 		if (options.skipFilter) {
-			yield* git.runGitCommand(
-				["git", "checkout", "-q", "-B", emitBranchName, sourceBranch],
-				gitRoot,
-			)
+			yield* git.createOrResetBranch(gitRoot, emitBranchName, sourceBranch)
 			// Switch back to source branch for consistency
 			yield* git.checkoutBranch(gitRoot, sourceBranch)
 		}
@@ -207,13 +204,11 @@ const pushBranchToRemoteEffect = (
 ) =>
 	Effect.gen(function* () {
 		const git = yield* GitService
-		const { force = false, verbose = false } = options
+		const { force = false } = options
 
 		// Try pushing without force first
 		const pushResult = yield* git
-			.runGitCommand(["git", "push", "-u", remote, branchName], gitRoot, {
-				captureOutput: !verbose,
-			})
+			.push(gitRoot, remote, branchName, { setUpstream: true })
 			.pipe(
 				Effect.catchAll((error: any) =>
 					Effect.succeed({
@@ -240,13 +235,7 @@ const pushBranchToRemoteEffect = (
 			if (needsForce && force) {
 				// User provided --force flag, retry with force
 				const forceResult = yield* git
-					.runGitCommand(
-						["git", "push", "-u", "--force", remote, branchName],
-						gitRoot,
-						{
-							captureOutput: !verbose,
-						},
-					)
+					.push(gitRoot, remote, branchName, { setUpstream: true, force: true })
 					.pipe(
 						Effect.catchAll((error: any) =>
 							Effect.succeed({

package/src/commands/rebase.ts

@@ -60,13 +60,9 @@ const rebaseCore = (gitRoot: string, options: RebaseOptions) =>
 		verboseLog(`Branch is an agency source branch`)
 
 		// Check for uncommitted changes
-		const statusResult = yield* git.runGitCommand(
-			["git", "status", "--porcelain"],
-			gitRoot,
-			{ captureOutput: true },
-		)
+		const statusOutput = yield* git.getStatus(gitRoot)
 
-		if (statusResult.stdout && statusResult.stdout.trim().length > 0) {
+		if (statusOutput && statusOutput.trim().length > 0) {
 			return yield* Effect.fail(
 				new Error(
 					`You have uncommitted changes. Please commit or stash them before rebasing.\n` +
@@ -114,11 +110,7 @@ const rebaseCore = (gitRoot: string, options: RebaseOptions) =>
 		const rebaseOperation = Effect.gen(function* () {
 			verboseLog(`Running: git rebase ${baseBranch}`)
 
-			const result = yield* git.runGitCommand(
-				["git", "rebase", baseBranch],
-				gitRoot,
-				{ captureOutput: true },
-			)
+			const result = yield* git.rebase(gitRoot, baseBranch)
 
 			if (result.exitCode !== 0) {
 				return yield* Effect.fail(

package/src/commands/status.ts

@@ -65,17 +65,13 @@ const readAgencyMetadataFromBranch = (gitRoot: string, branch: string) =>
 		const git = yield* GitService
 
 		// Try to read agency.json from the branch using git show
-		const result = yield* git.runGitCommand(
-			["git", "show", `${branch}:agency.json`],
-			gitRoot,
-			{ captureOutput: true },
-		)
+		const content = yield* git.getFileAtRef(gitRoot, branch, "agency.json")
 
-		if (result.exitCode !== 0 || !result.stdout) {
+		if (!content) {
 			return null
 		}
 
-		return yield* parseAgencyMetadata(result.stdout)
+		return yield* parseAgencyMetadata(content)
 	}).pipe(Effect.catchAll(() => Effect.succeed(null)))
 
 /**

package/src/commands/tasks.ts

@@ -28,17 +28,13 @@ const readAgencyMetadataFromBranch = (gitRoot: string, branch: string) =>
 		const git = yield* GitService
 
 		// Try to read agency.json from the branch using git show
-		const result = yield* git.runGitCommand(
-			["git", "show", `${branch}:agency.json`],
-			gitRoot,
-			{ captureOutput: true },
-		)
+		const content = yield* git.getFileAtRef(gitRoot, branch, "agency.json")
 
-		if (result.exitCode !== 0 || !result.stdout) {
+		if (!content) {
 			return null
 		}
 
-		return yield* parseAgencyMetadata(result.stdout)
+		return yield* parseAgencyMetadata(content)
 	}).pipe(Effect.catchAll(() => Effect.succeed(null)))
 
 /**
@@ -73,20 +69,7 @@ const findAllTaskBranches = (gitRoot: string) =>
 		const git = yield* GitService
 
 		// Get all local branches
-		const branchesResult = yield* git.runGitCommand(
-			["git", "branch", "--format=%(refname:short)"],
-			gitRoot,
-			{ captureOutput: true },
-		)
-
-		if (branchesResult.exitCode !== 0 || !branchesResult.stdout) {
-			return []
-		}
-
-		const branches = branchesResult.stdout
-			.split("\n")
-			.map((b) => b.trim())
-			.filter((b) => b.length > 0)
+		const branches = yield* git.getAllLocalBranches(gitRoot)
 
 		// For each branch, try to read agency.json
 		const taskBranches: TaskBranchInfo[] = []

package/src/services/AgencyMetadataService.ts

@@ -129,17 +129,13 @@ export const AgencyMetadataServiceLive = Layer.succeed(
 				const git = yield* GitService
 
 				// Try to read agency.json from the branch using git show
-				const result = yield* git.runGitCommand(
-					["git", "show", `${branch}:agency.json`],
-					gitRoot,
-					{ captureOutput: true },
-				)
+				const content = yield* git.getFileAtRef(gitRoot, branch, "agency.json")
 
-				if (result.exitCode !== 0 || !result.stdout) {
+				if (!content) {
 					return null
 				}
 
-				return yield* parseAgencyMetadata(result.stdout)
+				return yield* parseAgencyMetadata(content)
 			}).pipe(Effect.catchAll(() => Effect.succeed(null))),
 
 		write: (gitRoot: string, metadata: AgencyMetadata) =>

package/src/services/FilterRepoService.ts

@@ -0,0 +1,142 @@
+import { Effect, Data, pipe } from "effect"
+import { spawnProcess } from "../utils/process"
+
+// Error types for FilterRepo operations
+class FilterRepoError extends Data.TaggedError("FilterRepoError")<{
+	message: string
+	cause?: unknown
+}> {}
+
+class FilterRepoNotInstalledError extends Data.TaggedError(
+	"FilterRepoNotInstalledError",
+)<{
+	message: string
+}> {}
+
+/**
+ * Service for git-filter-repo operations.
+ * git-filter-repo is an external Python tool for rewriting git history.
+ */
+export class FilterRepoService extends Effect.Service<FilterRepoService>()(
+	"FilterRepoService",
+	{
+		sync: () => ({
+			/**
+			 * Check if git-filter-repo is installed.
+			 * @returns true if installed, false otherwise
+			 */
+			isInstalled: () =>
+				pipe(
+					spawnProcess(["which", "git-filter-repo"]),
+					Effect.map((result) => result.exitCode === 0),
+					Effect.catchAll(() => Effect.succeed(false)),
+				),
+
+			/**
+			 * Run git-filter-repo with the given arguments.
+			 * @param gitRoot - The git repository root
+			 * @param args - Arguments to pass to git-filter-repo
+			 * @param options - Additional options
+			 * @returns Object with exitCode, stdout, stderr
+			 */
+			run: (
+				gitRoot: string,
+				args: readonly string[],
+				options?: {
+					readonly env?: Record<string, string>
+				},
+			) =>
+				Effect.gen(function* () {
+					// First check if git-filter-repo is installed
+					const installed = yield* pipe(
+						spawnProcess(["which", "git-filter-repo"]),
+						Effect.map((result) => result.exitCode === 0),
+						Effect.catchAll(() => Effect.succeed(false)),
+					)
+
+					if (!installed) {
+						return yield* Effect.fail(
+							new FilterRepoNotInstalledError({
+								message:
+									"git-filter-repo is not installed. Install it with: pip install git-filter-repo",
+							}),
+						)
+					}
+
+					const fullArgs = ["git-filter-repo", ...args]
+
+					const result = yield* pipe(
+						spawnProcess(fullArgs, {
+							cwd: gitRoot,
+							env: options?.env,
+						}),
+						Effect.mapError(
+							(error) =>
+								new FilterRepoError({
+									message: `git-filter-repo failed: ${error.stderr}`,
+									cause: error,
+								}),
+						),
+					)
+
+					if (result.exitCode !== 0) {
+						return yield* Effect.fail(
+							new FilterRepoError({
+								message: `git-filter-repo failed with exit code ${result.exitCode}: ${result.stderr}`,
+							}),
+						)
+					}
+
+					return result
+				}),
+
+			/**
+			 * Filter files from repository history.
+			 * This is a higher-level operation that handles common filtering patterns.
+			 * @param gitRoot - The git repository root
+			 * @param options - Filtering options
+			 */
+			filterFiles: (
+				gitRoot: string,
+				options: {
+					readonly refs?: string
+					readonly pathsToRemove?: readonly string[]
+					readonly pathRenames?: readonly { from: string; to: string }[]
+					readonly force?: boolean
+				},
+			) =>
+				Effect.gen(function* () {
+					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")
+					}
+
+					// Always use these safety options
+					args.push("--prune-empty=always")
+
+					const filterRepo = yield* FilterRepoService
+
+					return yield* filterRepo.run(gitRoot, args, {
+						env: { GIT_CONFIG_GLOBAL: "" },
+					})
+				}),
+		}),
+	},
+) {}