@markjaquith/agency 2.71.19 → 2.71.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.19",
+  "version": "2.71.21",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -21,8 +21,9 @@
     "index.ts",
     "cli.ts",
     "cli-main.ts",
-    "pi-extensions",
     "src",
+    "pi-extensions",
+    "scripts/install-pi-extension.ts",
     "schemas",
     "fixtures/protocol",
     "README.md",
@@ -67,9 +68,11 @@
     "benchmark:act": "bun scripts/benchmark-act.ts",
     "benchmark:pr": "bun scripts/benchmark-pr.ts",
     "benchmark:release": "bun scripts/benchmark-release.ts",
+    "benchmark:repositories": "bun scripts/benchmark-repositories.ts",
     "benchmark:status": "bun scripts/benchmark-status.ts",
     "benchmark:next": "bun scripts/benchmark-next.ts",
     "benchmark:init": "bun scripts/benchmark-init.ts",
+    "benchmark:integration": "bun scripts/benchmark-integration.ts",
     "benchmark:workbase": "bun scripts/benchmark-workbase.ts",
     "benchmark:doctor": "bun scripts/benchmark-doctor.ts",
     "benchmark:context": "bun scripts/benchmark-context.ts",

package/scripts/install-pi-extension.ts

@@ -0,0 +1,25 @@
+import { cp, mkdir, rm } from "node:fs/promises"
+import { homedir } from "node:os"
+import { dirname, join } from "node:path"
+
+export const piExtensionPath = (home = homedir()) =>
+	join(home, ".pi", "agent", "extensions", "agency.ts")
+
+export const installPiExtension = async (
+	source = join(import.meta.dir, "..", "pi-extensions", "agency.ts"),
+	destination = piExtensionPath(),
+) => {
+	await mkdir(dirname(destination), { recursive: true })
+	await cp(source, destination)
+}
+
+export const uninstallPiExtension = async (destination = piExtensionPath()) => {
+	await rm(destination, { force: true })
+}
+
+if (import.meta.main) {
+	const command = process.argv[2] ?? "install"
+	if (command === "install") await installPiExtension()
+	else if (command === "uninstall") await uninstallPiExtension()
+	else throw new Error(`Unknown Pi extension lifecycle command: ${command}`)
+}

package/src/commands/init.ts

@@ -18,7 +18,7 @@ export const init = (options: InitOptions = {}) =>
 		const root = yield* workbase.initialize(
 			options.path ? resolve(cwd, options.path) : cwd,
 		)
-		yield* integrations.sync(root)
+		yield* integrations.syncRoot(root)
 		log(
 			options.json
 				? JSON.stringify({ root }, null, 2)

package/src/commands/work.test.ts

@@ -258,6 +258,18 @@ const createHarness = (options: HarnessOptions = {}) => {
 				],
 			})
 		},
