@markjaquith/agency 3.2.0 → 3.2.2

package/src/services/ContextService.ts

@@ -271,78 +271,57 @@ export class ContextService extends Effect.Service<ContextService>()(
 
 					if (relative(root, candidate) === "") {
 						const compact = !options.full
-						const discover = <S extends Schema.Schema.AnyNoContext>(
-							id: string,
-							path: string,
-							schema: S,
+						const validation = yield* provideContextServices(
+							workbase.validate(root, { includeDocuments: true }),
+						)
+						const projectDiscoveryDocument = <T>(
+							document: {
+								readonly id: string
+								readonly path: string
+								readonly content: string
+								readonly revision: string
+								readonly data: T
+							},
 							extra: Record<string, string> = {},
 						) =>
 							Effect.gen(function* () {
-								if (!(yield* fs.exists(path))) return null
-								const content = yield* fs.readFile(path)
-								const parsed = yield* Effect.either(
-									parseFrontmatter(content, path),
-								)
-								if (Either.isLeft(parsed)) return null
-								const decoded = decode(schema, parsed.right.data)
-								if (!decoded.ok) return null
+								const body = compact
+									? {}
+									: {
+											body: (yield* parseFrontmatter(
+												document.content,
+												document.path,
+											)).body,
+										}
 								return {
 									...extra,
-									id,
-									path,
-									sha256: documentRevision(content),
-									data: decoded.value,
-									...(compact ? {} : { body: parsed.right.body }),
+									id: document.id,
+									path: document.path,
+									sha256: document.revision,
+									data: document.data,
+									...body,
 								}
 							})
-
-						const epics: unknown[] = []
-						const tasks: unknown[] = []
-						const phases: unknown[] = []
-						const epicRoot = join(root, "epics")
-						if (yield* fs.isDirectory(epicRoot)) {
-							for (const entry of (yield* fs.readDirectory(epicRoot))
-								.filter((item) => item.isDirectory)
-								.sort((a, b) => a.name.localeCompare(b.name))) {
-								const document = yield* discover(
-									entry.name,
-									join(epicRoot, entry.name, "EPIC.md"),
-									EpicFrontmatter,
-								)
-								if (document) epics.push(document)
-							}
-						}
-
-						const taskRoot = join(root, "tasks")
-						if (yield* fs.isDirectory(taskRoot)) {
-							for (const entry of (yield* fs.readDirectory(taskRoot))
-								.filter((item) => item.isDirectory)
-								.sort((a, b) => a.name.localeCompare(b.name))) {
-								const document = yield* discover(
-									entry.name,
-									join(taskRoot, entry.name, "TASK.md"),
-									TaskFrontmatter,
-								)
-								if (document) tasks.push(document)
-
-								const phaseRoot = join(taskRoot, entry.name, "phases")
-								if (!(yield* fs.isDirectory(phaseRoot))) continue
-								for (const phaseEntry of (yield* fs.readDirectory(phaseRoot))
-									.filter((item) => item.isDirectory)
-									.sort((a, b) => a.name.localeCompare(b.name))) {
-									const phase = yield* discover(
-										phaseEntry.name,
-										join(phaseRoot, phaseEntry.name, "PHASE.md"),
-										PhaseFrontmatter,
-										{ taskId: entry.name },
-									)
-									if (phase) phases.push(phase)
-								}
-							}
-						}
-
-						const validation = yield* provideContextServices(
-							workbase.validate(root),
+						const documents = validation.documents!
+						const epics = yield* Effect.all(
+							documents.epics.map((document) =>
+								projectDiscoveryDocument(document),
+							),
+							{ concurrency: "unbounded" },
+						)
+						const tasks = yield* Effect.all(
+							documents.tasks.map((document) =>
+								projectDiscoveryDocument(document),
+							),
+							{ concurrency: "unbounded" },
+						)
+						const phases = yield* Effect.all(
+							[...documents.phasesByTask].flatMap(([taskId, records]) =>
+								records.map((document) =>
+									projectDiscoveryDocument(document, { taskId }),
+								),
+							),
+							{ concurrency: "unbounded" },
 						)
 						return {
 							projection: compact ? "compact" : "complete",
@@ -556,104 +535,74 @@ export class ContextService extends Effect.Service<ContextService>()(
 						})
 					}
 
-					const taskDocuments = new Map<string, Document<TaskData>>()
+					const validation = yield* provideContextServices(
+						workbase.validate(root, { includeDocuments: true }),
+					)
+					const validationDocuments = validation.documents!
+					const taskDocuments = new Map<string, Document<TaskData>>(
+						validationDocuments.tasks.map((document) => [
+							document.id,
+							{
+								id: document.id,
+								path: document.path,
+								sha256: document.revision,
+								data: document.data,
+								body: "",
+							},
+						]),
+					)
 					const phaseDocuments = new Map<string, Document<PhaseData>>()
-					for (const taskRoot of [
-						join(root, "tasks"),
-						join(root, "archive", "tasks"),
-					]) {
-						if (!(yield* fs.isDirectory(taskRoot))) continue
-						const entries = (yield* fs.readDirectory(taskRoot))
-							.filter((entry) => entry.isDirectory)
-							.sort((a, b) => a.name.localeCompare(b.name))
-						const documents = yield* Effect.all(
-							entries.map((entry) =>
-								Effect.gen(function* () {
-									const path = join(taskRoot, entry.name, "TASK.md")
-									let taskDocument: Document<TaskData> | null = null
-									if (yield* fs.exists(path)) {
-										const content = yield* fs.readFile(path)
-										const parsed = yield* Effect.either(
-											parseFrontmatter(content, path),
-										)
-										if (Either.isRight(parsed)) {
-											const decoded = decode(TaskFrontmatter, parsed.right.data)
-											if (decoded.ok) {
-												taskDocument = {
-													id: entry.name,
-													path,
-													sha256: documentRevision(content),
-													data: decoded.value,
-													body: parsed.right.body,
-												}
-											}
-										}
-									}
-
-									const phasesPath = join(taskRoot, entry.name, "phases")
-									if (!(yield* fs.isDirectory(phasesPath))) {
-										return { taskDocument, phaseDocuments: [] }
-									}
-									const phaseEntries = (yield* fs.readDirectory(phasesPath))
-										.filter((item) => item.isDirectory)
-										.sort((a, b) => a.name.localeCompare(b.name))
-									const childDocuments = yield* Effect.all(
-										phaseEntries.map((phaseEntry) =>
-											Effect.gen(function* () {
-												const phasePath = join(
-													phasesPath,
-													phaseEntry.name,
-													"PHASE.md",
-												)
-												if (!(yield* fs.exists(phasePath))) return null
-												const content = yield* fs.readFile(phasePath)
-												const parsed = yield* Effect.either(
-													parseFrontmatter(content, phasePath),
-												)
-												if (Either.isLeft(parsed)) return null
-												const decoded = decode(
-													PhaseFrontmatter,
-													parsed.right.data,
-												)
-												if (!decoded.ok) return null
-												return [
-													`${entry.name}/${phaseEntry.name}`,
-													{
-														id: phaseEntry.name,
-														path: phasePath,
-														sha256: documentRevision(content),
-														data: decoded.value,
-														body: parsed.right.body,
-													},
-												] as const
-											}),
-										),
-										{ concurrency: "unbounded" },
-									)
-									return {
-										taskDocument,
-										phaseDocuments: childDocuments.filter(
-											(document): document is NonNullable<typeof document> =>
-												document !== null,
-										),
-									}
-								}),
-							),
-							{ concurrency: "unbounded" },
-						)
+					for (const [taskId, documents] of validationDocuments.phasesByTask) {
 						for (const document of documents) {
-							if (
-								document.taskDocument &&
-								!taskDocuments.has(document.taskDocument.id)
-							) {
-								taskDocuments.set(
-									document.taskDocument.id,
-									document.taskDocument,
-								)
-							}
-							for (const [key, phaseDocument] of document.phaseDocuments) {
-								if (!phaseDocuments.has(key))
-									phaseDocuments.set(key, phaseDocument)
+							phaseDocuments.set(`${taskId}/${document.id}`, {
+								id: document.id,
+								path: document.path,
+								sha256: document.revision,
+								data: document.data,
+								body: "",
+							})
+						}
+					}
+					if (task && !taskDocuments.has(task.id))
+						taskDocuments.set(task.id, task)
+					if (phase && target.taskId) {
+						phaseDocuments.set(`${target.taskId}/${phase.id}`, phase)
+					}
+					const relevantTaskIds = new Set([
+						...(target.taskId ? [target.taskId] : []),
+						...(epic?.data.tasks.map((child: Dependency) => child.id) ?? []),
+					])
+					for (const taskId of relevantTaskIds) {
+						let document = taskDocuments.get(taskId)
+						if (!document) {
+							const archived = yield* Effect.either(
+								readOptionalDocument(
+									taskId,
+									join(archivedTaskDirectory(root, taskId), "TASK.md"),
+									TaskFrontmatter,
+								),
+							)
+							document = Either.isRight(archived)
+								? (archived.right ?? undefined)
+								: undefined
+							if (document) taskDocuments.set(taskId, document)
+						}
+						if (!document || !("phases" in document.data)) continue
+						for (const child of document.data.phases) {
+							const key = `${taskId}/${child.id}`
+							if (phaseDocuments.has(key)) continue
+							const archived = yield* Effect.either(
+								readOptionalDocument(
+									child.id,
+									join(
+										archivedPhaseDirectory(root, taskId, child.id),
+										"PHASE.md",
+									),
+									PhaseFrontmatter,
+								),
+							)
+							if (Either.isRight(archived) && archived.right) {
+								phaseDocuments.set(key, archived.right)
 							}
 						}
 					}
@@ -720,9 +669,6 @@ export class ContextService extends Effect.Service<ContextService>()(
 						})
 					}
 
-					const validation = yield* provideContextServices(
-						workbase.validate(root),
-					)
 					const relevantPaths = new Set<string>(
 						[epic?.path, task?.path, phase?.path]
 							.filter((path): path is string => Boolean(path))
@@ -1017,9 +963,11 @@ export class ContextService extends Effect.Service<ContextService>()(
 					const codePath = join(entityDirectory, "code")
 					const inspectionWarnings: string[] = []
 					const repositories = new Map(
-						(yield* provideContextServices(repositoryService.list(root))).map(
-							(repository) => [repository.alias, repository],
-						),
+						reviewData
+							? (yield* provideContextServices(
+									repositoryService.list(root),
+								)).map((repository) => [repository.alias, repository])
+							: [],
 					)
 
 					const inspectCheckout = (
@@ -1027,12 +975,18 @@ export class ContextService extends Effect.Service<ContextService>()(
 						checkoutPath: string,
 					) =>
 						Effect.gen(function* (): Generator<any, CheckoutInspection, any> {
-							const materialized = yield* fs.isDirectory(checkoutPath)
-							const listed = yield* runGit(fs, repositoryPath, [
-								"worktree",
-								"list",
-								"--porcelain",
-							])
+							const [materialized, listed, canonicalRoot] = yield* Effect.all(
+								[
+									fs.isDirectory(checkoutPath),
+									runGit(fs, repositoryPath, [
+										"worktree",
+										"list",
+										"--porcelain",
+									]),
+									fs.realPath(root),
+								],
+								{ concurrency: "unbounded" },
+							)
 							if (listed === null) {
 								inspectionWarnings.push(
 									`Unable to inspect worktree registrations for ${repositoryPath}`,
@@ -1040,7 +994,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 							}
 							const listedPaths = worktreePaths(listed)
 							const canonicalCheckoutPath = join(
-								yield* fs.realPath(root),
+								canonicalRoot,
 								relative(root, checkoutPath),
 							)
 							let registered =
@@ -1056,21 +1010,25 @@ export class ContextService extends Effect.Service<ContextService>()(
 									dirty: null,
 								}
 							}
-							const checkoutCommit = yield* runGit(fs, checkoutPath, [
-								"rev-parse",
-								"HEAD",
-							])
-							const checkoutBranch = yield* runGit(fs, checkoutPath, [
-								"symbolic-ref",
-								"--quiet",
-								"--short",
-								"HEAD",
-							])
-							const checkoutStatus = yield* runGitText(fs, checkoutPath, [
-								"status",
-								"--porcelain",
-							])
-							const resolvedCheckoutPath = yield* fs.realPath(checkoutPath)
+							const [
+								checkoutCommit,
+								checkoutBranch,
+								checkoutStatus,
+								resolvedCheckoutPath,
+							] = yield* Effect.all(
+								[
+									runGit(fs, checkoutPath, ["rev-parse", "HEAD"]),
+									runGit(fs, checkoutPath, [
+										"symbolic-ref",
+										"--quiet",
+										"--short",
+										"HEAD",
+									]),
+									runGitText(fs, checkoutPath, ["status", "--porcelain"]),
+									fs.realPath(checkoutPath),
+								],
+								{ concurrency: "unbounded" },
+							)
 							registered = registered || listedPaths.has(resolvedCheckoutPath)
 							if (checkoutCommit === null) {
 								inspectionWarnings.push(
@@ -1094,17 +1052,16 @@ export class ContextService extends Effect.Service<ContextService>()(
 								const repositoryPath =
 									repository?.path ?? join(root, "repos", executionData.repo)
 								const checkoutPath = join(codePath, executionData.repo)
-								const branchCommit = yield* backend.resolveRevision(
-									repositoryPath,
-									executionData.branch,
-								)
-								const baseCommit = yield* backend.resolveRevision(
-									repositoryPath,
-									executionData.base,
-								)
-								const checkout = yield* inspectCheckout(
-									repositoryPath,
-									checkoutPath,
+								const [branchCommit, baseCommit, checkout] = yield* Effect.all(
+									[
+										backend.resolveRevision(
+											repositoryPath,
+											executionData.branch,
+										),
+										backend.resolveRevision(repositoryPath, executionData.base),
+										inspectCheckout(repositoryPath, checkoutPath),
+									],
+									{ concurrency: "unbounded" },
 								)
 								if (branchCommit === null) {
 									inspectionWarnings.push(

package/src/services/FileSystemService.ts

@@ -245,6 +245,7 @@ export class FileSystemService extends Effect.Service<FileSystemService>()(
 					readonly forwardOutput?: boolean
 					readonly passthrough?: boolean
 					readonly env?: Record<string, string>
+					readonly timeoutMs?: number
 				},
 			) =>
 				pipe(
@@ -264,6 +265,7 @@ export class FileSystemService extends Effect.Service<FileSystemService>()(
 								? "tee"
 								: "pipe",
 						env: options?.env,
+						timeoutMs: options?.timeoutMs,
 					}),
 					Effect.mapError(
 						(processError) =>

package/src/services/PushService.test.ts

@@ -1,8 +1,9 @@
 import { afterEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { mkdir } from "node:fs/promises"
-import { join } from "node:path"
+import { chmod, mkdir } from "node:fs/promises"
+import { join, resolve } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
+import { errorEnvelope } from "../protocol"
 import { PushService } from "./PushService"
 import { TaskService } from "./TaskService"
 import { WorktreeService } from "./WorktreeService"
@@ -130,9 +131,18 @@ describe("PushService", () => {
 		}
 	}
 
-	const publish = (taskPath: string) =>
+	const publish = (
+		taskPath: string,
+		options: {
+			fetchTimeoutMs?: number
+			pushTimeoutMs?: number
+			retryDelayMs?: number
+		} = {},
+	) =>
 		runTestEffect(
-			PushService.pipe(Effect.flatMap((service) => service.publish(taskPath))),
+			PushService.pipe(
+				Effect.flatMap((service) => service.publish(taskPath, options)),
+			),
 		)
 
 	const remoteBranch = async (remote: string) =>
@@ -157,6 +167,17 @@ describe("PushService", () => {
 		)
 	}
 
+	const prePushHook = async (checkout: string) =>
+		resolve(
+			checkout,
+			(
+				await requireCommand(
+					["git", "rev-parse", "--git-path", "hooks/pre-push"],
+					checkout,
+				)
+			).stdout,
+		)
+
 	test("publishes a clean Git HEAD and establishes upstream tracking", async () => {
 		const fixture = await setup()
 		await configureAuthor(fixture.checkout)
@@ -299,4 +320,89 @@ describe("PushService", () => {
 			"has an invalid author",
 		)
 	})
+
+	test("bounds a stalled pre-push hook and confirms non-publication", async () => {
+		const fixture = await setup()
+		await configureAuthor(fixture.checkout)
+		await Bun.write(join(fixture.checkout, "feature.txt"), "timeout\n")
+		await requireCommand(["git", "add", "feature.txt"], fixture.checkout)
+		await requireCommand(
+			["git", "commit", "-m", "Add timed publication"],
+			fixture.checkout,
+		)
+		const hook = await prePushHook(fixture.checkout)
+		await Bun.write(hook, "#!/bin/sh\nsleep 30\n")
+		await chmod(hook, 0o755)
+
+		const startedAt = performance.now()
+		const failure = await publish(fixture.taskPath, {
+			pushTimeoutMs: 25,
+		}).catch((error) => error)
+		expect(performance.now() - startedAt).toBeLessThan(1_000)
+		expect(errorEnvelope(failure).error).toMatchObject({
+			code: "PUSH_TIMEOUT",
+			fields: { category: "timeout", stage: "publish" },
+			retryable: true,
+		})
+		await expect(remoteBranch(fixture.remote)).rejects.toThrow()
+	})
+
+	test("classifies hook rejection separately from transport failure", async () => {
+		const fixture = await setup()
+		await configureAuthor(fixture.checkout)
+		await Bun.write(join(fixture.checkout, "feature.txt"), "rejected\n")
+		await requireCommand(["git", "add", "feature.txt"], fixture.checkout)
+		await requireCommand(
+			["git", "commit", "-m", "Add rejected publication"],
+			fixture.checkout,
+		)
+		const hook = await prePushHook(fixture.checkout)
+		await Bun.write(
+			hook,
+			"#!/bin/sh\necho 'pre-push hook declined' >&2\nexit 1\n",
+		)
+		await chmod(hook, 0o755)
+
+		const failure = await publish(fixture.taskPath).catch((error) => error)
+		expect(errorEnvelope(failure).error).toMatchObject({
+			code: "PUSH_HOOK_REJECTED",
+			fields: { category: "hook_rejection", stage: "publish" },
+			retryable: false,
+		})
+	})
+
+	test("retries one transient fetch with non-interactive authentication", async () => {
+		const fixture = await setup()
+		await configureAuthor(fixture.checkout)
+		await Bun.write(join(fixture.checkout, "feature.txt"), "retried\n")
+		await requireCommand(["git", "add", "feature.txt"], fixture.checkout)
+		await requireCommand(
+			["git", "commit", "-m", "Add retried publication"],
+			fixture.checkout,
+		)
+		const attempts = join(fixture.root, "upload-pack-attempts")
+		const uploadPack = join(fixture.root, "upload-pack")
+		await Bun.write(
+			uploadPack,
+			`#!/bin/sh
+echo x >> ${JSON.stringify(attempts)}
+test "$GIT_TERMINAL_PROMPT" = 0 || exit 2
+test "$GCM_INTERACTIVE" = Never || exit 2
+if test "$(wc -l < ${JSON.stringify(attempts)})" -eq 1; then
+  echo 'Connection reset by peer' >&2
+  exit 1
+fi
+exec git-upload-pack "$@"
+`,
+		)
+		await chmod(uploadPack, 0o755)
+		await requireCommand(
+			["git", "config", "remote.origin.uploadpack", uploadPack],
+			fixture.checkout,
+		)
+
+		const result = await publish(fixture.taskPath, { retryDelayMs: 0 })
+		expect(result.tip).toBe(await remoteBranch(fixture.remote))
+		expect((await Bun.file(attempts).text()).trim().split("\n")).toHaveLength(2)
+	})
 })