@markjaquith/agency 1.11.1 → 2.0.0

package/src/commands/pull.test.ts

@@ -1,395 +0,0 @@
-import {
-	test,
-	expect,
-	describe,
-	beforeEach,
-	afterEach,
-	setDefaultTimeout,
-} from "bun:test"
-
-// Pull tests require more time due to git operations
-setDefaultTimeout(30000)
-import { join } from "path"
-import { pull } from "./pull"
-import {
-	createTempDir,
-	cleanupTempDir,
-	initGitRepo,
-	getCurrentBranch,
-	createCommit,
-	checkoutBranch,
-	runTestEffect,
-} from "../test-utils"
-
-async function createBranch(cwd: string, branchName: string): Promise<void> {
-	await Bun.spawn(["git", "checkout", "-b", branchName], {
-		cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-	}).exited
-}
-
-async function setupAgencyJson(
-	gitRoot: string,
-	emitBranch?: string,
-): Promise<void> {
-	const agencyJson = {
-		version: 1,
-		injectedFiles: ["AGENTS.MD", "TASK.md"],
-		template: "test",
-		createdAt: new Date().toISOString(),
-		...(emitBranch ? { emitBranch } : {}),
-	}
-	await Bun.write(
-		join(gitRoot, "agency.json"),
-		JSON.stringify(agencyJson, null, 2) + "\n",
-	)
-	await Bun.spawn(["git", "add", "agency.json"], {
-		cwd: gitRoot,
-		stdout: "pipe",
-		stderr: "pipe",
-	}).exited
-	await createCommit(gitRoot, "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
-}
-
-async function addRemote(cwd: string, remoteUrl: string): Promise<void> {
-	await Bun.spawn(["git", "remote", "add", "origin", remoteUrl], {
-		cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-	}).exited
-}
-
-async function getCommitCount(cwd: string, branch: string): Promise<number> {
-	const proc = Bun.spawn(["git", "rev-list", "--count", branch], {
-		cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	await proc.exited
-	const output = await new Response(proc.stdout).text()
-	return parseInt(output.trim(), 10)
-}
-
-async function getLatestCommitMessage(cwd: string): Promise<string> {
-	const proc = Bun.spawn(["git", "log", "-1", "--pretty=%B"], {
-		cwd,
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	await proc.exited
-	const output = await new Response(proc.stdout).text()
-	return output.trim()
-}
-
-describe("pull 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 Bun.spawn(["git", "branch", "-m", "main"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-		}
-
-		// Setup bare remote
-		remoteDir = await setupBareRemote(tempDir)
-		await addRemote(tempDir, remoteDir)
-
-		// Push main to remote
-		await Bun.spawn(["git", "push", "-u", "origin", "main"], {
-			cwd: tempDir,
-			stdout: "pipe",
-			stderr: "pipe",
-		}).exited
-	})
-
-	afterEach(async () => {
-		process.chdir(originalCwd)
-		delete process.env.AGENCY_CONFIG_PATH
-		await cleanupTempDir(tempDir)
-	})
-
-	describe("basic functionality", () => {
-		test("pulls commits from remote emit branch to source branch", async () => {
-			// Setup agency.json
-			await setupAgencyJson(tempDir)
-
-			// Create source branch: A1 A2
-			await createBranch(tempDir, "agency--feature")
-			await createCommit(tempDir, "A1: Feature work")
-
-			// Simulate agency emit: create local emit branch (B1) with rewritten history
-			await createBranch(tempDir, "feature")
-			// For test simplicity, we're not actually rewriting history, just creating emit branch
-
-			// Push emit branch to remote
-			await Bun.spawn(["git", "push", "-u", "origin", "feature"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Now local emit and remote emit are in sync (both at B1)
-			// Simulate someone adding commits to remote emit branch (B2, B3)
-			await Bun.write(join(tempDir, "file1.txt"), "content1")
-			await Bun.spawn(["git", "add", "file1.txt"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "B2: Remote commit 1")
-
-			await Bun.write(join(tempDir, "file2.txt"), "content2")
-			await Bun.spawn(["git", "add", "file2.txt"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "B3: Remote commit 2")
-
-			await Bun.spawn(["git", "push"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Reset local emit branch to B1 (before the remote commits B2, B3)
-			// This simulates the state where remote has moved ahead
-			await Bun.spawn(["git", "reset", "--hard", "HEAD~2"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Go back to source branch (still at A1)
-			await checkoutBranch(tempDir, "agency--feature")
-			const beforeCommitCount = await getCommitCount(tempDir, "agency--feature")
-
-			// Run pull command - should find B2 and B3 on remote that aren't on local emit
-			// and cherry-pick them onto source as A2 and A3
-			await runTestEffect(pull({ silent: true }))
-
-			// Should still be on source branch
-			expect(await getCurrentBranch(tempDir)).toBe("agency--feature")
-
-			// Should have the new commits
-			const afterCommitCount = await getCommitCount(tempDir, "agency--feature")
-			expect(afterCommitCount).toBe(beforeCommitCount + 2)
-
-			// Last commit should be the second remote commit
-			const lastCommit = await getLatestCommitMessage(tempDir)
-			expect(lastCommit).toBe("B3: Remote commit 2")
-		})
-
-		test("handles no new commits gracefully", async () => {
-			// Setup agency.json
-			await setupAgencyJson(tempDir)
-
-			// Create a source branch
-			await createBranch(tempDir, "agency--feature")
-			await createCommit(tempDir, "Feature work")
-
-			// Create emit branch with same commits
-			await createBranch(tempDir, "feature")
-
-			// Push emit branch to remote
-			await Bun.spawn(["git", "push", "-u", "origin", "feature"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Go back to source branch
-			await checkoutBranch(tempDir, "agency--feature")
-
-			// Capture output
-			const originalLog = console.log
-			let logMessages: string[] = []
-			console.log = (msg: string) => {
-				logMessages.push(msg)
-			}
-
-			// Run pull command - should report no new commits
-			await runTestEffect(pull({ silent: false }))
-
-			console.log = originalLog
-
-			// Should report no new commits
-			expect(logMessages.some((msg) => msg.includes("No new commits"))).toBe(
-				true,
-			)
-
-			// Should still be on source branch
-			expect(await getCurrentBranch(tempDir)).toBe("agency--feature")
-		})
-
-		test("works with custom remote", async () => {
-			// Setup agency.json
-			await setupAgencyJson(tempDir)
-
-			// Create a source branch
-			await createBranch(tempDir, "agency--feature")
-			await createCommit(tempDir, "Feature work")
-
-			// Create local emit branch
-			await createBranch(tempDir, "feature")
-
-			// Add a second remote
-			const upstreamDir = await setupBareRemote(tempDir)
-			await Bun.spawn(["git", "remote", "add", "upstream", upstreamDir], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Push emit branch to upstream
-			await Bun.spawn(["git", "push", "-u", "upstream", "feature"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Add a commit to upstream remote
-			await Bun.write(join(tempDir, "upstream-file.txt"), "upstream content")
-			await Bun.spawn(["git", "add", "upstream-file.txt"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Emit commit")
-			await Bun.spawn(["git", "push", "upstream", "feature"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Reset local emit branch to before the upstream commit
-			await Bun.spawn(["git", "reset", "--hard", "HEAD~1"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Go back to source branch
-			await checkoutBranch(tempDir, "agency--feature")
-
-			// Run pull with custom remote
-			await runTestEffect(pull({ remote: "upstream", silent: true }))
-
-			// Should still be on source branch
-			expect(await getCurrentBranch(tempDir)).toBe("agency--feature")
-
-			// Should have the new commit
-			const lastCommit = await getLatestCommitMessage(tempDir)
-			expect(lastCommit).toBe("Emit commit")
-		})
-	})
-
-	describe("error handling", () => {
-		test("throws error when not in a git repository", async () => {
-			const nonGitDir = await createTempDir()
-			process.chdir(nonGitDir)
-
-			await expect(runTestEffect(pull({ silent: true }))).rejects.toThrow(
-				"Not in a git repository",
-			)
-
-			await cleanupTempDir(nonGitDir)
-		})
-
-		test("handles case when only source branch exists (no emit on remote)", async () => {
-			// Setup agency.json
-			await setupAgencyJson(tempDir)
-
-			// Create a source branch
-			await createBranch(tempDir, "agency--feature")
-			await setupAgencyJson(tempDir, "feature")
-			await createCommit(tempDir, "Feature work")
-
-			// Don't create or push emit branch - just test that pull handles this gracefully
-			// Run pull - should fail because remote emit branch doesn't exist
-			await expect(runTestEffect(pull({ silent: true }))).rejects.toThrow()
-		})
-
-		test("throws error when remote emit branch does not exist", async () => {
-			// Setup agency.json
-			await setupAgencyJson(tempDir)
-
-			// Create a source branch
-			await createBranch(tempDir, "agency--feature")
-			await setupAgencyJson(tempDir, "feature")
-			await createCommit(tempDir, "Feature work")
-
-			// Run pull - should fail because remote emit branch doesn't exist
-			await expect(runTestEffect(pull({ silent: true }))).rejects.toThrow(
-				"Failed to fetch",
-			)
-		})
-	})
-
-	describe("silent mode", () => {
-		test("silent flag suppresses output", async () => {
-			// Setup agency.json
-			await setupAgencyJson(tempDir)
-
-			// Create a source branch
-			await createBranch(tempDir, "agency--feature")
-			await createCommit(tempDir, "Feature work")
-
-			// Create emit branch
-			await createBranch(tempDir, "feature")
-			await createCommit(tempDir, "Emit commit")
-
-			// Push emit branch to remote
-			await Bun.spawn(["git", "push", "-u", "origin", "feature"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			// Go back to source branch
-			await checkoutBranch(tempDir, "agency--feature")
-
-			// Capture output
-			const originalLog = console.log
-			let logCalled = false
-			console.log = () => {
-				logCalled = true
-			}
-
-			await runTestEffect(pull({ silent: true }))
-
-			console.log = originalLog
-			expect(logCalled).toBe(false)
-		})
-	})
-})

package/src/commands/pull.ts

@@ -1,205 +0,0 @@
-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
-`