@markjaquith/agency 1.8.4 → 1.8.6

package/package.json

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

package/src/commands/emit.test.ts

@@ -3,6 +3,7 @@ import { join } from "path"
 import { symlink } from "fs/promises"
 import { emit } from "../commands/emit"
 import { task } from "../commands/task"
+import { resolveGitInternalPath } from "../utils/git-path"
 import {
 	createTempDir,
 	cleanupTempDir,
@@ -326,6 +327,30 @@ describe("emit command", () => {
 			expect(lastCall!.env?.GIT_CONFIG_GLOBAL).toBe("")
 		})
 
+		test("streams git-filter-repo output in verbose mode", async () => {
+			await checkoutBranch(tempDir, "main")
+			await createBranch(tempDir, "agency--verbose-filter-test")
+
+			await Bun.write(
+				join(tempDir, "agency.json"),
+				JSON.stringify({
+					version: 1,
+					injectedFiles: ["AGENTS.md"],
+					template: "test",
+					createdAt: new Date().toISOString(),
+				}),
+			)
+			await addAndCommit(tempDir, "agency.json", "Add agency.json")
+
+			await runTestEffectWithMockFilterRepo(
+				emit({ silent: true, verbose: true }),
+			)
+
+			const lastCall = getLastCapturedFilterRepoCall()
+			expect(lastCall).toBeDefined()
+			expect(lastCall!.streamOutput).toBe(true)
+		})
+
 		test("includes symlink targets in files to filter", async () => {
 			// Set up fresh branch
 			await checkoutBranch(tempDir, "main")
@@ -400,4 +425,24 @@ describe("emit command", () => {
 			expect(lastCall!.args).toContain(".agents/foo/bar.whatever")
 		})
 	})
+
+	describe("git path resolution", () => {
+		test("resolves relative git internal paths from git root", () => {
+			expect(
+				resolveGitInternalPath(
+					"/repo/worktree",
+					"../.git/worktrees/worktree/filter-repo",
+				),
+			).toBe("/repo/.git/worktrees/worktree/filter-repo")
+		})
+
+		test("preserves absolute git internal paths", () => {
+			expect(
+				resolveGitInternalPath(
+					"/repo/worktree",
+					"/repo/.git/worktrees/worktree/filter-repo",
+				),
+			).toBe("/repo/.git/worktrees/worktree/filter-repo")
+		})
+	})
 })

package/src/commands/emit.ts

@@ -22,6 +22,7 @@ import {
 	resolveBaseBranch,
 	withBranchProtection,
 } from "../utils/effect"
+import { resolveGitInternalPath } from "../utils/git-path"
 import { withSpinner } from "../utils/spinner"
 import { AGENCY_REMOVE_COMMIT } from "../constants"
 
@@ -186,8 +187,12 @@ export const emitCore = (gitRoot: string, options: EmitOptions) =>
 
 		// Filter backpack files
 		const filterOperation = Effect.gen(function* () {
-			// Clean up .git/filter-repo directory
-			const filterRepoDir = `${gitRoot}/.git/filter-repo`
+			// Resolve the actual git-filter-repo state directory.
+			// In linked worktrees this lives under the worktree git dir, not repo/.git.
+			const filterRepoDir = yield* getFilterRepoStateDir(gitRoot)
+			verboseLog(
+				`Cleaning git-filter-repo state in ${highlight.file(filterRepoDir)}`,
+			)
 			yield* fs.deleteDirectory(filterRepoDir)
 			verboseLog("Cleaned up previous git-filter-repo state")
 
@@ -214,8 +219,15 @@ export const emitCore = (gitRoot: string, options: EmitOptions) =>
 				`${forkPoint}..${emitBranchName}`,
 			]
 
+			verboseLog(`git-filter-repo refs: ${forkPoint}..${emitBranchName}`)
+			verboseLog(
+				`git-filter-repo will evaluate ${filesToFilter.length} filtered path${filesToFilter.length === 1 ? "" : "s"}`,
+			)
+
 			yield* filterRepo.run(gitRoot, filterRepoArgs, {
 				env: { GIT_CONFIG_GLOBAL: "" },
+				verboseLog,
+				streamOutput: verbose,
 			})
 
 			verboseLog("git-filter-repo completed")
@@ -327,6 +339,23 @@ const getRemoteTrackingBranch = (
 		return null
 	})
 
