@markjaquith/agency 1.11.1 → 2.1.0

package/src/commands/push.test.ts

@@ -1,641 +0,0 @@
-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,
-	runTestEffectWithMockFilterRepo,
-} 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(): Promise<string> {
-	// Create a bare repository outside the working tree to avoid polluting git status
-	const remoteDir = await createTempDir()
-	await Bun.spawn(["git", "init", "--bare", remoteDir], {
-		stdout: "pipe",
-		stderr: "pipe",
-	}).exited
-	return remoteDir
-}
-
-async function checkoutNonAgencyBranch(gitRoot: string): Promise<void> {
-	const proc = Bun.spawn(
-		["git", "checkout", "-q", "-b", "plain-feature", "origin/main"],
-		{
-			cwd: gitRoot,
-			stdout: "pipe",
-			stderr: "pipe",
-		},
-	)
-	const exitCode = await proc.exited
-	if (exitCode !== 0) {
-		throw new Error(await new Response(proc.stderr).text())
-	}
-}
-
-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()
-		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)
-		await cleanupTempDir(remoteDir)
-	})
-
-	describe("basic functionality", () => {
-		test("falls back to git push outside agency context", async () => {
-			await checkoutNonAgencyBranch(tempDir)
-			await createCommit(tempDir, "Plain feature work")
-			await Bun.write(join(tempDir, "uncommitted.txt"), "uncommitted\n")
-
-			await runTestEffect(
-				push({
-					gitArgs: ["origin", "plain-feature"],
-					silent: true,
-				}),
-			)
-
-			const localHead = await getGitOutput(tempDir, ["rev-parse", "HEAD"])
-			const remoteHead = await getGitOutput(tempDir, [
-				"rev-parse",
-				"refs/remotes/origin/plain-feature",
-			])
-			expect(remoteHead.trim()).toBe(localHead.trim())
-			expect(await Bun.file(join(tempDir, "uncommitted.txt")).exists()).toBe(
-				true,
-			)
-		})
-
-		test("forwards --no-verify to the git push fallback", async () => {
-			await checkoutNonAgencyBranch(tempDir)
-			await createCommit(tempDir, "Plain feature work")
-
-			await Bun.spawn(
-				["git", "config", "core.hooksPath", join(tempDir, ".git", "hooks")],
-				{
-					cwd: tempDir,
-					stdout: "pipe",
-					stderr: "pipe",
-				},
-			).exited
-			const hookPath = join(tempDir, ".git", "hooks", "pre-push")
-			await Bun.write(hookPath, "#!/bin/sh\nexit 1\n")
-			await Bun.spawn(["chmod", "+x", hookPath], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			await runTestEffect(
-				push({
-					gitArgs: ["origin", "plain-feature"],
-					noVerify: true,
-					silent: true,
-				}),
-			)
-
-			const remoteBranches = await getGitOutput(tempDir, [
-				"ls-remote",
-				"--heads",
-				"origin",
-				"plain-feature",
-			])
-			expect(remoteBranches).toContain("plain-feature")
-		})
-
-		test("forwards force modes to the git push fallback", async () => {
-			await checkoutNonAgencyBranch(tempDir)
-			await createCommit(tempDir, "Initial plain feature work")
-			await Bun.spawn(["git", "push", "-u", "origin", "plain-feature"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			await createCommit(tempDir, "Remote state for lease")
-			await Bun.spawn(["git", "push"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await Bun.spawn(["git", "reset", "--hard", "HEAD~1"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Lease-protected rewrite")
-
-			await runTestEffect(push({ forceWithLease: true, silent: true }))
-
-			await createCommit(tempDir, "Remote state for force")
-			await Bun.spawn(["git", "push"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await Bun.spawn(["git", "reset", "--hard", "HEAD~1"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-			await createCommit(tempDir, "Forced rewrite")
-
-			await runTestEffect(push({ force: true, silent: true }))
-
-			const localHead = await getGitOutput(tempDir, ["rev-parse", "HEAD"])
-			const remoteHead = await getGitOutput(tempDir, [
-				"ls-remote",
-				"origin",
-				"refs/heads/plain-feature",
-			])
-			expect(remoteHead.split("\t")[0]).toBe(localHead.trim())
-		})
-
-		test("fails when there are uncommitted changes", async () => {
-			// Create uncommitted changes
-			await Bun.write(join(tempDir, "uncommitted.txt"), "uncommitted\n")
-
-			expect(
-				runTestEffect(
-					push({ baseBranch: "main", silent: true, skipFilter: true }),
-				),
-			).rejects.toThrow(/uncommitted changes/)
-		})
-
-		test("fails when there are staged but uncommitted changes", async () => {
-			// Create a staged but uncommitted change
-			await Bun.write(join(tempDir, "staged.txt"), "staged\n")
-			await Bun.spawn(["git", "add", "staged.txt"], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			expect(
-				runTestEffect(
-					push({ baseBranch: "main", silent: true, skipFilter: true }),
-				),
-			).rejects.toThrow(/uncommitted changes/)
-		})
-
-		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("forwards verbose output from emit step", async () => {
-			const originalLog = console.log
-			const logMessages: string[] = []
-			console.log = (msg: string) => {
-				logMessages.push(msg)
-			}
-
-			try {
-				await runTestEffect(
-					push({
-						baseBranch: "main",
-						verbose: true,
-						skipFilter: true,
-					}),
-				)
-			} finally {
-				console.log = originalLog
-			}
-
-			expect(logMessages).toContain("Step 1: Emitting...")
-			expect(
-				logMessages.some(
-					(msg) => msg.includes("Using base branch:") && msg.includes("main"),
-				),
-			).toBe(true)
-			expect(
-				logMessages.some((msg) =>
-					msg.includes("Skipping git-filter-repo (skipFilter=true)"),
-				),
-			).toBe(true)
-			expect(logMessages.some((msg) => msg.includes("Emitted"))).toBe(true)
-		})
-
-		test("works with custom branch name", async () => {
-			await runTestEffect(
-				push({
-					baseBranch: "main",
-					emit: "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("throws when emitted CLAUDE.md references AGENCY.md", async () => {
-			await Bun.write(
-				join(tempDir, "CLAUDE.md"),
-				"# Instructions\n\n@AGENCY.md\n",
-			)
-			await addAndCommit(tempDir, "CLAUDE.md", "Add Claude agency reference")
-
-			await expect(
-				runTestEffectWithMockFilterRepo(
-					push({ baseBranch: "main", silent: true }),
-				),
-			).rejects.toThrow(
-				"Failed to create emit branch: CLAUDE.md on emitted branch feature still references @AGENCY.md",
-			)
-		})
-
-		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(
-				/non-fast-forward update.*agency push --force|agency push --force.*non-fast-forward update/s,
-			)
-
-			// Should still be on agency--feature branch (not left in intermediate state)
-			expect(await getCurrentBranch(tempDir)).toBe("agency--feature")
-		})
-
-		test("reports pre-push hook output without suggesting --force", async () => {
-			await Bun.spawn(
-				["git", "config", "core.hooksPath", join(tempDir, ".git", "hooks")],
-				{
-					cwd: tempDir,
-					stdout: "pipe",
-					stderr: "pipe",
-				},
-			).exited
-			const hookPath = join(tempDir, ".git", "hooks", "pre-push")
-			await Bun.write(
-				hookPath,
-				[
-					"#!/bin/sh",
-					"printf 'pre-push hook stdout failure\\n'",
-					"printf 'pre-push hook stderr failure\\n' >&2",
-					"exit 1",
-					"",
-				].join("\n"),
-			)
-			await Bun.spawn(["chmod", "+x", hookPath], {
-				cwd: tempDir,
-				stdout: "pipe",
-				stderr: "pipe",
-			}).exited
-
-			let error: unknown
-			try {
-				await runTestEffect(
-					push({ baseBranch: "main", silent: true, skipFilter: true }),
-				)
-			} catch (caught) {
-				error = caught
-			}
-
-			expect(error).toBeInstanceOf(Error)
-			const message = error instanceof Error ? error.message : String(error)
-			expect(message).toContain("pre-push hook stdout failure")
-			expect(message).toContain("pre-push hook stderr failure")
-			expect(message).not.toContain("agency push --force")
-
-			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)
-		})
-	})
-})