@markjaquith/agency 2.20.0 → 2.22.0

package/src/services/GraphService.ts

@@ -20,6 +20,7 @@ import {
 	readinessState,
 } from "../readiness"
 import { parseFrontmatter } from "../workbase/frontmatter"
+import { normalizePullRequestRecord } from "../workbase/delivery-command"
 import {
 	EpicFrontmatter,
 	PhaseFrontmatter,
@@ -683,17 +684,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 								if (!data.pr) {
 									result.pr = { url: null, state: "none" }
 								} else {
-									const detail = yield* run(fs, [
-										"gh",
-										"pr",
-										"view",
-										data.pr,
-										"--json",
-										"number,state,title,isDraft,headRefName,baseRefName,url",
-									])
-									result.pr = detail
-										? { ...JSON.parse(detail), recordedUrl: data.pr }
-										: { url: data.pr, state: "unavailable" }
+									result.pr = normalizePullRequestRecord(data.pr)
 								}
 							}
 							return result

package/src/services/PullRequestService.test.ts

@@ -187,7 +187,12 @@ process.exit(${exitCode})
 				Effect.flatMap((service) => service.show("example", root)),
 			),
 		)
-		expect("pr" in task.data && task.data.pr).toBe(url)
+		expect("pr" in task.data && task.data.pr).toMatchObject({
+			provider: "github",
+			repository: "markjaquith/agency",
+			identifier: "123",
+			url,
+		})
 	})
 
 	test("rejects non-GitHub PR URLs", async () => {
@@ -228,7 +233,8 @@ process.exit(${exitCode})
 			cwd: await realpath(join(root, "tasks", "example", "code", "agency")),
 		})
 		const updated = await Bun.file(taskPath).text()
-		expect(updated).toContain("pr: https://github.com/example/agency/pull/42")
+		expect(updated).toContain("pr:\n  provider: github")
+		expect(updated).toContain("url: https://github.com/example/agency/pull/42")
 		expect(updated.endsWith(`${body}\n`)).toBe(true)
 	})
 
@@ -315,7 +321,7 @@ process.exit(${exitCode})
 		await createPullRequest("multi", "implementation")
 
 		expect(await Bun.file(taskPath).text()).toBe(originalTask)
-		expect(await Bun.file(phasePath).text()).toContain(`pr: ${url}`)
+		expect(await Bun.file(phasePath).text()).toContain(`url: ${url}`)
 		await expectRemoteBranch("task/multi-implementation")
 	})
 
@@ -400,7 +406,88 @@ process.exit(${exitCode})
 				Effect.flatMap((service) => service.show("example", root)),
 			),
 		)
