@markjaquith/agency 3.2.5 → 3.2.6

package/package.json

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

package/src/services/PullRequestService.test.ts

@@ -89,16 +89,28 @@ describe("PullRequestService", () => {
 		stdout = "",
 		stderr = "",
 		exitCode = 0,
+		listStdouts = ["[]"],
 	}: {
 		stdout?: string
 		stderr?: string
 		exitCode?: number
+		listStdouts?: readonly string[]
 	}) => {
 		const path = join(root, "bin", "gh")
 		await Bun.write(
 			path,
 			`#!/usr/bin/env bun
-await Bun.write(${JSON.stringify(ghCallPath)}, JSON.stringify({ args: Bun.argv.slice(2), cwd: process.cwd() }))
+const args = Bun.argv.slice(2)
+const callFile = Bun.file(${JSON.stringify(ghCallPath)})
+const calls = await callFile.exists() ? await callFile.json() : []
+const listIndex = calls.filter((call) => call.args[1] === "list").length
+calls.push({ args, cwd: process.cwd() })
+await Bun.write(${JSON.stringify(ghCallPath)}, JSON.stringify(calls))
+if (args[1] === "list") {
+  const responses = ${JSON.stringify(listStdouts)}
+  process.stdout.write(responses[Math.min(listIndex, responses.length - 1)] ?? "[]")
+  process.exit(0)
+}
 process.stdout.write(${JSON.stringify(stdout)})
 process.stderr.write(${JSON.stringify(stderr)})
 process.exit(${exitCode})
@@ -108,10 +120,33 @@ process.exit(${exitCode})
 	}
 
 	const readGhCall = async () =>
+		(
+			(await Bun.file(ghCallPath).json()) as {
+				args: string[]
+				cwd: string
+			}[]
+		).at(-1)!
+
+	const readGhCalls = async () =>
 		(await Bun.file(ghCallPath).json()) as {
 			args: string[]
 			cwd: string
-		}
+		}[]
+
+	const githubRecord = (
+		number: number,
+		branch = "task/example",
+		base = "main",
+	) => ({
+		number,
+		url: `https://github.com/example/agency/pull/${number}`,
+		state: "OPEN",
+		isDraft: false,
+		headRefName: branch,
+		baseRefName: base,
+		headRepository: { nameWithOwner: "example/agency" },
+		mergeable: "UNKNOWN",
+	})
 
 	const expectRemoteBranch = async (branch: string, exists = true) => {
 		const result = await runCommand([
@@ -233,7 +268,17 @@ process.exit(${exitCode})
 		await expectRemoteBranch("task/example")
 		const ghCall = await readGhCall()
 		expect(ghCall).toEqual({
-			args: ["pr", "create", "--fill", "--base", "main"],
+			args: [
+				"pr",
+				"create",
+				"--fill",
+				"--repo",
+				remotePath.replace(/\.git$/, ""),
+				"--base",
+				"main",
+				"--head",
+				"task/example",
+			],
 			cwd: await realpath(join(root, "tasks", "example", "code", "agency")),
 		})
 		const updated = await Bun.file(taskPath).text()
@@ -254,8 +299,12 @@ process.exit(${exitCode})
 			"pr",
 			"create",
 			"--fill",
+			"--repo",
+			remotePath.replace(/\.git$/, ""),
 			"--base",
 			"main",
+			"--head",
+			"task/example",
 			"--draft",
 		])
 	})
@@ -279,6 +328,8 @@ process.exit(${exitCode})
 			"--fill",
 			"--title",
 			"Ship the workflow",
+			"--repo",
+			remotePath.replace(/\.git$/, ""),
 			"--base",
 			"main",
 			"--head",
@@ -291,6 +342,94 @@ process.exit(${exitCode})
 		])
 	})
 