+const getFilterRepoStateDir = (gitRoot: string) =>
+	Effect.gen(function* () {
+		const git = yield* GitService
+		const result = yield* git.runGitCommand(
+			["git", "rev-parse", "--git-path", "filter-repo"],
+			gitRoot,
+			{ captureOutput: true },
+		)
+
+		const gitPath = result.stdout.trim()
+		if (result.exitCode !== 0 || !gitPath) {
+			return `${gitRoot}/.git/filter-repo`
+		}
+
+		return resolveGitInternalPath(gitRoot, gitPath)
+	})
+
 /**
  * Find the best fork point by checking both local and remote tracking branches.
  *

package/src/commands/push.test.ts

@@ -306,7 +306,9 @@ describe("push command", () => {
 				runTestEffect(
 					push({ baseBranch: "main", silent: true, skipFilter: true }),
 				),
-			).rejects.toThrow(/agency push --force/)
+			).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")

package/src/commands/push.ts

@@ -1,13 +1,8 @@
 import { Effect, Either } from "effect"
 import type { BaseCommandOptions } from "../utils/command"
-import { GitService } from "../services/GitService"
+import { GitCommandError, GitService } from "../services/GitService"
 import { ConfigService } from "../services/ConfigService"
-import {
-	extractSourceBranch,
-	makePrBranchName,
-	resolveBranchPairWithAgencyJson,
-} from "../utils/pr-branch"
-import { FileSystemService } from "../services/FileSystemService"
+import { resolveBranchPairWithAgencyJson } from "../utils/pr-branch"
 import { emit } from "./emit"
 import highlight, { done } from "../utils/colors"
 import {
@@ -28,6 +23,51 @@ interface PushOptions extends BaseCommandOptions {
 	skipFilter?: boolean
 }
 
+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 pushFailureNeedsForce = (stderr: string): boolean => {
+	const normalized = stderr.toLowerCase()
+
+	return [
+		"non-fast-forward",
+		"updates were rejected because the tip of your current branch is behind",
+		"fetch first",
+		"failed to push some refs",
+	].some((pattern) => normalized.includes(pattern))
+}
+
+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()
@@ -39,7 +79,6 @@ export const push = (options: PushOptions = {}) =>
 
 const pushCore = (gitRoot: string, options: PushOptions) =>
 	Effect.gen(function* () {
-		const { verbose = false } = options
 		const { log, verboseLog } = createLoggers(options)
 
 		const git = yield* GitService
@@ -52,7 +91,6 @@ const pushCore = (gitRoot: string, options: PushOptions) =>
 		let sourceBranch = yield* git.getCurrentBranch(gitRoot)
 
 		// Check if we're already on an emit branch using proper branch resolution
-		const fs = yield* FileSystemService
 		const branchInfo = yield* resolveBranchPairWithAgencyJson(
 			gitRoot,
 			sourceBranch,
@@ -153,7 +191,7 @@ const pushCore = (gitRoot: string, options: PushOptions) =>
 			),
 		)
 		if (Either.isLeft(pushEither)) {
-			const error = pushEither.left
+			const error = formatPushFailure(pushEither.left)
 			// If push failed, switch back to source branch
 			yield* git.checkoutBranch(gitRoot, sourceBranch)
 			return yield* Effect.fail(error)
@@ -226,11 +264,7 @@ const pushBranchToRemoteEffect = (
 			const stderr = pushResult.stderr
 
 			// Check if this is a force-push-needed error
-			const needsForce =
-				stderr.includes("rejected") ||
-				stderr.includes("non-fast-forward") ||
-				stderr.includes("fetch first") ||
-				stderr.includes("Updates were rejected")
+			const needsForce = pushFailureNeedsForce(stderr)
 
 			if (needsForce && force) {
 				// User provided --force flag, retry with force
@@ -258,15 +292,24 @@ const pushBranchToRemoteEffect = (
 			} else if (needsForce && !force) {
 				// User didn't provide --force but it's needed
 				return yield* Effect.fail(
-					new Error(
-						`Failed to push branch to remote. The branch has diverged from the remote.\n` +
-							`Run 'agency push --force' to force push the branch.`,
+					formatPushFailure(
+						new GitCommandError({
+							command: `git push -u ${remote} ${branchName}`,
+							exitCode: pushResult.exitCode,
+							stderr,
+						}),
 					),
 				)
 			} else {
 				// Some other error
 				return yield* Effect.fail(
-					new Error(`Failed to push branch to remote: ${stderr}`),
+					formatPushFailure(
+						new GitCommandError({
+							command: `git push -u ${remote} ${branchName}`,
+							exitCode: pushResult.exitCode,
+							stderr,
+						}),
+					),
 				)
 			}
 		}

package/src/services/FilterRepoService.ts

@@ -44,6 +44,8 @@ export class FilterRepoService extends Effect.Service<FilterRepoService>()(
 				args: readonly string[],
 				options?: {
 					readonly env?: Record<string, string>
+					readonly verboseLog?: (message: string) => void
+					readonly streamOutput?: boolean
 				},
 			) =>
 				Effect.gen(function* () {
@@ -64,11 +66,19 @@ export class FilterRepoService extends Effect.Service<FilterRepoService>()(
 					}
 
 					const fullArgs = ["git-filter-repo", ...args]
+					const verboseLog = options?.verboseLog ?? (() => {})
+
+					verboseLog(`Running ${fullArgs.join(" ")} in ${gitRoot}`)
+					if (options?.streamOutput) {
+						verboseLog("Streaming git-filter-repo output directly")
+					}
 
 					const result = yield* pipe(
 						spawnProcess(fullArgs, {
 							cwd: gitRoot,
 							env: options?.env,
+							stdout: options?.streamOutput ? "inherit" : "pipe",
+							stderr: options?.streamOutput ? "inherit" : "pipe",
 						}),
 						Effect.mapError(
 							(error) =>
@@ -79,6 +89,8 @@ export class FilterRepoService extends Effect.Service<FilterRepoService>()(
 						),
 					)
 
+					verboseLog(`git-filter-repo exited with code ${result.exitCode}`)
+
 					if (result.exitCode !== 0) {
 						return yield* Effect.fail(
 							new FilterRepoError({

package/src/services/MockFilterRepoService.ts

@@ -8,6 +8,7 @@ export interface CapturedFilterRepoCall {
 	gitRoot: string
 	args: readonly string[]
 	env?: Record<string, string>
+	streamOutput?: boolean
 }
 
 /**
@@ -63,6 +64,8 @@ export class MockFilterRepoService extends Effect.Service<MockFilterRepoService>
 				args: readonly string[],
 				options?: {
 					readonly env?: Record<string, string>
+					readonly verboseLog?: (message: string) => void
+					readonly streamOutput?: boolean
 				},
 			) => {
 				// Capture the call
@@ -70,6 +73,7 @@ export class MockFilterRepoService extends Effect.Service<MockFilterRepoService>
 					gitRoot,
 					args,
 					env: options?.env,
+					streamOutput: options?.streamOutput,
 				})
 
 				// Return a successful result

package/src/utils/git-path.ts

@@ -0,0 +1,6 @@
+import { isAbsolute, resolve } from "path"
+
+export const resolveGitInternalPath = (
+	gitRoot: string,
+	gitPath: string,
+): string => (isAbsolute(gitPath) ? gitPath : resolve(gitRoot, gitPath))

package/src/utils/pr-branch.ts

@@ -439,24 +439,3 @@ export const resolveBranchPairWithAgencyJson = (
 		// Strategy 4: Fall back to pattern-based resolution
 		return resolveBranchPair(currentBranch, sourcePattern, emitPattern)
 	})
-
-// Legacy function names for backward compatibility
-// These will be updated as we migrate the codebase
-
-/**
- * @deprecated Use makeEmitBranchName instead. This function now creates emit branches,
- * not PR branches with suffixes.
- */
-export function makePrBranchName(branchName: string, pattern: string): string {
-	return makeEmitBranchName(branchName, pattern)
-}
-
-/**
- * @deprecated Use extractCleanFromEmit instead. Extracts clean branch from emit branch.
- */
-export function extractSourceBranch(
-	emitBranchName: string,
-	pattern: string,
-): string | null {
-	return extractCleanFromEmit(emitBranchName, pattern)
-}