-		expect("pr" in task.data && task.data.pr).toBe(url)
+		expect("pr" in task.data && task.data.pr).toMatchObject({ url })
+	})
+
+	test("uses a configured remote and argv provider", async () => {
+		await createTask()
+		await requireCommand(
+			["git", "remote", "rename", "origin", "upstream"],
+			join(root, "repos", "agency"),
+		)
+		const callPath = join(root, "delivery-call.json")
+		const providerRecord = {
+			provider: "forge",
+			repository: remotePath.replace(/\.git$/, ""),
+			identifier: "17",
+			url: "https://forge.example/example/agency/pulls/17",
+			state: "open",
+			draft: false,
+			merged: false,
+		} as const
+		await Bun.write(
+			join(root, "bin", "deliver"),
+			`#!/usr/bin/env bun
+await Bun.write(${JSON.stringify(callPath)}, JSON.stringify({ args: Bun.argv.slice(2), base: process.env.DELIVERY_BASE }))
+process.stdout.write(${JSON.stringify(JSON.stringify(providerRecord))})
+`,
+		)
+		await chmod(join(root, "bin", "deliver"), 0o755)
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({
+				version: 2,
+				delivery: {
+					provider: "forge",
+					remote: "upstream",
+					createCommand: ["deliver", "create", "{repository}", "{branch}"],
+					queryCommand: ["deliver", "query", "{identifier}"],
+					environment: { DELIVERY_BASE: "{base}" },
+				},
+			}),
+		)
+
+		expect(await createPullRequest()).toBe(providerRecord.url)
+		expect(await Bun.file(callPath).json()).toEqual({
+			args: ["create", remotePath.replace(/\.git$/, ""), "task/example"],
+			base: "main",
+		})
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("example", root)),
+			),
+		)
+		expect("pr" in task.data && task.data.pr).toEqual(providerRecord)
+	})
+
+	test("does not persist malformed provider output", async () => {
+		await createTask()
+		await Bun.write(
+			join(root, "bin", "deliver"),
+			"#!/usr/bin/env bun\nprocess.stdout.write('{}')\n",
+		)
+		await chmod(join(root, "bin", "deliver"), 0o755)
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({
+				version: 2,
+				delivery: {
+					provider: "forge",
+					createCommand: ["deliver", "create"],
+					queryCommand: ["deliver", "query"],
+				},
+			}),
+		)
+
+		await expect(createPullRequest()).rejects.toThrow(
+			"Delivery provider did not return a valid pull request record",
+		)
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("example", root)),
+			),
+		)
+		expect("pr" in task.data && task.data.pr).toBeNull()
 	})
 
 	test("reports git status failure before push or gh", async () => {

package/src/services/PullRequestService.ts

@@ -10,12 +10,24 @@ import {
 	formatMarkdownDocument,
 	parseFrontmatter,
 } from "../workbase/frontmatter"
+import type { PullRequestRecord } from "../workbase/schemas"
+import {
+	normalizePullRequestRecord,
+	parsePullRequestRecord,
+	recordFromGitHubUrl,
+	resolveDeliveryCommand,
+} from "../workbase/delivery-command"
 
 class PullRequestError extends Data.TaggedError("PullRequestError")<{
 	readonly message: string
 }> {}
 
-const PR_URL = /^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+\/?$/
+const repositoryFromRemote = (remote: string) =>
+	remote
+		.replace(/^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?[^/]+\//i, "")
+		.replace(/^[^:]+:/, "")
+		.replace(/\.git\/?$/, "")
+		.replace(/\/$/, "")
 
 interface PullRequestOptions extends BaseCommandOptions {
 	readonly force?: boolean
@@ -25,25 +37,20 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 	"PullRequestService",
 	{
 		sync: () => ({
-			setUrl: (
+			setRecord: (
 				taskId: string,
 				phaseId: string | undefined,
-				url: string,
+				record: PullRequestRecord,
 				startPath: string = process.cwd(),
 			) =>
 				Effect.gen(function* () {
-					if (!PR_URL.test(url)) {
-						return yield* new PullRequestError({
-							message: `Invalid GitHub pull request URL: ${url}`,
-						})
-					}
 					const fs = yield* FileSystemService
 					const workbase = yield* WorkbaseService
 					const tasks = yield* TaskService
 					const phases = yield* PhaseService
 					const root = yield* workbase.discover(startPath)
 					const task = yield* tasks.show(taskId, root)
-					const record =
+					const target =
 						"phases" in task.data
 							? phaseId
 								? yield* phases.show(taskId, phaseId, root)
@@ -51,13 +58,30 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 										message: `Task '${taskId}' requires a phase ID`,
 									})
 							: task
-					const parsed = yield* parseFrontmatter(record.content, record.path)
-					const data = { ...record.data, pr: url }
+					const parsed = yield* parseFrontmatter(target.content, target.path)
 					yield* fs.writeFile(
-						record.path,
-						formatMarkdownDocument(data, parsed.body),
+						target.path,
+						formatMarkdownDocument({ ...target.data, pr: record }, parsed.body),
 					)
-					return url
+					return record.url
+				}),
+
+			setUrl: (
+				taskId: string,
+				phaseId: string | undefined,
+				url: string,
+				startPath: string = process.cwd(),
+			) =>
+				Effect.gen(function* () {
+					const service = yield* PullRequestService
+					const record = yield* Effect.try({
+						try: () => recordFromGitHubUrl(url),
+						catch: (cause) =>
+							new PullRequestError({
+								message: cause instanceof Error ? cause.message : String(cause),
+							}),
+					})
+					return yield* service.setRecord(taskId, phaseId, record, startPath)
 				}),
 
 			create: (
@@ -74,6 +98,7 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 					const phases = yield* PhaseService
 					const worktrees = yield* WorktreeService
 					const readiness = yield* ReadinessService
+					const workbase = yield* WorkbaseService
 					yield* readiness.guard(
 						"pr",
 						taskId,
@@ -92,6 +117,8 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 						"phases" in task.data
 							? (yield* phases.show(taskId, phaseId!, workspace.root)).data
 							: task.data
+					const { config } = yield* workbase.loadConfig(workspace.root)
+					const remote = config.delivery?.remote ?? "origin"
 
 					const status = yield* fs.runCommand(
 						["git", "-C", workspace.writablePath, "status", "--porcelain"],
@@ -115,7 +142,7 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 							workspace.writablePath,
 							"push",
 							"--set-upstream",
-							"origin",
+							remote,
 							execution.branch,
 						],
 						{ captureOutput: true },
@@ -126,33 +153,83 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 						})
 					}
 
-					const args = [
-						"gh",
-						"pr",
-						"create",
-						"--fill",
-						"--base",
-						execution.base,
-					]
-					if (draft) args.push("--draft")
-					const created = yield* fs.runCommand(args, {
+					const remoteResult = yield* fs.runCommand(
+						["git", "-C", workspace.writablePath, "remote", "get-url", remote],
+						{ captureOutput: true },
+					)
+					if (remoteResult.exitCode !== 0) {
+						return yield* new PullRequestError({
+							message: `Failed to inspect delivery remote '${remote}': ${remoteResult.stderr}`,
+						})
+					}
+					const repository = repositoryFromRemote(remoteResult.stdout.trim())
+					const resolved = config.delivery
+						? resolveDeliveryCommand(config.delivery, "create", {
+								repository,
+								branch: execution.branch,
+								base: execution.base,
+								draft: String(draft),
+								url: "",
+								identifier: "",
+							})
+						: {
+								argv: [
+									"gh",
+									"pr",
+									"create",
+									"--fill",
+									"--base",
+									execution.base,
+									...(draft ? ["--draft"] : []),
+								],
+								environment: {},
+							}
+					const created = yield* fs.runCommand(resolved.argv, {
 						cwd: workspace.writablePath,
 						captureOutput: true,
+						env: resolved.environment,
 					})
 					if (created.exitCode !== 0) {
 						return yield* new PullRequestError({
 							message: `Failed to create pull request: ${created.stderr}`,
 						})
 					}
-					const url = created.stdout
-						.split(/\s+/)
-						.find((value) => PR_URL.test(value))
-					if (!url) {
+					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
+								}
+							})
+							if (!url)
+								throw new Error("GitHub CLI did not return a pull request URL")
+							return { ...normalizePullRequestRecord(url), draft }
+						},
+						catch: (cause) =>
+							new PullRequestError({
+								message: cause instanceof Error ? cause.message : String(cause),
+							}),
+					})
+					if (
+						config.delivery &&
+						(record.provider !== config.delivery.provider ||
+							record.repository.toLowerCase() !== repository.toLowerCase())
+					) {
 						return yield* new PullRequestError({
-							message: "GitHub CLI did not return a pull request URL",
+							message:
+								"Delivery provider returned a record for the wrong provider or repository",
 						})
 					}
-					return yield* service.setUrl(taskId, phaseId, url, workspace.root)
+					return yield* service.setRecord(
+						taskId,
+						phaseId,
+						record,
+						workspace.root,
+					)
 				}),
 		}),
 	},