+		syncRoot: () => {
+			integrationSyncs += 1
+			return Effect.succeed({
+				root: "/workbase",
+				files: [
+					{
+						name: "opencode",
+						state: "managed",
+					},
+				],
+			})
+		},
 	}
 	const fs = {
 		isDirectory: (path: string) =>

package/src/commands/work.ts

@@ -130,7 +130,7 @@ export const work = (
 		const inputAllowed = options.inputAllowed ?? true
 		const root = yield* resolveWorkbase(startPath, pickBase, inputAllowed)
 		if (!root) return
-		yield* integrations.sync(root)
+		yield* integrations.syncRoot(root)
 		const { config } = yield* workbase.loadConfig(root)
 		const globalConfig = yield* workbase.loadGlobalConfig()
 

package/src/services/FileSystemService.ts

@@ -91,6 +91,38 @@ export class FileSystemService extends Effect.Service<FileSystemService>()(
 					catch: () => new FileNotFoundError({ path }),
 				}),
 
+			inspectFile: (path: string) =>
+				Effect.tryPromise({
+					try: async () => {
+						try {
+							const stats = await lstat(path)
+							if (stats.isSymbolicLink()) {
+								return { kind: "symlink" as const }
+							}
+							if (!stats.isFile()) return { kind: "other" as const }
+							return {
+								kind: "file" as const,
+								content: await Bun.file(path).text(),
+							}
+						} catch (error) {
+							if (
+								typeof error === "object" &&
+								error !== null &&
+								"code" in error &&
+								error.code === "ENOENT"
+							) {
+								return { kind: "missing" as const }
+							}
+							throw error
+						}
+					},
+					catch: (error) =>
+						new FileSystemError({
+							message: `Failed to inspect file: ${path}`,
+							cause: error,
+						}),
+				}),
+
 			writeFile: (path: string, content: string) =>
 				Effect.tryPromise({
 					try: () => Bun.write(path, content),

package/src/services/IntegrationService.test.ts

@@ -17,6 +17,7 @@ import {
 	managedWorkbaseOpencodeTuiPlugin,
 } from "../workbase/opencode-tui-plugin-file"
 import { IntegrationService } from "./IntegrationService"
+import { FileSystemService } from "./FileSystemService"
 
 const write = async (root: string, path: string, content: string) => {
 	const fullPath = join(root, path)
@@ -90,6 +91,54 @@ describe("IntegrationService", () => {
 		])
 	})
 
+	test("inspects each integration path once per status call", async () => {
+		const service = await Effect.runPromise(
+			Effect.provide(FileSystemService, FileSystemService.Default),
+		)
+		const inspected = new Map<string, number>()
+		const instrumented = {
+			...service,
+			inspectFile: (path: string) => {
+				inspected.set(path, (inspected.get(path) ?? 0) + 1)
+				return service.inspectFile(path)
+			},
+		}
+
+		await runTestEffect(
+			IntegrationService.pipe(
+				Effect.flatMap((integration) => integration.statusRoot(root)),
+				Effect.provideService(FileSystemService, instrumented),
+			),
+		)
+
+		expect(inspected.size).toBe(8)
+		expect([...inspected.values()]).toEqual(Array(8).fill(1))
+	})
+
+	test("inspects integration and legacy paths once per synchronized call", async () => {
+		const service = await Effect.runPromise(
+			Effect.provide(FileSystemService, FileSystemService.Default),
+		)
+		const inspected = new Map<string, number>()
+		const instrumented = {
+			...service,
+			inspectFile: (path: string) => {
+				inspected.set(path, (inspected.get(path) ?? 0) + 1)
+				return service.inspectFile(path)
+			},
+		}
+
+		await runTestEffect(
+			IntegrationService.pipe(
+				Effect.flatMap((integration) => integration.syncRoot(root)),
+				Effect.provideService(FileSystemService, instrumented),
+			),
+		)
+
+		expect(inspected.size).toBe(11)
+		expect([...inspected.values()]).toEqual(Array(11).fill(1))
+	})
+
 	test("reports customized and checksum-safe drifted files", async () => {
 		await write(root, ".agency/AGENTS.md", "# Custom instructions\n")
 		await write(

package/src/services/IntegrationService.ts

@@ -202,35 +202,54 @@ const inspect = (root: string) =>
 			"agency-repository-skills.ts",
 		)
 		const tuiPluginPath = join(opencodeDirectory, "tui", "agency-debug.ts")
+		const [
+			agents,
+			opencode,
+			opencodeJson,
+			plugin,
+			legacyPlugin,
+			tui,
+			tuiJson,
+			tuiPlugin,
+		] = yield* Effect.all(
+			[
+				fs.inspectFile(agentsPath),
+				fs.inspectFile(opencodePath),
+				fs.inspectFile(opencodeJsonPath),
+				fs.inspectFile(pluginPath),
+				fs.inspectFile(legacyPluginPath),
+				fs.inspectFile(tuiPath),
+				fs.inspectFile(tuiJsonPath),
+				fs.inspectFile(tuiPluginPath),
+			] as const,
+			{ concurrency: 8 },
+		)
 		const files: IntegrationFileStatus[] = []
 
 		files.push(
-			(yield* fs.readSymlinkTarget(agentsPath)) !== null
+			agents.kind === "symlink"
 				? fileStatus("agents", agentsPath, "customized")
-				: (yield* fs.exists(agentsPath))
+				: agents.kind === "file"
 					? classify(
 							"agents",
 							agentsPath,
-							yield* fs.readFile(agentsPath),
+							agents.content,
 							managedWorkbaseAgents,
 							canUpdateManagedWorkbaseAgents,
 						)
 					: fileStatus("agents", agentsPath, "missing"),
 		)
 
-		if ((yield* fs.readSymlinkTarget(opencodePath)) !== null) {
+		if (opencode.kind === "symlink") {
 			files.push(fileStatus("opencode", opencodePath, "customized"))
-		} else if (
-			(yield* fs.readSymlinkTarget(opencodeJsonPath)) !== null ||
-			(yield* fs.exists(opencodeJsonPath))
-		) {
+		} else if (opencodeJson.kind !== "missing") {
 			files.push(fileStatus("opencode", opencodeJsonPath, "customized"))
-		} else if (yield* fs.exists(opencodePath)) {
+		} else if (opencode.kind === "file") {
 			files.push(
 				classify(
 					"opencode",
 					opencodePath,
-					yield* fs.readFile(opencodePath),
+					opencode.content,
 					managedWorkbaseOpencode,
 					canUpdateManagedWorkbaseOpencode,
 				),
@@ -239,26 +258,21 @@ const inspect = (root: string) =>
 			files.push(fileStatus("opencode", opencodePath, "missing"))
 		}
 
-		if ((yield* fs.readSymlinkTarget(pluginPath)) !== null) {
+		if (plugin.kind === "symlink") {
 			files.push(fileStatus("opencode-plugin", pluginPath, "customized"))
-		} else if (yield* fs.exists(pluginPath)) {
+		} else if (plugin.kind === "file") {
 			files.push(
 				classify(
 					"opencode-plugin",
 					pluginPath,
-					yield* fs.readFile(pluginPath),
+					plugin.content,
 					managedWorkbaseOpencodePlugin,
 					canUpdateManagedWorkbaseOpencodePlugin,
 				),
 			)
-		} else if (
-			(yield* fs.readSymlinkTarget(legacyPluginPath)) !== null ||
-			(yield* fs.exists(legacyPluginPath))
-		) {
+		} else if (legacyPlugin.kind !== "missing") {
 			const legacyContent =
-				(yield* fs.readSymlinkTarget(legacyPluginPath)) === null
-					? yield* fs.readFile(legacyPluginPath)
-					: null
+				legacyPlugin.kind === "file" ? legacyPlugin.content : null
 			files.push(
 				legacyContent !== null &&
 					canUpdateManagedWorkbaseOpencodePlugin(legacyContent)
@@ -269,19 +283,16 @@ const inspect = (root: string) =>
 			files.push(fileStatus("opencode-plugin", pluginPath, "missing"))
 		}
 
-		if ((yield* fs.readSymlinkTarget(tuiPath)) !== null) {
+		if (tui.kind === "symlink") {
 			files.push(fileStatus("opencode-tui", tuiPath, "customized"))
-		} else if (
-			(yield* fs.readSymlinkTarget(tuiJsonPath)) !== null ||
-			(yield* fs.exists(tuiJsonPath))
-		) {
+		} else if (tuiJson.kind !== "missing") {
 			files.push(fileStatus("opencode-tui", tuiJsonPath, "customized"))
-		} else if (yield* fs.exists(tuiPath)) {
+		} else if (tui.kind === "file") {
 			files.push(
 				classify(
 					"opencode-tui",
 					tuiPath,
-					yield* fs.readFile(tuiPath),
+					tui.content,
 					managedWorkbaseOpencodeTui,
 					canUpdateManagedWorkbaseOpencodeTui,
 				),
@@ -290,14 +301,14 @@ const inspect = (root: string) =>
 			files.push(fileStatus("opencode-tui", tuiPath, "missing"))
 		}
 
-		if ((yield* fs.readSymlinkTarget(tuiPluginPath)) !== null) {
+		if (tuiPlugin.kind === "symlink") {
 			files.push(fileStatus("opencode-tui-plugin", tuiPluginPath, "customized"))
-		} else if (yield* fs.exists(tuiPluginPath)) {
+		} else if (tuiPlugin.kind === "file") {
 			files.push(
 				classify(
 					"opencode-tui-plugin",
 					tuiPluginPath,
-					yield* fs.readFile(tuiPluginPath),
+					tuiPlugin.content,
 					managedWorkbaseOpencodeTuiPlugin,
 					canUpdateManagedWorkbaseOpencodeTuiPlugin,
 				),
@@ -306,32 +317,25 @@ const inspect = (root: string) =>
 			files.push(fileStatus("opencode-tui-plugin", tuiPluginPath, "missing"))
 		}
 
-		return files
+		return { files, legacyPlugin }
 	})
 
 const canRemoveLegacyAgents = (root: string) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
 		const path = join(root, "AGENTS.md")
-		if (
-			(yield* fs.readSymlinkTarget(path)) !== null ||
-			!(yield* fs.exists(path))
-		)
-			return false
-		return canUpdateManagedWorkbaseAgents(yield* fs.readFile(path))
+		const file = yield* fs.inspectFile(path)
+		return file.kind === "file" && canUpdateManagedWorkbaseAgents(file.content)
 	})
 
 const canRemoveLegacyOpencodeCommand = (root: string) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
 		const path = join(root, ".opencode", "command", "agency.md")
-		if (
-			(yield* fs.readSymlinkTarget(path)) !== null ||
-			!(yield* fs.exists(path))
-		)
-			return false
+		const file = yield* fs.inspectFile(path)
+		if (file.kind !== "file") return false
 
-		const content = yield* fs.readFile(path)
+		const content = file.content
 		const header = /^---\r?\n# agency-managed: sha256=([a-f0-9]{64})\r?\n/
 		const match = content.match(header)
 		if (!match?.[1]) return false
@@ -340,23 +344,6 @@ const canRemoveLegacyOpencodeCommand = (root: string) =>
 		return createHash("sha256").update(canonical).digest("hex") === match[1]
 	})
 
-const canRemoveLegacyOpencodePlugin = (root: string) =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystemService
-		const path = join(
-			root,
-			".opencode",
-			"plugin",
-			"agency-repository-skills.ts",
-		)
-		if (
-			(yield* fs.readSymlinkTarget(path)) !== null ||
-			!(yield* fs.exists(path))
-		)
-			return false
-		return canUpdateManagedWorkbaseOpencodePlugin(yield* fs.readFile(path))
-	})
-
 export class IntegrationService extends Effect.Service<IntegrationService>()(
 	"IntegrationService",
 	{
@@ -365,34 +352,59 @@ export class IntegrationService extends Effect.Service<IntegrationService>()(
 				Effect.gen(function* () {
 					const workbase = yield* WorkbaseService
 					const root = yield* workbase.discover(startPath)
-					return { root, files: yield* inspect(root) }
+					return { root, files: (yield* inspect(root)).files }
 				}),
 
+			statusRoot: (root: string) =>
+				inspect(root).pipe(Effect.map(({ files }) => ({ root, files }))),
+
 			sync: (startPath: string = process.cwd()) =>
 				Effect.gen(function* () {
-					const fs = yield* FileSystemService
 					const workbase = yield* WorkbaseService
 					const root = yield* workbase.discover(startPath)
-					const statuses = yield* inspect(root)
-					const removeLegacyAgents =
-						statuses.some(
-							(status) =>
-								status.name === "opencode" && status.state !== "customized",
-						) && (yield* canRemoveLegacyAgents(root))
-					const removeLegacyOpencodeCommand =
-						yield* canRemoveLegacyOpencodeCommand(root)
-					const removeLegacyOpencodePlugin =
-						yield* canRemoveLegacyOpencodePlugin(root)
+					const service = yield* IntegrationService
+					return yield* service.syncRoot(root)
+				}),
+
+			syncRoot: (root: string) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const { files: statuses, legacyPlugin } = yield* inspect(root)
 					const legacyPiExtension = join(
 						root,
 						".pi",
 						"extensions",
 						"agency-workbase.ts",
 					)
-					const removeLegacyPiExtension =
-						(yield* fs.readSymlinkTarget(legacyPiExtension)) === null &&
-						(yield* fs.exists(legacyPiExtension)) &&
-						canRemoveLegacyPiExtension(yield* fs.readFile(legacyPiExtension))
+					const canRemoveAgents = statuses.some(
+						(status) =>
+							status.name === "opencode" && status.state !== "customized",
+					)
+					const [
+						removeLegacyAgents,
+						removeLegacyOpencodeCommand,
+						removeLegacyPiExtension,
+					] = yield* Effect.all(
+						[
+							canRemoveAgents
+								? canRemoveLegacyAgents(root)
+								: Effect.succeed(false),
+							canRemoveLegacyOpencodeCommand(root),
+							fs
+								.inspectFile(legacyPiExtension)
+								.pipe(
+									Effect.map(
+										(file) =>
+											file.kind === "file" &&
+											canRemoveLegacyPiExtension(file.content),
+									),
+								),
+						] as const,
+						{ concurrency: 3 },
+					)
+					const removeLegacyOpencodePlugin =
+						legacyPlugin.kind === "file" &&
+						canUpdateManagedWorkbaseOpencodePlugin(legacyPlugin.content)
 					const files: IntegrationSyncFile[] = []
 
 					for (const status of statuses) {

package/src/services/RepositoryService.ts

@@ -520,8 +520,9 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						...Object.keys(config.repositories ?? {}),
 						...local.keys(),
 					])
-					const repositories = yield* Effect.all(
-						[...aliases].sort().map((alias) =>
+					return yield* Effect.forEach(
+						[...aliases].sort(),
+						(alias) =>
 							Effect.gen(function* () {
 								const path = join(reposPath, alias)
 								const entry = local.get(alias)
@@ -575,10 +576,8 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 									states,
 								} satisfies RepositoryInfo
 							}),
-						),
-						{ concurrency: 4 },
+						{ concurrency: 8 },
 					)
-					return repositories
 				}),
 
 			show: (alias: string, startPath: string = process.cwd()) =>

package/src/services/VersionControlService.test.ts

@@ -1,9 +1,13 @@
 import { afterEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
+import { Effect, Layer } from "effect"
 import { mkdir, realpath, stat } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
-import { VersionControlService } from "./VersionControlService"
+import {
+	GitVersionControlService,
+	VersionControlService,
+} from "./VersionControlService"
+import { FileSystemService } from "./FileSystemService"
 import { preferredVersionControl } from "../workbase/version-control"
 
 const run = async (args: string[], cwd?: string) => {
@@ -24,6 +28,39 @@ describe("VersionControlService", () => {
 		expect(preferredVersionControl(() => null)).toBe("git")
 	})
 
+	test("inspects a Git repository with one subprocess", async () => {
+		const commands: readonly string[][] = []
+		const fileSystem = {
+			...FileSystemService.Default,
+			runCommand: (command: readonly string[]) => {
+				;(commands as string[][]).push([...command])
+				return Effect.succeed({
+					exitCode: 0,
+					stdout:
+						"local\tcore.bare true\nlocal\tremote.origin.url agency:agency.git\nglobal\turl.https://example.com/.insteadof agency:\n",
+					stderr: "",
+				})
+			},
+		} as unknown as Effect.Effect.Success<typeof FileSystemService>
+		const backend = await Effect.runPromise(
+			GitVersionControlService.pipe(
+				Effect.provide(GitVersionControlService.Default),
+			),
+		)
+		const inspection = await Effect.runPromise(
+			backend
+				.inspectRepository("/repository")
+				.pipe(Effect.provide(Layer.succeed(FileSystemService, fileSystem))),
+		)
+
+		expect(commands).toHaveLength(1)
+		expect(commands[0]).toContain("--get-regexp")
+		expect(inspection).toEqual({
+			kind: "bare",
+			remote: "https://example.com/agency.git",
+		})
+	})
+
 	test("selects the backend persisted by the workbase", async () => {
 		for (const kind of ["git", "jj"] as const) {
 			const root = await createTempDir()

package/src/services/VersionControlService.ts

@@ -118,6 +118,52 @@ const requireSuccess = (
 		),
 	)
 
+interface GitConfigEntry {
+	readonly scope: string
+	readonly key: string
+	readonly value: string
+}
+
+const parseGitConfig = (output: string): readonly GitConfigEntry[] =>
+	output
+		.trim()
+		.split("\n")
+		.filter(Boolean)
+		.flatMap((line) => {
+			const scopeSeparator = line.indexOf("\t")
+			const valueSeparator = line.indexOf(" ", scopeSeparator + 1)
+			return scopeSeparator >= 0 && valueSeparator >= 0
+				? [
+						{
+							scope: line.slice(0, scopeSeparator),
+							key: line.slice(scopeSeparator + 1, valueSeparator),
+							value: line.slice(valueSeparator + 1),
+						},
+					]
+				: []
+		})
+
+const expandGitUrl = (
+	url: string,
+	entries: readonly GitConfigEntry[],
+): string => {
+	let replacement: { readonly prefix: string; readonly base: string } | null =
+		null
+	for (const entry of entries) {
+		const match = /^url\.(.*)\.insteadof$/i.exec(entry.key)
+		if (
+			match?.[1] !== undefined &&
+			url.startsWith(entry.value) &&
+			(replacement === null || entry.value.length > replacement.prefix.length)
+		) {
+			replacement = { prefix: entry.value, base: match[1] }
+		}
+	}
+	return replacement === null
+		? url
+		: replacement.base + url.slice(replacement.prefix.length)
+}
+
 const parseGitWorktrees = (output: string): readonly RegisteredWorkspace[] => {
 	const workspaces: RegisteredWorkspace[] = []
 	let current: RegisteredWorkspace | null = null
@@ -168,22 +214,33 @@ export class GitVersionControlService extends Effect.Service<GitVersionControlSe
 				inspectRepository: (path) =>
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService
-						const valid = yield* fs.runCommand(
-							["git", "-C", path, "rev-parse", "--git-dir"],
-							{ captureOutput: true },
-						)
-						if (valid.exitCode !== 0) return null
-						const bare = yield* fs.runCommand(
-							["git", "-C", path, "rev-parse", "--is-bare-repository"],
-							{ captureOutput: true },
-						)
-						const remote = yield* fs.runCommand(
-							["git", "-C", path, "remote", "get-url", "origin"],
+						const inspection = yield* fs.runCommand(
+							[
+								"git",
+								"-C",
+								path,
+								"config",
+								"--show-scope",
+								"--get-regexp",
+								"^(core\\.bare|remote\\.origin\\.url|url\\..*\\.insteadof)$",
+							],
 							{ captureOutput: true },
 						)
+						if (inspection.exitCode !== 0) return null
+						const entries = parseGitConfig(inspection.stdout)
+						const bare = entries.find(
+							(entry) =>
+								(entry.scope === "local" || entry.scope === "worktree") &&
+								entry.key === "core.bare",
+						)
+						if (!bare) return null
+						const remote = entries.find(
+							(entry) => entry.key === "remote.origin.url",
+						)?.value
 						return {
-							kind: bare.stdout.trim() === "true" ? "bare" : "repository",
-							remote: remote.exitCode === 0 ? remote.stdout.trim() : null,
+							kind: bare.value === "true" ? "bare" : "repository",
+							remote:
+								remote === undefined ? null : expandGitUrl(remote, entries),
 						} as const
 					}),
 				gitEnvironment: () => Effect.succeed({}),