@markjaquith/agency 2.71.17 → 2.71.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.17",
+  "version": "2.71.19",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -75,7 +75,9 @@
     "benchmark:context": "bun scripts/benchmark-context.ts",
     "benchmark:claim": "bun scripts/benchmark-claim.ts",
     "benchmark:finish": "bun scripts/benchmark-finish.ts",
+    "benchmark:epic": "bun scripts/benchmark-epic.ts",
     "benchmark:phase": "bun scripts/benchmark-phase.ts",
+    "benchmark:graph": "bun scripts/benchmark-graph.ts",
     "benchmark:push": "bun scripts/benchmark-push.ts",
     "benchmark:archive": "bun scripts/benchmark-archive.ts",
     "benchmark:sync": "bun scripts/benchmark-sync.ts",

package/src/commands/epic.test.ts

@@ -111,6 +111,35 @@ describe("epic command", () => {
 		})
 	})
 
+	test("reads each epic document once when listing JSON", async () => {
+		await runTestEffect(
+			epic({
+				subcommand: "create",
+				args: ["example"],
+				ticketUrl: "https://example.com/epic",
+				repos: ["agency:main"],
+				cwd: root,
+				silent: true,
+			}),
+		)
+		const original = Bun.file
+		let reads = 0
+		Bun.file = ((path: Parameters<typeof Bun.file>[0], ...args: never[]) => {
+			if (String(path).endsWith("/epics/example/EPIC.md")) reads += 1
+			return original(path as unknown as string, ...args)
+		}) as typeof Bun.file
+		try {
+			await captureLogs(() =>
+				runTestEffect(
+					epic({ subcommand: "list", args: [], cwd: root, json: true }),
+				),
+			)
+		} finally {
+			Bun.file = original
+		}
+		expect(reads).toBe(2)
+	})
+
 	test("renders a readable operational table", async () => {
 		await runTestEffect(
 			epic({

package/src/commands/epic.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect"
+import { join } from "node:path"
 import type { BaseCommandOptions } from "../utils/command"
 import { EpicService } from "../services/EpicService"
 import { createLoggers } from "../utils/effect"
@@ -71,7 +72,6 @@ export const epic = (options: EpicOptions, work: StartWork = startWork) =>
 			}
 
 			case "list": {
-				const records = yield* epics.list(cwd)
 				const { epicRows } = yield* getWorkViews({
 					cwd,
 					statuses: options.statuses,
@@ -80,14 +80,15 @@ export const epic = (options: EpicOptions, work: StartWork = startWork) =>
 					blocked: options.blocked,
 					pr: options.pr,
 				})
-				const ordered = epicRows.flatMap((row) => {
-					const record = records.find((item) => item.id === row.key)
-					return record ? [record] : []
-				})
 				if (options.json) {
 					log(
 						JSON.stringify(
-							ordered.map(({ content: _, ...record }) => record),
+							epicRows.map((row) => ({
+								id: row.id,
+								path: join(cwd, "epics", row.id, "EPIC.md"),
+								revision: row.revision,
+								data: row.data,
+							})),
 							null,
 							2,
 						),

package/src/readiness.ts

@@ -24,23 +24,27 @@ export const canTransitionStatus = (from: WorkStatus, to: WorkStatus) =>
 export const aggregateProgress = (statuses: readonly WorkStatus[]) => {
 	const counts = {
 		total: statuses.length,
-		open: statuses.filter((status) => status === "open").length,
-		working: statuses.filter((status) => status === "working").length,
-		delegated: statuses.filter((status) => status === "delegated").length,
-		done: statuses.filter((status) => status === "done").length,
-		dropped: statuses.filter((status) => status === "dropped").length,
-		terminal: statuses.filter(isTerminalStatus).length,
+		open: 0,
+		working: 0,
+		delegated: 0,
+		done: 0,
+		dropped: 0,
+		terminal: 0,
+	}
+	for (const status of statuses) {
+		counts[status] += 1
+		if (isTerminalStatus(status)) counts.terminal += 1
 	}
 	const status: WorkStatus =
-		statuses.length === 0
+		counts.total === 0
 			? "open"
-			: statuses.every((value) => value === "done")
+			: counts.done === counts.total
 				? "done"
-				: statuses.every(isTerminalStatus)
+				: counts.terminal === counts.total
 					? "dropped"
-					: statuses.includes("working")
+					: counts.working > 0
 						? "working"
-						: statuses.includes("delegated")
+						: counts.delegated > 0
 							? "delegated"
 							: "open"
 	return { status, ...counts }

package/src/services/GraphService.test.ts

@@ -6,7 +6,10 @@ import { dirname, join } from "node:path"
 import { AgencyGraph } from "../graph-schema"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { GraphService } from "./GraphService"
-import { VersionControlService } from "./VersionControlService"
+import {
+	VersionControlService,
+	type VersionControlBackend,
+} from "./VersionControlService"
 
 const write = async (root: string, path: string, content: string) => {
 	const fullPath = join(root, path)
@@ -364,6 +367,15 @@ status: open
 
 		const detailed = await getGraph(root, {
 			include: ["bodies", "workspace", "git", "pr"],
+			backend: {
+				kind: "git",
+				inspectRepository: () => Effect.succeed(null),
+				listWorkspaces: () => Effect.succeed([]),
+				resolveRevision: () => Effect.succeed(null),
+				workspaceHead: () => Effect.succeed(null),
+				workspaceDirty: () => Effect.succeed(null),
+				remoteUrl: () => Effect.succeed(null),
+			} as unknown as VersionControlBackend,
 		})
 		expect(detailed.includes).toEqual(["bodies", "git", "pr", "workspace"])
 		expect(detailed.workbase.root).toBe(root)
@@ -386,4 +398,51 @@ status: open
 		expect(execution?.pr).toEqual({ url: null, state: "none" })
 		expect(Schema.decodeUnknownSync(AgencyGraph)(detailed)).toEqual(detailed)
 	})
+
+	test("reuses repository metadata and revision lookups for git details", async () => {
+		const root = await createWorkbase()
+		roots.push(root)
+		const calls = {
+			listWorkspaces: 0,
+			remoteUrl: 0,
+			resolveRevision: new Map<string, number>(),
+		}
+		const backend = {
+			kind: "git",
+			inspectRepository: () => Effect.succeed(null),
+			listWorkspaces: () =>
+				Effect.sync(() => {
+					calls.listWorkspaces += 1
+					return []
+				}),
+			remoteUrl: () =>
+				Effect.sync(() => {
+					calls.remoteUrl += 1
+					return null
+				}),
+			resolveRevision: (_path: string, revision: string) =>
+				Effect.sync(() => {
+					calls.resolveRevision.set(
+						revision,
+						(calls.resolveRevision.get(revision) ?? 0) + 1,
+					)
+					return revision
+				}),
+			workspaceHead: () => Effect.succeed(null),
+			workspaceDirty: () => Effect.succeed(null),
+		} as unknown as VersionControlBackend
+
+		await getGraph(root, { include: ["git"], backend })
+
+		expect(calls.listWorkspaces).toBe(0)
+		expect(calls.remoteUrl).toBe(1)
+		expect(calls.resolveRevision).toEqual(
+			new Map([
+				["feat/prepare", 1],
+				["feat/implement", 1],
+				["feat/verify", 1],
+				["main", 1],
+			]),
+		)
+	})
 })

package/src/services/GraphService.ts

@@ -298,22 +298,28 @@ export class GraphService extends Effect.Service<GraphService>()(
 					}
 					const taskDependencies = (taskId: string) =>
 						taskDeclarations.get(taskId)?.dependsOn ?? []
+					const taskLeafStatusCache = new Map<string, WorkStatus[]>()
 					const taskLeafStatuses = (taskId: string): WorkStatus[] => {
+						const cached = taskLeafStatusCache.get(taskId)
+						if (cached) return cached
 						const task = tasks.get(taskId)
 						if (!task) return []
-						return "phases" in task.data
-							? task.data.phases.map(
-									(item) =>
-										phases.get(`${taskId}/${item.id}`)?.data.status ?? "open",
-								)
-							: [task.data.status]
+						const statuses =
+							"phases" in task.data
+								? task.data.phases.map(
+										(item) =>
+											phases.get(`${taskId}/${item.id}`)?.data.status ?? "open",
+									)
+								: [task.data.status]
+						taskLeafStatusCache.set(taskId, statuses)
+						return statuses
 					}
-					const taskStatuses = new Map<string, WorkStatus>()
+					const taskStatusCache = new Map<string, WorkStatus>()
 					const taskStatus = (taskId: string) => {
-						const cached = taskStatuses.get(taskId)
+						const cached = taskStatusCache.get(taskId)
 						if (cached) return cached
 						const status = aggregateProgress(taskLeafStatuses(taskId)).status
-						taskStatuses.set(taskId, status)
+						taskStatusCache.set(taskId, status)
 						return status
 					}
 					const dependencyBlockers = (
@@ -668,6 +674,40 @@ export class GraphService extends Effect.Service<GraphService>()(
 					}
 					const dependents = (id: string) =>
 						[...(reverseDependencies.get(id) ?? [])].sort()
+					const repositoryWorkspaces = new Map<
+						string,
+						ReturnType<VersionControlBackend["listWorkspaces"]>
+					>()
+					const listWorkspaces = (path: string) => {
+						if (!backend) return Effect.succeed([])
+						const cached = repositoryWorkspaces.get(path)
+						if (cached) return cached
+						const workspaces = backend
+							.listWorkspaces(path)
+							.pipe(Effect.catchAll(() => Effect.succeed([])))
+						repositoryWorkspaces.set(path, workspaces)
+						return workspaces
+					}
+					const repositoryRemotes = new Map<string, string | null>()
+					const remoteUrl = (path: string, remote: string) =>
+						Effect.gen(function* () {
+							if (!backend) return null
+							const key = `${path}\u0000${remote}`
+							if (repositoryRemotes.has(key)) return repositoryRemotes.get(key)!
+							const url = yield* backend.remoteUrl(path, remote)
+							repositoryRemotes.set(key, url)
+							return url
+						})
+					const resolvedRevisions = new Map<string, string | null>()
+					const resolveRevision = (path: string, revision: string) =>
+						Effect.gen(function* () {
+							if (!backend) return null
+							const key = `${path}\u0000${revision}`
+							if (resolvedRevisions.has(key)) return resolvedRevisions.get(key)!
+							const resolved = yield* backend.resolveRevision(path, revision)
+							resolvedRevisions.set(key, resolved)
+							return resolved
+						})
 
 					const documentDetails = <T extends Record<string, unknown>>(
 						document: Document<T>,
@@ -691,11 +731,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 						Effect.gen(function* () {
 							if (!backend) return undefined
 							const inspection = yield* backend.inspectRepository(path)
-							const workspaces = inspection
-								? yield* backend
-										.listWorkspaces(path)
-										.pipe(Effect.catchAll(() => Effect.succeed([])))
-								: []
+							const workspaces = inspection ? yield* listWorkspaces(path) : []
 							const primary = workspaces.find(
 								(workspace) => workspace.path === path,
 							)
@@ -728,15 +764,12 @@ export class GraphService extends Effect.Service<GraphService>()(
 							}
 							if (include.has("git")) {
 								if (!backend) return result
-								const remote = yield* backend.remoteUrl(
-									repositoryPath,
-									"origin",
-								)
+								const remote = yield* remoteUrl(repositoryPath, "origin")
 								const canonicalCheckoutPath = materialized
 									? yield* fs.realPath(checkoutPath)
 									: checkoutPath
 								const actualBranch = materialized
-									? yield* backend.listWorkspaces(repositoryPath).pipe(
+									? yield* listWorkspaces(repositoryPath).pipe(
 											Effect.map(
 												(workspaces) =>
 													workspaces
@@ -777,11 +810,11 @@ export class GraphService extends Effect.Service<GraphService>()(
 										: {
 												branch: data.branch,
 												base: data.base,
-												branchCommit: yield* backend.resolveRevision(
+												branchCommit: yield* resolveRevision(
 													repositoryPath,
 													data.branch,
 												),
-												baseCommit: yield* backend.resolveRevision(
+												baseCommit: yield* resolveRevision(
 													repositoryPath,
 													data.base,
 												),

package/src/work-view.ts

@@ -34,6 +34,7 @@ export interface WorkViewRow {
 	readonly pr: string
 	readonly worktree: string
 	readonly hasPr: boolean
+	readonly data: Readonly<Record<string, unknown>>
 }
 
 const allowedStatuses = new Set<WorkStatus>([
@@ -122,6 +123,9 @@ const rowFor = (
 		hasPr: executions.some(
 			(execution) => "pr" in execution.data && Boolean(execution.data.pr),
 		),
+		data: Object.fromEntries(
+			Object.entries(node.data).filter(([key]) => key !== "sha256"),
+		),
 	}
 }