@markjaquith/agency 3.2.7 → 3.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "3.2.7",
+  "version": "3.2.9",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",

package/src/services/FileSystemService.test.ts

@@ -0,0 +1,81 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import { cleanupTempDir, createTempDir } from "../test-utils"
+import { FileSystemService } from "./FileSystemService"
+
+const runFileSystem = <A, E>(effect: Effect.Effect<A, E, FileSystemService>) =>
+	Effect.runPromise(effect.pipe(Effect.provide(FileSystemService.Default)))
+
+describe("FileSystemService", () => {
+	const roots: string[] = []
+
+	afterEach(async () => {
+		await Promise.all(roots.splice(0).map(cleanupTempDir))
+	})
+
+	test("distinguishes missing files from other read failures", async () => {
+		const root = await createTempDir()
+		roots.push(root)
+		const directory = join(root, "document")
+		await mkdir(directory)
+
+		const missing = await runFileSystem(
+			FileSystemService.pipe(
+				Effect.flatMap((service) => service.readFile(join(root, "missing"))),
+				Effect.either,
+			),
+		)
+		expect(missing).toMatchObject({
+			_tag: "Left",
+			left: { _tag: "FileNotFoundError" },
+		})
+
+		const unreadable = await runFileSystem(
+			FileSystemService.pipe(
+				Effect.flatMap((service) => service.readFile(directory)),
+				Effect.either,
+			),
+		)
+		expect(unreadable).toMatchObject({
+			_tag: "Left",
+			left: {
+				_tag: "FileSystemError",
+				message: `Failed to read file: ${directory}`,
+			},
+		})
+	})
+
+	test("only treats a missing symlink path as absent", async () => {
+		const root = await createTempDir()
+		roots.push(root)
+		const regularFile = join(root, "regular")
+		await Bun.write(regularFile, "content")
+
+		await expect(
+			runFileSystem(
+				FileSystemService.pipe(
+					Effect.flatMap((service) =>
+						service.readSymlinkTarget(join(root, "missing")),
+					),
+				),
+			),
+		).resolves.toBeNull()
+		const unreadable = await runFileSystem(
+			FileSystemService.pipe(
+				Effect.flatMap((service) =>
+					service.readSymlinkTarget(join(regularFile, "child")),
+				),
+				Effect.either,
+			),
+		)
+		expect(unreadable).toMatchObject({
+			_tag: "Left",
+			left: {
+				_tag: "FileSystemError",
+				message: `Failed to read symlink target: ${join(regularFile, "child")}`,
+			},
+		})
+	})
+})

package/src/services/FileSystemService.ts

@@ -23,6 +23,12 @@ class FileNotFoundError extends Data.TaggedError("FileNotFoundError")<{
 	path: string
 }> {}
 
+const isFileNotFound = (error: unknown) =>
+	typeof error === "object" &&
+	error !== null &&
+	"code" in error &&
+	error.code === "ENOENT"
+
 // FileSystem Service using Effect.Service pattern
 export class FileSystemService extends Effect.Service<FileSystemService>()(
 	"FileSystemService",
@@ -88,7 +94,13 @@ export class FileSystemService extends Effect.Service<FileSystemService>()(
 			readFile: (path: string) =>
 				Effect.tryPromise({
 					try: () => Bun.file(path).text(),
-					catch: () => new FileNotFoundError({ path }),
+					catch: (error) =>
+						isFileNotFound(error)
+							? new FileNotFoundError({ path })
+							: new FileSystemError({
+									message: `Failed to read file: ${path}`,
+									cause: error,
+								}),
 				}),
 
 			inspectFile: (path: string) =>
@@ -184,10 +196,12 @@ export class FileSystemService extends Effect.Service<FileSystemService>()(
 						}))
 					},
 					catch: (error) =>
-						new FileSystemError({
-							message: `Failed to read directory: ${path}`,
-							cause: error,
-						}),
+						isFileNotFound(error)
+							? new FileNotFoundError({ path })
+							: new FileSystemError({
+									message: `Failed to read directory: ${path}`,
+									cause: error,
+								}),
 				}),
 
 			deleteDirectory: (path: string) =>
