@markjaquith/agency 1.11.1 → 2.1.0

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

package/src/services/TaskService.ts

@@ -0,0 +1,192 @@
+import { Schema, TreeFormatter } from "@effect/schema"
+import { Data, Effect, Either } from "effect"
+import { join } from "node:path"
+import { FileSystemService } from "./FileSystemService"
+import { WorkbaseService } from "./WorkbaseService"
+import { EpicService, type EpicRecord } from "./EpicService"
+import {
+	EntityId,
+	TaskFrontmatter,
+	type RepositoryReference,
+	type TaskFrontmatter as TaskData,
+} from "../workbase/schemas"
+import {
+	formatMarkdownDocument,
+	parseFrontmatter,
+} from "../workbase/frontmatter"
+
+class TaskError extends Data.TaggedError("TaskError")<{
+	readonly message: string
+}> {}
+
+interface TaskRecord {
+	readonly id: string
+	readonly path: string
+	readonly content: string
+	readonly data: TaskData
+}
+
+export interface CreateTaskInput {
+	readonly id: string
+	readonly ticketUrl: string
+	readonly description?: string
+	readonly epic?: string
+	readonly multiPhase?: boolean
+	readonly repo?: string
+	readonly repos?: readonly RepositoryReference[]
+	readonly branch?: string
+	readonly base?: string
+}
+
+const decodeTask = (input: unknown) => {
+	const result = Schema.decodeUnknownEither(TaskFrontmatter, {
+		errors: "all",
+		onExcessProperty: "error",
+	})(input)
+	return Either.isLeft(result)
+		? Effect.fail(
+				new TaskError({ message: TreeFormatter.formatErrorSync(result.left) }),
+			)
+		: Effect.succeed(result.right)
+}
+
+const decodeId = (id: string) => {
+	const result = Schema.decodeUnknownEither(EntityId)(id)
+	return Either.isLeft(result)
+		? Effect.fail(new TaskError({ message: `Invalid task ID '${id}'` }))
+		: Effect.succeed(result.right)
+}
+
+export class TaskService extends Effect.Service<TaskService>()("TaskService", {
+	sync: () => ({
+		create: (input: CreateTaskInput, startPath: string = process.cwd()) =>
+			Effect.gen(function* () {
+				const fs = yield* FileSystemService
+				const workbase = yield* WorkbaseService
+				const epics = yield* EpicService
+				const root = yield* workbase.discover(startPath)
+				const id = yield* decodeId(input.id)
+				const directory = join(root, "tasks", id)
+				const path = join(directory, "TASK.md")
+
+				if (yield* fs.exists(directory)) {
+					return yield* new TaskError({
+						message: `Task '${id}' already exists`,
+					})
+				}
+
+				let data: TaskData
+				if (input.multiPhase) {
+					data = yield* decodeTask({
+						ticketUrl: input.ticketUrl,
+						...(input.description !== undefined
+							? { description: input.description }
+							: {}),
+						...(input.epic ? { epic: input.epic } : {}),
+						phases: [],
+					})
+				} else {
+					if (!input.repo || !input.branch || !input.base) {
+						return yield* new TaskError({
+							message: "Single-phase tasks require repo, branch, and base",
+						})
+					}
+					data = yield* decodeTask({
+						ticketUrl: input.ticketUrl,
+						...(input.description !== undefined
+							? { description: input.description }
+							: {}),
+						...(input.epic ? { epic: input.epic } : {}),
+						repo: input.repo,
+						...(input.repos?.length ? { repos: input.repos } : {}),
+						branch: input.branch,
+						base: input.base,
+						pr: null,
+					})
+				}
+
+				const referencedRepos =
+					"repo" in data
+						? [
+								data.repo,
+								...(data.repos ?? []).map((reference) => reference.repo),
+							]
+						: []
+				for (const alias of referencedRepos) {
+					if (!(yield* fs.exists(join(root, "repos", alias)))) {
+						return yield* new TaskError({
+							message: `Unknown repository alias '${alias}'`,
+						})
+					}
+				}
+
+				let parentEpic: EpicRecord | undefined
+				if (input.epic) {
+					parentEpic = yield* epics.show(input.epic, root)
+				}
+
+				const title = id
+					.split("-")
+					.map((part) => part[0]?.toUpperCase() + part.slice(1))
+					.join(" ")
+				const content = formatMarkdownDocument(
+					data,
+					`# ${title}\n\nDescribe the task outcome.`,
+				)
+				yield* fs.createDirectory(directory)
+				yield* fs.writeFile(path, content)
+
+				if (input.epic && parentEpic) {
+					const parsed = yield* parseFrontmatter(
+						parentEpic.content,
+						parentEpic.path,
+					)
+					const epicData = {
+						...parentEpic.data,
+						tasks: [...parentEpic.data.tasks, { id }],
+					}
+					const updated = formatMarkdownDocument(epicData, parsed.body)
+					yield* fs.writeFile(parentEpic.path, updated)
+				}
+
+				return { id, path, content, data } satisfies TaskRecord
+			}),
+
+		list: (startPath: string = process.cwd()) =>
+			Effect.gen(function* () {
+				const fs = yield* FileSystemService
+				const workbase = yield* WorkbaseService
+				const root = yield* workbase.discover(startPath)
+				const directory = join(root, "tasks")
+				if (!(yield* fs.isDirectory(directory))) return [] as TaskRecord[]
+				const entries = (yield* fs.readDirectory(directory))
+					.filter((entry) => entry.isDirectory)
+					.sort((a, b) => a.name.localeCompare(b.name))
+				const records: TaskRecord[] = []
+				for (const entry of entries) {
+					const path = join(directory, entry.name, "TASK.md")
+					if (!(yield* fs.exists(path))) continue
+					const content = yield* fs.readFile(path)
+					const parsed = yield* parseFrontmatter(content, path)
+					const data = yield* decodeTask(parsed.data)
+					records.push({ id: entry.name, path, content, data })
+				}
+				return records
+			}),
+
+		show: (id: string, startPath: string = process.cwd()) =>
+			Effect.gen(function* () {
+				const service = yield* TaskService
+				const validId = yield* decodeId(id)
+				const record = (yield* service.list(startPath)).find(
+					(task) => task.id === validId,
+				)
+				if (!record) {
+					return yield* new TaskError({
+						message: `Task '${validId}' does not exist`,
+					})
+				}
+				return record
+			}),
+	}),
+}) {}