+	test("records an existing matching GitHub PR without creating another", async () => {
+		await createTask()
+		const existing = githubRecord(46)
+		await writeFakeGh({ listStdouts: [JSON.stringify([existing])] })
+
+		expect(await createPullRequest()).toBe(existing.url)
+		const calls = await readGhCalls()
+		expect(calls).toHaveLength(1)
+		expect(calls[0]!.args).toEqual([
+			"pr",
+			"list",
+			"--repo",
+			remotePath.replace(/\.git$/, ""),
+			"--head",
+			"task/example",
+			"--base",
+			"main",
+			"--state",
+			"all",
+			"--json",
+			"number,state,isDraft,headRefName,baseRefName,headRepository,url,mergedAt,mergeable",
+		])
+	})
+
+	test("recovers a matching GitHub PR after an ambiguous create failure", async () => {
+		await createTask()
+		const recovered = githubRecord(47)
+		await writeFakeGh({
+			stderr: "a pull request already exists",
+			exitCode: 1,
+			listStdouts: ["[]", JSON.stringify([recovered])],
+		})
+
+		expect(await createPullRequest()).toBe(recovered.url)
+		expect((await readGhCalls()).map((call) => call.args[1])).toEqual([
+			"list",
+			"create",
+			"list",
+		])
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("example", root)),
+			),
+		)
+		expect("pr" in task.data && task.data.pr).toMatchObject({
+			url: recovered.url,
+			headBranch: "task/example",
+			baseBranch: "main",
+		})
+	})
+
+	test("recovers a matching GitHub PR after create output is lost", async () => {
+		await createTask()
+		const recovered = githubRecord(48)
+		await writeFakeGh({
+			stdout: "Pull request created successfully",
+			listStdouts: ["[]", JSON.stringify([recovered])],
+		})
+
+		expect(await createPullRequest()).toBe(recovered.url)
+		expect((await readGhCalls()).map((call) => call.args[1])).toEqual([
+			"list",
+			"create",
+			"list",
+		])
+	})
+
+	test("does not adopt a GitHub PR with mismatched refs", async () => {
+		await createTask()
+		await writeFakeGh({
+			stdout: "Pull request created successfully",
+			listStdouts: [
+				JSON.stringify([githubRecord(49, "task/other")]),
+				JSON.stringify([githubRecord(49, "task/other")]),
+			],
+		})
+
+		await expect(createPullRequest()).rejects.toThrow(
+			"GitHub CLI did not return a pull request URL",
+		)
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("example", root)),
+			),
+		)
+		expect("pr" in task.data && task.data.pr).toBeNull()
+	})
+
 	test("rejects task-aware head and base values that contradict declarations", async () => {
 		await createTask()
 		await expect(

package/src/services/PullRequestService.ts

@@ -15,12 +15,16 @@ import type { PullRequestRecord } from "../workbase/schemas"
 import {
 	normalizePullRequestRecord,
 	parsePullRequestRecord,
+	recordFromGitHubJson,
 	recordFromGitHubUrl,
 	repositoryFromRemote,
 	resolveDeliveryCommand,
 	resolveGitHubCreateCommand,
 } from "../workbase/delivery-command"
 
+const GITHUB_PR_FIELDS =
+	"number,state,isDraft,headRefName,baseRefName,headRepository,url,mergedAt,mergeable"
+
 class PullRequestError extends Data.TaggedError("PullRequestError")<{
 	readonly message: string
 }> {}
@@ -205,6 +209,84 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 						})
 					}
 					const repository = repositoryFromRemote(remoteUrl)
+					const isGitHubRepository = /^[^/]+\/[^/]+$/.test(repository)
+					const discoverGitHubPullRequest = () =>
+						Effect.gen(function* () {
+							const listed = yield* fs.runCommand(
+								[
+									"gh",
+									"pr",
+									"list",
+									"--repo",
+									repository,
+									"--head",
+									execution.branch,
+									"--base",
+									execution.base,
+									"--state",
+									"all",
+									"--json",
+									GITHUB_PR_FIELDS,
+								],
+								{ cwd: workspace.writablePath!, captureOutput: true },
+							)
+							if (listed.exitCode !== 0) {
+								return yield* new PullRequestError({
+									message: `Failed to discover existing pull requests: ${listed.stderr}`,
+								})
+							}
+							const records = yield* Effect.try({
+								try: () => {
+									const parsed: unknown = JSON.parse(listed.stdout)
+									if (!Array.isArray(parsed)) {
+										throw new Error(
+											"GitHub CLI did not return a pull request list",
+										)
+									}
+									return parsed.map((value) =>
+										recordFromGitHubJson(value as Record<string, unknown>),
+									)
+								},
+								catch: (cause) =>
+									new PullRequestError({
+										message:
+											cause instanceof Error ? cause.message : String(cause),
+									}),
+							})
+							const matches = records.filter(
+								(record) =>
+									(!isGitHubRepository ||
+										(record.repository.toLowerCase() ===
+											repository.toLowerCase() &&
+											record.headRepository?.toLowerCase() ===
+												repository.toLowerCase() &&
+											record.baseRepository?.toLowerCase() ===
+												repository.toLowerCase())) &&
+									record.headBranch === execution.branch &&
+									record.baseBranch === execution.base,
+							)
+							if (matches.length > 1) {
+								return yield* new PullRequestError({
+									message: `Multiple pull requests match '${execution.branch}' -> '${execution.base}'`,
+								})
+							}
+							return matches[0] ?? null
+						})
+					const recoverGitHubPullRequest = () =>
+						discoverGitHubPullRequest().pipe(
+							Effect.catchAll(() => Effect.succeed(null)),
+						)
+					if (!config.delivery) {
+						const existing = yield* discoverGitHubPullRequest()
+						if (existing) {
+							return yield* service.setRecord(
+								taskId,
+								phaseId,
+								existing,
+								workspace.root,
+							)
+						}
+					}
 					const resolved = config.delivery
 						? resolveDeliveryCommand(config.delivery, "create", {
 								repository,
@@ -215,10 +297,11 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 								identifier: "",
 							})
 						: resolveGitHubCreateCommand({
+								repository,
 								base: execution.base,
 								draft,
 								title: options.title,
-								head: options.head,
+								head: execution.branch,
 								labels: options.labels,
 							})
 					const created = yield* fs.runCommand(resolved.argv, {
@@ -227,38 +310,79 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 						env: resolved.environment,
 					})
 					if (created.exitCode !== 0) {
+						if (!config.delivery) {
+							const recovered = yield* recoverGitHubPullRequest()
+							if (recovered) {
+								return yield* service.setRecord(
+									taskId,
+									phaseId,
+									recovered,
+									workspace.root,
+								)
+							}
+						}
 						return yield* new PullRequestError({
 							message: `Failed to create pull request: ${created.stderr}`,
 						})
 					}