package/src/services/SyncService.test.ts

@@ -176,11 +176,105 @@ JSON
 		)
 		expect(task.data).toMatchObject({
 			status: "done",
-			pr: "https://github.com/example/agency/pull/42",
+			pr: {
+				provider: "github",
+				repository: "example/agency",
+				identifier: "42",
+				url: "https://github.com/example/agency/pull/42",
+				state: "merged",
+				draft: false,
+				merged: true,
+			},
 			claim: { state: "released", sessionId: "session-1" },
 		})
 	})
 
+	test("queries and records a configured delivery provider", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "custom",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "feat/custom",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("custom", undefined, root),
+				),
+			),
+		)
+		await git(
+			[
+				"remote",
+				"set-url",
+				"origin",
+				"https://forge.example/example/agency.git",
+			],
+			join(root, "repos/agency"),
+		)
+		const callPath = join(root, "query-call.json")
+		const record = {
+			provider: "forge",
+			repository: "example/agency",
+			identifier: "17",
+			url: "https://forge.example/example/agency/pulls/17",
+			state: "open",
+			draft: false,
+			merged: false,
+		} as const
+		await Bun.write(
+			join(root, "bin", "deliver"),
+			`#!/usr/bin/env bun
+await Bun.write(${JSON.stringify(callPath)}, JSON.stringify({ args: Bun.argv.slice(2), base: process.env.DELIVERY_BASE }))
+process.stdout.write(${JSON.stringify(JSON.stringify(record))})
+`,
+		)
+		await chmod(join(root, "bin", "deliver"), 0o755)
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({
+				version: 2,
+				delivery: {
+					provider: "forge",
+					createCommand: ["deliver", "create"],
+					queryCommand: ["deliver", "query", "{repository}", "{branch}"],
+					environment: { DELIVERY_BASE: "{base}" },
+				},
+			}),
+		)
+
+		const result = await runTestEffect(
+			SyncService.pipe(
+				Effect.flatMap((service) =>
+					service.reconcile({ cwd: root, apply: true }),
+				),
+			),
+		)
+		expect(result.changes).toContainEqual(
+			expect.objectContaining({ kind: "record-pr", target: "task:custom" }),
+		)
+		expect(await Bun.file(callPath).json()).toEqual({
+			args: ["query", "example/agency", "feat/custom"],
+			base: "main",
+		})
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("custom", root)),
+			),
+		)
+		expect("pr" in task.data && task.data.pr).toEqual(record)
+	})
+
 	test("materializes missing workspaces but leaves branch conflicts unresolved", async () => {
 		for (const [id, branch] of [
 			["missing", "feat/missing"],