@markjaquith/agency 1.9.0 → 1.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "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/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/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(),

package/src/utils/spinner.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { withSpinner } from "./spinner"
+
+describe("withSpinner", () => {
+	test("clears and stops the spinner when an Effect failure has no fail text", async () => {
+		const originalNodeEnv = process.env.NODE_ENV
+		const originalBunEnv = process.env.BUN_ENV
+		delete process.env.NODE_ENV
+		delete process.env.BUN_ENV
+
+		const calls: string[] = []
+		const error = new Error("boom")
+
+		try {
+			await expect(
+				Effect.runPromise(
+					withSpinner(Effect.fail(error), {
+						text: "Working",
+						createSpinner: () => ({
+							succeed: () => calls.push("succeed"),
+							fail: () => calls.push("fail"),
+							clear: () => calls.push("clear"),
+							stop: () => calls.push("stop"),
+						}),
+					}),
+				),
+			).rejects.toThrow("boom")
+
+			expect(calls).toEqual(["clear", "stop"])
+		} finally {
+			if (originalNodeEnv === undefined) {
+				delete process.env.NODE_ENV
+			} else {
+				process.env.NODE_ENV = originalNodeEnv
+			}
+
+			if (originalBunEnv === undefined) {
+				delete process.env.BUN_ENV
+			} else {
+				process.env.BUN_ENV = originalBunEnv
+			}
+		}
+	})
+})

package/src/utils/spinner.ts

@@ -1,5 +1,12 @@
 import ora from "ora"
-import { Effect } from "effect"
+import { Effect, Exit } from "effect"
+
+interface Spinner {
+	succeed: (text?: string) => unknown
+	fail: (text?: string) => unknown
+	clear: () => unknown
+	stop: () => unknown
+}
 
 /**
  * Check if we're running in a test environment
@@ -20,6 +27,8 @@ interface SpinnerConfig {
 	failText?: string
 	/** Whether the spinner is enabled (defaults to true) */
 	enabled?: boolean
+	/** Creates the spinner instance. Intended for tests. */
+	createSpinner?: (text: string) => Spinner
 }
 
 /**
@@ -53,31 +62,35 @@ export const withSpinner = <A, E, R>(
 		return effect
 	}
 
-	return Effect.gen(function* () {
-		const spinner = ora({
-			text,
-			spinner: "dots",
-			color: "cyan",
-		}).start()
-
-		try {
-			const result = yield* effect
+	const createSpinner =
+		config.createSpinner ??
+		((text: string) =>
+			ora({
+				text,
+				spinner: "dots",
+				color: "cyan",
+			}).start())
 
-			if (successText) {
-				spinner.succeed(successText)
-			} else {
-				spinner.stop()
-			}
+	return Effect.acquireUseRelease(
+		Effect.sync(() => createSpinner(text)),
+		() => effect,
+		(spinner, exit) =>
+			Effect.sync(() => {
+				if (Exit.isSuccess(exit)) {
+					if (successText) {
+						spinner.succeed(successText)
+					} else {
+						spinner.stop()
+					}
+					return
+				}
 
-			return result
-		} catch (error) {
-			if (failText) {
-				spinner.fail(failText)
-			} else {
-				spinner.clear()
-				spinner.stop()
-			}
-			throw error
-		}
-	})
+				if (failText) {
+					spinner.fail(failText)
+				} else {
+					spinner.clear()
+					spinner.stop()
+				}
+			}),
+	)
 }