@markjaquith/agency 1.8.5 → 1.8.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "1.8.5",
+  "version": "1.8.7",
   "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

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

package/src/commands/push.ts

@@ -44,15 +44,21 @@ const getPushFailureStderr = (error: unknown): string => {
 	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 [
-		"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))
+	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 => {
@@ -261,7 +267,7 @@ const pushBranchToRemoteEffect = (
 
 		// If push failed, check if we should retry with --force
 		if (pushResult.exitCode !== 0) {
-			const stderr = pushResult.stderr
+			const stderr = formatProcessOutput(pushResult)
 
 			// Check if this is a force-push-needed error
 			const needsForce = pushFailureNeedsForce(stderr)
@@ -283,7 +289,7 @@ const pushBranchToRemoteEffect = (
 				if (forceResult.exitCode !== 0) {
 					return yield* Effect.fail(
 						new Error(
-							`Failed to force push branch to remote: ${forceResult.stderr}`,
+							`Failed to force push branch to remote: ${formatProcessOutput(forceResult)}`,
 						),
 					)
 				}

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/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) =>