@markjaquith/agency 1.8.7 → 1.9.1

package/cli.ts

@@ -186,6 +186,7 @@ const commands: Record<string, Command> = {
 					emit: options.emit || options.branch,
 					silent: options.silent,
 					force: options.force,
+					noVerify: options["no-verify"],
 					verbose: options.verbose,
 					pr: options.pr,
 				}),
@@ -593,6 +594,9 @@ try {
 				type: "boolean",
 				short: "f",
 			},
+			"no-verify": {
+				type: "boolean",
+			},
 			verbose: {
 				type: "boolean",
 				short: "v",

package/package.json

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

package/src/commands/emit.test.ts

@@ -349,6 +349,37 @@ describe("emit command", () => {
 			const lastCall = getLastCapturedFilterRepoCall()
 			expect(lastCall).toBeDefined()
 			expect(lastCall!.streamOutput).toBe(true)
+			expect(lastCall!.progressIntervalMs).toBe(5000)
+		})
+
+		test("logs filter preflight diagnostics in verbose mode", async () => {
+			await checkoutBranch(tempDir, "main")
+			await createBranch(tempDir, "agency--filter-diagnostics-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")
+
+			const logs: string[] = []
+			const originalLog = console.log
+			console.log = (...args: any[]) => logs.push(args.join(" "))
+
+			try {
+				await runTestEffectWithMockFilterRepo(emit({ verbose: true }))
+			} finally {
+				console.log = originalLog
+			}
+
+			expect(logs.join("\n")).toContain("Commit range contains")
+			expect(logs.join("\n")).toContain("Filtered paths are touched by")
+			expect(logs.join("\n")).toContain("Filtered path diff contains")
 		})
 
 		test("includes symlink targets in files to filter", async () => {

package/src/commands/emit.ts

@@ -143,7 +143,7 @@ export const emitCore = (gitRoot: string, options: EmitOptions) =>
 			gitRoot,
 			currentBranch,
 			baseBranch,
-			verbose,
+			options,
 		)
 
 		verboseLog(`Branch forked at commit: ${highlight.commit(forkPoint)}`)
@@ -223,11 +223,19 @@ export const emitCore = (gitRoot: string, options: EmitOptions) =>
 			verboseLog(
 				`git-filter-repo will evaluate ${filesToFilter.length} filtered path${filesToFilter.length === 1 ? "" : "s"}`,
 			)
+			yield* logFilterPreflight(
+				gitRoot,
+				forkPoint,
+				emitBranchName,
+				filesToFilter,
+				verboseLog,
+			)
 
 			yield* filterRepo.run(gitRoot, filterRepoArgs, {
 				env: { GIT_CONFIG_GLOBAL: "" },
 				verboseLog,
 				streamOutput: verbose,
+				progressIntervalMs: 5_000,
 			})
 
 			verboseLog("git-filter-repo completed")
@@ -245,6 +253,77 @@ export const emitCore = (gitRoot: string, options: EmitOptions) =>
 		log(done(`Emitted ${highlight.branch(emitBranchName)}`))
 	})
 
