@markjaquith/agency 1.9.3 → 1.9.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "1.9.3",
+  "version": "1.9.5",
   "description": "Manages personal agents files",
   "keywords": [
     "agents",

package/src/commands/pr.test.ts

@@ -0,0 +1,177 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { chmod, mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import { pr } from "./pr"
+import {
+	cleanupTempDir,
+	createBranch,
+	createTempDir,
+	initGitRepo,
+	runTestEffect,
+} from "../test-utils"
+
+const restoreEnv = (key: string, value: string | undefined) => {
+	if (value === undefined) {
+		delete process.env[key]
+		return
+	}
+
+	process.env[key] = value
+}
+
+const readGhArgs = async (recordPath: string): Promise<string[]> => {
+	const file = Bun.file(recordPath)
+
+	if (!(await file.exists())) {
+		return []
+	}
+
+	const content = await file.text()
+	return content.trim().split("\n").filter(Boolean)
+}
+
+describe("pr command", () => {
+	let tempDir: string
+	let recordPath: string
+	let originalCwd: string
+	let originalPath: string | undefined
+	let originalAgencyConfigPath: string | undefined
+	let originalGhArgsFile: string | undefined
+
+	beforeEach(async () => {
+		tempDir = await createTempDir()
+		recordPath = join(tempDir, "gh-args.txt")
+		originalCwd = process.cwd()
+		originalPath = process.env.PATH
+		originalAgencyConfigPath = process.env.AGENCY_CONFIG_PATH
+		originalGhArgsFile = process.env.AGENCY_TEST_GH_ARGS_FILE
+
+		process.chdir(tempDir)
+		process.env.AGENCY_CONFIG_PATH = join(tempDir, "non-existent-config.json")
+		process.env.AGENCY_TEST_GH_ARGS_FILE = recordPath
+
+		const binDir = join(tempDir, "bin")
+		const ghPath = join(binDir, "gh")
+		await mkdir(binDir)
+		await Bun.write(
+			ghPath,
+			`#!/bin/sh
+: > "$AGENCY_TEST_GH_ARGS_FILE"
+for arg in "$@"; do
+	printf '%s\n' "$arg" >> "$AGENCY_TEST_GH_ARGS_FILE"
+done
+`,
+		)
+		await chmod(ghPath, 0o755)
+		process.env.PATH = `${binDir}:${originalPath ?? ""}`
+
+		await initGitRepo(tempDir)
+	})
+
+	afterEach(async () => {
+		process.chdir(originalCwd)
+		restoreEnv("PATH", originalPath)
+		restoreEnv("AGENCY_CONFIG_PATH", originalAgencyConfigPath)
+		restoreEnv("AGENCY_TEST_GH_ARGS_FILE", originalGhArgsFile)
+		await cleanupTempDir(tempDir)
+	})
+
+	test("passes through to gh pr unchanged outside agency context", async () => {
+		await createBranch(tempDir, "feature")
+
+		await runTestEffect(pr({ args: ["status"], silent: false }))
+
+		expect(await readGhArgs(recordPath)).toEqual(["pr", "status"])
+	})
+
+	test("passes through outside agency context with custom emit pattern", async () => {
+		const configPath = process.env.AGENCY_CONFIG_PATH
+
+		if (!configPath) {
+			throw new Error("AGENCY_CONFIG_PATH is not set")
+		}
+
+		await Bun.write(
+			configPath,
+			JSON.stringify({
+				sourceBranchPattern: "agency--%branch%",
+				emitBranch: "%branch%--PR",
+			}),
+		)
+		await createBranch(tempDir, "feature")
+
+		await runTestEffect(pr({ args: ["status"], silent: false }))
+
+		expect(await readGhArgs(recordPath)).toEqual(["pr", "status"])
+	})
+
+	test("appends emitted branch in agency context", async () => {
+		await createBranch(tempDir, "agency--feature")
+
+		await runTestEffect(pr({ args: ["view", "--web"], silent: false }))
+
+		expect(await readGhArgs(recordPath)).toEqual([
+			"pr",
+			"view",
+			"--web",
+			"feature",
+		])
+	})
+
+	test("appends emitted branch with gh pr value flags when no selector is provided", async () => {
+		await createBranch(tempDir, "agency--feature")
+
+		await runTestEffect(
+			pr({
+				args: ["view", "--json", "number", "--jq", ".number"],
+				silent: false,
+			}),
+		)
+
+		expect(await readGhArgs(recordPath)).toEqual([
+			"pr",
+			"view",
+			"--json",
+			"number",
+			"--jq",
+			".number",
+			"feature",
+		])
+	})
+
+	test("does not append emitted branch when an explicit selector is provided", async () => {
+		await createBranch(tempDir, "agency--feature")
+
+		await runTestEffect(
+			pr({
+				args: [
+					"view",
+					"123",
+					"--json",
+					"statusCheckRollup",
+					"--jq",
+					".statusCheckRollup[]",
+				],
+				silent: false,
+			}),
+		)
+
+		expect(await readGhArgs(recordPath)).toEqual([
+			"pr",
+			"view",
+			"123",
+			"--json",
+			"statusCheckRollup",
+			"--jq",
+			".statusCheckRollup[]",
+		])
+	})
+
+	test("does not append emitted branch for subcommands without a selector", async () => {
+		await createBranch(tempDir, "agency--feature")
+
+		await runTestEffect(pr({ args: ["status"], silent: false }))
+
+		expect(await readGhArgs(recordPath)).toEqual(["pr", "status"])
+	})
+})

package/src/commands/pr.ts

@@ -2,7 +2,7 @@ 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 { resolveAgencyBranchPairWithAgencyJson } from "../utils/pr-branch"
 import { ensureGitRepo } from "../utils/effect"
 
 interface PrOptions extends BaseCommandOptions {
@@ -10,6 +10,120 @@ interface PrOptions extends BaseCommandOptions {
 	args: string[]
 }
 
+const PR_SUBCOMMANDS_WITH_OPTIONAL_SELECTOR = new Set([
+	"checkout",
+	"checks",
+	"close",
+	"comment",
+	"diff",
+	"edit",
+	"lock",
+	"merge",
+	"ready",
+	"reopen",
+	"review",
+	"unlock",
+	"update-branch",
+	"view",
+])
+
+const GH_PR_FLAGS_WITH_VALUE = new Set([
+	"--add-assignee",
+	"--add-label",
+	"--add-project",
+	"--add-reviewer",
+	"--app",
+	"--assignee",
+	"--author",
+	"--base",
+	"--body",
+	"--body-file",
+	"--head",
+	"--hostname",
+	"--json",
+	"--jq",
+	"--label",
+	"--limit",
+	"--match-head-commit",
+	"--milestone",
+	"--project",
+	"--remove-assignee",
+	"--remove-label",
+	"--remove-project",
+	"--remove-reviewer",
+	"--repo",
+	"--reviewer",
+	"--search",
+	"--state",
+	"--template",
+	"--title",
+])
+
+const GH_PR_SHORT_FLAGS_WITH_VALUE = new Set([
+	"-A",
+	"-B",
+	"-H",
+	"-L",
+	"-R",
+	"-a",
+	"-b",
+	"-l",
+	"-m",
+	"-p",
+	"-q",
+	"-r",
+	"-s",
+	"-t",
+])
+
+const hasExplicitPrSelector = (args: readonly string[]): boolean => {
+	const subcommandArgs = args.slice(1)
+
+	for (let i = 0; i < subcommandArgs.length; i++) {
+		const arg = subcommandArgs[i]
+
+		if (!arg) {
+			continue
+		}
+
+		if (arg === "--") {
+			return subcommandArgs.slice(i + 1).some(Boolean)
+		}
+
+		if (arg.startsWith("--")) {
+			const flagName = arg.includes("=") ? arg.slice(0, arg.indexOf("=")) : arg
+
+			if (!arg.includes("=") && GH_PR_FLAGS_WITH_VALUE.has(flagName)) {
+				i++
+			}
+
+			continue
+		}
+
+		if (arg.startsWith("-") && arg.length > 1) {
+			if (GH_PR_SHORT_FLAGS_WITH_VALUE.has(arg)) {
+				i++
+			}
+
+			continue
+		}
+
+		return true
+	}
+
+	return false
+}
+
+const shouldAppendEmitBranch = (args: readonly string[]): boolean => {
+	const subcommand = args[0]
+
+	return (
+		typeof subcommand === "string" &&
+		PR_SUBCOMMANDS_WITH_OPTIONAL_SELECTOR.has(subcommand) &&
+		!hasExplicitPrSelector(args)
+	)
+}
+
 export const pr = (options: PrOptions) =>
 	Effect.gen(function* () {
 		const git = yield* GitService
@@ -20,23 +134,27 @@ export const pr = (options: PrOptions) =>
 		// Load config
 		const config = yield* configService.loadConfig()
 
-		// Get current branch and resolve the branch pair
+		// Get current branch and resolve the branch pair when agency context exists
 		const currentBranch = yield* git.getCurrentBranch(gitRoot)
-		const branches = yield* resolveBranchPairWithAgencyJson(
+		const branches = yield* resolveAgencyBranchPairWithAgencyJson(
 			gitRoot,
 			currentBranch,
 			config.sourceBranchPattern,
 			config.emitBranch,
 		)
 
-		// Build the gh pr command with the emit branch
-		const ghArgs = ["gh", "pr", ...options.args, branches.emitBranch]
+		// Build the gh pr command with the emit branch only when gh accepts a selector.
+		const ghArgs =
+			branches && shouldAppendEmitBranch(options.args)
+				? ["gh", "pr", ...options.args, branches.emitBranch]
+				: ["gh", "pr", ...options.args]
 
 		// Run gh pr with stdio inherited so output goes directly to terminal
 		const exitCode = yield* Effect.tryPromise({
 			try: async () => {
 				const proc = Bun.spawn(ghArgs, {
 					cwd: gitRoot,
+					env: process.env,
 					stdin: "inherit",
 					stdout: "inherit",
 					stderr: "inherit",
@@ -59,19 +177,20 @@ export const pr = (options: PrOptions) =>
 export const help = `
 Usage: agency pr <subcommand> [flags]
 
-Wrapper for 'gh pr' that automatically appends the emitted branch name.
+Wrapper for 'gh pr' that automatically uses the emitted branch in agency context.
 
-This command passes all arguments to 'gh pr' with the emitted branch name
-appended, making it easy to work with PRs for your feature branch without
-needing to remember or type the emit branch name.
+For gh pr subcommands that accept a PR selector, this command appends the
+emitted branch name when you do not provide a selector. Outside agency context,
+or when you provide a selector, it passes arguments through to 'gh pr' unchanged.
 
 Examples:
   agency pr view --web              # gh pr view --web <emit-branch>
   agency pr checks                  # gh pr checks <emit-branch>
-  agency pr status                  # gh pr status <emit-branch>
+  agency pr diff                    # gh pr diff <emit-branch>
 
 Notes:
   - Requires gh CLI to be installed and authenticated
   - Uses source and emit patterns from ~/.config/agency/agency.json
   - Respects emitBranch field in agency.json when present
+  - Falls through to gh pr unchanged outside agency context
 `

package/src/commands/push.test.ts

@@ -115,6 +115,39 @@ describe("push command", () => {
 			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({

package/src/commands/push.ts

@@ -122,41 +122,36 @@ const pushCore = (gitRoot: string, options: PushOptions) =>
 		verboseLog(`Starting push workflow from ${highlight.branch(sourceBranch)}`)
 
 		// Step 1: Create emit branch (agency emit)
-		let emitHadIgnorableFailure = false
-
-		if (!options.skipFilter) {
-			verboseLog("Step 1: Emitting...")
-			// Use emit command - prefer emit option, fallback to branch for backward compatibility
-			const prEffectWithOptions = emit({
-				baseBranch: options.baseBranch,
-				emit: options.emit || options.branch,
-				silent: true, // Suppress emit command output, we'll provide our own
-				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}`),
-					)
-				}
-
-				emitHadIgnorableFailure = true
-				verboseLog("Emit reported existing branch; continuing")
+		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)
@@ -164,15 +159,6 @@ const pushCore = (gitRoot: string, options: PushOptions) =>
 		const emitBranchName =
 			options.emit || options.branch || branchInfo.emitBranch
 
-		// If skipFilter, we skipped emit() so we must create the emit branch manually
-		if (options.skipFilter) {
-			yield* git.createOrResetBranch(gitRoot, emitBranchName, sourceBranch)
-			// Switch back to source branch for consistency
-			yield* git.checkoutBranch(gitRoot, sourceBranch)
-		}
-
-		log(done(`Emitted ${highlight.branch(emitBranchName)}`))
-
 		// Step 2: Push to remote (git push)
 		const remote = yield* getRemoteName(gitRoot)
 		verboseLog(

package/src/utils/pr-branch.ts

@@ -439,3 +439,70 @@ export const resolveBranchPairWithAgencyJson = (
 		// Strategy 4: Fall back to pattern-based resolution
 		return resolveBranchPair(currentBranch, sourcePattern, emitPattern)
 	})
+
+/**
+ * Resolve branch pair only when the current branch is in agency context.
+ * Unlike resolveBranchPairWithAgencyJson, this intentionally does not treat
+ * arbitrary legacy branches as source branches.
+ */
+export const resolveAgencyBranchPairWithAgencyJson = (
+	gitRoot: string,
+	currentBranch: string,
+	sourcePattern: string,
+	emitPattern: string,
+): Effect.Effect<BranchPair | null, never, GitService | FileSystemService> =>
+	Effect.gen(function* () {
+		const fromCurrentAgencyJson = yield* tryResolveFromCurrentAgencyJson(
+			gitRoot,
+			currentBranch,
+		)
+		if (fromCurrentAgencyJson) {
+			return fromCurrentAgencyJson
+		}
+
+		const fromOtherBranchAgencyJson =
+			yield* tryResolveFromOtherBranchAgencyJson(gitRoot, currentBranch)
+		if (fromOtherBranchAgencyJson) {
+			return fromOtherBranchAgencyJson
+		}
+
+		const fromPatternedSource = yield* tryResolveFromPatternedSourceBranch(
+			gitRoot,
+			currentBranch,
+			sourcePattern,
+			emitPattern,
+		)
+		if (fromPatternedSource) {
+			return fromPatternedSource
+		}
+
+		if (extractCleanBranch(currentBranch, sourcePattern)) {
+			return resolveBranchPair(currentBranch, sourcePattern, emitPattern)
+		}
+
+		if (emitPattern !== "%branch%") {
+			const cleanFromEmit = extractCleanFromEmit(currentBranch, emitPattern)
+
+			if (cleanFromEmit) {
+				const git = yield* GitService
+				const possibleSourceBranch = makeSourceBranchName(
+					cleanFromEmit,
+					sourcePattern,
+				)
+				const sourceExists = yield* pipe(
+					git.branchExists(gitRoot, possibleSourceBranch),
+					Effect.catchAll(() => Effect.succeed(false)),
+				)
+
+				if (sourceExists) {
+					return {
+						sourceBranch: possibleSourceBranch,
+						emitBranch: currentBranch,
+						isOnEmitBranch: true,
+					}
+				}
+			}
+		}
+
+		return null
+	})