@markjaquith/agency 2.24.0 → 2.26.0

package/src/services/RepositoryService.ts

@@ -2,6 +2,7 @@ import { Schema, TreeFormatter } from "@effect/schema"
 import { Data, Effect, Either } from "effect"
 import { join, resolve } from "node:path"
 import { FileSystemService } from "./FileSystemService"
+import { GraphService } from "./GraphService"
 import { WorkbaseService } from "./WorkbaseService"
 import { RepositoryAlias } from "../workbase/schemas"
 
@@ -18,6 +19,11 @@ interface RepositoryInfo {
 	readonly target: string | null
 }
 
+interface RepositoryVerification extends RepositoryInfo {
+	readonly valid: boolean
+	readonly issues: readonly string[]
+}
+
 const validateAlias = (alias: string) => {
 	const result = Schema.decodeUnknownEither(RepositoryAlias)(alias)
 	return Either.isLeft(result)
@@ -29,6 +35,65 @@ const validateAlias = (alias: string) => {
 		: Effect.succeed(result.right)
 }
 
+const find = (alias: string, startPath: string) =>
+	Effect.gen(function* () {
+		const service = yield* RepositoryService
+		const validAlias = yield* validateAlias(alias)
+		const repositories = yield* service.list(startPath)
+		const repository = repositories.find((item) => item.alias === validAlias)
+		if (!repository) {
+			return yield* new RepositoryError({
+				message: `Unknown repository alias '${validAlias}'`,
+			})
+		}
+		return repository
+	})
+
+const removalBlockers = (repository: RepositoryInfo, startPath: string) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		const graph = yield* GraphService
+		const report = yield* graph.get({ cwd: startPath })
+		const repositoryId = `repository:${repository.alias}`
+		const references = report.edges
+			.filter(
+				(edge) =>
+					edge.to === repositoryId &&
+					(edge.kind === "writes" || edge.kind === "references"),
+			)
+			.map((edge) => edge.from)
+			.sort()
+		const worktrees: string[] = []
+		if (repository.kind !== "symlink") {
+			const result = yield* fs.runCommand(
+				["git", "-C", repository.path, "worktree", "list", "--porcelain"],
+				{ captureOutput: true },
+			)
+			if (result.exitCode === 0) {
+				for (const block of result.stdout.trim().split(/\n\n+/)) {
+					if (!block || /(^|\n)bare(\n|$)/.test(block)) continue
+					const path = block.match(/^worktree (.+)$/m)?.[1]
+					if (path) worktrees.push(path)
+				}
+			}
+		}
+		return { references, worktrees }
+	})
+
+const assertRemovable = (repository: RepositoryInfo, startPath: string) =>
+	Effect.gen(function* () {
+		const blockers = yield* removalBlockers(repository, startPath)
+		const details = [
+			...blockers.references.map((item) => `active reference ${item}`),
+			...blockers.worktrees.map((item) => `linked worktree ${item}`),
+		]
+		if (details.length > 0) {
+			return yield* new RepositoryError({
+				message: `Repository alias '${repository.alias}' is in use and cannot be removed or renamed:\n${details.map((item) => `- ${item}`).join("\n")}`,
+			})
+		}
+	})
+
 export class RepositoryService extends Effect.Service<RepositoryService>()(
 	"RepositoryService",
 	{
@@ -154,6 +219,122 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 
 					return repositories
 				}),
