@markjaquith/agency 0.5.0

package/src/commands/merge.ts

@@ -0,0 +1,253 @@
+import { Effect } from "effect"
+import type { BaseCommandOptions } from "../utils/command"
+import { GitService, GitCommandError } from "../services/GitService"
+import { ConfigService } from "../services/ConfigService"
+import { resolveBranchPairWithAgencyJson } from "../utils/pr-branch"
+import { FileSystemService } from "../services/FileSystemService"
+import { emit } from "./emit"
+import highlight, { done } from "../utils/colors"
+import {
+	createLoggers,
+	ensureGitRepo,
+	ensureBranchExists,
+	getBaseBranchFromMetadataEffect,
+	getBaseBranchFromBranch,
+	getRemoteName,
+} from "../utils/effect"
+
+interface MergeOptions extends BaseCommandOptions {
+	squash?: boolean
+	push?: boolean
+	skipFilter?: boolean
+}
+
+// Helper to merge a branch using git
+const mergeBranchEffect = (
+	gitRoot: string,
+	branch: string,
+	squash: boolean = false,
+) =>
+	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,
+		})
+
+		if (result.exitCode !== 0) {
+			return yield* Effect.fail(
+				new GitCommandError({
+					command: args.join(" "),
+					exitCode: result.exitCode,
+					stderr: result.stderr,
+				}),
+			)
+		}
+	})
+
+export const merge = (options: MergeOptions = {}) =>
+	Effect.gen(function* () {
+		const { squash = false, push = false, verbose = false } = options
+		const { log, verboseLog } = createLoggers(options)
+
+		const git = yield* GitService
+		const configService = yield* ConfigService
+
+		const gitRoot = yield* ensureGitRepo()
+
+		const config = yield* configService.loadConfig()
+		const currentBranch = yield* git.getCurrentBranch(gitRoot)
+
+		verboseLog(`Current branch: ${highlight.branch(currentBranch)}`)
+
+		// Use proper branch resolution with agency.json support
+		const fs = yield* FileSystemService
+		const branchInfo = yield* resolveBranchPairWithAgencyJson(
+			gitRoot,
+			currentBranch,
+			config.sourceBranchPattern,
+			config.emitBranch,
+		)
+
+		let emitBranchToMerge: string
+		let baseBranchToMergeInto: string
+
+		if (branchInfo.isOnEmitBranch) {
+			const sourceBranch = branchInfo.sourceBranch
+			verboseLog(
+				`Current branch appears to be an emit branch for source: ${highlight.branch(sourceBranch)}`,
+			)
+
+			yield* ensureBranchExists(
+				gitRoot,
+				sourceBranch,
+				`Current branch ${highlight.branch(currentBranch)} appears to be an emit branch, but source branch ${highlight.branch(sourceBranch)} does not exist.\n` +
+					`Cannot merge without a valid source branch.`,
+			)
+
+			// Get the base branch from the source branch's agency.json using git show
+			// No need to checkout the branch - we can read the file directly
+			const configuredBase = yield* getBaseBranchFromBranch(
+				gitRoot,
+				sourceBranch,
+			)
+
+			if (!configuredBase) {
+				return yield* Effect.fail(
+					new Error(
+						`No base branch configured for ${highlight.branch(sourceBranch)}.\n` +
+							`Please switch to ${highlight.branch(sourceBranch)} and run: agency base set <branch>`,
+					),
+				)
+			}
+
+			verboseLog(`Configured base branch: ${highlight.branch(configuredBase)}`)
+
+			// For git operations (checkout/merge), use local branch name
+			baseBranchToMergeInto = git.stripRemotePrefix(configuredBase)
+
+			// Verify local base branch exists
+			yield* ensureBranchExists(
+				gitRoot,
+				baseBranchToMergeInto,
+				`Base branch ${highlight.branch(baseBranchToMergeInto)} does not exist locally.\n` +
+					`You may need to checkout the branch first or update your base branch configuration.`,
+			)
+
+			emitBranchToMerge = currentBranch
+		} else {
+			// We're on a source branch - need to create/update emit branch first
+			verboseLog(
+				`Current branch appears to be a source branch, will create emit branch first`,
+			)
+
+			// Use the emit branch from branchInfo we already computed
+			const emitBranch = branchInfo.emitBranch
+			const emitExists = yield* git.branchExists(gitRoot, emitBranch)
+
+			if (emitExists) {
+				verboseLog(
+					`Emit branch ${highlight.branch(emitBranch)} already exists, will recreate it`,
+				)
+			}
+
+			// Run 'agency emit' to create/update the emit branch
+			verboseLog(`Creating emit branch ${highlight.branch(emitBranch)}...`)
+			yield* emit({ silent: true, verbose, skipFilter: options.skipFilter })
+
+			// emit() leaves us on the source branch, so we can read agency.json directly
+			const configuredBase = yield* getBaseBranchFromMetadataEffect(gitRoot)
+			if (!configuredBase) {
+				return yield* Effect.fail(
+					new Error(
+						`No base branch configured for ${highlight.branch(currentBranch)}.\n` +
+							`Please set one with: agency base set <branch>`,
+					),
+				)
+			}
+
+			verboseLog(`Configured base branch: ${highlight.branch(configuredBase)}`)
+
+			// For git operations (checkout/merge), use local branch name
+			baseBranchToMergeInto = git.stripRemotePrefix(configuredBase)
+
+			// Verify local base branch exists
+			yield* ensureBranchExists(
+				gitRoot,
+				baseBranchToMergeInto,
+				`Base branch ${highlight.branch(baseBranchToMergeInto)} does not exist locally.\n` +
+					`You may need to checkout the branch first or update your base branch configuration.`,
+			)
+
+			emitBranchToMerge = emitBranch
+		}
+
+		// Now switch to the base branch
+		verboseLog(`Switching to ${highlight.branch(baseBranchToMergeInto)}...`)
+		yield* git.checkoutBranch(gitRoot, baseBranchToMergeInto)
+
+		// Merge the emit branch
+		verboseLog(
+			`Merging ${highlight.branch(emitBranchToMerge)} into ${highlight.branch(baseBranchToMergeInto)}${squash ? " (squash)" : ""}...`,
+		)
+		yield* mergeBranchEffect(gitRoot, emitBranchToMerge, squash)
+
+		if (squash) {
+			log(done(`Squash merged (awaiting commit)`))
+		} else {
+			log(done("Merged"))
+		}
+
+		// Push the base branch if --push flag is set
+		if (push) {
+			const remote = yield* getRemoteName(gitRoot)
+			verboseLog(
+				`Pushing ${highlight.branch(baseBranchToMergeInto)} to ${highlight.remote(remote)}...`,
+			)
+
+			const pushResult = yield* git.runGitCommand(
+				["git", "push", remote, baseBranchToMergeInto],
+				gitRoot,
+				{ captureOutput: true },
+			)
+
+			if (pushResult.exitCode !== 0) {
+				return yield* Effect.fail(
+					new GitCommandError({
+						command: `git push ${remote} ${baseBranchToMergeInto}`,
+						exitCode: pushResult.exitCode,
+						stderr: pushResult.stderr,
+					}),
+				)
+			}
+
+			log(done(`Pushed to ${highlight.remote(remote)}`))
+		}
+	})
+
+export const help = `
+Usage: agency merge [options]
+
+Merge the current emit branch into the configured base branch.
+
+This command handles two scenarios:
+  1. If on an emit branch (e.g., feature--PR): Switches to the base branch and merges the emit branch
+  2. If on a source branch (e.g., feature): Runs 'agency emit' first to create/update the emit branch, then merges it
+
+Behavior:
+  - Automatically detects whether you're on a source or emit branch
+  - Retrieves the configured base branch (e.g., 'main') from git config
+  - Switches to the base branch
+  - Merges the emit branch into the base branch
+  - Leaves you on the base branch after merge
+
+This is useful for local development workflows where you want to test merging
+your clean emit branch (without AGENTS.md modifications) into the base branch
+before pushing.
+
+Prerequisites:
+  - Must be on either a source branch or its corresponding emit branch
+  - Base branch must exist locally
+  - For source branches: Must have a corresponding emit branch or be able to create one
+
+Options:
+  --squash                       # Use squash merge instead of regular merge
+  --push                         # Push the base branch to origin after merging
+
+Examples:
+  agency merge                   # From source branch: creates emit branch then merges
+  agency merge --squash          # Squash merge (stages changes, requires manual commit)
+  agency merge --push            # Merge and push the base branch to origin
+
+Notes:
+  - The command determines the base branch from git config (agency.pr.<branch>.baseBranch)
+  - If you're on a source branch, 'agency emit' is run automatically
+  - The emit branch must have both a source branch and base branch configured
+  - After merge, you remain on the base branch
+  - Merge conflicts must be resolved manually if they occur
+  - With --squash, changes are staged but not committed (you must commit manually)
+  - With --push, the base branch is pushed to origin after a successful merge
+`

package/src/commands/pull.test.ts

@@ -0,0 +1,385 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+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)
+		})
+	})
+})