@markjaquith/agency 1.9.4 → 1.9.6

package/package.json

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

package/src/commands/emit.test.ts

@@ -326,6 +326,36 @@ describe("emit command", () => {
 			clearCapturedFilterRepoCalls()
 		})
 
+		test("throws when emitted CLAUDE.md references AGENCY.md", async () => {
+			await checkoutBranch(tempDir, "main")
+			await createBranch(tempDir, "agency--claude-reference-test")
+
+			await Bun.write(
+				join(tempDir, "agency.json"),
+				JSON.stringify({
+					version: 1,
+					injectedFiles: ["AGENTS.md"],
+					template: "test",
+					createdAt: new Date().toISOString(),
+				}),
+			)
+			await Bun.write(
+				join(tempDir, "CLAUDE.md"),
+				"# Instructions\n\n@AGENCY.md\n",
+			)
+			await addAndCommit(
+				tempDir,
+				["agency.json", "CLAUDE.md"],
+				"Add Claude agency reference",
+			)
+
+			await expect(
+				runTestEffectWithMockFilterRepo(emit({ silent: true })),
+			).rejects.toThrow(
+				"CLAUDE.md on emitted branch claude-reference-test still references @AGENCY.md",
+			)
+		})
+
 		test("constructs correct filter-repo arguments", async () => {
 			// Set up fresh branch with agency.json
 			await checkoutBranch(tempDir, "main")

package/src/commands/emit.ts

@@ -248,9 +248,34 @@ export const emitCore = (gitRoot: string, options: EmitOptions) =>
 			enabled: !options.silent && !verbose,
 		})
 
+		yield* validateClaudeDoesNotReferenceAgency(gitRoot, emitBranchName)
+
 		log(done(`Emitted ${highlight.branch(emitBranchName)}`))
 	})
 
+const validateClaudeDoesNotReferenceAgency = (
+	gitRoot: string,
+	emitBranchName: string,
+) =>
+	Effect.gen(function* () {
+		const git = yield* GitService
+		const claudeContents = yield* git.getFileAtRef(
+			gitRoot,
+			emitBranchName,
+			"CLAUDE.md",
+		)
+
+		if (!claudeContents?.includes("@AGENCY.md")) {
+			return
+		}
+
+		return yield* Effect.fail(
+			new Error(
+				`CLAUDE.md on emitted branch ${emitBranchName} still references @AGENCY.md. Remove the agency file reference before emitting.`,
+			),
+		)
+	})
+
 const logFilterPreflight = (
 	gitRoot: string,
 	forkPoint: string,

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

@@ -13,6 +13,7 @@ import {
 	addAndCommit,
 	renameBranch,
 	runTestEffect,
+	runTestEffectWithMockFilterRepo,
 } from "../test-utils"
 
 async function setupAgencyJson(gitRoot: string): Promise<void> {
@@ -187,6 +188,22 @@ describe("push command", () => {
 	})
 
 	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(

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
+	})