@markjaquith/agency 0.5.0

package/src/commands/pull.ts

@@ -0,0 +1,205 @@
+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 highlight, { done } from "../utils/colors"
+import {
+	createLoggers,
+	ensureGitRepo,
+	withBranchProtection,
+} from "../utils/effect"
+import { withSpinner } from "../utils/spinner"
+
+interface PullOptions extends BaseCommandOptions {
+	remote?: string
+}
+
+export const pull = (options: PullOptions = {}) =>
+	Effect.gen(function* () {
+		const gitRoot = yield* ensureGitRepo()
+
+		// Wrap the entire pull operation with branch protection
+		// This ensures we return to the original branch on Ctrl-C interrupt
+		yield* withBranchProtection(gitRoot, pullCore(gitRoot, options))
+	})
+
+const pullCore = (gitRoot: string, options: PullOptions) =>
+	Effect.gen(function* () {
+		const { verbose = false } = options
+		const { log, verboseLog } = createLoggers(options)
+
+		const git = yield* GitService
+		const configService = yield* ConfigService
+
+		// Resolve remote name (use provided option, config, or auto-detect)
+		const remote = options.remote
+			? yield* git.resolveRemote(gitRoot, options.remote)
+			: yield* git.resolveRemote(gitRoot)
+
+		// Load config
+		const config = yield* configService.loadConfig()
+
+		// Get current branch
+		let currentBranch = yield* git.getCurrentBranch(gitRoot)
+
+		// Resolve branch pair to find source and emit branches
+		const branches = yield* resolveBranchPairWithAgencyJson(
+			gitRoot,
+			currentBranch,
+			config.sourceBranchPattern,
+			config.emitBranch,
+		)
+		const { sourceBranch, emitBranch, isOnEmitBranch } = branches
+
+		// If we're on emit branch, switch to source branch
+		if (isOnEmitBranch) {
+			verboseLog(
+				`Currently on emit branch ${highlight.branch(currentBranch)}, switching to source branch ${highlight.branch(sourceBranch)}`,
+			)
+			const sourceExists = yield* git.branchExists(gitRoot, sourceBranch)
+			if (!sourceExists) {
+				return yield* Effect.fail(
+					new Error(
+						`Source branch ${highlight.branch(sourceBranch)} does not exist`,
+					),
+				)
+			}
+			yield* git.checkoutBranch(gitRoot, sourceBranch)
+			currentBranch = sourceBranch
+		}
+
+		verboseLog(`Source branch: ${highlight.branch(sourceBranch)}`)
+		verboseLog(`Emit branch: ${highlight.branch(emitBranch)}`)
+
+		// Fetch the remote emit branch
+		const remoteEmitBranch = `${remote}/${emitBranch}`
+		const fetchOperation = Effect.gen(function* () {
+			const result = yield* git.fetch(gitRoot, remote, emitBranch).pipe(
+				Effect.map(() => true),
+				Effect.catchAll(() => Effect.succeed(false)),
+			)
+
+			if (!result) {
+				return yield* Effect.fail(
+					new Error(
+						`Failed to fetch ${highlight.branch(remoteEmitBranch)}. Does the remote branch exist?`,
+					),
+				)
+			}
+
+			verboseLog(`Fetched ${highlight.branch(remoteEmitBranch)}`)
+
+			// Check if remote emit branch exists after fetch
+			const remoteExists = yield* git.branchExists(gitRoot, remoteEmitBranch)
+			if (!remoteExists) {
+				return yield* Effect.fail(
+					new Error(
+						`Remote emit branch ${highlight.branch(remoteEmitBranch)} does not exist`,
+					),
+				)
+			}
+		})
+
+		yield* withSpinner(fetchOperation, {
+			text: `Fetching ${highlight.branch(remoteEmitBranch)}`,
+			successText: `Fetched ${highlight.branch(remoteEmitBranch)}`,
+			enabled: !options.silent && !verbose,
+		})
+
+		// Check if local emit branch exists
+		const localEmitExists = yield* git.branchExists(gitRoot, emitBranch)
+		if (!localEmitExists) {
+			verboseLog(
+				`Local emit branch ${highlight.branch(emitBranch)} does not exist, comparing against source branch`,
+			)
+		}
+
+		// Get the list of commits on remote emit branch that aren't on local emit branch
+		// If local emit branch doesn't exist, compare against source branch
+		const compareBase = localEmitExists ? emitBranch : sourceBranch
+		verboseLog(
+			`Comparing ${highlight.branch(remoteEmitBranch)} against ${highlight.branch(compareBase)}`,
+		)
+
+		const commitsResult = yield* git
+			.getCommitsBetween(gitRoot, compareBase, remoteEmitBranch)
+			.pipe(Effect.catchAll(() => Effect.succeed("")))
+
+		if (!commitsResult || commitsResult.trim() === "") {
+			log(done("No new commits to pull"))
+			return
+		}
+
+		const commits = commitsResult.split("\n").filter((c) => c.trim().length > 0)
+		verboseLog(`Found ${commits.length} commits to cherry-pick`)
+
+		// Cherry-pick each commit
+		let successCount = 0
+		let failedCommit: string | null = null
+
+		for (const commit of commits) {
+			verboseLog(`Cherry-picking ${highlight.commit(commit.substring(0, 8))}`)
+
+			const result = yield* git.cherryPick(gitRoot, commit).pipe(
+				Effect.map(() => true),
+				Effect.catchAll(() => {
+					failedCommit = commit
+					return Effect.succeed(false)
+				}),
+			)
+
+			if (!result) {
+				break
+			}
+
+			successCount++
+		}
+
+		if (failedCommit) {
+			log(
+				`Cherry-picked ${successCount} of ${commits.length} commits before conflict`,
+			)
+			return yield* Effect.fail(
+				new Error(
+					`Cherry-pick conflict at commit ${highlight.commit(failedCommit.substring(0, 8))}. Resolve conflicts and continue with: git cherry-pick --continue`,
+				),
+			)
+		}
+
+		log(
+			done(
+				`Pulled ${commits.length} commit${commits.length === 1 ? "" : "s"} from ${highlight.branch(remoteEmitBranch)}`,
+			),
+		)
+	})
+
+export const help = `
+Usage: agency pull [options]
+
+Pull commits from the remote emit branch and cherry-pick them onto the source branch.
+
+This command is useful when someone else has pushed commits to the emit branch
+(e.g., after a PR review) and you want to bring those changes back into your
+source branch.
+
+Workflow:
+  1. Determines the source and emit branch names
+  2. If on emit branch, switches to source branch
+  3. Fetches the remote emit branch
+  4. Finds commits on remote emit branch that aren't on source branch
+  5. Cherry-picks each commit onto the source branch
+
+Options:
+  -r, --remote      Remote name to fetch from (defaults to 'origin')
+
+Examples:
+  agency pull                       # Pull from origin/<emit-branch>
+  agency pull --remote upstream     # Pull from upstream/<emit-branch>
+
+Notes:
+  - If a cherry-pick conflict occurs, you'll need to resolve it manually
+  - Use 'git cherry-pick --continue' after resolving conflicts
+  - The command will stop at the first conflict
+  - Only commits that don't exist on the source branch are cherry-picked
+`

