@markjaquith/agency 1.11.1 → 2.0.0

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")
+	})
+})

package/src/services/RepositoryService.ts

@@ -0,0 +1,159 @@
+import { Schema, TreeFormatter } from "@effect/schema"
+import { Data, Effect, Either } from "effect"
+import { join, resolve } from "node:path"
+import { FileSystemService } from "./FileSystemService"
+import { WorkbaseService } from "./WorkbaseService"
+import { RepositoryAlias } from "../workbase/schemas"
+
+class RepositoryError extends Data.TaggedError("RepositoryError")<{
+	readonly message: string
+	readonly cause?: unknown
+}> {}
+
+interface RepositoryInfo {
+	readonly alias: string
+	readonly path: string
+	readonly kind: "bare" | "repository" | "symlink"
+	readonly remote: string | null
+	readonly target: string | null
+}
+
+const validateAlias = (alias: string) => {
+	const result = Schema.decodeUnknownEither(RepositoryAlias)(alias)
+	return Either.isLeft(result)
+		? Effect.fail(
+				new RepositoryError({
+					message: `Invalid repository alias '${alias}': ${TreeFormatter.formatErrorSync(result.left)}`,
+				}),
+			)
+		: Effect.succeed(result.right)
+}
+
+export class RepositoryService extends Effect.Service<RepositoryService>()(
+	"RepositoryService",
+	{
+		sync: () => ({
+			add: (alias: string, remote: string, startPath: string = process.cwd()) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const workbase = yield* WorkbaseService
+					const validAlias = yield* validateAlias(alias)
+					const root = yield* workbase.discover(startPath)
+					const reposPath = join(root, "repos")
+					const destination = join(reposPath, validAlias)
+
+					if (!remote.trim()) {
+						return yield* new RepositoryError({
+							message: "Repository remote is required",
+						})
+					}
+					if (yield* fs.exists(destination)) {
+						return yield* new RepositoryError({
+							message: `Repository alias '${validAlias}' already exists`,
+						})
+					}
+
+					yield* fs.createDirectory(reposPath)
+					const result = yield* fs.runCommand(
+						["git", "clone", "--bare", remote, destination],
+						{ captureOutput: true },
+					)
+					if (result.exitCode !== 0) {
+						yield* fs.deleteDirectory(destination).pipe(Effect.ignore)
+						return yield* new RepositoryError({
+							message: `Failed to clone repository '${remote}': ${result.stderr.trim()}`,
+						})
+					}
+
+					return destination
+				}),
+
+			link: (
+				alias: string,
+				target: string,
+				startPath: string = process.cwd(),
+			) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const workbase = yield* WorkbaseService
+					const validAlias = yield* validateAlias(alias)
+					const root = yield* workbase.discover(startPath)
+					const reposPath = join(root, "repos")
+					const destination = join(reposPath, validAlias)
+					const resolvedTarget = resolve(startPath, target)
+
+					if (yield* fs.exists(destination)) {
+						return yield* new RepositoryError({
+							message: `Repository alias '${validAlias}' already exists`,
+						})
+					}
+					if (!(yield* fs.isDirectory(resolvedTarget))) {
+						return yield* new RepositoryError({
+							message: `Repository path does not exist: ${resolvedTarget}`,
+						})
+					}
+
+					const result = yield* fs.runCommand(
+						["git", "-C", resolvedTarget, "rev-parse", "--git-dir"],
+						{ captureOutput: true },
+					)
+					if (result.exitCode !== 0) {
+						return yield* new RepositoryError({
+							message: `Path is not a Git repository: ${resolvedTarget}`,
+						})
+					}
+
+					yield* fs.createDirectory(reposPath)
+					yield* fs.createSymlink(resolvedTarget, destination)
+					return destination
+				}),
+
+			list: (startPath: string = process.cwd()) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const workbase = yield* WorkbaseService
+					const root = yield* workbase.discover(startPath)
+					const reposPath = join(root, "repos")
+
+					if (!(yield* fs.isDirectory(reposPath))) {
+						return [] as RepositoryInfo[]
+					}
+
+					const entries = (yield* fs.readDirectory(reposPath))
+						.filter((entry) => entry.isDirectory || entry.isSymlink)
+						.sort((a, b) => a.name.localeCompare(b.name))
+					const repositories: RepositoryInfo[] = []
+
+					for (const entry of entries) {
+						const path = join(reposPath, entry.name)
+						const target = entry.isSymlink
+							? yield* fs.readSymlinkTarget(path)
+							: null
+						const bareResult = yield* fs.runCommand(
+							["git", "-C", path, "rev-parse", "--is-bare-repository"],
+							{ captureOutput: true },
+						)
+						const remoteResult = yield* fs.runCommand(
+							["git", "-C", path, "remote", "get-url", "origin"],
+							{ captureOutput: true },
+						)
+
+						repositories.push({
+							alias: entry.name,
+							path,
+							kind: entry.isSymlink
+								? "symlink"
+								: bareResult.stdout.trim() === "true"
+									? "bare"
+									: "repository",
+							remote:
+								remoteResult.exitCode === 0 ? remoteResult.stdout.trim() : null,
+							target,
+						})
+					}
+
+					return repositories
+				}),
+		}),
+	},
+) {}