@@ -301,8 +315,16 @@ export class FileSystemService extends Effect.Service<FileSystemService>()(
 						}
 						return await readlink(path)
 					},
-					catch: () => null,
-				}).pipe(Effect.catchAll(() => Effect.succeed(null))),
+					catch: (error) =>
+						isFileNotFound(error)
+							? new FileNotFoundError({ path })
+							: new FileSystemError({
+									message: `Failed to read symlink target: ${path}`,
+									cause: error,
+								}),
+				}).pipe(
+					Effect.catchTag("FileNotFoundError", () => Effect.succeed(null)),
+				),
 		}),
 	},
 ) {}

package/src/services/GraphService.test.ts

@@ -230,6 +230,17 @@ describe("GraphService", () => {
 		expect(calls).toBe(0)
 	})
 
+	test("propagates directory discovery failures", async () => {
+		const root = await createTempDir()
+		roots.push(root)
+		await write(root, "agency.json", '{"version":2}\n')
+		await write(root, "tasks", "not a directory")
+
+		await expect(getGraph(root)).rejects.toThrow(
+			`Failed to read directory: ${join(root, "tasks")}`,
+		)
+	})
+
 	test("never reports active or terminal execution units as ready", async () => {
 		const root = await createWorkbase()
 		roots.push(root)

package/src/services/GraphService.ts

@@ -158,7 +158,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 									.map((entry) => entry.name)
 									.sort(),
 							),
-							Effect.catchAll(() => Effect.succeed([])),
+							Effect.catchTag("FileNotFoundError", () => Effect.succeed([])),
 						)
 
 					const readDocument = <S extends Schema.Schema.AnyNoContext>(

package/src/services/SyncService.test.ts

@@ -4,6 +4,7 @@ import { chmod, mkdir, rm } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { PullRequestService } from "./PullRequestService"
+import { ReviewService } from "./ReviewService"
 import { SyncService } from "./SyncService"
 import { TaskService } from "./TaskService"
 import { WorktreeService } from "./WorktreeService"
@@ -1123,6 +1124,134 @@ exit 9
 		).toEqual([])
 	})
 