package/src/utils/process.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { spawnProcess } from "./process"
+
+describe("spawnProcess", () => {
+	test("captures large stdout and stderr without hanging", async () => {
+		const line = "x".repeat(4096)
+		const script = [
+			`const line = ${JSON.stringify(line)}`,
+			"for (let i = 0; i < 2000; i++) {",
+			"console.log(`out:${i}:${line}`)",
+			"console.error(`err:${i}:${line}`)",
+			"}",
+		].join("\n")
+
+		const result = await Effect.runPromise(
+			spawnProcess([process.execPath, "-e", script]),
+		)
+
+		expect(result.exitCode).toBe(0)
+		expect(result.stdout).toContain("out:0:")
+		expect(result.stdout).toContain("out:1999:")
+		expect(result.stderr).toContain("err:0:")
+		expect(result.stderr).toContain("err:1999:")
+	})
+})

package/src/utils/process.ts

@@ -55,21 +55,28 @@ export const spawnProcess = (
 				env: options?.env ? { ...process.env, ...options.env } : process.env,
 			})
 
-			await proc.exited
-
-			const stdout =
+			// Start draining stdout/stderr immediately so verbose subprocesses
+			// cannot block on filled pipe buffers before they exit.
+			const stdoutPromise =
 				options?.stdout === "inherit"
-					? ""
-					: await new Response(proc.stdout).text()
-			const stderr =
+					? Promise.resolve("")
+					: new Response(proc.stdout ?? "").text()
+			const stderrPromise =
 				options?.stderr === "inherit"
-					? ""
-					: await new Response(proc.stderr).text()
+					? Promise.resolve("")
+					: new Response(proc.stderr ?? "").text()
+
+			const [exitCode, stdout, stderr] = await Promise.all([
+				proc.exited,
+				stdoutPromise,
+				stderrPromise,
+			])
 
 			return {
 				stdout: stdout.trim(),
 				stderr: stderr.trim(),
-				exitCode: proc.exitCode ?? 0,
+				exitCode:
+					typeof exitCode === "number" ? exitCode : (proc.exitCode ?? 0),
 			}
 		},
 		catch: (error) =>

package/src/utils/spinner.ts

@@ -74,6 +74,7 @@ export const withSpinner = <A, E, R>(
 			if (failText) {
 				spinner.fail(failText)
 			} else {
+				spinner.clear()
 				spinner.stop()
 			}
 			throw error