@markjaquith/agency 2.49.0 → 2.51.0

package/src/services/ContextService.ts

@@ -8,6 +8,7 @@ import { RepositoryService } from "./RepositoryService"
 import { aggregateProgress, readinessState } from "../readiness"
 import { parseFrontmatter } from "../workbase/frontmatter"
 import { documentRevision } from "../workbase/document-revision"
+import { VersionControlService } from "./VersionControlService"
 import {
 	EpicFrontmatter,
 	PhaseFrontmatter,
@@ -54,6 +55,7 @@ interface CheckoutInspection {
 	readonly checkoutCommit: string | null
 	readonly checkoutBranch: string | null
 	readonly detached: boolean | null
+	readonly dirty: boolean | null
 }
 
 type ExecutionData = PhaseData & Partial<Pick<TaskData, "ticketUrl" | "epic">>
@@ -92,6 +94,18 @@ const runGit = (fs: FileSystemService, cwd: string, args: readonly string[]) =>
 		Effect.catchAll(() => Effect.succeed(null)),
 	)
 
+const runGitText = (
+	fs: FileSystemService,
+	cwd: string,
+	args: readonly string[],
+) =>
+	fs.runCommand(["git", "-C", cwd, ...args], { captureOutput: true }).pipe(
+		Effect.map((result) =>
+			result.exitCode === 0 ? result.stdout.trim() : null,
+		),
+		Effect.catchAll(() => Effect.succeed(null)),
+	)
+
 const worktreePaths = (output: string | null) =>
 	new Set(
 		(output ?? "")
@@ -114,6 +128,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 					const fs = yield* FileSystemService
 					const workbase = yield* WorkbaseService
 					const repositoryService = yield* RepositoryService
+					const versionControl = yield* VersionControlService
 					const cwd = resolve(options.cwd ?? process.cwd())
 					const suppliedTarget = options.target ?? "."
 					const candidate = resolve(cwd, suppliedTarget)
@@ -121,6 +136,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 					const { root, config } = yield* workbase.loadConfig(
 						candidateExists ? candidate : cwd,
 					)
+					const backend = yield* versionControl.forWorkbase(root)
 
 					if (relative(root, candidate) === "") {
 						const compact = !options.full
@@ -201,6 +217,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 								root,
 								configPath: join(root, "agency.json"),
 								version: config.version,
+								vcs: config.vcs ?? "git",
 							},
 							target: { kind: "workbase", path: root },
 							hint: compact
@@ -765,9 +782,13 @@ export class ContextService extends Effect.Service<ContextService>()(
 						: task?.data && "repo" in task.data
 							? (task.data as ExecutionData)
 							: null
-					const references: readonly RepositoryReference[] = executionData
-						? (executionData.repos ?? [])
-						: (epic?.data.repos ?? [])
+					const reviewData =
+						task?.data && "review" in task.data ? task.data.review : null
+					const references: readonly RepositoryReference[] = reviewData
+						? [{ repo: reviewData.repo, ref: reviewData.commit }]
+						: executionData
+							? (executionData.repos ?? [])
+							: (epic?.data.repos ?? [])
 					const entityDirectory = target.path.replace(
 						/\/(?:EPIC|TASK|PHASE)\.md$/,
 						"",
@@ -784,9 +805,45 @@ export class ContextService extends Effect.Service<ContextService>()(
 					const inspectCheckout = (
 						repositoryPath: string,
 						checkoutPath: string,
+						expectedBranch: string | null = null,
 					) =>
 						Effect.gen(function* (): Generator<any, CheckoutInspection, any> {
 							const materialized = yield* fs.isDirectory(checkoutPath)
+							if (backend.kind === "jj") {
+								const listed = yield* Effect.either(
+									backend.listWorkspaces(repositoryPath),
+								)
+								const workspaces = Either.isRight(listed) ? listed.right : []
+								if (Either.isLeft(listed)) {
+									inspectionWarnings.push(
+										`Unable to inspect jj workspace registrations for ${repositoryPath}`,
+									)
+								}
+								const canonicalCheckoutPath = materialized
+									? yield* fs.realPath(checkoutPath)
+									: resolve(checkoutPath)
+								const registered = workspaces.some(
+									(workspace) => workspace.path === canonicalCheckoutPath,
+								)
+								if (!materialized) {
+									return {
+										materialized: false,
+										registered,
+										checkoutCommit: null,
+										checkoutBranch: null,
+										detached: null,
+										dirty: null,
+									}
+								}
+								return {
+									materialized: true,
+									registered,
+									checkoutCommit: yield* backend.workspaceHead(checkoutPath),
+									checkoutBranch: expectedBranch,
+									detached: expectedBranch === null,
+									dirty: yield* backend.workspaceDirty(checkoutPath),
+								}
+							}
 							const listed = yield* runGit(fs, repositoryPath, [
 								"worktree",
 								"list",
@@ -812,6 +869,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 									checkoutCommit: null,
 									checkoutBranch: null,
 									detached: null,
+									dirty: null,
 								}
 							}
 							const checkoutCommit = yield* runGit(fs, checkoutPath, [
@@ -824,6 +882,10 @@ export class ContextService extends Effect.Service<ContextService>()(
 								"--short",
 								"HEAD",
 							])
+							const checkoutStatus = yield* runGitText(fs, checkoutPath, [
+								"status",
+								"--porcelain",
+							])
 							const resolvedCheckoutPath = yield* fs.realPath(checkoutPath)
 							registered = registered || listedPaths.has(resolvedCheckoutPath)
 							if (checkoutCommit === null) {
@@ -837,6 +899,8 @@ export class ContextService extends Effect.Service<ContextService>()(
 								checkoutCommit,
 								checkoutBranch,
 								detached: checkoutBranch === null,
+								dirty:
+									checkoutStatus === null ? null : checkoutStatus.length > 0,
 							}
 						})
 
@@ -846,14 +910,22 @@ export class ContextService extends Effect.Service<ContextService>()(
 								const repositoryPath =
 									repository?.path ?? join(root, "repos", executionData.repo)
 								const checkoutPath = join(codePath, executionData.repo)
-								const branchCommit = yield* runGit(fs, repositoryPath, [
-									"rev-parse",
-									`${executionData.branch}^{commit}`,
-								])
-								const baseCommit = yield* runGit(fs, repositoryPath, [
-									"rev-parse",
-									`${executionData.base}^{commit}`,
-								])
+								let branchCommit = yield* backend.resolveRevision(
+									repositoryPath,
+									executionData.branch,
+								)
+								const baseCommit = yield* backend.resolveRevision(
+									repositoryPath,
+									executionData.base,
+								)
+								const checkout = yield* inspectCheckout(
+									repositoryPath,
+									checkoutPath,
+									executionData.branch,
+								)
+								if (backend.kind === "jj" && branchCommit === null) {
+									branchCommit = checkout.checkoutCommit
+								}
 								if (branchCommit === null) {
 									inspectionWarnings.push(
 										`Unable to resolve branch '${executionData.branch}' in ${repositoryPath}`,
@@ -872,7 +944,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 									base: executionData.base,
 									branchCommit,
 									baseCommit,
-									...(yield* inspectCheckout(repositoryPath, checkoutPath)),
+									...checkout,
 								}
 							})
 						: null
@@ -883,10 +955,10 @@ export class ContextService extends Effect.Service<ContextService>()(
 						const repositoryPath =
 							repository?.path ?? join(root, "repos", reference.repo)
 						const checkoutPath = join(codePath, reference.repo)
-						const resolvedCommit = yield* runGit(fs, repositoryPath, [
-							"rev-parse",
-							`${reference.ref}^{commit}`,
-						])
+						const resolvedCommit = yield* backend.resolveRevision(
+							repositoryPath,
+							reference.ref,
+						)
 						if (resolvedCommit === null) {
 							inspectionWarnings.push(
 								`Unable to resolve reference '${reference.ref}' in ${repositoryPath}`,
@@ -901,6 +973,17 @@ export class ContextService extends Effect.Service<ContextService>()(
 							...(yield* inspectCheckout(repositoryPath, checkoutPath)),
 						})
 					}
+					const reviewSourceCommit = reviewData
+						? yield* runGit(fs, join(root, "repos", reviewData.repo), [
+								"ls-remote",
+								"origin",
+								reviewData.source.kind === "pull-request"
+									? reviewData.source.fetchRef
+									: reviewData.source.ref
+											.replace(/^refs\/remotes\/origin\//, "")
+											.replace(/^origin\//, ""),
+							])
+						: null
 
 					const checkoutStates = [writable, ...referenceCheckouts].filter(
 						(value): value is NonNullable<typeof value> => value !== null,
@@ -933,6 +1016,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 							root,
 							configPath: join(root, "agency.json"),
 							version: config.version,
+							vcs: config.vcs ?? "git",
 						},
 						target,
 						documents: {
@@ -956,7 +1040,11 @@ export class ContextService extends Effect.Service<ContextService>()(
 							aggregate: aggregateProgress(aggregateStatuses),
 						},
 						authority: {
-							mode: executionData ? "execution" : "orchestration",
+							mode: reviewData
+								? "review"
+								: executionData
+									? "execution"
+									: "orchestration",
 							writable: writable
 								? {
 										repo: writable.repo,
@@ -972,6 +1060,9 @@ export class ContextService extends Effect.Service<ContextService>()(
 								repositoryPath: reference.repositoryPath,
 								checkoutPath: reference.checkoutPath,
 							})),
+							documents: {
+								writable: reviewData && task ? [task.path] : [],
+							},
 						},
 						workspace: options.compact
 							? {
@@ -997,6 +1088,16 @@ export class ContextService extends Effect.Service<ContextService>()(
 									references: referenceCheckouts,
 									warnings: inspectionWarnings,
 								},
+						review: reviewData
+							? {
+									...reviewData,
+									sourceObservation: {
+										available: reviewSourceCommit !== null,
+										commit: reviewSourceCommit?.split(/\s+/)[0] ?? null,
+									},
+									checkout: referenceCheckouts[0] ?? null,
+								}
+							: null,
 						pr: executionData?.pr
 							? normalizePullRequestRecord(executionData.pr)
 							: { url: null, state: "none" },

package/src/services/DoctorService.ts

@@ -126,6 +126,14 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 					}
 
 					const gitAvailable = yield* tool("tool.git", "git", "error", "Git")
+					const jjAvailable = yield* tool(
+						"tool.jj",
+						"jj",
+						config.vcs === "jj" ? "error" : "optional",
+						"Jujutsu",
+					)
+					const versionControlAvailable =
+						gitAvailable && (config.vcs !== "jj" || jjAvailable)
 					yield* tool(
 						"capability.runner.opencode",
 						"opencode",
@@ -282,6 +290,8 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 					}
 
 					const refs = new Map<string, Set<string>>()
+					const reviewSources: { repo: string; task: string; ref: string }[] =
+						[]
 					const declareRef = (repo: string, ref: string) => {
 						const values = refs.get(repo) ?? new Set<string>()
 						values.add(ref)
@@ -293,7 +303,19 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 								declareRef(reference.repo, reference.ref)
 						}
 						for (const task of yield* tasks.list(root)) {
-							if ("repo" in task.data) {
+							if ("review" in task.data) {
+								declareRef(task.data.review.repo, task.data.review.commit)
+								reviewSources.push({
+									repo: task.data.review.repo,
+									task: task.id,
+									ref:
+										task.data.review.source.kind === "pull-request"
+											? task.data.review.source.fetchRef
+											: task.data.review.source.ref
+													.replace(/^refs\/remotes\/origin\//, "")
+													.replace(/^origin\//, ""),
+								})
+							} else if ("repo" in task.data) {
 								declareRef(task.data.repo, task.data.base)
 								for (const reference of task.data.repos ?? [])
 									declareRef(reference.repo, reference.ref)
@@ -307,18 +329,17 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 						}
 					}
 
-					const repositoryList = gitAvailable
+					const repositoryList = versionControlAvailable
 						? yield* repositories.list(root)
 						: []
-					if (!gitAvailable) {
+					if (!versionControlAvailable) {
 						add({
 							id: "repository.inspection",
 							category: "repository",
 							level: "warning",
 							status: "fail",
-							message:
-								"Repository, ref, remote, and worktree checks were skipped because Git is unavailable",
-							remediation: "Install 'git' and rerun 'agency doctor'.",
+							message: `Repository, ref, remote, and workspace checks were skipped because the ${config.vcs ?? "git"} backend is unavailable`,
+							remediation: `Install '${config.vcs === "jj" ? "jj" : "git"}' and rerun 'agency doctor'.`,
 						})
 					}
 					for (const repository of repositoryList) {
@@ -357,6 +378,36 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 						})
 						if (!repositoryValid) continue
 
+						for (const source of reviewSources.filter(
+							(item) => item.repo === repository.alias,
+						)) {
+							const observed = yield* fs.runCommand(
+								[
+									"git",
+									"-C",
+									repository.path,
+									"ls-remote",
+									"origin",
+									source.ref,
+								],
+								{ captureOutput: true },
+							)
+							const available =
+								observed.exitCode === 0 && Boolean(observed.stdout.trim())
+							add({
+								id: `review.${source.task}.source`,
+								category: "repository",
+								level: "warning",
+								status: available ? "pass" : "fail",
+								message: available
+									? `Review source '${source.ref}' is available for task '${source.task}'`
+									: `Review source '${source.ref}' is unavailable for task '${source.task}'; its pin remains usable`,
+								remediation: available
+									? undefined
+									: "Use the pinned checkout or refresh after restoring the source.",
+							})
+						}
+
 						for (const ref of [...(refs.get(repository.alias) ?? [])].sort()) {
 							const local = yield* fs.runCommand(
 								[
@@ -395,7 +446,7 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 						}
 					}
 
-					if (validation.valid && gitAvailable) {
+					if (validation.valid && versionControlAvailable) {
 						const inspected = yield* Effect.either(worktrees.list(root))
 						if (Either.isLeft(inspected)) {
 							add({

package/src/services/GraphMutationService.ts

@@ -360,6 +360,11 @@ export class GraphMutationService extends Effect.Service<GraphMutationService>()
 						"base",
 						"pr",
 					].some((key) => updates[key as keyof TaskUpdates] !== undefined)
+					if ("review" in record.data && executionChange) {
+						return yield* new GraphMutationError({
+							message: `Review task '${id}' does not have writable execution metadata`,
+						})
+					}
 					if ("phases" in record.data && executionChange) {
 						return yield* new GraphMutationError({
 							message: `Task '${id}' has multiple phases; update execution metadata on a phase instead`,

package/src/services/GraphService.ts

@@ -54,7 +54,10 @@ interface RepositoryRecord {
 	readonly target: string | null
 }
 
-type ExecutionData = PhaseData | Extract<TaskData, { readonly repo: string }>
+type ExecutionData =
+	| PhaseData
+	| Extract<TaskData, { readonly repo: string }>
+	| Extract<TaskData, { readonly review: unknown }>
 
 export interface GraphOptions {
 	readonly cwd?: string
@@ -548,10 +551,18 @@ export class GraphService extends Effect.Service<GraphService>()(
 					const executionRepositories = (
 						data: TaskData | PhaseData,
 					): readonly string[] =>
-						"repo" in data
-							? [data.repo, ...(data.repos ?? []).map((item) => item.repo)]
-							: []
+						"review" in data
+							? [data.review.repo]
+							: "repo" in data
+								? [data.repo, ...(data.repos ?? []).map((item) => item.repo)]
+								: []
 					const executionEdges = (id: string, data: TaskData | PhaseData) => {
+						if ("review" in data) {
+							edges.push(
+								edge("references", id, repositoryNodeId(data.review.repo)),
+							)
+							return
+						}
 						if (!("repo" in data)) return
 						edges.push(edge("writes", id, repositoryNodeId(data.repo)))
 						for (const reference of data.repos ?? []) {
@@ -650,8 +661,9 @@ export class GraphService extends Effect.Service<GraphService>()(
 					const executionDetails = (entityPath: string, data: ExecutionData) =>
 						Effect.gen(function* () {
 							const directory = entityPath.replace(/\/(?:TASK|PHASE)\.md$/, "")
-							const checkoutPath = join(directory, "code", data.repo)
-							const repositoryPath = join(root, "repos", data.repo)
+							const repo = "review" in data ? data.review.repo : data.repo
+							const checkoutPath = join(directory, "code", repo)
+							const repositoryPath = join(root, "repos", repo)
 							const materialized = yield* fs.isDirectory(checkoutPath)
 							const result: {
 								workspace?: GraphExecutionWorkspace
@@ -666,58 +678,110 @@ export class GraphService extends Effect.Service<GraphService>()(
 								}
 							}
 							if (include.has("git")) {
-								result.git = {
-									branch: data.branch,
-									base: data.base,
-									branchCommit: yield* run(fs, [
-										"git",
-										"-C",
-										repositoryPath,
-										"rev-parse",
-										`${data.branch}^{commit}`,
-									]),
-									baseCommit: yield* run(fs, [
-										"git",
-										"-C",
-										repositoryPath,
-										"rev-parse",
-										`${data.base}^{commit}`,
-									]),
-									checkoutCommit: materialized
-										? yield* run(fs, [
-												"git",
-												"-C",
-												checkoutPath,
-												"rev-parse",
-												"HEAD",
-											])
-										: null,
-									checkoutBranch: materialized
-										? yield* run(fs, [
-												"git",
-												"-C",
-												checkoutPath,
-												"symbolic-ref",
-												"--quiet",
-												"--short",
-												"HEAD",
-											])
-										: null,
-									dirty: materialized
-										? ((status) =>
-												status === null ? null : status.length > 0)(
-												yield* runText(fs, [
+								result.git =
+									"review" in data
+										? {
+												pinnedCommit: data.review.commit,
+												sourceCommit: ((value) =>
+													value?.split(/\s+/)[0] ?? null)(
+													yield* run(fs, [
+														"git",
+														"-C",
+														repositoryPath,
+														"ls-remote",
+														"origin",
+														data.review.source.kind === "pull-request"
+															? data.review.source.fetchRef
+															: data.review.source.ref
+																	.replace(/^refs\/remotes\/origin\//, "")
+																	.replace(/^origin\//, ""),
+													]),
+												),
+												checkoutCommit: materialized
+													? yield* run(fs, [
+															"git",
+															"-C",
+															checkoutPath,
+															"rev-parse",
+															"HEAD",
+														])
+													: null,
+												checkoutBranch: materialized
+													? yield* run(fs, [
+															"git",
+															"-C",
+															checkoutPath,
+															"symbolic-ref",
+															"--quiet",
+															"--short",
+															"HEAD",
+														])
+													: null,
+												dirty: materialized
+													? ((status) =>
+															status === null ? null : status.length > 0)(
+															yield* runText(fs, [
+																"git",
+																"-C",
+																checkoutPath,
+																"status",
+																"--porcelain",
+															]),
+														)
+													: null,
+											}
+										: {
+												branch: data.branch,
+												base: data.base,
+												branchCommit: yield* run(fs, [
 													"git",
 													"-C",
-													checkoutPath,
-													"status",
-													"--porcelain",
+													repositoryPath,
+													"rev-parse",
+													`${data.branch}^{commit}`,
 												]),
-											)
-										: null,
-								}
+												baseCommit: yield* run(fs, [
+													"git",
+													"-C",
+													repositoryPath,
+													"rev-parse",
+													`${data.base}^{commit}`,
+												]),
+												checkoutCommit: materialized
+													? yield* run(fs, [
+															"git",
+															"-C",
+															checkoutPath,
+															"rev-parse",
+															"HEAD",
+														])
+													: null,
+												checkoutBranch: materialized
+													? yield* run(fs, [
+															"git",
+															"-C",
+															checkoutPath,
+															"symbolic-ref",
+															"--quiet",
+															"--short",
+															"HEAD",
+														])
+													: null,
+												dirty: materialized
+													? ((status) =>
+															status === null ? null : status.length > 0)(
+															yield* runText(fs, [
+																"git",
+																"-C",
+																checkoutPath,
+																"status",
+																"--porcelain",
+															]),
+														)
+													: null,
+											}
 							}
-							if (include.has("pr")) {
+							if (include.has("pr") && !("review" in data)) {
 								if (!data.pr) {
 									result.pr = { url: null, state: "none" }
 								} else {
@@ -879,6 +943,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 						version: GRAPH_VERSION,
 						workbase: {
 							version: config.version,
+							vcs: config.vcs ?? "git",
 							...(include.has("workspace") ? { root } : {}),
 						},
 						filters,