+	test("inspects workspace dirtiness concurrently", async () => {
+		for (const id of ["first", "second", "third"]) {
+			await runTestEffect(
+				TaskService.pipe(
+					Effect.flatMap((service) =>
+						service.create(
+							{
+								id,
+								ticketUrl: null,
+								repo: "agency",
+								branch: `feat/${id}`,
+								base: "main",
+							},
+							root,
+						),
+					),
+				),
+			)
+			await runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) => service.materialize(id, undefined, root)),
+				),
+			)
+		}
+
+		const barrier = join(root, "status-barrier")
+		await mkdir(barrier)
+		const realGit = Bun.which("git")!
+		await Bun.write(
+			join(root, "bin", "git"),
+			`#!/bin/sh
+case "$*" in
+*" status --porcelain"*)
+  workspace=""
+  previous=""
+  for argument in "$@"; do
+    if [ "$previous" = "-C" ]; then workspace="$argument"; fi
+    previous="$argument"
+  done
+  id="$(basename "$(dirname "$(dirname "$workspace")")")"
+  touch ${JSON.stringify(barrier)}/"$id"
+  attempt=0
+  while [ "$attempt" -lt 200 ]; do
+    set -- ${JSON.stringify(barrier)}/*
+    if [ -e "$1" ] && [ "$#" -ge 3 ]; then exec ${JSON.stringify(realGit)} -C "$workspace" status --porcelain; fi
+    attempt=$((attempt + 1))
+    sleep 0.01
+  done
+  echo "workspace inspections were serialized" >&2
+  exit 9
+  ;;
+esac
+exec ${JSON.stringify(realGit)} "$@"
+`,
+		)
+		await chmod(join(root, "bin", "git"), 0o755)
+
+		const result = await runTestEffect(
+			SyncService.pipe(
+				Effect.flatMap((service) => service.reconcile({ cwd: root })),
+			),
+		)
+		expect(
+			result.warnings.filter(
+				(warning) => warning.kind === "status-inspection-failed",
+			),
+		).toEqual([])
+	})
+
+	test("queries review sources concurrently", async () => {
+		const source = join(root, "source")
+		for (const id of ["first", "second", "third"]) {
+			const ref = `review-${id}`
+			await git(["branch", ref, "main"], source)
+			const review = await runTestEffect(
+				ReviewService.pipe(
+					Effect.flatMap((service) => service.resolve("agency", { ref }, root)),
+				),
+			)
+			await runTestEffect(
+				TaskService.pipe(
+					Effect.flatMap((service) =>
+						service.create({ id, ticketUrl: null, review }, root),
+					),
+				),
+			)
+		}
+
+		const barrier = join(root, "review-query-barrier")
+		await mkdir(barrier)
+		const realGit = Bun.which("git")!
+		await Bun.write(
+			join(root, "bin", "git"),
+			`#!/bin/sh
+case "$*" in
+*"ls-remote"*)
+  ref=""
+  for argument in "$@"; do ref="$argument"; done
+  id="\${ref##*-}"
+  touch ${JSON.stringify(barrier)}/"$id"
+  attempt=0
+  while [ "$attempt" -lt 200 ]; do
+    set -- ${JSON.stringify(barrier)}/*
+    if [ -e "$1" ] && [ "$#" -ge 3 ]; then printf '%s\t%s\n' '0123456789012345678901234567890123456789' "$ref"; exit 0; fi
+    attempt=$((attempt + 1))
+    sleep 0.01
+  done
+  echo "review source queries were serialized" >&2
+  exit 9
+  ;;
+esac
+exec ${JSON.stringify(realGit)} "$@"
+`,
+		)
+		await chmod(join(root, "bin", "git"), 0o755)
+
+		const result = await runTestEffect(
+			SyncService.pipe(
+				Effect.flatMap((service) => service.reconcile({ cwd: root })),
+			),
+		)
+		expect(
+			result.warnings.filter(
+				(warning) => warning.kind === "review-source-unavailable",
+			),
+		).toEqual([])
+	})
+
 	test("keeps pull request query failures concise", async () => {
 		await runTestEffect(
 			TaskService.pipe(

package/src/services/SyncService.ts

@@ -493,6 +493,34 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						{ concurrency: 8 },
 					),
 				)
+				const reviewSourceQueries = new Map(
+					yield* Effect.forEach(
+						reviewRecords,
+						(task) =>
+							Effect.gen(function* () {
+								if (!("review" in task.data)) return [task.id, null] as const
+								const repositoryPath = join(
+									root,
+									"repos",
+									task.data.review.repo,
+								)
+								const remote = yield* backend.remoteUrl(
+									repositoryPath,
+									"origin",
+								)
+								const source = yield* runExternal([
+									"git",
+									"ls-remote",
+									remote ?? "origin",
+									task.data.review.source.kind === "pull-request"
+										? task.data.review.source.fetchRef
+										: originRef(task.data.review.source.ref),
+								])
+								return [task.id, source] as const
+							}),
+						{ concurrency: 8 },
+					),
+				)
 				const executionTotal = records.length + reviewRecords.length
 				let reconciledExecutions = 0
 				const reportExecution = (target: string) => {
@@ -504,6 +532,55 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						target,
 					})
 				}