+const logFilterPreflight = (
+	gitRoot: string,
+	forkPoint: string,
+	emitBranchName: string,
+	filesToFilter: readonly string[],
+	verboseLog: (message: string) => void,
+) =>
+	Effect.gen(function* () {
+		const git = yield* GitService
+		const range = `${forkPoint}..${emitBranchName}`
+		const summarize = (value: string) => value.trim() || "0"
+
+		const commitCount = yield* git
+			.runGitCommand(["git", "rev-list", "--count", range], gitRoot, {
+				captureOutput: true,
+			})
+			.pipe(Effect.option)
+
+		if (commitCount._tag === "Some" && commitCount.value.exitCode === 0) {
+			verboseLog(
+				`Commit range contains ${summarize(commitCount.value.stdout)} commit${summarize(commitCount.value.stdout) === "1" ? "" : "s"}`,
+			)
+		} else {
+			verboseLog("Unable to count commits in git-filter-repo range")
+		}
+
+		if (filesToFilter.length === 0) {
+			verboseLog("No filtered paths were resolved before git-filter-repo")
+			return
+		}
+
+		const pathArgs = ["--", ...filesToFilter]
+		const matchingCommitCount = yield* git
+			.runGitCommand(
+				["git", "rev-list", "--count", range, ...pathArgs],
+				gitRoot,
+				{ captureOutput: true },
+			)
+			.pipe(Effect.option)
+
+		if (
+			matchingCommitCount._tag === "Some" &&
+			matchingCommitCount.value.exitCode === 0
+		) {
+			verboseLog(
+				`Filtered paths are touched by ${summarize(matchingCommitCount.value.stdout)} commit${summarize(matchingCommitCount.value.stdout) === "1" ? "" : "s"} in the range`,
+			)
+		} else {
+			verboseLog("Unable to count commits touching filtered paths")
+		}
+
+		const changedFiles = yield* git
+			.runGitCommand(
+				["git", "diff", "--name-only", range, ...pathArgs],
+				gitRoot,
+				{ captureOutput: true },
+			)
+			.pipe(Effect.option)
+
+		if (changedFiles._tag === "Some" && changedFiles.value.exitCode === 0) {
+			const changedFileCount = changedFiles.value.stdout
+				.split("\n")
+				.filter(Boolean).length
+			verboseLog(
+				`Filtered path diff contains ${changedFileCount} changed file${changedFileCount === 1 ? "" : "s"}`,
+			)
+		} else {
+			verboseLog("Unable to count changed filtered files")
+		}
+	})
+
 // Helper: Ensure emitBranch is set in agency.json metadata
 const ensureEmitBranchInMetadata = (
 	gitRoot: string,
@@ -368,11 +447,11 @@ const findBestForkPoint = (
 	gitRoot: string,
 	featureBranch: string,
 	baseBranch: string,
-	verbose: boolean,
+	options: Pick<EmitOptions, "silent" | "verbose">,
 ) =>
 	Effect.gen(function* () {
 		const git = yield* GitService
-		const { verboseLog } = createLoggers({ verbose })
+		const { verboseLog } = createLoggers(options)
 
 		// Strategy 1: Get fork-point against local base branch
 		const localForkPoint = yield* getForkPointOrMergeBase(

package/src/commands/push.ts

@@ -19,6 +19,7 @@ interface PushOptions extends BaseCommandOptions {
 	emit?: string
 	branch?: string // Deprecated: use emit instead
 	force?: boolean
+	noVerify?: boolean
 	pr?: boolean
 	skipFilter?: boolean
 }
@@ -186,6 +187,7 @@ const pushCore = (gitRoot: string, options: PushOptions) =>
 			withSpinner(
 				pushBranchToRemoteEffect(gitRoot, emitBranchName, remote, {
 					force: options.force,
+					noVerify: options.noVerify,
 					verbose: options.verbose,
 				}),
 				{
@@ -243,16 +245,17 @@ const pushBranchToRemoteEffect = (
 	remote: string,
 	options: {
 		readonly force?: boolean
+		readonly noVerify?: boolean
 		readonly verbose?: boolean
 	},
 ) =>
 	Effect.gen(function* () {
 		const git = yield* GitService
-		const { force = false } = options
+		const { force = false, noVerify = false } = options
 
 		// Try pushing without force first
 		const pushResult = yield* git
-			.push(gitRoot, remote, branchName, { setUpstream: true })
+			.push(gitRoot, remote, branchName, { setUpstream: true, noVerify })
 			.pipe(
 				Effect.catchAll((error: any) =>
 					Effect.succeed({
@@ -275,7 +278,11 @@ const pushBranchToRemoteEffect = (
 			if (needsForce && force) {
 				// User provided --force flag, retry with force
 				const forceResult = yield* git
-					.push(gitRoot, remote, branchName, { setUpstream: true, force: true })
+					.push(gitRoot, remote, branchName, {
+						setUpstream: true,
+						force: true,
+						noVerify,
+					})
 					.pipe(
 						Effect.catchAll((error: any) =>
 							Effect.succeed({
@@ -405,15 +412,17 @@ Arguments:
 
 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
-  --pr              Open GitHub PR in browser after pushing (requires gh CLI)
+	--branch          (Deprecated: use --emit) Custom name for emit branch
+	-f, --force       Force push to remote if branch has diverged
+	--no-verify      Bypass git pre-push hooks
+	--pr              Open GitHub PR in browser after pushing (requires gh CLI)
 
 Examples:
   agency push                          # Create PR, push, return to source
-  agency push origin/main              # Explicitly use origin/main as base
-  agency push --force                  # Force push if branch has diverged
-  agency push --pr                     # Push and open GitHub PR in browser
+	agency push origin/main              # Explicitly use origin/main as base
+	agency push --force                  # Force push if branch has diverged
+	agency push --no-verify              # Push without running pre-push hooks
+	agency push --pr                     # Push and open GitHub PR in browser
 
 Notes:
   - Must be run from a source branch (not a emit branch)

package/src/services/FilterRepoService.ts

@@ -46,6 +46,7 @@ export class FilterRepoService extends Effect.Service<FilterRepoService>()(
 					readonly env?: Record<string, string>
 					readonly verboseLog?: (message: string) => void
 					readonly streamOutput?: boolean
+					readonly progressIntervalMs?: number
 				},
 			) =>
 				Effect.gen(function* () {
@@ -79,6 +80,15 @@ export class FilterRepoService extends Effect.Service<FilterRepoService>()(
 							env: options?.env,
 							stdout: options?.streamOutput ? "inherit" : "pipe",
 							stderr: options?.streamOutput ? "inherit" : "pipe",
+							onProgress: options?.streamOutput
+								? ({ elapsedMs, pid }) => {
+										const elapsedSeconds = Math.round(elapsedMs / 1000)
+										verboseLog(
+											`git-filter-repo still running after ${elapsedSeconds}s${pid ? ` (pid ${pid})` : ""}`,
+										)
+									}
+								: undefined,
+							progressIntervalMs: options?.progressIntervalMs,
 						}),
 						Effect.mapError(
 							(error) =>

package/src/services/GitService.ts

@@ -1046,6 +1046,7 @@ export class GitService extends Effect.Service<GitService>()("GitService", {
 			options?: {
 				readonly setUpstream?: boolean
 				readonly force?: boolean
+				readonly noVerify?: boolean
 			},
 		) => {
 			const args = ["git", "push"]
@@ -1055,6 +1056,9 @@ export class GitService extends Effect.Service<GitService>()("GitService", {
 			if (options?.force) {
 				args.push("--force")
 			}
+			if (options?.noVerify) {
+				args.push("--no-verify")
+			}
 			args.push(remote, branch)
 
 			return pipe(

package/src/services/MockFilterRepoService.ts

@@ -9,6 +9,7 @@ export interface CapturedFilterRepoCall {
 	args: readonly string[]
 	env?: Record<string, string>
 	streamOutput?: boolean
+	progressIntervalMs?: number
 }
 
 /**
@@ -66,6 +67,7 @@ export class MockFilterRepoService extends Effect.Service<MockFilterRepoService>
 					readonly env?: Record<string, string>
 					readonly verboseLog?: (message: string) => void
 					readonly streamOutput?: boolean
+					readonly progressIntervalMs?: number
 				},
 			) => {
 				// Capture the call
@@ -74,6 +76,7 @@ export class MockFilterRepoService extends Effect.Service<MockFilterRepoService>
 					args,
 					env: options?.env,
 					streamOutput: options?.streamOutput,
+					progressIntervalMs: options?.progressIntervalMs,
 				})
 
 				// Return a successful result

package/src/utils/process.test.ts

@@ -23,4 +23,19 @@ describe("spawnProcess", () => {
 		expect(result.stderr).toContain("err:0:")
 		expect(result.stderr).toContain("err:1999:")
 	})
+
+	test("reports progress while process is still running", async () => {
+		const progress: number[] = []
+		const script = "await new Promise((resolve) => setTimeout(resolve, 80))"
+
+		const result = await Effect.runPromise(
+			spawnProcess([process.execPath, "-e", script], {
+				onProgress: ({ elapsedMs }) => progress.push(elapsedMs),
+				progressIntervalMs: 10,
+			}),
+		)
+
+		expect(result.exitCode).toBe(0)
+		expect(progress.length).toBeGreaterThan(0)
+	})
 })

package/src/utils/process.ts

@@ -18,6 +18,11 @@ interface SpawnOptions {
 	readonly stdout?: "pipe" | "inherit"
 	readonly stderr?: "pipe" | "inherit"
 	readonly env?: Record<string, string>
+	readonly onProgress?: (progress: {
+		readonly elapsedMs: number
+		readonly pid?: number
+	}) => void
+	readonly progressIntervalMs?: number
 }
 
 /**
@@ -54,6 +59,17 @@ export const spawnProcess = (
 				stderr: options?.stderr ?? "pipe",
 				env: options?.env ? { ...process.env, ...options.env } : process.env,
 			})
+			const startedAt = Date.now()
+			const progressInterval = options?.onProgress
+				? setInterval(
+						() =>
+							options.onProgress?.({
+								elapsedMs: Date.now() - startedAt,
+								pid: proc.pid,
+							}),
+						options.progressIntervalMs ?? 10_000,
+					)
+				: null
 
 			// Start draining stdout/stderr immediately so verbose subprocesses
 			// cannot block on filled pipe buffers before they exit.
@@ -70,7 +86,11 @@ export const spawnProcess = (
 				proc.exited,
 				stdoutPromise,
 				stderrPromise,
-			])
+			]).finally(() => {
+				if (progressInterval) {
+					clearInterval(progressInterval)
+				}
+			})
 
 			return {
 				stdout: stdout.trim(),