-					const record = yield* Effect.try({
-						try: () => {
-							if (config.delivery) return parsePullRequestRecord(created.stdout)
-							const url = created.stdout.split(/\s+/).find((value) => {
-								try {
-									recordFromGitHubUrl(value)
-									return true
-								} catch {
-									return false
+					const parsedRecord = yield* Effect.either(
+						Effect.try({
+							try: () => {
+								if (config.delivery)
+									return parsePullRequestRecord(created.stdout)
+								const url = created.stdout.split(/\s+/).find((value) => {
+									try {
+										recordFromGitHubUrl(value)
+										return true
+									} catch {
+										return false
+									}
+								})
+								if (!url)
+									throw new Error(
+										"GitHub CLI did not return a pull request URL",
+									)
+								const normalized = normalizePullRequestRecord(url)
+								if (
+									isGitHubRepository &&
+									normalized.repository.toLowerCase() !==
+										repository.toLowerCase()
+								) {
+									throw new Error(
+										"GitHub CLI returned a pull request for the wrong repository",
+									)
 								}
-							})
-							if (!url)
-								throw new Error("GitHub CLI did not return a pull request URL")
-							const normalized = normalizePullRequestRecord(url)
-							return {
-								...normalized,
-								headRepository: repository,
-								headBranch: execution.branch,
-								baseRepository: normalized.repository,
-								baseBranch: execution.base,
-								draft,
+								return {
+									...normalized,
+									headRepository: repository,
+									headBranch: execution.branch,
+									baseRepository: normalized.repository,
+									baseBranch: execution.base,
+									draft,
+								}
+							},
+							catch: (cause) =>
+								new PullRequestError({
+									message:
+										cause instanceof Error ? cause.message : String(cause),
+								}),
+						}),
+					)
+					if (parsedRecord._tag === "Left") {
+						if (!config.delivery) {
+							const recovered = yield* recoverGitHubPullRequest()
+							if (recovered) {
+								return yield* service.setRecord(
+									taskId,
+									phaseId,
+									recovered,
+									workspace.root,
+								)
 							}
-						},
-						catch: (cause) =>
-							new PullRequestError({
-								message: cause instanceof Error ? cause.message : String(cause),
-							}),
-					})
+						}
+						return yield* parsedRecord.left
+					}
+					const record = parsedRecord.right
 					if (
 						config.delivery &&
 						(record.provider !== config.delivery.provider ||

package/src/workbase/delivery-command.test.ts

@@ -34,24 +34,19 @@ describe("delivery commands", () => {
 
 	test("builds the default GitHub create command", () => {
 		const input = {
+			repository: "example/agency",
 			base: "main",
 			draft: false,
+			head: "feat/example",
 		} as const
 		expect(resolveGitHubCreateCommand(input)).toEqual({
-			argv: ["gh", "pr", "create", "--fill", "--base", "main"],
-			environment: {},
-		})
-		expect(
-			resolveGitHubCreateCommand({
-				...input,
-				head: "feat/example",
-			}),
-		).toEqual({
 			argv: [
 				"gh",
 				"pr",
 				"create",
 				"--fill",
+				"--repo",
+				"example/agency",
 				"--base",
 				"main",
 				"--head",
@@ -74,6 +69,8 @@ describe("delivery commands", () => {
 				"--fill",
 				"--title",
 				"Requested",
+				"--repo",
+				"example/agency",
 				"--base",
 				"main",
 				"--head",

package/src/workbase/delivery-command.ts

@@ -19,16 +19,18 @@ export const repositoryFromRemote = (remote: string) =>
 		.replace(/\/$/, "")
 
 export const resolveGitHubCreateCommand = ({
+	repository,
 	base,
 	draft,
 	title,
 	head,
 	labels = [],
 }: {
+	readonly repository: string
 	readonly base: string
 	readonly draft: boolean
 	readonly title?: string
-	readonly head?: string
+	readonly head: string
 	readonly labels?: readonly string[]
 }) => ({
 	argv: [
@@ -36,9 +38,12 @@ export const resolveGitHubCreateCommand = ({
 		"pr",
 		"create",
 		...(title ? ["--fill", "--title", title] : ["--fill"]),
+		"--repo",
+		repository,
 		"--base",
 		base,
-		...(head ? ["--head", head] : []),
+		"--head",
+		head,
 		...(draft ? ["--draft"] : []),
 		...labels.flatMap((label) => ["--label", label]),
 	],