+
+			show: (alias: string, startPath: string = process.cwd()) =>
+				find(alias, startPath),
+
+			fetch: (alias: string, startPath: string = process.cwd()) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const repository = yield* find(alias, startPath)
+					const result = yield* fs.runCommand(
+						["git", "-C", repository.path, "fetch", "--prune"],
+						{ captureOutput: true },
+					)
+					if (result.exitCode !== 0) {
+						return yield* new RepositoryError({
+							message: `Failed to fetch repository '${alias}': ${result.stderr.trim()}`,
+						})
+					}
+					return repository
+				}),
+
+			remove: (alias: string, startPath: string = process.cwd()) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const repository = yield* find(alias, startPath)
+					yield* assertRemovable(repository, startPath)
+					yield* fs.deleteDirectory(repository.path)
+					return repository
+				}),
+
+			unlink: (alias: string, startPath: string = process.cwd()) =>
+				Effect.gen(function* () {
+					const service = yield* RepositoryService
+					const repository = yield* find(alias, startPath)
+					if (repository.kind !== "symlink") {
+						return yield* new RepositoryError({
+							message: `Repository alias '${alias}' is not a link; use 'agency repo remove ${alias}'`,
+						})
+					}
+					return yield* service.remove(alias, startPath)
+				}),
+
+			rename: (
+				alias: string,
+				newAlias: string,
+				startPath: string = process.cwd(),
+			) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const workbase = yield* WorkbaseService
+					const repository = yield* find(alias, startPath)
+					const validNewAlias = yield* validateAlias(newAlias)
+					const root = yield* workbase.discover(startPath)
+					const destination = join(root, "repos", validNewAlias)
+					if (yield* fs.exists(destination)) {
+						return yield* new RepositoryError({
+							message: `Repository alias '${validNewAlias}' already exists`,
+						})
+					}
+					yield* assertRemovable(repository, startPath)
+					yield* fs.moveDirectory(repository.path, destination)
+					return yield* find(validNewAlias, startPath)
+				}),
+
+			remote: (
+				alias: string,
+				remote: string | undefined,
+				startPath: string = process.cwd(),
+			) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const repository = yield* find(alias, startPath)
+					if (remote === undefined) return repository
+					if (!remote.trim()) {
+						return yield* new RepositoryError({
+							message: "Repository remote is required",
+						})
+					}
+					const hasOrigin = repository.remote !== null
+					const result = yield* fs.runCommand(
+						[
+							"git",
+							"-C",
+							repository.path,
+							"remote",
+							hasOrigin ? "set-url" : "add",
+							"origin",
+							remote,
+						],
+						{ captureOutput: true },
+					)
+					if (result.exitCode !== 0) {
+						return yield* new RepositoryError({
+							message: `Failed to update remote for repository '${alias}': ${result.stderr.trim()}`,
+						})
+					}
+					return yield* find(alias, startPath)
+				}),
+
+			verify: (alias: string, startPath: string = process.cwd()) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const repository = yield* find(alias, startPath)
+					const issues: string[] = []
+					const git = yield* fs.runCommand(
+						["git", "-C", repository.path, "rev-parse", "--git-dir"],
+						{ captureOutput: true },
+					)
+					if (git.exitCode !== 0) issues.push("Path is not a Git repository")
+					if (repository.remote === null)
+						issues.push("Origin remote is not configured")
+					return {
+						...repository,
+						valid: issues.length === 0,
+						issues,
+					} satisfies RepositoryVerification
+				}),
 		}),
 	},
 ) {}

package/src/services/TaskPhaseService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { mkdir } from "node:fs/promises"
+import { mkdir, rm } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { EpicService } from "./EpicService"
@@ -60,6 +60,52 @@ describe("task and phase services", () => {
 		expect(epic.data.tasks).toEqual([{ id: "task-one" }])
 	})
 