+				const checkoutRecords = records.filter((record) => {
+					if (record.data.completion) return false
+					const merged = config.delivery
+						? null
+						: mergedPullRequestFromGitHub(
+								record.data,
+								prQueries.get(record.key),
+							)
+					return merged === null
+				})
+				const checkoutCandidates = checkoutRecords.flatMap((record) => {
+					const codePath = join(dirname(record.path), "code")
+					return [
+						{ repo: record.data.repo, path: join(codePath, record.data.repo) },
+						...(record.data.repos ?? []).map((reference) => ({
+							repo: reference.repo,
+							path: join(codePath, reference.repo),
+						})),
+					]
+				})
+				const checkoutRepositoryPaths = [
+					...new Set(
+						checkoutCandidates.map(({ repo }) => join(root, "repos", repo)),
+					),
+				]
+				yield* Effect.forEach(checkoutRepositoryPaths, listRegistered, {
+					concurrency: 8,
+				})
+				const dirtyByCheckoutPath = new Map<string, boolean | null>()
+				yield* Effect.forEach(
+					checkoutCandidates,
+					({ repo, path }) =>
+						Effect.gen(function* () {
+							if (!(yield* fs.isDirectory(path))) return
+							const repositoryPath = join(root, "repos", repo)
+							const registered = registeredByRepository.get(repositoryPath)
+							if (!registered) return
+							const expectedPath = yield* fs.realPath(path)
+							const atPath = registered.find(
+								(item) => item.path === expectedPath,
+							)
+							if (!atPath) return
+							dirtyByCheckoutPath.set(
+								path,
+								atPath.dirty ?? (yield* backend.workspaceDirty(path)),
+							)
+						}),
+					{ concurrency: 8 },
+				)
 
 				for (const record of records.sort((a, b) =>
 					a.key.localeCompare(b.key),
@@ -666,8 +743,11 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 
 						const dirty =
 							exists && atPath
-								? (atPath.dirty ??
-									(yield* backend.workspaceDirty(checkoutPath)))
+								? atPath.dirty !== undefined
+									? atPath.dirty
+									: dirtyByCheckoutPath.has(checkoutPath)
+										? dirtyByCheckoutPath.get(checkoutPath)!
+										: yield* backend.workspaceDirty(checkoutPath)
 								: null
 						if (exists && atPath && dirty === null) {
 							warnings.push({
@@ -1021,20 +1101,8 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							status: apply ? "applied" : "planned",
 						})
 					}
-					const repositoryPath = join(root, "repos", data.review.repo)
-					const reviewRemote = yield* backend.remoteUrl(
-						repositoryPath,
-						"origin",
-					)
-					const source = yield* runExternal([
-						"git",
-						"ls-remote",
-						reviewRemote ?? "origin",
-						data.review.source.kind === "pull-request"
-							? data.review.source.fetchRef
-							: originRef(data.review.source.ref),
-					])
-					const sourceCommit = source.stdout.trim().split(/\s+/)[0] || null
+					const source = reviewSourceQueries.get(task.id)
+					const sourceCommit = source?.stdout.trim().split(/\s+/)[0] || null
 					if (!sourceCommit) {
 						warnings.push({
 							kind: "review-source-unavailable",

package/src/services/WorkbaseService.test.ts

@@ -164,6 +164,21 @@ pr: null
 		expect(exists).not.toContain(join(root, "tasks/example/TASK.md"))
 	})
 
+	test("propagates document read failures instead of reporting them as missing", async () => {
+		await write(root, "agency.json", '{"version":2}\n')
+		await mkdir(join(root, "tasks/example/TASK.md"), { recursive: true })
+
+		await expect(
+			runTestEffect(
+				WorkbaseService.pipe(
+					Effect.flatMap((service) => service.validate(root)),
+				),
+			),
+		).rejects.toThrow(
+			`Failed to read file: ${join(root, "tasks/example/TASK.md")}`,
+		)
+	})
+
 	test("validates non-PR completion invariants without rejecting legacy done work", async () => {
 		await write(
 			root,

package/src/services/WorkbaseService.ts

@@ -694,7 +694,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 									.map((entry) => entry.name)
 									.sort(),
 							),
-							Effect.catchAll(() => Effect.succeed([])),
+							Effect.catchTag("FileNotFoundError", () => Effect.succeed([])),
 						)
 
 					const aliases = new Set(Object.keys(config.repositories ?? {}))
@@ -710,12 +710,18 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 						schema: S,
 					) =>
 						Effect.gen(function* () {
-							const content = yield* Effect.option(fs.readFile(path))
-							if (content._tag === "None") {
+							const content = yield* fs
+								.readFile(path)
+								.pipe(
+									Effect.catchTag("FileNotFoundError", () =>
+										Effect.succeed(null),
+									),
+								)
+							if (content === null) {
 								issue(path, "Required document is missing")
 								return null
 							}
-							const documentContent = content.value
+							const documentContent = content
 							const parsed = yield* Effect.either(
 								parseFrontmatter(documentContent, path),
 							)