@markjaquith/agency 1.11.1 → 2.1.0

package/src/commands/merge.test.ts

@@ -1,246 +0,0 @@
-import { test, expect, describe, beforeEach, afterEach } from "bun:test"
-import { join } from "path"
-import { merge } from "./merge"
-import { emit } from "./emit"
-import { task } from "./task"
-import {
-	createTempDir,
-	cleanupTempDir,
-	initGitRepo,
-	initAgency,
-	getGitOutput,
-	getCurrentBranch,
-	createCommit,
-	checkoutBranch,
-	createBranch,
-	addAndCommit,
-	setupRemote,
-	deleteBranch,
-	runTestEffect,
-} from "../test-utils"
-
-describe("merge command", () => {
-	let tempDir: 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")
-		// Set config dir to temp dir to avoid picking up user's config files
-		process.env.AGENCY_CONFIG_DIR = await createTempDir()
-
-		// Initialize git repo with main branch (already includes initial commit)
-		await initGitRepo(tempDir)
-
-		// Set up origin for git-filter-repo
-		await setupRemote(tempDir, "origin", tempDir)
-
-		// Create a source branch (with agency-- prefix per new default config)
-		await createBranch(tempDir, "agency--feature")
-
-		// Initialize AGENTS.md on feature branch
-		await initAgency(tempDir, "test")
-
-		await runTestEffect(task({ silent: true, fromCurrent: true }))
-
-		// Ensure agency.json has baseBranch set (task should auto-detect it, but ensure it's there)
-		const agencyJsonPath = join(tempDir, "agency.json")
-		const agencyJson = await Bun.file(agencyJsonPath).json()
-		if (!agencyJson.baseBranch) {
-			agencyJson.baseBranch = "origin/main"
-			await Bun.write(
-				agencyJsonPath,
-				JSON.stringify(agencyJson, null, 2) + "\n",
-			)
-		}
-
-		await addAndCommit(tempDir, "AGENTS.md agency.json", "Add AGENTS.md")
-
-		// Create another commit on feature branch
-		await createCommit(tempDir, "Feature work")
-	})
-
-	afterEach(async () => {
-		process.chdir(originalCwd)
-		delete process.env.AGENCY_CONFIG_PATH
-		if (process.env.AGENCY_CONFIG_DIR) {
-			await cleanupTempDir(process.env.AGENCY_CONFIG_DIR)
-			delete process.env.AGENCY_CONFIG_DIR
-		}
-		await cleanupTempDir(tempDir)
-	})
-
-	describe("error handling", () => {
-		test("throws error when not in a git repository", async () => {
-			const nonGitDir = await createTempDir()
-			process.chdir(nonGitDir)
-
-			await expect(runTestEffect(merge({ silent: true }))).rejects.toThrow(
-				"Not in a git repository",
-			)
-
-			await cleanupTempDir(nonGitDir)
-		})
-
-		test("throws error if base branch does not exist locally", async () => {
-			// Create emit branch (skipFilter for speed since we're testing error handling)
-			await runTestEffect(emit({ silent: true, skipFilter: true }))
-
-			// Delete main branch (the base)
-			await checkoutBranch(tempDir, "feature")
-			await deleteBranch(tempDir, "main", true)
-
-			// Try to merge - should fail
-			await expect(
-				runTestEffect(merge({ silent: true, skipFilter: true })),
-			).rejects.toThrow("does not exist locally")
-		})
-	})
-
-	describe("silent mode", () => {
-		test("silent flag suppresses output", async () => {
-			const logs: string[] = []
-			const originalLog = console.log
-			console.log = (...args: any[]) => logs.push(args.join(" "))
-
-			await runTestEffect(merge({ silent: true, skipFilter: true }))
-
-			console.log = originalLog
-
-			expect(logs.length).toBe(0)
-		})
-	})
-
-	describe("squash merge", () => {
-		test("performs squash merge when --squash flag is set", async () => {
-			// We're on feature branch (source)
-			const currentBranch = await getCurrentBranch(tempDir)
-			expect(currentBranch).toBe("agency--feature")
-
-			// Run merge with squash flag (skipFilter for speed, we're testing squash behavior)
-			await runTestEffect(
-				merge({ silent: true, squash: true, skipFilter: true }),
-			)
-
-			// Should be on main branch after merge
-			const afterMergeBranch = await getCurrentBranch(tempDir)
-			expect(afterMergeBranch).toBe("main")
-
-			// Check that changes are staged but not committed
-			const status = await getGitOutput(tempDir, ["status", "--porcelain"])
-
-			// Staged changes should be present (indicated by status codes in first column)
-			expect(status.trim().length).toBeGreaterThan(0)
-
-			// Get the log to verify no merge commit was created
-			const log = await getGitOutput(tempDir, ["log", "--oneline", "-5"])
-
-			// Should not contain a merge commit message
-			expect(log).not.toContain("Merge branch")
-		})
-
-		test("performs regular merge when --squash flag is not set", async () => {
-			// We're on feature branch (source)
-			const currentBranch = await getCurrentBranch(tempDir)
-			expect(currentBranch).toBe("agency--feature")
-
-			// Run merge without squash flag (skipFilter for speed, we're testing merge behavior)
-			await runTestEffect(
-				merge({ silent: true, squash: false, skipFilter: true }),
-			)
-
-			// Should be on main branch after merge
-			const afterMergeBranch = await getCurrentBranch(tempDir)
-			expect(afterMergeBranch).toBe("main")
-
-			// With regular merge (not squash), there should be no staged changes
-			const status = await getGitOutput(tempDir, ["status", "--porcelain"])
-
-			// No staged changes - everything should be committed
-			expect(status.trim().length).toBe(0)
-
-			// Get the log to verify commits were included
-			const log = await getGitOutput(tempDir, ["log", "--oneline", "-5"])
-
-			// Should contain the feature work commit (regular merge includes all commits)
-			expect(log).toContain("Feature work")
-		})
-	})
-
-	describe("push flag", () => {
-		test("pushes base branch to origin when --push flag is set", async () => {
-			// We're on feature branch (source)
-			const currentBranch = await getCurrentBranch(tempDir)
-			expect(currentBranch).toBe("agency--feature")
-
-			// Get the current commit on main before merge
-			await checkoutBranch(tempDir, "main")
-			const beforeCommit = (
-				await getGitOutput(tempDir, ["rev-parse", "HEAD"])
-			).trim()
-
-			// Go back to feature branch
-			await checkoutBranch(tempDir, "agency--feature")
-
-			// Run merge with push flag (skipFilter for speed, we're testing push behavior)
-			await runTestEffect(merge({ silent: true, push: true, skipFilter: true }))
-
-			// Should be on main branch after merge
-			const afterMergeBranch = await getCurrentBranch(tempDir)
-			expect(afterMergeBranch).toBe("main")
-
-			// Get the current commit on main after merge
-			const afterCommit = (
-				await getGitOutput(tempDir, ["rev-parse", "HEAD"])
-			).trim()
-
-			// The commit should have changed (merge happened)
-			expect(afterCommit).not.toBe(beforeCommit)
-
-			// Verify that origin/main points to the same commit as local main
-			const originMainCommit = (
-				await getGitOutput(tempDir, ["rev-parse", "origin/main"])
-			).trim()
-
-			// origin/main should be at the same commit as local main (push succeeded)
-			expect(originMainCommit).toBe(afterCommit)
-		})
-
-		test("does not push when --push flag is not set", async () => {
-			// We're on feature branch (source)
-			const currentBranch = await getCurrentBranch(tempDir)
-			expect(currentBranch).toBe("agency--feature")
-
-			// Get the current commit on origin/main before merge
-			const beforeOriginCommit = (
-				await getGitOutput(tempDir, ["rev-parse", "origin/main"])
-			).trim()
-
-			// Run merge without push flag (skipFilter for speed, we're testing push behavior)
-			await runTestEffect(merge({ silent: true, skipFilter: true }))
-
-			// Should be on main branch after merge
-			const afterMergeBranch = await getCurrentBranch(tempDir)
-			expect(afterMergeBranch).toBe("main")
-
-			// Get the current commit on origin/main after merge
-			const afterOriginCommit = (
-				await getGitOutput(tempDir, ["rev-parse", "origin/main"])
-			).trim()
-
-			// origin/main should still be at the same commit (no push happened)
-			expect(afterOriginCommit).toBe(beforeOriginCommit)
-
-			// But local main should have moved forward
-			const localMainCommit = (
-				await getGitOutput(tempDir, ["rev-parse", "HEAD"])
-			).trim()
-
-			expect(localMainCommit).not.toBe(beforeOriginCommit)
-		})
-	})
-})

package/src/commands/merge.ts

@@ -1,244 +0,0 @@
-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 result = yield* git.merge(gitRoot, branch, { squash })
-
-		if (result.exitCode !== 0) {
-			return yield* Effect.fail(
-				new GitCommandError({
-					command: `git merge${squash ? " --squash" : ""} ${branch}`,
-					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.push(gitRoot, remote, baseBranchToMergeInto)
-
-			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
-`