@markjaquith/agency 2.52.0 → 2.52.2

package/src/services/WorktreeService.ts

@@ -13,6 +13,12 @@ import type { BaseCommandOptions } from "../utils/command"
 import { createLoggers } from "../utils/effect"
 import { withWorktreeLocks } from "./WorktreeLock"
 import { VersionControlService } from "./VersionControlService"
+import type {
+	RegisteredWorkspace,
+	VersionControlBackend,
+} from "./VersionControlService"
+import type { TaskRecord } from "./TaskService"
+import type { PhaseRecord } from "./PhaseService"
 
 class WorktreeError extends Data.TaggedError("WorktreeError")<{
 	readonly message: string
@@ -113,6 +119,19 @@ interface WorktreeInspection {
 	readonly conflicts: readonly WorktreeConflict[]
 }
 
+interface InspectionContext {
+	readonly root: string
+	readonly backend: VersionControlBackend
+	readonly tasks: readonly TaskRecord[]
+	readonly phasesByTask: ReadonlyMap<string, readonly PhaseRecord[]>
+	readonly ownership: ReadonlyMap<string, readonly WorktreeOwner[]>
+	readonly workspacesByRepository: ReadonlyMap<
+		string,
+		readonly RegisteredWorkspace[]
+	>
+	readonly skipWritableRevisionResolution: boolean
+}
+
 interface WorktreeLifecycleResult {
 	readonly operation: "remove" | "rebuild" | "repair"
 	readonly dryRun: boolean
@@ -176,10 +195,17 @@ interface LifecycleOptions extends BaseCommandOptions {
 	readonly lockHeld?: boolean
 }
 
+interface ListOptions {
+	readonly materializedOnly?: boolean
+	readonly tasks?: readonly TaskRecord[]
+	readonly phasesByTask?: ReadonlyMap<string, readonly PhaseRecord[]>
+}
+
 const inspectExecution = (
 	taskId: string,
 	phaseId: string | undefined,
 	startPath: string,
+	context?: InspectionContext,
 ) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
@@ -187,9 +213,17 @@ const inspectExecution = (
 		const versionControl = yield* VersionControlService
 		const tasks = yield* TaskService
 		const phases = yield* PhaseService
-		const root = yield* workbase.discover(startPath)
-		const backend = yield* versionControl.forWorkbase(root)
-		const task = yield* tasks.show(taskId, root)
+		const root = context?.root ?? (yield* workbase.discover(startPath))
+		const backend =
+			context?.backend ?? (yield* versionControl.forWorkbase(root))
+		const task = context
+			? context.tasks.find((record) => record.id === taskId)
+			: yield* tasks.show(taskId, root)
+		if (!task) {
+			return yield* new WorktreeError({
+				message: `Task '${taskId}' does not exist`,
+			})
+		}
 
 		let execution:
 			| {
@@ -207,7 +241,16 @@ const inspectExecution = (
 					message: `Task '${taskId}' has multiple phases; phase ID is required`,
 				})
 			}
-			const phase = yield* phases.show(taskId, phaseId, root)
+			const phase = context
+				? context.phasesByTask
+						.get(taskId)
+						?.find((record) => record.id === phaseId)
+				: yield* phases.show(taskId, phaseId, root)
+			if (!phase) {
+				return yield* new WorktreeError({
+					message: `Phase '${phaseId}' does not exist on task '${taskId}'`,
+				})
+			}
 			execution = phase.data
 			owner = {
 				kind: "phase",
@@ -227,31 +270,37 @@ const inspectExecution = (
 			codePath = join(dirname(task.path), "code")
 		}
 
-		const ownership = new Map<string, WorktreeOwner[]>()
-		for (const taskRecord of yield* tasks.list(root)) {
-			if ("phases" in taskRecord.data) {
-				for (const phaseRecord of yield* phases.list(taskRecord.id, root)) {
-					const key = `${phaseRecord.data.repo}:${phaseRecord.data.branch}`
-					const owners = ownership.get(key) ?? []
+		let ownership: ReadonlyMap<string, readonly WorktreeOwner[]>
+		if (context) {
+			ownership = context.ownership
+		} else {
+			const discoveredOwnership = new Map<string, WorktreeOwner[]>()
+			for (const taskRecord of yield* tasks.list(root)) {
+				if ("phases" in taskRecord.data) {
+					for (const phaseRecord of yield* phases.list(taskRecord.id, root)) {
+						const key = `${phaseRecord.data.repo}:${phaseRecord.data.branch}`
+						const owners = discoveredOwnership.get(key) ?? []
+						owners.push({
+							kind: "phase",
+							taskId: taskRecord.id,
+							phaseId: phaseRecord.id,
+							documentPath: phaseRecord.path,
+						})
+						discoveredOwnership.set(key, owners)
+					}
+				} else {
+					if (!("repo" in taskRecord.data)) continue
+					const key = `${taskRecord.data.repo}:${taskRecord.data.branch}`
+					const owners = discoveredOwnership.get(key) ?? []
 					owners.push({
-						kind: "phase",
+						kind: "task",
 						taskId: taskRecord.id,
-						phaseId: phaseRecord.id,
-						documentPath: phaseRecord.path,
+						documentPath: taskRecord.path,
 					})
-					ownership.set(key, owners)
+					discoveredOwnership.set(key, owners)
 				}
-			} else {
-				if (!("repo" in taskRecord.data)) continue
-				const key = `${taskRecord.data.repo}:${taskRecord.data.branch}`
-				const owners = ownership.get(key) ?? []
-				owners.push({
-					kind: "task",
-					taskId: taskRecord.id,
-					documentPath: taskRecord.path,
-				})
-				ownership.set(key, owners)
 			}
+			ownership = discoveredOwnership
 		}
 
 		const declared: readonly (
@@ -318,19 +367,27 @@ const inspectExecution = (
 				const expectedPath = exists
 					? yield* fs.realPath(checkoutPath)
 					: resolve(checkoutPath)
-				const registered = yield* backend.listWorkspaces(repositoryPath)
+				const registered =
+					context?.workspacesByRepository.get(repositoryPath) ??
+					(yield* backend.listWorkspaces(repositoryPath))
 				const atPath = registered.find(
 					(workspace) => workspace.path === expectedPath,
 				)
 				const actualCommit = atPath
-					? yield* backend.workspaceHead(checkoutPath)
+					? atPath.head !== undefined
+						? atPath.head
+						: yield* backend.workspaceHead(checkoutPath)
 					: null
 				const dirty =
-					exists && atPath ? yield* backend.workspaceDirty(checkoutPath) : null
-				const expectedCommit = yield* backend.resolveRevision(
-					repositoryPath,
-					requestedRef,
-				)
+					exists && atPath
+						? atPath.dirty !== undefined
+							? atPath.dirty
+							: yield* backend.workspaceDirty(checkoutPath)
+						: null
+				const expectedCommit =
+					"branch" in checkout && context?.skipWritableRevisionResolution
+						? actualCommit
+						: yield* backend.resolveRevision(repositoryPath, requestedRef)
 
 				if (owners.length > 1) {
 					conflict(
@@ -647,6 +704,95 @@ const jjWorkspaceName = (
 	repo: string,
 ) => `agency-${taskId}-${phaseId ?? "task"}-${repo}`
 
+const buildInspectionContext = (
+	startPath: string,
+	skipWritableRevisionResolution: boolean,
+	preloadedTasks?: readonly TaskRecord[],
+	preloadedPhasesByTask?: ReadonlyMap<string, readonly PhaseRecord[]>,
+) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		const workbase = yield* WorkbaseService
+		const versionControl = yield* VersionControlService
+		const taskService = yield* TaskService
+		const phaseService = yield* PhaseService
+		const root = yield* workbase.discover(startPath)
+		const backend = yield* versionControl.forWorkbase(root)
+		const tasks = preloadedTasks ?? (yield* taskService.list(root))
+		const phasesByTask = new Map<string, readonly PhaseRecord[]>()
+		const ownership = new Map<string, WorktreeOwner[]>()
+		const repositoryAliases = new Set<string>()
+
+		const addExecution = (
+			execution:
+				| {
+						repo: string
+						repos?: readonly RepositoryReference[]
+						branch: string
+				  }
+				| { review: { repo: string } },
+			owner: WorktreeOwner,
+		) => {
+			if ("review" in execution) {
+				repositoryAliases.add(execution.review.repo)
+				return
+			}
+			repositoryAliases.add(execution.repo)
+			for (const reference of execution.repos ?? [])
+				repositoryAliases.add(reference.repo)
+			const key = `${execution.repo}:${execution.branch}`
+			const owners = ownership.get(key) ?? []
+			owners.push(owner)
+			ownership.set(key, owners)
+		}
+
+		for (const task of tasks) {
+			if ("phases" in task.data) {
+				const phaseRecords =
+					preloadedPhasesByTask?.get(task.id) ??
+					(yield* phaseService.list(task.id, root))
+				phasesByTask.set(task.id, phaseRecords)
+				for (const phase of phaseRecords) {
+					addExecution(phase.data, {
+						kind: "phase",
+						taskId: task.id,
+						phaseId: phase.id,
+						documentPath: phase.path,
+					})
+				}
+			} else {
+				addExecution(task.data, {
+					kind: "task",
+					taskId: task.id,
+					documentPath: task.path,
+				})
+			}
+		}
+
+		const workspacesByRepository = new Map<
+			string,
+			readonly RegisteredWorkspace[]
+		>()
+		for (const alias of repositoryAliases) {
+			const repositoryPath = join(root, "repos", alias)
+			if (!(yield* fs.exists(repositoryPath))) continue
+			workspacesByRepository.set(
+				repositoryPath,
+				yield* backend.listWorkspaces(repositoryPath),
+			)
+		}
+
+		return {
+			root,
+			backend,
+			tasks,
+			phasesByTask,
+			ownership,
+			workspacesByRepository,
+			skipWritableRevisionResolution,
+		} satisfies InspectionContext
+	})
+
 const materializeJj = (options: {
 	readonly root: string
 	readonly taskId: string
@@ -935,23 +1081,71 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 	"WorktreeService",
 	{
 		sync: () => ({
-			list: (startPath: string = process.cwd()) =>
+			list: (startPath: string = process.cwd(), options: ListOptions = {}) =>
 				Effect.gen(function* () {
-					const workbase = yield* WorkbaseService
-					const tasks = yield* TaskService
-					const phases = yield* PhaseService
-					const root = yield* workbase.discover(startPath)
+					const fs = yield* FileSystemService
+					const context = yield* buildInspectionContext(
+						startPath,
+						options.materializedOnly === true,
+						options.tasks,
+						options.phasesByTask,
+					)
 					const inspections: WorktreeInspection[] = []
-					for (const task of yield* tasks.list(root)) {
+					const shouldInspect = (
+						documentPath: string,
+						execution:
+							| {
+									repo: string
+									repos?: readonly RepositoryReference[]
+							  }
+							| { review: { repo: string } },
+					) =>
+						Effect.gen(function* () {
+							if (!options.materializedOnly) return true
+							const codePath = join(dirname(documentPath), "code")
+							const aliases =
+								"review" in execution
+									? [execution.review.repo]
+									: [
+											execution.repo,
+											...(execution.repos ?? []).map(
+												(reference) => reference.repo,
+											),
+										]
+							for (const alias of aliases) {
+								if (yield* fs.isDirectory(join(codePath, alias))) return true
+							}
+							return [...context.workspacesByRepository.values()].some(
+								(workspaces) =>
+									workspaces.some(
+										(workspace) =>
+											workspace.path === codePath ||
+											workspace.path.startsWith(`${codePath}/`),
+									),
+							)
+						})
+					for (const task of context.tasks) {
 						if ("phases" in task.data) {
-							for (const phase of yield* phases.list(task.id, root)) {
+							for (const phase of context.phasesByTask.get(task.id) ?? []) {
+								if (!(yield* shouldInspect(phase.path, phase.data))) continue
 								inspections.push(
-									yield* inspectExecution(task.id, phase.id, root),
+									yield* inspectExecution(
+										task.id,
+										phase.id,
+										context.root,
+										context,
+									),
 								)
 							}
 						} else {
+							if (!(yield* shouldInspect(task.path, task.data))) continue
 							inspections.push(
-								yield* inspectExecution(task.id, undefined, root),
+								yield* inspectExecution(
+									task.id,
+									undefined,
+									context.root,
+									context,
+								),
 							)
 						}
 					}

package/src/vcs-status-fast.ts

@@ -0,0 +1,315 @@
+import { lstat, readdir, realpath, stat } from "node:fs/promises"
+import { dirname, join, resolve } from "node:path"
+
+interface Execution {
+	readonly taskId: string
+	readonly phaseId?: string
+	readonly documentPath: string
+	readonly repo: string
+	readonly branch: string
+	readonly claimActive: boolean
+}
+
+interface Workspace {
+	readonly path: string
+	readonly dirty: boolean
+}
+
+interface Blocker {
+	readonly kind: string
+	readonly target: string
+	readonly message: string
+}
+
+const run = async (args: readonly string[]) => {
+	const process = Bun.spawn([...args], { stdout: "pipe", stderr: "pipe" })
+	const [exitCode, stdout] = await Promise.all([
+		process.exited,
+		new Response(process.stdout).text(),
+	])
+	return { exitCode, stdout: stdout.trim() }
+}
+
+const directoryExists = async (path: string) => {
+	try {
+		return (await stat(path)).isDirectory()
+	} catch {
+		return false
+	}
+}
+
+const frontmatter = (content: string) => {
+	if (!content.startsWith("---\n")) return null
+	const end = content.indexOf("\n---\n", 4)
+	return end === -1 ? null : content.slice(4, end)
+}
+
+const scalar = (content: string, key: string) => {
+	const match = content.match(new RegExp(`^${key}:\\s*(.+?)\\s*$`, "m"))
+	if (!match) return null
+	const value = match[1]!
+	return value.startsWith('"') && value.endsWith('"')
+		? value.slice(1, -1)
+		: value
+}
+
+const activeClaim = (content: string) => {
+	const claim = content.match(/^claim:\s*\n((?:^[ \t]+.*(?:\n|$))*)/m)?.[1]
+	return claim ? /^\s+state:\s*active\s*$/m.test(claim) : false
+}
+
+const discoverRoot = async (startPath: string) => {
+	let current = startPath
+	while (true) {
+		const configPath = join(current, "agency.json")
+		if (await Bun.file(configPath).exists()) return current
+		const parent = dirname(current)
+		if (parent === current) return null
+		current = parent
+	}
+}
+
+const readExecution = async (
+	documentPath: string,
+	taskId: string,
+	phaseId?: string,
+): Promise<Execution | null> => {
+	const content = frontmatter(await Bun.file(documentPath).text())
+	if (!content || /^repos:/m.test(content) || /^review:/m.test(content))
+		return null
+	const repo = scalar(content, "repo")
+	const branch = scalar(content, "branch")
+	if (!repo || !branch) return null
+	return {
+		taskId,
+		...(phaseId ? { phaseId } : {}),
+		documentPath,
+		repo,
+		branch,
+		claimActive: activeClaim(content),
+	}
+}
+
+const readExecutions = async (root: string) => {
+	const tasksPath = join(root, "tasks")
+	const entries = (await readdir(tasksPath, { withFileTypes: true }))
+		.filter((entry) => entry.isDirectory())
+		.sort((left, right) => left.name.localeCompare(right.name))
+	const executions: Execution[] = []
+	for (const entry of entries) {
+		const taskPath = join(tasksPath, entry.name, "TASK.md")
+		const taskContent = frontmatter(await Bun.file(taskPath).text())
+		if (!taskContent) return null
+		if (/^phases:/m.test(taskContent)) {
+			const phasesPath = join(tasksPath, entry.name, "phases")
+			const phases = (await readdir(phasesPath, { withFileTypes: true }))
+				.filter((phase) => phase.isDirectory())
+				.sort((left, right) => left.name.localeCompare(right.name))
+			for (const phase of phases) {
+				const execution = await readExecution(
+					join(phasesPath, phase.name, "PHASE.md"),
+					entry.name,
+					phase.name,
+				)
+				if (!execution) return null
+				executions.push(execution)
+			}
+		} else {
+			const execution = await readExecution(taskPath, entry.name)
+			if (!execution) return null
+			executions.push(execution)
+		}
+	}
+	return executions
+}
+
+const inspectRepository = async (root: string, alias: string) => {
+	const path = join(root, "repos", alias)
+	let stats
+	try {
+		stats = await lstat(path)
+	} catch {
+		return null
+	}
+	if (!stats.isDirectory() && !stats.isSymbolicLink()) return null
+	const [git, bare] = await Promise.all([
+		run(["git", "-C", path, "rev-parse", "--git-dir"]),
+		run(["git", "-C", path, "rev-parse", "--is-bare-repository"]),
+	])
+	if (git.exitCode !== 0 || bare.exitCode !== 0) return null
+	return {
+		alias,
+		path,
+		kind: stats.isSymbolicLink()
+			? ("symlink" as const)
+			: bare.stdout === "true"
+				? ("bare" as const)
+				: ("repository" as const),
+		initialized: await directoryExists(join(path, ".jj")),
+	}
+}
+
+const listWorkspaces = async (repositoryPath: string) => {
+	const result = await run([
+		"jj",
+		"-R",
+		repositoryPath,
+		"--no-pager",
+		"workspace",
+		"list",
+		"-T",
+		'name ++ "\\t" ++ root ++ "\\t" ++ target.empty() ++ "\\n"',
+	])
+	if (result.exitCode !== 0) return null
+	return result.stdout
+		.split("\n")
+		.filter(Boolean)
+		.map((line): Workspace => {
+			const [, path, empty] = line.split("\t")
+			return { path: path!, dirty: empty === "false" }
+		})
+}
+
+const inspectVcsStatusFast = async (startPath: string) => {
+	const root = await discoverRoot(startPath)
+	if (!root) return null
+	const config = await Bun.file(join(root, "agency.json")).json()
+	if (config?.version !== 2 || config?.vcs !== "jj") return null
+	const executions = await readExecutions(root)
+	if (!executions) return null
+
+	const localRepositories = (
+		await readdir(join(root, "repos"), {
+			withFileTypes: true,
+		})
+	)
+		.filter((entry) => !entry.name.startsWith(".agency-"))
+		.map((entry) => entry.name)
+	const aliases = [
+		...new Set([
+			...Object.keys(config.repositories ?? {}),
+			...localRepositories,
+		]),
+	].sort()
+	const repositories = await Promise.all(
+		aliases.map((alias) => inspectRepository(root, alias)),
+	)
+	if (repositories.some((repository) => repository === null)) return null
+	const repositoryRecords = repositories.filter(
+		(repository) => repository !== null,
+	)
+	if (repositoryRecords.some((repository) => !repository.initialized))
+		return null
+
+	const workspaceLists = await Promise.all(
+		repositoryRecords.map(async (repository) => ({
+			alias: repository.alias,
+			workspaces: await listWorkspaces(repository.path),
+		})),
+	)
+	if (workspaceLists.some(({ workspaces }) => workspaces === null)) return null
+	const workspacesByRepo = new Map(
+		workspaceLists.map(({ alias, workspaces }) => [alias, workspaces!]),
+	)
+	const owners = new Map<string, Execution[]>()
+	for (const execution of executions) {
+		const key = `${execution.repo}:${execution.branch}`
+		const entries = owners.get(key) ?? []
+		entries.push(execution)
+		owners.set(key, entries)
+	}
+
+	const blockers: Blocker[] = []
+	for (const execution of executions) {
+		if (!execution.claimActive) continue
+		const target = execution.phaseId
+			? `phase:${execution.taskId}/${execution.phaseId}`
+			: `task:${execution.taskId}`
+		blockers.push({
+			kind: "active-work",
+			target,
+			message: `${target} is active; finish or release it before migration`,
+		})
+	}
+
+	let workspaceCount = 0
+	for (const execution of executions) {
+		const checkoutPath = join(
+			dirname(execution.documentPath),
+			"code",
+			execution.repo,
+		)
+		const exists = await directoryExists(checkoutPath)
+		const expectedPath = exists
+			? await realpath(checkoutPath)
+			: resolve(checkoutPath)
+		const registered = workspacesByRepo
+			.get(execution.repo)
+			?.find((workspace) => workspace.path === expectedPath)
+		const conflicts: string[] = []
+		if ((owners.get(`${execution.repo}:${execution.branch}`)?.length ?? 0) > 1)
+			conflicts.push(
+				`Branch '${execution.branch}' for repository '${execution.repo}' has multiple Agency owners`,
+			)
+		if (registered && !exists)
+			conflicts.push(
+				`Workspace registry contains a missing checkout at ${checkoutPath}`,
+			)
+		if (exists && !registered)
+			conflicts.push(
+				`Existing checkout ${checkoutPath} is not registered as a jj workspace`,
+			)
+		if (conflicts.length > 0) {
+			blockers.push({
+				kind: "workspace-conflict",
+				target: checkoutPath,
+				message: conflicts.join("; "),
+			})
+			continue
+		}
+		if (!exists || !registered) continue
+		if (registered.dirty) {
+			blockers.push({
+				kind: "dirty-workspace",
+				target: checkoutPath,
+				message: `Workspace ${checkoutPath} must be clean before migration`,
+			})
+			continue
+		}
+		workspaceCount++
+	}
+
+	return {
+		root,
+		configured: "jj",
+		source: "jj",
+		target: "jj",
+		available: { git: Bun.which("git") !== null, jj: Bun.which("jj") !== null },
+		repositories: repositoryRecords,
+		workspaceCount,
+		blockers,
+	}
+}
+
+export const runVcsStatusFast = async (
+	json: boolean,
+	startPath: string = process.cwd(),
+	write: (message: string) => void = console.log,
+) => {
+	const status = await inspectVcsStatusFast(startPath)
+	if (!status) return false
+	if (json) {
+		write(JSON.stringify({ version: 1, ok: true, result: status }))
+	} else {
+		write("Version control: jj")
+		write(
+			`Tools: git=${status.available.git ? "available" : "missing"} jj=${status.available.jj ? "available" : "missing"}`,
+		)
+		write(
+			`Repositories: ${status.repositories.length}; managed workspaces: ${status.workspaceCount}; blockers: ${status.blockers.length}`,
+		)
+		for (const blocker of status.blockers)
+			write(`blocker ${blocker.kind} ${blocker.target}: ${blocker.message}`)
+	}
+	return true
+}