@markjaquith/agency 2.16.0 → 2.18.0

package/src/services/WorkbaseService.ts

@@ -6,7 +6,9 @@ import { dirname, join, relative, resolve } from "node:path"
 import { FileSystemService } from "./FileSystemService"
 import { parseFrontmatter } from "../workbase/frontmatter"
 import {
+	EntityId,
 	EpicFrontmatter,
+	LegacyWorkbaseRegistry,
 	PhaseFrontmatter,
 	TaskFrontmatter,
 	WorkbaseConfig,
@@ -15,6 +17,8 @@ import {
 	type EpicFrontmatter as EpicData,
 	type PhaseFrontmatter as PhaseData,
 	type TaskFrontmatter as TaskData,
+	type WorkbaseRegistry as WorkbaseRegistryData,
+	type WorkbaseRegistration,
 } from "../workbase/schemas"
 import { validateWorktreeCreateCommand } from "../workbase/worktree-command"
 
@@ -81,12 +85,17 @@ const registryPath = (configDirectory?: string) =>
 		"workbases.json",
 	)
 
+const registrationId = (path: string) =>
+	`wb-${new Bun.CryptoHasher("sha256").update(path).digest("hex").slice(0, 12)}`
+
+const emptyRegistry: WorkbaseRegistryData = { version: 2, workbases: [] }
+
 const readRegistry = (configDirectory?: string) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
 		const path = registryPath(configDirectory)
 		if (!(yield* fs.exists(path))) {
-			return { path, registry: { version: 1, workbases: [] } as const }
+			return { path, registry: emptyRegistry }
 		}
 
 		const content = yield* fs.readFile(path)
@@ -102,13 +111,37 @@ const readRegistry = (configDirectory?: string) =>
 		}
 
 		const decoded = decode(WorkbaseRegistry, input)
-		if (!decoded.success) {
+		if (decoded.success) return { path, registry: decoded.value }
+
+		const legacy = decode(LegacyWorkbaseRegistry, input)
+		if (!legacy.success) {
 			return yield* new WorkbaseRegistryError({
 				path,
 				message: `Invalid workbase registry in ${path}:\n${decoded.error}`,
 			})
 		}
-		return { path, registry: decoded.value }
+		const registry: WorkbaseRegistryData = {
+			version: 2 as const,
+			workbases: legacy.value.workbases.map((workbasePath) => ({
+				id: registrationId(workbasePath),
+				path: workbasePath,
+			})),
+		}
+		return { path, registry }
+	})
+
+const writeRegistry = (
+	path: string,
+	registry: {
+		readonly version: 2
+		readonly workbases: readonly WorkbaseRegistration[]
+		readonly defaultId?: string
+	},
+) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		yield* fs.createDirectory(dirname(path))
+		yield* fs.writeJSON(path, registry)
 	})
 
 const findCycles = (nodes: readonly Dependency[]): readonly string[] => {
@@ -285,26 +318,195 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 					return { root, config: decoded.value }
 				}),
 
-			register: (startPath: string, configDirectory?: string) =>
+			register: (startPath: string, configDirectory?: string, name?: string) =>
 				Effect.gen(function* () {
 					const service = yield* WorkbaseService
 					const fs = yield* FileSystemService
 					const discovered = yield* service.discover(startPath)
 					const root = yield* fs.realPath(discovered)
 					const { path, registry } = yield* readRegistry(configDirectory)
-					if (registry.workbases.includes(root)) return root
+					if (name !== undefined) {
+						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 named = name
+						? registry.workbases.find(
+								(entry) =>
+									(entry.name === name && entry.path !== root) ||
+									entry.id === name,
+							)
+						: undefined
+					if (named) {
+						return yield* new WorkbaseRegistryError({
+							path,
+							message: `Workbase name '${name}' is already registered for ${named.path}`,
+						})
+					}
+					const existing = registry.workbases.find(
+						(entry) => entry.path === root,
+					)
+					const registration = {
+						id: existing?.id ?? registrationId(root),
+						...(name
+							? { name }
+							: existing?.name
+								? { name: existing.name }
+								: {}),
+						path: root,
+					}
+					const idNameCollision = registry.workbases.find(
+						(entry) => entry.name === registration.id && entry.path !== root,
+					)
+					if (idNameCollision) {
+						return yield* new WorkbaseRegistryError({
+							path,
+							message: `Workbase ID '${registration.id}' conflicts with the registered name for ${idNameCollision.path}`,
+						})
+					}
+					const workbases = existing
+						? registry.workbases.map((entry) =>
+								entry.id === existing.id ? registration : entry,
+							)
+						: [...registry.workbases, registration]
+					yield* writeRegistry(path, { ...registry, workbases })
+					return registration
+				}),
+
+			listRegistered: (configDirectory?: string) =>
+				readRegistry(configDirectory).pipe(
+					Effect.map(({ registry }) =>
+						registry.workbases.map((entry) => entry.path),
+					),
+				),
+
+			listRegistrations: (configDirectory?: string) =>
+				readRegistry(configDirectory).pipe(
+					Effect.map(({ registry }) => ({
+						workbases: registry.workbases,
+						defaultId: registry.defaultId,
+					})),
+				),
+
+			resolveRegistered: (
+				selector: string,
+				configDirectory?: string,
+				basePath: string = process.cwd(),
+			) =>
+				Effect.gen(function* () {
+					const service = yield* WorkbaseService
+					const fs = yield* FileSystemService
+					const { path, registry } = yield* readRegistry(configDirectory)
+					const candidatePath = resolve(basePath, selector)
+					const direct =
+						registry.workbases.find((entry) => entry.id === selector) ??
+						registry.workbases.find((entry) => entry.name === selector) ??
+						registry.workbases.find((entry) => entry.path === candidatePath)
+					if (direct) return direct.path
+					if (yield* fs.exists(candidatePath))
+						return yield* service.discover(candidatePath)
+					return yield* new WorkbaseRegistryError({
+						path,
+						message: `Unknown workbase selector '${selector}'`,
+					})
+				}),
+
+			removeRegistered: (
+				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}'`,
+						})
+					}
+					const workbases = registry.workbases.filter(
+						(item) => item.id !== entry.id,
+					)
+					const next = {
+						version: 2 as const,
+						workbases,
+						...(registry.defaultId && registry.defaultId !== entry.id
+							? { defaultId: registry.defaultId }
+							: {}),
+					}
+					yield* writeRegistry(path, next)
+					return entry
+				}),
 