package/src/services/TaskPhaseService.test.ts

@@ -0,0 +1,217 @@
+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 { EpicService } from "./EpicService"
+import { TaskService } from "./TaskService"
+import { PhaseService } from "./PhaseService"
+import { PullRequestService } from "./PullRequestService"
+
+describe("task and phase services", () => {
+	let root: string
+
+	beforeEach(async () => {
+		root = await createTempDir()
+		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
+		await mkdir(join(root, "repos/agency"), { recursive: true })
+		await mkdir(join(root, "repos/effect"), { recursive: true })
+	})
+
+	afterEach(async () => cleanupTempDir(root))
+
+	test("creates a single-phase task and updates its epic", async () => {
+		await runTestEffect(
+			EpicService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						"example",
+						"https://example.com/epic",
+						[{ repo: "agency", ref: "main" }],
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "task-one",
+							ticketUrl: "https://example.com/task",
+							epic: "example",
+							repo: "agency",
+							repos: [{ repo: "effect", ref: "main" }],
+							branch: "task/one",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		const epic = await runTestEffect(
+			EpicService.pipe(
+				Effect.flatMap((service) => service.show("example", root)),
+			),
+		)
+		expect(epic.data.tasks).toEqual([{ id: "task-one" }])
+	})
+
+	test("creates and sequences phases on a multi-phase task", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "multi",
+							ticketUrl: "https://example.com/task",
+							multiPhase: true,
+						},
+						root,
+					),
+				),
+			),
+		)
+		for (const phase of [
+			{ id: "first", dependsOn: undefined },
+			{ id: "second", dependsOn: ["first"] },
+		]) {
+			await runTestEffect(
+				PhaseService.pipe(
+					Effect.flatMap((service) =>
+						service.create(
+							{
+								taskId: "multi",
+								id: phase.id,
+								repo: "agency",
+								branch: `task/${phase.id}`,
+								base: "main",
+								dependsOn: phase.dependsOn,
+							},
+							root,
+						),
+					),
+				),
+			)
+		}
+
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("multi", root)),
+			),
+		)
+		expect("phases" in task.data && task.data.phases).toEqual([
+			{ id: "first" },
+			{ id: "second", dependsOn: ["first"] },
+		])
+		const phases = await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) => service.list("multi", root)),
+			),
+		)
+		expect(phases.map((phase) => phase.id)).toEqual(["first", "second"])
+	})
+
+	test("converts a single-phase task when the existing phase ID is provided", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "single",
+							ticketUrl: "https://example.com/task",
+							description: "Deliver the complete task.",
+							repo: "agency",
+							repos: [{ repo: "effect", ref: "main" }],
+							branch: "task/single",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			PullRequestService.pipe(
+				Effect.flatMap((service) =>
+					service.setUrl(
+						"single",
+						undefined,
+						"https://github.com/example/agency/pull/42",
+						root,
+					),
+				),
+			),
+		)
+		await expect(
+			runTestEffect(
+				PhaseService.pipe(
+					Effect.flatMap((service) =>
+						service.create(
+							{
+								taskId: "single",
+								id: "extra",
+								repo: "agency",
+								branch: "task/extra",
+								base: "main",
+							},
+							root,
+						),
+					),
+				),
+			),
+		).rejects.toThrow("requires --first-phase")
+
+		await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							taskId: "single",
+							id: "extra",
+							firstPhase: "implementation",
+							repo: "agency",
+							branch: "task/extra",
+							base: "main",
+							dependsOn: ["implementation"],
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("single", root)),
+			),
+		)
+		expect(task.data).toEqual({
+			ticketUrl: "https://example.com/task",
+			description: "Deliver the complete task.",
+			phases: [
+				{ id: "implementation" },
+				{ id: "extra", dependsOn: ["implementation"] },
+			],
+		})
+		expect(task.content).toContain("Describe the task outcome.")
+
+		const firstPhase = await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) =>
+					service.show("single", "implementation", root),
+				),
+			),
+		)
+		expect(firstPhase.data).toEqual({
+			repo: "agency",
+			repos: [{ repo: "effect", ref: "main" }],
+			branch: "task/single",
+			base: "main",
+			pr: "https://github.com/example/agency/pull/42",
+		})
+	})
+})