@markjaquith/agency 2.71.4 → 2.71.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.4",
+  "version": "2.71.5",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -21,9 +21,8 @@
     "index.ts",
     "cli.ts",
     "cli-main.ts",
-    "src",
     "pi-extensions",
-    "scripts/install-pi-extension.ts",
+    "src",
     "schemas",
     "fixtures/protocol",
     "README.md",
@@ -65,6 +64,7 @@
   "scripts": {
     "postinstall": "bun scripts/install-pi-extension.ts install",
     "preuninstall": "bun scripts/install-pi-extension.ts uninstall",
+    "benchmark:status": "bun scripts/benchmark-status.ts",
     "benchmark:workbase": "bun scripts/benchmark-workbase.ts",
     "benchmark:context": "bun scripts/benchmark-context.ts",
     "benchmark:sync": "bun scripts/benchmark-sync.ts",

package/src/services/GraphService.ts

@@ -277,6 +277,13 @@ export class GraphService extends Effect.Service<GraphService>()(
 					}
 
 					const taskDeclarations = new Map<string, Dependency>()
+					const phasesByTask = new Map<string, Document<PhaseData>[]>()
+					for (const [key, phase] of phases) {
+						const taskId = key.slice(0, key.indexOf("/"))
+						const values = phasesByTask.get(taskId) ?? []
+						values.push(phase)
+						phasesByTask.set(taskId, values)
+					}
 					for (const epic of epics.values()) {
 						for (const declaration of epic.data.tasks) {
 							taskDeclarations.set(declaration.id, declaration)
@@ -294,8 +301,14 @@ export class GraphService extends Effect.Service<GraphService>()(
 								)
 							: [task.data.status]
 					}
-					const taskStatus = (taskId: string) =>
-						aggregateProgress(taskLeafStatuses(taskId)).status
+					const taskStatuses = new Map<string, WorkStatus>()
+					const taskStatus = (taskId: string) => {
+						const cached = taskStatuses.get(taskId)
+						if (cached) return cached
+						const status = aggregateProgress(taskLeafStatuses(taskId)).status
+						taskStatuses.set(taskId, status)
+						return status
+					}
 					const dependencyBlockers = (
 						dependencies: readonly string[],
 						toId: (id: string) => string,
@@ -320,16 +333,20 @@ export class GraphService extends Effect.Service<GraphService>()(
 
 					const validation =
 						options.validation ?? (yield* workbase.validate(root))
+					const validationIssuesByPath = Map.groupBy(
+						validation.issues,
+						(issue) => issue.path,
+					)
 					const validationBlockers = (
 						paths: readonly string[],
 					): GraphBlocker[] =>
-						validation.issues
-							.filter((issue) => paths.includes(issue.path))
-							.map((issue) => ({
+						paths.flatMap((path) =>
+							(validationIssuesByPath.get(path) ?? []).map((issue) => ({
 								kind: "validation" as const,
 								id: issue.path,
 								reason: issue.message,
-							}))
+							})),
+						)
 					const uniqueBlockers = (blockers: readonly GraphBlocker[]) => [
 						...new Map(
 							blockers.map((item) => [
@@ -339,7 +356,9 @@ export class GraphService extends Effect.Service<GraphService>()(
 						).values(),
 					]
 
-					const phaseState = (taskId: string, phaseId: string) => {
+					type PhaseState = ReturnType<typeof createPhaseState>
+					const phaseStates = new Map<string, PhaseState>()
+					function createPhaseState(taskId: string, phaseId: string) {
 						const task = tasks.get(taskId)
 						const phase = phases.get(`${taskId}/${phaseId}`)
 						const parentEpic = task?.data.epic
@@ -386,8 +405,18 @@ export class GraphService extends Effect.Service<GraphService>()(
 							},
 						}
 					}
+					const phaseState = (taskId: string, phaseId: string) => {
+						const key = `${taskId}/${phaseId}`
+						const cached = phaseStates.get(key)
+						if (cached) return cached
+						const state = createPhaseState(taskId, phaseId)
+						phaseStates.set(key, state)
+						return state
+					}
 
-					const taskState = (taskId: string) => {
+					type TaskState = ReturnType<typeof createTaskState>
+					const taskStates = new Map<string, TaskState>()
+					function createTaskState(taskId: string) {
 						const task = tasks.get(taskId)
 						const parentEpic = task?.data.epic
 							? epics.get(task.data.epic)
@@ -398,9 +427,9 @@ export class GraphService extends Effect.Service<GraphService>()(
 							? [
 									relative(root, task.path),
 									...(parentEpic ? [relative(root, parentEpic.path)] : []),
-									...[...phases.entries()]
-										.filter(([key]) => key.startsWith(`${taskId}/`))
-										.map(([, phase]) => relative(root, phase.path)),
+									...(phasesByTask.get(taskId) ?? []).map((phase) =>
+										relative(root, phase.path),
+									),
 								]
 							: []
 						const blockers = [
@@ -461,6 +490,13 @@ export class GraphService extends Effect.Service<GraphService>()(
 							},
 						}
 					}
+					const taskState = (taskId: string) => {
+						const cached = taskStates.get(taskId)
+						if (cached) return cached
+						const state = createTaskState(taskId)
+						taskStates.set(taskId, state)
+						return state
+					}
 
 					const epicState = (epicId: string) => {
 						const epic = epics.get(epicId)
@@ -475,9 +511,9 @@ export class GraphService extends Effect.Service<GraphService>()(
 										const task = tasks.get(item.id)
 										return [
 											...(task ? [relative(root, task.path)] : []),
-											...[...phases.entries()]
-												.filter(([key]) => key.startsWith(`${item.id}/`))
-												.map(([, phase]) => relative(root, phase.path)),
+											...(phasesByTask.get(item.id) ?? []).map((phase) =>
+												relative(root, phase.path),
+											),
 										]
 									}),
 								]
@@ -761,6 +797,36 @@ export class GraphService extends Effect.Service<GraphService>()(
 							return result
 						})
 
+					const executionDetailsByKey = new Map<
+						string,
+						Effect.Effect.Success<ReturnType<typeof executionDetails>>
+					>()
+					const executionDocuments: readonly (readonly [
+						string,
+						string,
+						ExecutionData,
+					])[] = [
+						...[...tasks.values()].flatMap((task) =>
+							"phases" in task.data
+								? []
+								: ([[task.id, task.path, task.data]] as const),
+						),
+						...[...phases].map(
+							([key, phase]) => [key, phase.path, phase.data] as const,
+						),
+					]
+					const inspectedExecutions = yield* Effect.all(
+						executionDocuments.map(([key, path, data]) =>
+							executionDetails(path, data).pipe(
+								Effect.map((details) => [key, details] as const),
+							),
+						),
+						{ concurrency: 16 },
+					)
+					for (const [key, details] of inspectedExecutions) {
+						executionDetailsByKey.set(key, details)
+					}
+
 					const nodes: GraphNode[] = []
 					for (const epic of epics.values()) {
 						const state = epicState(epic.id)
@@ -805,7 +871,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 								dependents: dependents(taskNodeId(task.id)),
 								repositories,
 								data: { taskId: task.id, ...task.data },
-								...(yield* executionDetails(task.path, task.data)),
+								...executionDetailsByKey.get(task.id),
 							})
 						}
 					}
@@ -830,7 +896,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 							dependents: dependents(phaseNodeId(taskId, phase.id)),
 							repositories,
 							data: { taskId, phaseId: phase.id, ...phase.data },
-							...(yield* executionDetails(phase.path, phase.data)),
+							...executionDetailsByKey.get(key),
 						})
 					}
 					for (const repository of [...repositoryRecords.values()].sort(

package/src/services/RepositoryService.ts

@@ -520,62 +520,64 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						...Object.keys(config.repositories ?? {}),
 						...local.keys(),
 					])
-					const repositories: RepositoryInfo[] = []
-
-					for (const alias of [...aliases].sort()) {
-						const path = join(reposPath, alias)
-						const entry = local.get(alias)
-						const declaredRemote = config.repositories?.[alias]?.remote ?? null
-						if (!entry) {
-							repositories.push({
-								alias,
-								path,
-								kind: null,
-								remote: null,
-								declaredRemote,
-								target: null,
-								states: ["declared", "missing"],
-							})
-							continue
-						}
-						if (!entry.isDirectory && !entry.isSymlink) {
-							repositories.push({
-								alias,
-								path,
-								kind: null,
-								remote: null,
-								declaredRemote,
-								target: null,
-								states: [
-									...(declaredRemote ? (["declared"] as const) : []),
-									"invalid",
-								],
-							})
-							continue
-						}
-						const target = entry.isSymlink
-							? yield* fs.readSymlinkTarget(path)
-							: null
-						const inspection = yield* backend.inspectRepository(path)
-						const remote = inspection?.remote ?? null
-						const states: RepositoryState[] = []
-						if (declaredRemote) states.push("declared")
-						states.push(entry.isSymlink ? "linked" : "materialized")
-						if (!inspection) states.push("invalid")
-						if (declaredRemote && remote !== declaredRemote)
-							states.push("remote-drifted")
-						repositories.push({
-							alias,
-							path,
-							kind: entry.isSymlink
-								? "symlink"
-								: (inspection?.kind ?? "repository"),
-							remote,
-							declaredRemote,
-							target,
-							states,
-						})
-					}
+					const repositories = yield* Effect.all(
+						[...aliases].sort().map((alias) =>
+							Effect.gen(function* () {
+								const path = join(reposPath, alias)
+								const entry = local.get(alias)
+								const declaredRemote =
+									config.repositories?.[alias]?.remote ?? null
+								if (!entry) {
+									return {
+										alias,
+										path,
+										kind: null,
+										remote: null,
+										declaredRemote,
+										target: null,
+										states: ["declared", "missing"] as RepositoryState[],
+									} satisfies RepositoryInfo
+								}
+								if (!entry.isDirectory && !entry.isSymlink) {
+									return {
+										alias,
+										path,
+										kind: null,
+										remote: null,
+										declaredRemote,
+										target: null,
+										states: [
+											...(declaredRemote ? (["declared"] as const) : []),
+											"invalid",
+										] as RepositoryState[],
+									} satisfies RepositoryInfo
+								}
+								const target = entry.isSymlink
+									? yield* fs.readSymlinkTarget(path)
+									: null
+								const inspection = yield* backend.inspectRepository(path)
+								const remote = inspection?.remote ?? null
+								const states: RepositoryState[] = []
+								if (declaredRemote) states.push("declared")
+								states.push(entry.isSymlink ? "linked" : "materialized")
+								if (!inspection) states.push("invalid")
+								if (declaredRemote && remote !== declaredRemote)
+									states.push("remote-drifted")
+								return {
+									alias,
+									path,
+									kind: entry.isSymlink
+										? "symlink"
+										: (inspection?.kind ?? "repository"),
+									remote,
+									declaredRemote,
+									target,
+									states,
+								} satisfies RepositoryInfo
+							}),
+						),
+						{ concurrency: 4 },
+					)
 					return repositories
 				}),
 