-					yield* fs.createDirectory(dirname(path))
-					yield* fs.writeJSON(path, {
-						version: 1,
-						workbases: [...registry.workbases, root],
+			pruneRegistered: (configDirectory?: string) =>
+				Effect.gen(function* () {
+					const fs = yield* FileSystemService
+					const { path, registry } = yield* readRegistry(configDirectory)
+					const kept: WorkbaseRegistration[] = []
+					const removed: WorkbaseRegistration[] = []
+					for (const entry of registry.workbases) {
+						if (yield* fs.exists(join(entry.path, "agency.json")))
+							kept.push(entry)
+						else removed.push(entry)
+					}
+					const defaultId = kept.some(
+						(entry) => entry.id === registry.defaultId,
+					)
+						? registry.defaultId
+						: undefined
+					yield* writeRegistry(path, {
+						version: 2,
+						workbases: kept,
+						...(defaultId ? { defaultId } : {}),
 					})
-					return root
+					return removed
 				}),
 
-			listRegistered: (configDirectory?: string) =>
+			setDefault: (selector: string | null, configDirectory?: string) =>
+				Effect.gen(function* () {
+					const { path, registry } = yield* readRegistry(configDirectory)
+					if (selector === null) {
+						yield* writeRegistry(path, {
+							version: 2,
+							workbases: registry.workbases,
+						})
+						return null
+					}
+					const entry = registry.workbases.find(
+						(item) => item.id === selector || item.name === selector,
+					)
+					if (!entry) {
+						return yield* new WorkbaseRegistryError({
+							path,
+							message: `Unknown registered workbase selector '${selector}'`,
+						})
+					}
+					yield* writeRegistry(path, {
+						version: 2,
+						workbases: registry.workbases,
+						defaultId: entry.id,
+					})
+					return entry
+				}),
+
+			getDefault: (configDirectory?: string) =>
 				readRegistry(configDirectory).pipe(
-					Effect.map(({ registry }) => registry.workbases),
+					Effect.map(({ registry }) =>
+						registry.workbases.find((entry) => entry.id === registry.defaultId),
+					),
 				),
 
 			validate: (startPath: string = process.cwd()) =>

package/src/services/WorktreeService.test.ts

@@ -206,6 +206,18 @@ describe("WorktreeService", () => {
 		expect(
 			await Bun.file(join(root, "tasks", "valid-target", "code")).exists(),
 		).toBe(false)
+
+		await expect(
+			runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) =>
+						service.materialize("valid-target", undefined, root, {
+							force: true,
+						}),
+					),
+				),
+			),
+		).resolves.toMatchObject({ repo: "agency" })
 	})
 
 	test("uses a configured worktree creation command", async () => {

package/src/services/WorktreeService.ts

@@ -84,6 +84,10 @@ const isCommitId = (ref: string) => /^[0-9a-f]{40,64}$/i.test(ref)
 const originRef = (ref: string) =>
 	ref.replace(/^refs\/remotes\/origin\//, "").replace(/^origin\//, "")
 
+interface MaterializeOptions extends BaseCommandOptions {
+	readonly force?: boolean
+}
+
 export class WorktreeService extends Effect.Service<WorktreeService>()(
 	"WorktreeService",
 	{
@@ -92,7 +96,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 				taskId: string,
 				phaseId?: string,
 				startPath: string = process.cwd(),
-				options: BaseCommandOptions = {},
+				options: MaterializeOptions = {},
 			) =>
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
@@ -105,7 +109,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 					const { root, config } = yield* workbase.loadConfig(startPath)
 					const report = yield* workbase.validate(root)
 					const validationIssue = report.issues[0]
-					if (validationIssue) {
+					if (validationIssue && !options.force) {
 						return yield* new WorktreeError({
 							message: `${validationIssue.path}: ${validationIssue.message}`,
 						})

package/src/test-utils.ts

@@ -17,6 +17,7 @@ import { ContextService } from "./services/ContextService"
 import { GraphService } from "./services/GraphService"
 import { ClaimService } from "./services/ClaimService"
 import { SyncService } from "./services/SyncService"
+import { ReadinessService } from "./services/ReadinessService"
 
 export const createTempDir = () => mkdtemp(join(tmpdir(), "agency-test-"))
 
@@ -38,6 +39,7 @@ const TestLayer = Layer.mergeAll(
 	GraphService.Default,
 	ClaimService.Default,
 	SyncService.Default,
+	ReadinessService.Default,
 )
 
 export async function runTestEffect<A, E>(

package/src/workbase/schemas.test.ts

@@ -185,23 +185,34 @@ describe("workbase registry", () => {
 	test("accepts registered paths", () => {
 		expect(
 			Schema.decodeUnknownSync(WorkbaseRegistry)({
-				version: 1,
-				workbases: ["/work/one", "/work/two"],
+				version: 2,
+				workbases: [
+					{ id: "wb-one", name: "one", path: "/work/one" },
+					{ id: "wb-two", path: "/work/two" },
+				],
+				defaultId: "wb-one",
 			}),
-		).toEqual({ version: 1, workbases: ["/work/one", "/work/two"] })
+		).toEqual({
+			version: 2,
+			workbases: [
+				{ id: "wb-one", name: "one", path: "/work/one" },
+				{ id: "wb-two", path: "/work/two" },
+			],
+			defaultId: "wb-one",
+		})
 	})
 
 	test("rejects invalid versions and empty paths", () => {
 		expect(() =>
 			Schema.decodeUnknownSync(WorkbaseRegistry)({
-				version: 2,
+				version: 3,
 				workbases: [],
 			}),
 		).toThrow()
 		expect(() =>
 			Schema.decodeUnknownSync(WorkbaseRegistry)({
-				version: 1,
-				workbases: [""],
+				version: 2,
+				workbases: [{ id: "wb-one", path: "" }],
 			}),
 		).toThrow()
 	})

package/src/workbase/schemas.ts

@@ -54,11 +54,23 @@ export const WorkbaseConfig = Schema.Struct({
 	worktreeCreateCommand: Schema.optional(Schema.NonEmptyArray(NonEmptyString)),
 })
 
-export const WorkbaseRegistry = Schema.Struct({
+export const LegacyWorkbaseRegistry = Schema.Struct({
 	version: Schema.Literal(1),
 	workbases: Schema.Array(NonEmptyString),
 })
 
+export const WorkbaseRegistration = Schema.Struct({
+	id: EntityId,
+	name: Schema.optional(EntityId),
+	path: NonEmptyString,
+})
+
+export const WorkbaseRegistry = Schema.Struct({
+	version: Schema.Literal(2),
+	workbases: Schema.Array(WorkbaseRegistration),
+	defaultId: Schema.optional(EntityId),
+})
+
 export const Dependency = Schema.Struct({
 	id: EntityId,
 	dependsOn: Schema.optional(Schema.Array(EntityId)),
@@ -107,6 +119,9 @@ export const PhaseFrontmatter = Schema.Struct({
 
 export type WorkbaseConfig = Schema.Schema.Type<typeof WorkbaseConfig>
 export type WorkbaseRegistry = Schema.Schema.Type<typeof WorkbaseRegistry>
+export type WorkbaseRegistration = Schema.Schema.Type<
+	typeof WorkbaseRegistration
+>
 export type Dependency = Schema.Schema.Type<typeof Dependency>
 export type RepositoryReference = Schema.Schema.Type<typeof RepositoryReference>
 export type WorkStatus = Schema.Schema.Type<typeof WorkStatus>

package/src/workbase/workbase-choice.ts

@@ -30,6 +30,8 @@ export const resolveWorkbase = (
 		return yield* workbase.discover(startPath).pipe(
 			Effect.catchTag("WorkbaseNotFoundError", () =>
 				Effect.gen(function* () {
+					const defaultWorkbase = yield* workbase.getDefault()
+					if (defaultWorkbase) return defaultWorkbase.path
 					const registered = yield* workbase.listRegistered()
 					if (registered.length === 0) {
 						return yield* Effect.fail(