@markjaquith/agency 3.2.8 → 3.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "3.2.8",
+  "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/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),
 							)