@markjaquith/agency 1.11.1 → 2.0.0

package/src/commands/push.ts

@@ -1,482 +0,0 @@
-import { Effect, Either } from "effect"
-import type { BaseCommandOptions } from "../utils/command"
-import { GitCommandError, GitService } from "../services/GitService"
-import { ConfigService } from "../services/ConfigService"
-import { resolveAgencyBranchPairWithAgencyJson } from "../utils/pr-branch"
-import { emit } from "./emit"
-import highlight, { done } from "../utils/colors"
-import {
-	createLoggers,
-	ensureGitRepo,
-	getRemoteName,
-	withBranchProtection,
-} from "../utils/effect"
-import { withSpinner } from "../utils/spinner"
-import { spawnProcess } from "../utils/process"
-
-interface PushOptions extends BaseCommandOptions {
-	baseBranch?: string
-	gitArgs?: string[]
-	emit?: string
-	branch?: string // Deprecated: use emit instead
-	force?: boolean
-	forceWithLease?: boolean
-	noVerify?: boolean
-	pr?: boolean
-	skipFilter?: boolean
-}
-
-const getFallbackGitPushArgs = (options: PushOptions): string[] => {
-	const args: string[] = []
-
-	if (options.force) {
-		args.push("--force")
-	}
-	if (options.forceWithLease) {
-		args.push("--force-with-lease")
-	}
-	if (options.noVerify) {
-		args.push("--no-verify")
-	}
-
-	args.push(...(options.gitArgs ?? []))
-	return args
-}
-
-const pushWithGit = (gitRoot: string, options: PushOptions) =>
-	Effect.gen(function* () {
-		const args = ["git", "push", ...getFallbackGitPushArgs(options)]
-		const result = yield* spawnProcess(args, {
-			cwd: gitRoot,
-			stdin: "inherit",
-			stdout: options.silent ? "pipe" : "inherit",
-			stderr: options.silent ? "pipe" : "inherit",
-		})
-
-		if (result.exitCode !== 0) {
-			return yield* Effect.fail(
-				new GitCommandError({
-					command: args.join(" "),
-					exitCode: result.exitCode,
-					stderr: result.stderr,
-				}),
-			)
-		}
-	})
-
-const getPushFailureStderr = (error: unknown): string => {
-	if (error instanceof GitCommandError) {
-		return error.stderr.trim()
-	}
-
-	if (
-		typeof error === "object" &&
-		error !== null &&
-		"cause" in error &&
-		(error as { cause?: unknown }).cause instanceof GitCommandError
-	) {
-		return (error as { cause: GitCommandError }).cause.stderr.trim()
-	}
-
-	if (error instanceof Error) {
-		return error.message.trim()
-	}
-
-	return String(error).trim()
-}
-
-const formatProcessOutput = (result: {
-	readonly stdout?: string
-	readonly stderr?: string
-}): string => [result.stdout, result.stderr].filter(Boolean).join("\n").trim()
-
-const pushFailureNeedsForce = (stderr: string): boolean => {
-	const normalized = stderr.toLowerCase()
-
-	return (
-		normalized.includes("non-fast-forward") ||
-		normalized.includes(
-			"updates were rejected because the tip of your current branch is behind",
-		) ||
-		(normalized.includes("[rejected]") && normalized.includes("fetch first"))
-	)
-}
-
-const formatPushFailure = (error: unknown): Error => {
-	const stderr = getPushFailureStderr(error)
-
-	if (pushFailureNeedsForce(stderr)) {
-		return new Error(
-			"Failed to push branch to remote: the remote rejected a non-fast-forward update, which usually means the branch was rebased or rewritten.\n" +
-				"Run `agency push --force` to replace the remote branch.",
-		)
-	}
-
-	return new Error(`Failed to push branch to remote: ${stderr}`)
-}
-
-export const push = (options: PushOptions = {}) =>
-	Effect.gen(function* () {
-		const gitRoot = yield* ensureGitRepo()
-
-		// Wrap the entire push operation with branch protection
-		// This ensures we return to the original branch on Ctrl-C interrupt
-		yield* withBranchProtection(gitRoot, pushCore(gitRoot, options))
-	})
-
-const pushCore = (gitRoot: string, options: PushOptions) =>
-	Effect.gen(function* () {
-		const { log, verboseLog } = createLoggers(options)
-
-		const git = yield* GitService
-		const configService = yield* ConfigService
-
-		// Load config to check emit branch pattern
-		const config = yield* configService.loadConfig()
-
-		// Get current branch
-		let sourceBranch = yield* git.getCurrentBranch(gitRoot)
-
-		// Check if we're already on an emit branch using proper branch resolution
-		const branchInfo = yield* resolveAgencyBranchPairWithAgencyJson(
-			gitRoot,
-			sourceBranch,
-			config.sourceBranchPattern,
-			config.emitBranch,
-		)
-
-		if (!branchInfo) {
-			verboseLog("Outside agency branch context; falling back to git push")
-			return yield* pushWithGit(gitRoot, options)
-		}
-
-		// Agency push performs internal checkouts, so require a clean worktree.
-		const statusOutput = yield* git.getStatus(gitRoot)
-
-		if (statusOutput && statusOutput.trim().length > 0) {
-			return yield* Effect.fail(
-				new Error(
-					`You have uncommitted changes. Please commit or stash them before pushing.\n` +
-						`The push command performs internal checkouts that would destroy uncommitted work.\n` +
-						`Run 'git status' to see the changes.`,
-				),
-			)
-		}
-
-		verboseLog(`Working directory is clean`)
-
-		// If we're on an emit branch, switch to the source branch first
-		if (branchInfo.isOnEmitBranch) {
-			const actualSourceBranch = branchInfo.sourceBranch
-			// Check if the source branch exists
-			const sourceExists = yield* git.branchExists(gitRoot, actualSourceBranch)
-			if (sourceExists) {
-				verboseLog(
-					`Currently on emit branch ${highlight.branch(sourceBranch)}, switching to source branch ${highlight.branch(actualSourceBranch)}`,
-				)
-				yield* git.checkoutBranch(gitRoot, actualSourceBranch)
-				sourceBranch = actualSourceBranch
-			}
-		}
-
-		verboseLog(`Starting push workflow from ${highlight.branch(sourceBranch)}`)
-
-		// Step 1: Create emit branch (agency emit)
-		verboseLog("Step 1: Emitting...")
-		// Use the emit command for the entire emit step so push and emit stay in sync.
-		const prEffectWithOptions = emit({
-			baseBranch: options.baseBranch,
-			emit: options.emit || options.branch,
-			silent: options.silent,
-			force: options.force,
-			verbose: options.verbose,
-			skipFilter: options.skipFilter,
-		})
-
-		const prResult = yield* Effect.either(prEffectWithOptions)
-		if (Either.isLeft(prResult)) {
-			const error =
-				prResult.left instanceof Error
-					? prResult.left
-					: new Error(String(prResult.left))
-			const message = error.message || ""
-			const ignorable =
-				message === "" ||
-				message.includes("already exists") ||
-				message.includes("check if branch exists")
-
-			if (!ignorable) {
-				return yield* Effect.fail(
-					new Error(`Failed to create emit branch: ${message}`),
-				)
-			}
-
-			verboseLog("Emit reported existing branch; continuing")
-		}
-
-		// Compute the emit branch name (emit() command now stays on source branch)
-		// Use the branchInfo we already computed earlier
-		const emitBranchName =
-			options.emit || options.branch || branchInfo.emitBranch
-
-		// Step 2: Push to remote (git push)
-		const remote = yield* getRemoteName(gitRoot)
-		verboseLog(
-			`Step 2: Pushing ${highlight.branch(emitBranchName)} to ${highlight.remote(remote)}...`,
-		)
-
-		// Switch to emit branch before pushing so that pre-push hooks run
-		// in the context of the emit branch (without backpack files)
-		yield* git.checkoutBranch(gitRoot, emitBranchName)
-
-		const pushEither = yield* Effect.either(
-			withSpinner(
-				pushBranchToRemoteEffect(gitRoot, emitBranchName, remote, {
-					force: options.force,
-					forceWithLease: options.forceWithLease,
-					noVerify: options.noVerify,
-					verbose: options.verbose,
-				}),
-				{
-					text:
-						options.force || options.forceWithLease
-							? `Pushing to ${highlight.remote(remote)} (forced)`
-							: `Pushing to ${highlight.remote(remote)}`,
-					enabled: !options.silent && !options.verbose,
-				},
-			),
-		)
-		if (Either.isLeft(pushEither)) {
-			const error = formatPushFailure(pushEither.left)
-			// If push failed, switch back to source branch
-			yield* git.checkoutBranch(gitRoot, sourceBranch)
-			return yield* Effect.fail(error)
-		}
-
-		const usedForce = pushEither.right
-
-		if (usedForce) {
-			log(done(`Pushed to ${highlight.remote(remote)} (forced)`))
-		} else {
-			log(done(`Pushed to ${highlight.remote(remote)}`))
-		}
-
-		// Step 3 (optional): Open GitHub PR if --pr flag is set
-		if (options.pr) {
-			verboseLog("Step 3: Opening GitHub PR...")
-
-			const ghEither = yield* Effect.either(
-				openGitHubPR(gitRoot, emitBranchName, {
-					verbose: options.verbose,
-				}),
-			)
-
-			if (Either.isLeft(ghEither)) {
-				const error = ghEither.left
-				// Don't fail the entire command if gh fails, just warn
-				console.error(
-					`⚠ Failed to open GitHub PR: ${error instanceof Error ? error.message : String(error)}`,
-				)
-			} else {
-				log(done("Opened GitHub PR in browser"))
-			}
-		}
-
-		// Switch back to source branch
-		yield* git.checkoutBranch(gitRoot, sourceBranch)
-	})
-
-// Helper: Push branch to remote with optional force and retry logic
-const pushBranchToRemoteEffect = (
-	gitRoot: string,
-	branchName: string,
-	remote: string,
-	options: {
-		readonly force?: boolean
-		readonly forceWithLease?: boolean
-		readonly noVerify?: boolean
-		readonly verbose?: boolean
-	},
-) =>
-	Effect.gen(function* () {
-		const git = yield* GitService
-		const { force = false, forceWithLease = false, noVerify = false } = options
-
-		// Try pushing without force first
-		const pushResult = yield* git
-			.push(gitRoot, remote, branchName, { setUpstream: true, noVerify })
-			.pipe(
-				Effect.catchAll((error: any) =>
-					Effect.succeed({
-						exitCode: error.exitCode ?? -1,
-						stdout: "",
-						stderr: error.stderr ?? String(error),
-					}),
-				),
-			)
-
-		let usedForce = false
-
-		// If push failed, check if we should retry with --force
-		if (pushResult.exitCode !== 0) {
-			const stderr = formatProcessOutput(pushResult)
-
-			// Check if this is a force-push-needed error
-			const needsForce = pushFailureNeedsForce(stderr)
-
-			if (needsForce && (force || forceWithLease)) {
-				// Retry using the force mode explicitly requested by the user.
-				const forceResult = yield* git
-					.push(gitRoot, remote, branchName, {
-						setUpstream: true,
-						force,
-						forceWithLease,
-						noVerify,
-					})
-					.pipe(
-						Effect.catchAll((error: any) =>
-							Effect.succeed({
-								exitCode: error.exitCode ?? -1,
-								stdout: "",
-								stderr: error.stderr ?? String(error),
-							}),
-						),
-					)
-
-				if (forceResult.exitCode !== 0) {
-					return yield* Effect.fail(
-						new Error(
-							`Failed to force push branch to remote: ${formatProcessOutput(forceResult)}`,
-						),
-					)
-				}
-
-				usedForce = true
-			} else if (needsForce) {
-				// User didn't provide --force but it's needed
-				return yield* Effect.fail(
-					formatPushFailure(
-						new GitCommandError({
-							command: `git push -u ${remote} ${branchName}`,
-							exitCode: pushResult.exitCode,
-							stderr,
-						}),
-					),
-				)
-			} else {
-				// Some other error
-				return yield* Effect.fail(
-					formatPushFailure(
-						new GitCommandError({
-							command: `git push -u ${remote} ${branchName}`,
-							exitCode: pushResult.exitCode,
-							stderr,
-						}),
-					),
-				)
-			}
-		}
-
-		return usedForce
-	})
-
-// Helper: Open GitHub PR using gh CLI
-const openGitHubPR = (
-	gitRoot: string,
-	branchName: string,
-	options: {
-		readonly verbose?: boolean
-	},
-) =>
-	Effect.gen(function* () {
-		const { verbose = false } = options
-
-		// Run gh pr create --web with --head to specify the emit branch
-		// Set environment variables to ensure non-interactive mode in CI
-		// Add a 3 second timeout to prevent hanging in CI environments
-		const ghEffect = spawnProcess(
-			["gh", "pr", "create", "--web", "--head", branchName],
-			{
-				cwd: gitRoot,
-				stdout: verbose ? "inherit" : "pipe",
-				stderr: "pipe",
-				env: {
-					GH_PROMPT_DISABLED: "1",
-					NO_COLOR: "1",
-				},
-			},
-		).pipe(
-			Effect.timeout("3 seconds"),
-			Effect.catchAll((error) => {
-				// Handle timeout or process errors
-				if (error._tag === "TimeoutException") {
-					return Effect.succeed({
-						exitCode: -1,
-						stdout: "",
-						stderr: "gh command timed out after 3 seconds",
-					})
-				}
-				// Handle ProcessError
-				return Effect.succeed({
-					exitCode: (error as any).exitCode ?? -1,
-					stdout: "",
-					stderr: (error as any).stderr ?? String(error),
-				})
-			}),
-		)
-
-		const ghResult = yield* ghEffect
-
-		if (ghResult.exitCode !== 0) {
-			return yield* Effect.fail(
-				new Error(`gh CLI command failed: ${ghResult.stderr.trim()}`),
-			)
-		}
-	})
-
-export const help = `
-Usage: agency push [arguments] [options]
-
-Create an emit branch, push it to remote, and return to the source branch.
-Outside agency branch context, fall through to plain 'git push'.
-
-This command is a convenience wrapper that runs operations in sequence:
-  1. agency emit [base-branch]  - Create emit branch with backpack files reverted
-  2. git push -u origin <pr-branch>  - Push emit branch to remote
-  3. gh pr create --web (optional with --pr)  - Open GitHub PR in browser
-  4. git checkout <source-branch>  - Switch back to source branch
-
-The command ensures you end up back on your source branch after pushing
-the emit branch, making it easy to continue working locally while having
-a clean emit branch ready on the remote.
-
-Base Branch Selection:
-  Same as 'agency emit' - see 'agency emit --help' for details
-
-Prerequisites:
-  - Agency branch pushes require git-filter-repo: brew install git-filter-repo
-  - A Git remote must be configured
-
-Arguments:
-  arguments         In agency context, the first argument is the base branch.
-                    Otherwise, arguments are passed to git push as remote/refspecs.
-
-Options:
-  --emit            Custom name for emit branch (defaults to pattern from config)
-  --branch          (Deprecated: use --emit) Custom name for emit branch
-  -f, --force       Force push to remote if branch has diverged
-  --force-with-lease  Force push only if the remote branch is unchanged
-  --no-verify       Bypass git pre-push hooks
-  --pr              Open GitHub PR in browser after pushing (requires gh CLI)
-
-Examples:
-  agency push                       # Push the emitted branch or current branch
-  agency push origin/main           # Use an explicit base in agency context
-  agency push origin feature        # Pass remote/refspec outside agency context
-
-Notes:
-  - Outside agency context, positional arguments and --force, --force-with-lease, and --no-verify are passed to git push
-  - In agency context, creates or recreates the emit branch and pushes it with -u
-  - In agency context, automatically returns to the source branch after pushing
-  - If any step fails, the command stops and reports the error
-`