@markjaquith/agency 3.2.6 → 3.2.8

package/package.json

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

package/src/check-commits.test.ts

@@ -0,0 +1,58 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { cleanupTempDir, createTempDir } from "./test-utils"
+
+const checkCommits = join(import.meta.dir, "../scripts/check-commits")
+
+describe("check-commits", () => {
+	let root: string
+
+	function git(...args: string[]): void {
+		const result = Bun.spawnSync(["git", ...args], { cwd: root })
+		if (result.exitCode !== 0) {
+			throw new Error(new TextDecoder().decode(result.stderr))
+		}
+	}
+
+	function commit(subject: string, file: string): void {
+		writeFileSync(join(root, file), `${subject}\n`)
+		git("add", file)
+		git("commit", "-m", subject)
+	}
+
+	beforeEach(async () => {
+		root = await createTempDir()
+		git("init", "--initial-branch=main")
+		git("config", "user.email", "agency@example.com")
+		git("config", "user.name", "Agency Test")
+		commit("chore: initial commit", "initial.txt")
+		git("update-ref", "refs/remotes/origin/main", "HEAD")
+	})
+
+	afterEach(async () => cleanupTempDir(root))
+
+	test("allows merge commits with non-conventional subjects", () => {
+		git("checkout", "-b", "feature")
+		commit("feat: add feature", "feature.txt")
+		git("checkout", "-b", "topic", "main")
+		commit("fix: add topic", "topic.txt")
+		git("checkout", "feature")
+		git("merge", "--no-ff", "topic", "-m", "Combine topic into feature")
+
+		const result = Bun.spawnSync([checkCommits], { cwd: root })
+
+		expect(result.exitCode).toBe(0)
+	})
+
+	test("rejects non-conventional non-merge commits", () => {
+		commit("not a conventional commit", "invalid.txt")
+
+		const result = Bun.spawnSync([checkCommits], { cwd: root })
+
+		expect(result.exitCode).toBe(1)
+		expect(new TextDecoder().decode(result.stderr)).toContain(
+			"not a conventional commit",
+		)
+	})
+})

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",