package/src/commands/push.test.ts

@@ -0,0 +1,394 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import { join } from "path"
+import { push } from "./push"
+import {
+	createTempDir,
+	cleanupTempDir,
+	initGitRepo,
+	getCurrentBranch,
+	getGitOutput,
+	createCommit,
+	checkoutBranch,
+	createBranch,
+	addAndCommit,
+	renameBranch,
+	runTestEffect,
+} from "../test-utils"
+
+async function setupAgencyJson(gitRoot: string): Promise<void> {
+	const agencyJson = {
+		version: 1,
+		injectedFiles: ["AGENTS.MD", "TASK.md"],
+		template: "test",
+		createdAt: new Date().toISOString(),
+	}
+	await Bun.write(
+		join(gitRoot, "agency.json"),
+		JSON.stringify(agencyJson, null, 2) + "\n",
+	)
+	await addAndCommit(gitRoot, "agency.json", "Add agency.json")
+}
+
+async function setupBareRemote(tempDir: string): Promise<string> {
+	// Create a bare repository to use as remote
+	const remoteDir = join(tempDir, "remote.git")
+	await Bun.spawn(["git", "init", "--bare", remoteDir], {
+		stdout: "pipe",
+		stderr: "pipe",
+	}).exited
+	return remoteDir
+}
+
+describe("push command", () => {
+	let tempDir: string
+	let remoteDir: 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")
+
+		// Initialize git repo
+		await initGitRepo(tempDir)
+		await createCommit(tempDir, "Initial commit")
+
+		// Rename to main if needed
+		const currentBranch = await getCurrentBranch(tempDir)
+		if (currentBranch === "master") {
+			await renameBranch(tempDir, "main")
+		}
+
+		// Setup bare remote and push main
+		remoteDir = await setupBareRemote(tempDir)
+		await Bun.spawn(["git", "remote", "add", "origin", remoteDir], {
+			cwd: tempDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		}).exited
+		await Bun.spawn(["git", "push", "-u", "origin", "main"], {
+			cwd: tempDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		}).exited
+
+		// Setup agency.json
+		await setupAgencyJson(tempDir)
+
+		// Create a source branch (with agency/ prefix per new default config)
+		await createBranch(tempDir, "agency/feature")
+		await createCommit(tempDir, "Feature work")
+	})
+
+	afterEach(async () => {
+		process.chdir(originalCwd)
+		delete process.env.AGENCY_CONFIG_PATH
+		await cleanupTempDir(tempDir)
+	})
+
+	describe("basic functionality", () => {
+		test("creates emit branch, pushes it, and returns to source", async () => {
+			// We're on agency/feature branch (source)
+			expect(await getCurrentBranch(tempDir)).toBe("agency/feature")
+
+			// Run push command
+			await runTestEffect(
+				push({ baseBranch: "main", silent: true, skipFilter: true }),
+			)
+
+			// Should be back on agency/feature branch (source)
+			expect(await getCurrentBranch(tempDir)).toBe("agency/feature")
+
+			// emit branch (feature) should exist locally and on remote
+			const branches = await getGitOutput(tempDir, ["branch"])
+			expect(branches).toContain("feature")
+
+			const remoteBranches = await getGitOutput(tempDir, [
+				"ls-remote",
+				"--heads",
+				"origin",
+				"feature",
+			])
+			expect(remoteBranches).toContain("feature")
+		})
+
+		test("works with custom branch name", async () => {
+			await runTestEffect(
+				push({
+					baseBranch: "main",
+					branch: "custom-pr-branch",
+					silent: true,
+					skipFilter: true,
+				}),
+			)
+
+			// Should be back on agency/feature branch (source)
+			expect(await getCurrentBranch(tempDir)).toBe("agency/feature")
+
+			// Custom branch should exist
+			const branches = await getGitOutput(tempDir, ["branch"])
+			expect(branches).toContain("custom-pr-branch")
+		})
+
+		test("recreates emit branch if it already exists", async () => {
+			// First push
+			await runTestEffect(
+				push({ baseBranch: "main", silent: true, skipFilter: true }),
+			)
+
+			// Make more changes on source branch
+			await checkoutBranch(tempDir, "agency/feature")
+			await createCommit(tempDir, "More feature work")
+
+			// Second push should recreate the emit branch
+			await runTestEffect(
+				push({ baseBranch: "main", silent: true, skipFilter: true }),
+			)
+
+			// Should still be back on agency/feature branch (source)
+			expect(await getCurrentBranch(tempDir)).toBe("agency/feature")
+		})
+	})
+
+	describe("error handling", () => {
+		test("switches to source branch when run from emit branch", async () => {
+			// First create the emit branch from source branch
+			await runTestEffect(
+				push({ baseBranch: "main", silent: true, skipFilter: true }),
+			)
+
+			// Now we're on agency/feature, switch to the emit branch (feature)
+			await checkoutBranch(tempDir, "feature")
+
+			// Verify we're on the emit branch
+			expect(await getCurrentBranch(tempDir)).toBe("feature")
+
+			// Make a change on source branch that we'll push
+			await checkoutBranch(tempDir, "agency/feature")
+			await createCommit(tempDir, "Another feature commit")
+
+			// Switch back to emit branch
+			await checkoutBranch(tempDir, "feature")
+
+			// Run push from emit branch - should detect we're on emit branch,
+			// switch to source (agency/feature), and continue
+			await runTestEffect(
+				push({ baseBranch: "main", silent: true, skipFilter: true }),
+			)
+
+			// Should be back on agency/feature branch (the source branch)
+			expect(await getCurrentBranch(tempDir)).toBe("agency/feature")
+		})
+
+		test("throws error when not in a git repository", async () => {
+			const nonGitDir = await createTempDir()
+			process.chdir(nonGitDir)
+
+			await expect(
+				runTestEffect(
+					push({ baseBranch: "main", silent: true, skipFilter: true }),
+				),
+			).rejects.toThrow("Not in a git repository")
+
+			await cleanupTempDir(nonGitDir)
+		})
+
+		test("handles push failure gracefully", async () => {
+			// Remove the remote to cause push to fail
+			await Bun.spawn(["git", "remote", "remove", "origin"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+
+			// Push should fail because no remote exists
+			await expect(
+				runTestEffect(
+					push({ baseBranch: "main", silent: true, skipFilter: true }),
+				),
+			).rejects.toThrow(/No git remotes found/)
+		})
+	})
+
+	describe("silent mode", () => {
+		test("silent flag suppresses output", async () => {
+			// Capture output
+			const originalLog = console.log
+			let logCalled = false
+			console.log = () => {
+				logCalled = true
+			}
+
+			await runTestEffect(
+				push({ baseBranch: "main", silent: true, skipFilter: true }),
+			)
+
+			console.log = originalLog
+			expect(logCalled).toBe(false)
+		})
+	})
+
+	describe("force push", () => {
+		test("force pushes when branch has diverged and --force is provided", async () => {
+			// First push
+			await runTestEffect(
+				push({ baseBranch: "main", silent: true, skipFilter: true }),
+			)
+
+			// Make changes on source branch
+			await checkoutBranch(tempDir, "agency/feature")
+			await createCommit(tempDir, "More feature work")
+
+			// Modify the emit branch to create divergence
+			await checkoutBranch(tempDir, "feature")
+			await createCommit(tempDir, "Direct emit branch commit")
+			await Bun.spawn(["git", "push"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+
+			// Go back to source branch and try to push again with --force
+			await checkoutBranch(tempDir, "agency/feature")
+
+			// Capture output to check for force push message
+			const originalLog = console.log
+			let logMessages: string[] = []
+			console.log = (msg: string) => {
+				logMessages.push(msg)
+			}
+
+			await runTestEffect(
+				push({
+					baseBranch: "main",
+					force: true,
+					silent: false,
+					skipFilter: true,
+				}),
+			)
+
+			console.log = originalLog
+
+			// Should be back on agency/feature branch (source)
+			expect(await getCurrentBranch(tempDir)).toBe("agency/feature")
+
+			// Should have reported force push
+			expect(logMessages.some((msg) => msg.includes("(forced)"))).toBe(true)
+		})
+
+		test("suggests using --force when push is rejected without it", async () => {
+			// First push
+			await runTestEffect(
+				push({ baseBranch: "main", silent: true, skipFilter: true }),
+			)
+
+			// Make changes on source branch
+			await checkoutBranch(tempDir, "agency/feature")
+			await createCommit(tempDir, "More feature work")
+
+			// Modify the emit branch to create divergence
+			await checkoutBranch(tempDir, "feature")
+			await createCommit(tempDir, "Direct emit branch commit")
+			await Bun.spawn(["git", "push"], {
+				cwd: tempDir,
+				stdout: "pipe",
+				stderr: "pipe",
+			}).exited
+
+			// Go back to source branch and try to push without --force
+			await checkoutBranch(tempDir, "agency/feature")
+
+			// Should throw error suggesting --force
+			await expect(
+				runTestEffect(
+					push({ baseBranch: "main", silent: true, skipFilter: true }),
+				),
+			).rejects.toThrow(/agency push --force/)
+
+			// Should still be on agency/feature branch (not left in intermediate state)
+			expect(await getCurrentBranch(tempDir)).toBe("agency/feature")
+		})
+
+		test("does not report force push when --force is provided but not needed", async () => {
+			// Capture output to check for force push message
+			const originalLog = console.log
+			let logMessages: string[] = []
+			console.log = (msg: string) => {
+				logMessages.push(msg)
+			}
+
+			// First push with --force (but it won't actually need force)
+			await runTestEffect(
+				push({
+					baseBranch: "main",
+					force: true,
+					silent: false,
+					skipFilter: true,
+				}),
+			)
+
+			console.log = originalLog
+
+			// Should be back on agency/feature branch (source)
+			expect(await getCurrentBranch(tempDir)).toBe("agency/feature")
+
+			// Should NOT have reported force push (since it wasn't actually used)
+			expect(logMessages.some((msg) => msg.includes("Force pushed"))).toBe(
+				false,
+			)
+			expect(logMessages.some((msg) => msg.includes("Pushed"))).toBe(true)
+		})
+	})
+
+	describe("--pr flag", () => {
+		test("handles gh CLI failure gracefully and continues", async () => {
+			// Capture error output
+			const originalError = console.error
+			let errorMessages: string[] = []
+			console.error = (msg: string) => {
+				errorMessages.push(msg)
+			}
+
+			// Should not throw - command should complete despite gh failure
+			// (gh will fail in test environment because there's no GitHub remote)
+			await runTestEffect(
+				push({ baseBranch: "main", pr: true, silent: true, skipFilter: true }),
+			)
+
+			console.error = originalError
+
+			// Should be back on agency/feature branch (command completes despite gh failure)
+			expect(await getCurrentBranch(tempDir)).toBe("agency/feature")
+
+			// Should have warned about gh failure
+			expect(
+				errorMessages.some((msg) => msg.includes("Failed to open GitHub PR")),
+			).toBe(true)
+		})
+
+		test("does not call gh when --pr flag is not set", async () => {
+			// Capture error output
+			const originalError = console.error
+			let errorMessages: string[] = []
+			console.error = (msg: string) => {
+				errorMessages.push(msg)
+			}
+
+			// Push without --pr flag
+			await runTestEffect(
+				push({ baseBranch: "main", silent: true, skipFilter: true }),
+			)
+
+			console.error = originalError
+
+			// Should be back on agency/feature branch (source)
+			expect(await getCurrentBranch(tempDir)).toBe("agency/feature")
+
+			// gh should NOT have been called (no error about GitHub PR)
+			expect(errorMessages.some((msg) => msg.includes("GitHub PR"))).toBe(false)
+		})
+	})
+})