package/src/work-view.ts

@@ -211,27 +211,34 @@ export const getWorkViews = (options: WorkViewOptions = {}) =>
 			(node): node is ExecutionNode => node.kind === "execution-unit",
 		)
 		const taskOrder = orderedTasks(epics, tasks)
-		const phaseOrder = taskOrder.flatMap((task) => orderedPhases(task, phases))
+		const phasesByTask = new Map(
+			taskOrder.map((task) => [task.key, orderedPhases(task, phases)]),
+		)
+		const phaseOrder = taskOrder.flatMap(
+			(task) => phasesByTask.get(task.key) ?? [],
+		)
+		const executionsByTask = new Map<string, ExecutionNode[]>()
+		const executionsByPhase = new Map<string, ExecutionNode[]>()
+		for (const execution of executions) {
+			const taskExecutions = executionsByTask.get(execution.data.taskId) ?? []
+			taskExecutions.push(execution)
+			executionsByTask.set(execution.data.taskId, taskExecutions)
+			if ("phaseId" in execution.data) {
+				const key = `${execution.data.taskId}/${execution.data.phaseId}`
+				const phaseExecutions = executionsByPhase.get(key) ?? []
+				phaseExecutions.push(execution)
+				executionsByPhase.set(key, phaseExecutions)
+			}
+		}
 		const executionsFor = (node: EntityNode) => {
 			if (node.kind === "phase") {
-				const separator = node.key.indexOf("/")
-				const taskId = node.key.slice(0, separator)
-				const phaseId = node.key.slice(separator + 1)
-				return executions.filter(
-					(execution) =>
-						execution.data.taskId === taskId &&
-						"phaseId" in execution.data &&
-						execution.data.phaseId === phaseId,
-				)
+				return executionsByPhase.get(node.key) ?? []
 			}
 			if (node.kind === "task") {
-				return executions.filter(
-					(execution) => execution.data.taskId === node.key,
-				)
+				return executionsByTask.get(node.key) ?? []
 			}
-			const taskIds = new Set(node.data.tasks.map((item) => item.id))
-			return executions.filter((execution) =>
-				taskIds.has(execution.data.taskId),
+			return node.data.tasks.flatMap(
+				(item) => executionsByTask.get(item.id) ?? [],
 			)
 		}
 		const makeRows = (nodes: readonly EntityNode[]) =>
@@ -257,7 +264,7 @@ export const getWorkViews = (options: WorkViewOptions = {}) =>
 		const phaseRows = filterRows(makeRows(phaseOrder))
 		const executionEntities: EntityNode[] = []
 		for (const task of taskOrder) {
-			const taskPhases = orderedPhases(task, phases)
+			const taskPhases = phasesByTask.get(task.key) ?? []
 			executionEntities.push(...(taskPhases.length > 0 ? taskPhases : [task]))
 		}
 		const executionRows = filterRows(makeRows(executionEntities))

package/scripts/install-pi-extension.ts

@@ -1,25 +0,0 @@
-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}`)
-}