@markjaquith/agency 2.71.20 → 2.71.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.20",
+  "version": "2.71.22",
   "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,6 +68,7 @@
     "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",
@@ -85,6 +87,7 @@
     "benchmark:task": "bun scripts/benchmark-task.ts",
     "benchmark:validate": "bun scripts/benchmark-validate.ts",
     "benchmark:worktree": "bun scripts/benchmark-worktree.ts",
+    "benchmark:review": "bun scripts/benchmark-review.ts",
     "test": "find src \\( -name '*.test.ts' -o -name '*.test.tsx' \\) -print0 | xargs -0 -n 1 -P 4 bun test",
     "test:opencode": "AGENCY_TEST_OPENCODE=1 bun test src/cli.test.ts --test-name-pattern 'provides effective whole-workbase OpenCode access'",
     "format": "oxfmt",

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/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/ReviewService.ts

@@ -23,7 +23,10 @@ import {
 	runLifecycleTransaction,
 	type TransactionStep,
 } from "./LifecycleTransaction"
-import { RevisionConflictError } from "../workbase/document-revision"
+import {
+	documentRevision,
+	RevisionConflictError,
+} from "../workbase/document-revision"
 import {
 	formatMarkdownDocument,
 	parseFrontmatter,
@@ -359,24 +362,33 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 									message: `Cannot refresh review task '${taskId}'; its checkout is dirty or structurally unexpected`,
 								})
 							}
-							const latest = yield* service.resolve(
+							const repository = yield* repositories.show(
 								task.data.review.repo,
-								task.data.review.source.kind === "pull-request"
-									? { pullRequest: task.data.review.source.url }
-									: { ref: task.data.review.source.ref },
 								root,
 							)
+							if (!repository.remote || repository.states.includes("missing")) {
+								return yield* new ReviewError({
+									message: `Repository alias '${task.data.review.repo}' must be materialized with an origin remote`,
+								})
+							}
+							const versionControl = yield* VersionControlService
+							const backend = yield* versionControl.forWorkbase(root)
+							const latest = {
+								...task.data.review,
+								commit: yield* fetchCommit(
+									repository.path,
+									task.data.review.source.kind === "pull-request"
+										? task.data.review.source.fetchRef
+										: task.data.review.source.ref,
+									backend,
+								),
+								refreshedAt: new Date().toISOString(),
+							} satisfies ReviewRecord
 							const parsed = yield* parseFrontmatter(task.content, task.path)
 							const content = formatMarkdownDocument(
 								{ ...task.data, review: latest },
 								parsed.body,
 							)
-							const repository = yield* repositories.show(
-								task.data.review.repo,
-								root,
-							)
-							const versionControl = yield* VersionControlService
-							const backend = yield* versionControl.forWorkbase(root)
 							const gitEnvironment = yield* backend.gitEnvironment(
 								repository.path,
 							)
@@ -456,7 +468,7 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 								commit: latest.commit,
 								changed: latest.commit !== task.data.review.commit,
 								refreshedAt: latest.refreshedAt,
-								revision: (yield* tasks.show(taskId, root)).revision,
+								revision: documentRevision(content),
 							}
 						}),
 					)

package/src/services/TaskService.ts

@@ -594,12 +594,13 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 				}
 				const content = yield* fs.readFile(path)
 				const parsed = yield* parseFrontmatter(content, path)
+				const data: TaskData = yield* decodeTask(parsed.data)
 				return {
 					id: validId,
 					path,
 					content,
 					revision: documentRevision(content),
-					data: yield* decodeTask(parsed.data),
+					data,
 				} satisfies TaskRecord
 			}),
 

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({}),