+	test("does not create a task when its parent update cannot start", async () => {
+		await runTestEffect(
+			EpicService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						"locked",
+						"https://example.com/epic",
+						[{ repo: "agency", ref: "main" }],
+						root,
+					),
+				),
+			),
+		)
+		const lock = join(root, ".agency-graph-mutation.lock")
+		await Bun.write(lock, "held")
+		await expect(
+			runTestEffect(
+				TaskService.pipe(
+					Effect.flatMap((service) =>
+						service.create(
+							{
+								id: "not-created",
+								ticketUrl: null,
+								epic: "locked",
+								repo: "agency",
+								branch: "task/not-created",
+								base: "main",
+							},
+							root,
+						),
+					),
+				),
+			),
+		).rejects.toThrow("Another graph mutation is in progress")
+		await rm(lock)
+		expect(
+			await Bun.file(join(root, "tasks/not-created/TASK.md")).exists(),
+		).toBe(false)
+		const epic = await runTestEffect(
+			EpicService.pipe(
+				Effect.flatMap((service) => service.show("locked", root)),
+			),
+		)
+		expect(epic.data.tasks).toEqual([])
+	})
+
 	test("creates and sequences phases on a multi-phase task", async () => {
 		await runTestEffect(
 			TaskService.pipe(

package/src/services/TaskService.ts

@@ -18,6 +18,10 @@ import {
 import { canTransitionStatus } from "../readiness"
 import { documentRevision } from "../workbase/document-revision"
 import { archivedTaskDirectory } from "../workbase/archive"
+import {
+	documentWriteStep,
+	runLifecycleTransaction,
+} from "./LifecycleTransaction"
 
 class TaskError extends Data.TaggedError("TaskError")<{
 	readonly message: string
@@ -129,6 +133,12 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 								...(data.repos ?? []).map((reference) => reference.repo),
 							]
 						: []
+				if (new Set(referencedRepos).size !== referencedRepos.length) {
+					return yield* new TaskError({
+						message:
+							"Repository references must be unique and cannot include the writable repository",
+					})
+				}
 				for (const alias of referencedRepos) {
 					if (!(yield* fs.exists(join(root, "repos", alias)))) {
 						return yield* new TaskError({
@@ -140,6 +150,11 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 				let parentEpic: EpicRecord | undefined
 				if (input.epic) {
 					parentEpic = yield* epics.show(input.epic, root)
+					if (parentEpic.data.tasks.some((task) => task.id === id)) {
+						return yield* new TaskError({
+							message: `Epic '${input.epic}' already lists task '${id}'`,
+						})
+					}
 				}
 
 				const title = id
@@ -150,9 +165,11 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 					data,
 					`# ${title}\n\nDescribe the task outcome.`,
 				)
-				yield* fs.createDirectory(directory)
-				yield* fs.writeFile(path, content)
-
+				const writes: {
+					path: string
+					content: string
+					create?: boolean
+				}[] = [{ path, content, create: true }]
 				if (input.epic && parentEpic) {
 					const parsed = yield* parseFrontmatter(
 						parentEpic.content,
@@ -163,8 +180,15 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 						tasks: [...parentEpic.data.tasks, { id }],
 					}
 					const updated = formatMarkdownDocument(epicData, parsed.body)
-					yield* fs.writeFile(parentEpic.path, updated)
+					writes.push({ path: parentEpic.path, content: updated })
 				}
+				yield* runLifecycleTransaction({
+					root,
+					preconditions: parentEpic
+						? [{ path: parentEpic.path, revision: parentEpic.revision }]
+						: [],
+					steps: [documentWriteStep(root, writes)],
+				})
 
 				return {
 					id,

package/src/services/WorkbaseService.test.ts

@@ -111,6 +111,52 @@ describe("WorkbaseService", () => {
 		expect(result.defaultWorkbase).toEqual(registered)
 	})
 
+	test("shows, names, clears names, and defaults by path", async () => {
+		const workbaseRoot = join(root, "workbase")
+		const configDirectory = join(root, "config")
+		await write(workbaseRoot, "agency.json", '{"version":2}\n')
+		const registered = await runTestEffect(
+			WorkbaseService.pipe(
+				Effect.flatMap((service) =>
+					service.register(workbaseRoot, configDirectory),
+				),
+			),
+		)
+
+		const result = await runTestEffect(
+			WorkbaseService.pipe(
+				Effect.flatMap((service) =>
+					Effect.gen(function* () {
+						const named = yield* service.nameRegistered(
+							workbaseRoot,
+							"primary",
+							configDirectory,
+						)
+						const shown = yield* service.showRegistered(
+							"primary",
+							configDirectory,
+						)
+						const defaultWorkbase = yield* service.setDefault(
+							workbaseRoot,
+							configDirectory,
+						)
+						const unnamed = yield* service.nameRegistered(
+							registered.id,
+							null,
+							configDirectory,
+						)
+						return { named, shown, defaultWorkbase, unnamed }
+					}),
+				),
+			),
+		)
+
+		expect(result.named.name).toBe("primary")
+		expect(result.shown).toEqual(result.named)
+		expect(result.defaultWorkbase?.id).toBe(registered.id)
+		expect(result.unnamed).toEqual({ id: registered.id, path: registered.path })
+	})
+
 	test("rejects names that collide with stable IDs", async () => {
 		const firstRoot = join(root, "first")
 		const secondRoot = join(root, "second")

package/src/services/WorkbaseService.ts

@@ -146,6 +146,31 @@ const writeRegistry = (
 		yield* fs.writeJSON(path, registry)
 	})
 
+const findRegistration = (
+	selector: string,
+	configDirectory?: string,
+	basePath: string = process.cwd(),
+) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		const { path, registry } = yield* readRegistry(configDirectory)
+		const candidatePath = resolve(basePath, selector)
+		const canonicalCandidate = (yield* fs.exists(candidatePath))
+			? yield* fs.realPath(candidatePath)
+			: candidatePath
+		const entry =
+			registry.workbases.find((item) => item.id === selector) ??
+			registry.workbases.find((item) => item.name === selector) ??
+			registry.workbases.find((item) => item.path === canonicalCandidate)
+		if (!entry) {
+			return yield* new WorkbaseRegistryError({
+				path,
+				message: `Unknown workbase selector '${selector}'`,
+			})
+		}
+		return { path, registry, entry }
+	})
+
 export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 	"WorkbaseService",
 	{
@@ -401,22 +426,11 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 				basePath: string = process.cwd(),
 			) =>
 				Effect.gen(function* () {
-					const fs = yield* FileSystemService
-					const { path, registry } = yield* readRegistry(configDirectory)
-					const candidatePath = resolve(basePath, selector)
-					const canonicalCandidate = (yield* fs.exists(candidatePath))
-						? yield* fs.realPath(candidatePath)
-						: candidatePath
-					const entry =
-						registry.workbases.find((item) => item.id === selector) ??
-						registry.workbases.find((item) => item.name === selector) ??
-						registry.workbases.find((item) => item.path === canonicalCandidate)
-					if (!entry) {
-						return yield* new WorkbaseRegistryError({
-							path,
-							message: `Unknown workbase selector '${selector}'`,
-						})
-					}
+					const { path, registry, entry } = yield* findRegistration(
+						selector,
+						configDirectory,
+						basePath,
+					)
 					const workbases = registry.workbases.filter(
 						(item) => item.id !== entry.id,
 					)
@@ -431,6 +445,61 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 					return entry
 				}),
 
+			showRegistered: (
+				selector: string,
+				configDirectory?: string,
+				basePath: string = process.cwd(),
+			) =>
+				findRegistration(selector, configDirectory, basePath).pipe(
+					Effect.map(({ entry }) => entry),
+				),
+
+			nameRegistered: (
+				selector: string,
+				name: string | null,
+				configDirectory?: string,
+				basePath: string = process.cwd(),
+			) =>
+				Effect.gen(function* () {
+					const { path, registry, entry } = yield* findRegistration(
+						selector,
+						configDirectory,
+						basePath,
+					)
+					if (name !== null) {
+						const decodedName = decode(EntityId, name)
+						if (!decodedName.success) {
+							return yield* new WorkbaseRegistryError({
+								path,
+								message: `Invalid workbase name '${name}': names must contain only letters, numbers, dots, underscores, and hyphens`,
+							})
+						}
+						const collision = registry.workbases.find(
+							(item) =>
+								item.id !== entry.id &&
+								(item.id === name || item.name === name),
+						)
+						if (collision) {
+							return yield* new WorkbaseRegistryError({
+								path,
+								message: `Workbase name '${name}' is already registered for ${collision.path}`,
+							})
+						}
+					}
+					const updated = {
+						id: entry.id,
+						...(name === null ? {} : { name }),
+						path: entry.path,
+					}
+					yield* writeRegistry(path, {
+						...registry,
+						workbases: registry.workbases.map((item) =>
+							item.id === entry.id ? updated : item,
+						),
+					})
+					return updated
+				}),
+
 			pruneRegistered: (configDirectory?: string) =>
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
@@ -455,7 +524,11 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 					return removed
 				}),
 
-			setDefault: (selector: string | null, configDirectory?: string) =>
+			setDefault: (
+				selector: string | null,
+				configDirectory?: string,
+				basePath: string = process.cwd(),
+			) =>
 				Effect.gen(function* () {
 					const { path, registry } = yield* readRegistry(configDirectory)
 					if (selector === null) {
@@ -465,15 +538,11 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 						})
 						return null
 					}
-					const entry = registry.workbases.find(
-						(item) => item.id === selector || item.name === selector,
+					const { entry } = yield* findRegistration(
+						selector,
+						configDirectory,
+						basePath,
 					)
-					if (!entry) {
-						return yield* new WorkbaseRegistryError({
-							path,
-							message: `Unknown registered workbase selector '${selector}'`,
-						})
-					}
 					yield* writeRegistry(path, {
 						version: 2,
 						workbases: registry.workbases,

package/src/services/WorktreeLock.ts

@@ -0,0 +1,60 @@
+import { Data, Effect } from "effect"
+import { open, rm } from "node:fs/promises"
+import { join } from "node:path"
+
+class WorktreeLockError extends Data.TaggedError("WorktreeLockError")<{
+	readonly message: string
+	readonly cause?: unknown
+}> {}
+
+export interface WorktreeLockTarget {
+	readonly taskId: string
+	readonly phaseId?: string
+}
+
+const withWorktreeLock = <A, E, R>(
+	root: string,
+	target: WorktreeLockTarget,
+	effect: Effect.Effect<A, E, R>,
+): Effect.Effect<A, E | WorktreeLockError, R> => {
+	const key = Buffer.from(
+		`${target.taskId}:${target.phaseId ?? "task"}`,
+	).toString("hex")
+	const lockPath = join(root, `.agency-worktree-${key}.lock`)
+	return Effect.acquireUseRelease(
+		Effect.tryPromise({
+			try: () => open(lockPath, "wx"),
+			catch: (cause) =>
+				new WorktreeLockError({
+					message: `Another worktree operation is in progress for '${target.taskId}${target.phaseId ? `/${target.phaseId}` : ""}'`,
+					cause,
+				}),
+		}),
+		() => effect,
+		(lock) =>
+			Effect.promise(async () => {
+				await lock.close().catch(() => undefined)
+				await rm(lockPath, { force: true }).catch(() => undefined)
+			}),
+	)
+}
+
+export const withWorktreeLocks = <A, E, R>(
+	root: string,
+	targets: readonly WorktreeLockTarget[],
+	effect: Effect.Effect<A, E, R>,
+): Effect.Effect<A, E | WorktreeLockError, R> => {
+	const unique = new Map(
+		targets.map((target) => [
+			`${target.taskId}:${target.phaseId ?? "task"}`,
+			target,
+		]),
+	)
+	let current: Effect.Effect<A, E | WorktreeLockError, R> = effect
+	for (const [, target] of [...unique.entries()]
+		.sort(([left], [right]) => left.localeCompare(right))
+		.reverse()) {
+		current = withWorktreeLock(root, target, current)
+	}
+	return current
+}