@markjaquith/agency 1.11.1 → 2.1.0

package/src/services/PullRequestService.test.ts

@@ -0,0 +1,386 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { chmod, mkdir, realpath, rm } from "node:fs/promises"
+import { join } from "node:path"
+import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
+import { PhaseService } from "./PhaseService"
+import { TaskService } from "./TaskService"
+import { PullRequestService } from "./PullRequestService"
+import { WorktreeService } from "./WorktreeService"
+
+interface CommandResult {
+	readonly stdout: string
+	readonly stderr: string
+	readonly exitCode: number
+}
+
+const runCommand = async (
+	args: readonly string[],
+	cwd?: string,
+): Promise<CommandResult> => {
+	const process = Bun.spawn([...args], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	})
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(process.stdout).text(),
+		new Response(process.stderr).text(),
+		process.exited,
+	])
+	return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode }
+}
+
+const requireCommand = async (args: readonly string[], cwd?: string) => {
+	const result = await runCommand(args, cwd)
+	if (result.exitCode !== 0) {
+		throw new Error(`${args.join(" ")} failed: ${result.stderr}`)
+	}
+	return result
+}
+
+describe("PullRequestService", () => {
+	let root: string
+	let remotePath: string
+	let ghCallPath: string
+	let originalPath: string | undefined
+
+	const createTask = (id = "example", branch = `task/${id}`) =>
+		runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id,
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							branch,
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+
+	const createPullRequest = (
+		taskId = "example",
+		phaseId?: string,
+		draft = false,
+	) =>
+		runTestEffect(
+			PullRequestService.pipe(
+				Effect.flatMap((service) =>
+					service.create(taskId, phaseId, draft, root),
+				),
+			),
+		)
+
+	const materialize = (taskId = "example", phaseId?: string) =>
+		runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) => service.materialize(taskId, phaseId, root)),
+			),
+		)
+
+	const writeFakeGh = async ({
+		stdout = "",
+		stderr = "",
+		exitCode = 0,
+	}: {
+		stdout?: string
+		stderr?: string
+		exitCode?: number
+	}) => {
+		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() }))
+process.stdout.write(${JSON.stringify(stdout)})
+process.stderr.write(${JSON.stringify(stderr)})
+process.exit(${exitCode})
+`,
+		)
+		await chmod(path, 0o755)
+	}
+
+	const readGhCall = async () =>
+		(await Bun.file(ghCallPath).json()) as {
+			args: string[]
+			cwd: string
+		}
+
+	const expectRemoteBranch = async (branch: string, exists = true) => {
+		const result = await runCommand([
+			"git",
+			"--git-dir",
+			remotePath,
+			"show-ref",
+			"--verify",
+			`refs/heads/${branch}`,
+		])
+		expect(result.exitCode === 0).toBe(exists)
+	}
+
+	beforeEach(async () => {
+		root = await createTempDir()
+		remotePath = join(root, "remote.git")
+		ghCallPath = join(root, "gh-call.json")
+		originalPath = process.env.PATH
+		await mkdir(join(root, "bin"), { recursive: true })
+		process.env.PATH = `${join(root, "bin")}:${originalPath ?? ""}`
+		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
+		await mkdir(join(root, "repos"), { recursive: true })
+		await requireCommand([
+			"git",
+			"init",
+			"--bare",
+			"--initial-branch=main",
+			remotePath,
+		])
+		const seedPath = join(root, "seed")
+		await requireCommand(["git", "init", "--initial-branch=main", seedPath])
+		await requireCommand(
+			["git", "config", "user.name", "Agency Test"],
+			seedPath,
+		)
+		await requireCommand(
+			["git", "config", "user.email", "agency@example.com"],
+			seedPath,
+		)
+		await Bun.write(join(seedPath, "README.md"), "# Test repository\n")
+		await requireCommand(["git", "add", "README.md"], seedPath)
+		await requireCommand(["git", "commit", "-m", "Initial commit"], seedPath)
+		await requireCommand(
+			["git", "remote", "add", "origin", remotePath],
+			seedPath,
+		)
+		await requireCommand(["git", "push", "-u", "origin", "main"], seedPath)
+		await requireCommand([
+			"git",
+			"clone",
+			"--bare",
+			remotePath,
+			join(root, "repos", "agency"),
+		])
+	})
+
+	afterEach(async () => {
+		process.env.PATH = originalPath
+		await cleanupTempDir(root)
+	})
+
+	test("updates the execution document with a PR URL", async () => {
+		await createTask()
+		const url = "https://github.com/markjaquith/agency/pull/123"
+		await runTestEffect(
+			PullRequestService.pipe(
+				Effect.flatMap((service) =>
+					service.setUrl("example", undefined, url, root),
+				),
+			),
+		)
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("example", root)),
+			),
+		)
+		expect("pr" in task.data && task.data.pr).toBe(url)
+	})
+
+	test("rejects non-GitHub PR URLs", async () => {
+		await createTask()
+		await expect(
+			runTestEffect(
+				PullRequestService.pipe(
+					Effect.flatMap((service) =>
+						service.setUrl(
+							"example",
+							undefined,
+							"https://example.com/pr/1",
+							root,
+						),
+					),
+				),
+			),
+		).rejects.toThrow("Invalid GitHub pull request URL")
+	})
+
+	test("creates a clean single-phase PR and preserves the task body", async () => {
+		await createTask()
+		const taskPath = join(root, "tasks", "example", "TASK.md")
+		const body = "# Example\n\nKeep this exact body after creating the PR."
+		const original = await Bun.file(taskPath).text()
+		await Bun.write(
+			taskPath,
+			original.replace("# Example\n\nDescribe the task outcome.", body),
+		)
+		const url = "https://github.com/example/agency/pull/42"
+		await writeFakeGh({ stdout: `${url}\n` })
+
+		expect(await createPullRequest()).toBe(url)
+		await expectRemoteBranch("task/example")
+		const ghCall = await readGhCall()
+		expect(ghCall).toEqual({
+			args: ["pr", "create", "--fill", "--base", "main"],
+			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.endsWith(`${body}\n`)).toBe(true)
+	})
+
+	test("passes --draft to gh", async () => {
+		await createTask()
+		await writeFakeGh({
+			stdout: "https://github.com/example/agency/pull/43\n",
+		})
+
+		await createPullRequest("example", undefined, true)
+
+		expect((await readGhCall()).args).toEqual([
+			"pr",
+			"create",
+			"--fill",
+			"--base",
+			"main",
+			"--draft",
+		])
+	})
+
+	test("updates only PHASE.md for a phase PR", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "multi",
+							ticketUrl: "https://example.com/task",
+							multiPhase: true,
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							taskId: "multi",
+							id: "implementation",
+							repo: "agency",
+							branch: "task/multi-implementation",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const taskPath = join(root, "tasks", "multi", "TASK.md")
+		const phasePath = join(
+			root,
+			"tasks",
+			"multi",
+			"phases",
+			"implementation",
+			"PHASE.md",
+		)
+		const originalTask = await Bun.file(taskPath).text()
+		const url = "https://github.com/example/agency/pull/44"
+		await writeFakeGh({ stdout: url })
+
+		await createPullRequest("multi", "implementation")
+
+		expect(await Bun.file(taskPath).text()).toBe(originalTask)
+		expect(await Bun.file(phasePath).text()).toContain(`pr: ${url}`)
+		await expectRemoteBranch("task/multi-implementation")
+	})
+
+	test("blocks a dirty checkout before push or gh", async () => {
+		await createTask()
+		const workspace = await materialize()
+		await Bun.write(join(workspace.writablePath, "dirty.txt"), "dirty\n")
+		await writeFakeGh({ stdout: "https://github.com/example/agency/pull/45" })
+
+		await expect(createPullRequest()).rejects.toThrow(
+			"Cannot create a PR with a dirty worktree",
+		)
+
+		await expectRemoteBranch("task/example", false)
+		expect(await Bun.file(ghCallPath).exists()).toBe(false)
+	})
+
+	test("reports push failure and does not invoke gh", async () => {
+		await createTask()
+		await materialize()
+		const hookPath = join(remotePath, "hooks", "pre-receive")
+		await Bun.write(hookPath, "#!/bin/sh\necho push rejected >&2\nexit 1\n")
+		await chmod(hookPath, 0o755)
+		await writeFakeGh({ stdout: "https://github.com/example/agency/pull/46" })
+
+		await expect(createPullRequest()).rejects.toThrow("Failed to push branch")
+
+		await expectRemoteBranch("task/example", false)
+		expect(await Bun.file(ghCallPath).exists()).toBe(false)
+	})
+
+	test("reports gh failure without persisting a URL", async () => {
+		await createTask()
+		await writeFakeGh({ stderr: "authentication failed\n", exitCode: 1 })
+
+		await expect(createPullRequest()).rejects.toThrow(
+			"Failed to create pull request: authentication failed",
+		)
+
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("example", root)),
+			),
+		)
+		expect("pr" in task.data && task.data.pr).toBeNull()
+	})
+
+	test("rejects successful gh output without a PR URL", async () => {
+		await createTask()
+		await writeFakeGh({ stdout: "Pull request created successfully\n" })
+
+		await expect(createPullRequest()).rejects.toThrow(
+			"GitHub CLI did not return a pull request URL",
+		)
+	})
+
+	test("extracts a PR URL from noisy gh output", async () => {
+		await createTask()
+		const url = "https://github.com/example/agency/pull/47"
+		await writeFakeGh({
+			stdout: `Creating pull request...\n${url}\nView it in your browser.\n`,
+		})
+
+		expect(await createPullRequest()).toBe(url)
+
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("example", root)),
+			),
+		)
+		expect("pr" in task.data && task.data.pr).toBe(url)
+	})
+
+	test("reports git status failure before push or gh", async () => {
+		await createTask()
+		const workspace = await materialize()
+		await rm(join(workspace.writablePath, ".git"))
+		await writeFakeGh({ stdout: "https://github.com/example/agency/pull/48" })
+
+		await expect(createPullRequest()).rejects.toThrow(
+			"Failed to inspect worktree status",
+		)
+
+		await expectRemoteBranch("task/example", false)
+		expect(await Bun.file(ghCallPath).exists()).toBe(false)
+	})
+})

package/src/services/PullRequestService.ts

@@ -0,0 +1,143 @@
+import { Data, Effect } from "effect"
+import { FileSystemService } from "./FileSystemService"
+import { WorkbaseService } from "./WorkbaseService"
+import { WorktreeService } from "./WorktreeService"
+import { TaskService } from "./TaskService"
+import { PhaseService } from "./PhaseService"
+import {
+	formatMarkdownDocument,
+	parseFrontmatter,
+} from "../workbase/frontmatter"
+
+class PullRequestError extends Data.TaggedError("PullRequestError")<{
+	readonly message: string
+}> {}
+
+const PR_URL = /^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+\/?$/
+
+export class PullRequestService extends Effect.Service<PullRequestService>()(
+	"PullRequestService",
+	{
+		sync: () => ({
+			setUrl: (
+				taskId: string,
+				phaseId: string | undefined,
+				url: string,
+				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 =
+						"phases" in task.data
+							? phaseId
+								? yield* phases.show(taskId, phaseId, root)
+								: yield* new PullRequestError({
+										message: `Task '${taskId}' requires a phase ID`,
+									})
+							: task
+					const parsed = yield* parseFrontmatter(record.content, record.path)
+					const data = { ...record.data, pr: url }
+					yield* fs.writeFile(
+						record.path,
+						formatMarkdownDocument(data, parsed.body),
+					)
+					return url
+				}),
+
+			create: (
+				taskId: string,
+				phaseId?: string,
+				draft = false,
+				startPath: string = process.cwd(),
+			) =>
+				Effect.gen(function* () {
+					const service = yield* PullRequestService
+					const fs = yield* FileSystemService
+					const tasks = yield* TaskService
+					const phases = yield* PhaseService
+					const worktrees = yield* WorktreeService
+					const workspace = yield* worktrees.materialize(
+						taskId,
+						phaseId,
+						startPath,
+					)
+					const task = yield* tasks.show(taskId, workspace.root)
+					const execution =
+						"phases" in task.data
+							? (yield* phases.show(taskId, phaseId!, workspace.root)).data
+							: task.data
+
+					const status = yield* fs.runCommand(
+						["git", "-C", workspace.writablePath, "status", "--porcelain"],
+						{ captureOutput: true },
+					)
+					if (status.exitCode !== 0) {
+						return yield* new PullRequestError({
+							message: `Failed to inspect worktree status: ${status.stderr}`,
+						})
+					}
+					if (status.stdout) {
+						return yield* new PullRequestError({
+							message: "Cannot create a PR with a dirty worktree",
+						})
+					}
+
+					const push = yield* fs.runCommand(
+						[
+							"git",
+							"-C",
+							workspace.writablePath,
+							"push",
+							"--set-upstream",
+							"origin",
+							execution.branch,
+						],
+						{ captureOutput: true },
+					)
+					if (push.exitCode !== 0) {
+						return yield* new PullRequestError({
+							message: `Failed to push branch: ${push.stderr}`,
+						})
+					}
+
+					const args = [
+						"gh",
+						"pr",
+						"create",
+						"--fill",
+						"--base",
+						execution.base,
+					]
+					if (draft) args.push("--draft")
+					const created = yield* fs.runCommand(args, {
+						cwd: workspace.writablePath,
+						captureOutput: true,
+					})
+					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) {
+						return yield* new PullRequestError({
+							message: "GitHub CLI did not return a pull request URL",
+						})
+					}
+					return yield* service.setUrl(taskId, phaseId, url, workspace.root)
+				}),
+		}),
+	},
+) {}

package/src/services/RepositoryService.test.ts

@@ -0,0 +1,106 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
+import { RepositoryService } from "./RepositoryService"
+
+const runGit = async (args: string[]) => {
+	const process = Bun.spawn(["git", ...args], {
+		stdout: "pipe",
+		stderr: "pipe",
+	})
+	await process.exited
+	if (process.exitCode !== 0) {
+		throw new Error(await new Response(process.stderr).text())
+	}
+}
+
+describe("RepositoryService", () => {
+	let root: string
+
+	beforeEach(async () => {
+		root = await createTempDir()
+		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
+	})
+
+	afterEach(async () => {
+		await cleanupTempDir(root)
+	})
+
+	test("adds a bare repository from a remote", async () => {
+		const source = join(root, "source.git")
+		await runGit(["init", "--bare", "--initial-branch=main", source])
+
+		const destination = await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.add("agency", source, root)),
+			),
+		)
+
+		expect(destination).toBe(join(root, "repos/agency"))
+		expect(await Bun.file(join(destination, "HEAD")).exists()).toBe(true)
+
+		const repositories = await runTestEffect(
+			RepositoryService.pipe(Effect.flatMap((service) => service.list(root))),
+		)
+		expect(repositories).toEqual([
+			{
+				alias: "agency",
+				path: destination,
+				kind: "bare",
+				remote: source,
+				target: null,
+			},
+		])
+	})
+
+	test("links an existing repository", async () => {
+		const target = join(root, "linked-repository")
+		await mkdir(target, { recursive: true })
+		await runGit(["init", "--initial-branch=main", target])
+
+		const destination = await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.link("effect", target, root)),
+			),
+		)
+
+		const repositories = await runTestEffect(
+			RepositoryService.pipe(Effect.flatMap((service) => service.list(root))),
+		)
+		expect(repositories[0]).toEqual({
+			alias: "effect",
+			path: destination,
+			kind: "symlink",
+			remote: null,
+			target,
+		})
+	})
+
+	test("rejects invalid and duplicate aliases", async () => {
+		const source = join(root, "source.git")
+		await runGit(["init", "--bare", "--initial-branch=main", source])
+
+		await expect(
+			runTestEffect(
+				RepositoryService.pipe(
+					Effect.flatMap((service) => service.add("bad/alias", source, root)),
+				),
+			),
+		).rejects.toThrow("Invalid repository alias")
+
+		await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.add("agency", source, root)),
+			),
+		)
+		await expect(
+			runTestEffect(
+				RepositoryService.pipe(
+					Effect.flatMap((service) => service.add("agency", source, root)),
+				),
+			),
+		).rejects.toThrow("already exists")
+	})
+})