@markjaquith/agency 2.74.0 → 3.0.0

package/src/services/PushService.ts

@@ -19,14 +19,13 @@ interface CommandResult {
 type CommitMetadata = PushCommitMetadata
 
 interface PushResult {
-	readonly vcs: "git" | "jj"
+	readonly vcs: "git"
 	readonly taskId: string
 	readonly phaseId?: string
 	readonly branch: string
 	readonly base: string
 	readonly remote: string
 	readonly tip: string
-	readonly changeId?: string
 }
 
 type PushStage = "context" | "fetch" | "inspect" | "validate" | "publish"
@@ -234,224 +233,6 @@ const publishGit = (
 		return { tip }
 	})
 
-const jjTemplate =
-	'"{\\"commitId\\":" ++ json(commit_id) ++ ",\\"changeId\\":" ++ json(change_id) ++ ",\\"description\\":" ++ json(description) ++ ",\\"empty\\":" ++ json(empty) ++ ",\\"authorName\\":" ++ json(author.name()) ++ ",\\"authorEmail\\":" ++ json(author.email()) ++ ",\\"conflict\\":" ++ json(conflict) ++ ",\\"parents\\":" ++ json(parents.map(|parent| parent.commit_id())) ++ "}\\n"'
-
-const jjExact = (value: string) =>
-	value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')
-
-const jj = (
-	fs: FileSystemService,
-	cwd: string,
-	args: readonly string[],
-	label: string,
-) => requireCommand(fs, ["jj", "--no-pager", ...args], cwd, label)
-
-const jjCommits = (fs: FileSystemService, cwd: string, revision: string) =>
-	jj(
-		fs,
-		cwd,
-		["log", "--no-graph", "-r", revision, "-T", jjTemplate],
-		"Failed to inspect jj changes",
-	).pipe(
-		Effect.map((result) =>
-			result.stdout
-				.split("\n")
-				.filter(Boolean)
-				.map((line) => JSON.parse(line) as CommitMetadata),
-		),
-	)
-
-const jjRevision = (fs: FileSystemService, cwd: string, revision: string) =>
-	jjCommits(fs, cwd, revision).pipe(
-		Effect.map((commits) => {
-			if (commits.length === 0) return null
-			if (commits.length === 1) return commits[0]!
-			throw new PushError({
-				message: `Revision '${revision}' resolves to multiple jj commits`,
-			})
-		}),
-	)
-
-const optionalJjRevision = (
-	fs: FileSystemService,
-	cwd: string,
-	revision: string,
-) =>
-	jjCommits(fs, cwd, revision).pipe(
-		Effect.catchTag("PushError", () => Effect.succeed([])),
-		Effect.map((commits) => {
-			if (commits.length === 0) return null
-			if (commits.length === 1) return commits[0]!
-			throw new PushError({
-				message: `Bookmark '${revision}' is conflicted or resolves to multiple commits`,
-			})
-		}),
-	)
-
-const jjAncestor = (
-	fs: FileSystemService,
-	cwd: string,
-	ancestor: string,
-	descendant: string,
-) =>
-	jjCommits(fs, cwd, `${ancestor} & ::${descendant}`).pipe(
-		Effect.map((commits) => commits.length === 1),
-	)
-
-const validateJjCommits = (
-	commits: readonly CommitMetadata[],
-	base: string,
-) => {
-	if (commits.length === 0) {
-		throw new PushError({
-			message: `No changes to publish after base '${base}'`,
-		})
-	}
-	const issues: string[] = []
-	for (const commit of commits) {
-		const id = commit.changeId!
-		if (commit.conflict) {
-			issues.push(`Change ${id} contains conflicts. Run: jj resolve -r ${id}`)
-		}
-		if (!commit.description.trim()) {
-			issues.push(`Change ${id} has no description. Run: jj describe -r ${id}`)
-		}
-		if (!commit.authorName.trim() || !validEmail(commit.authorEmail.trim())) {
-			issues.push(
-				`Change ${id} has an invalid author. Run: jj metaedit -r ${id} --author 'Name <email>'`,
-			)
-		}
-	}
-	if (issues.length > 0) throw new PushError({ message: issues.join("\n") })
-}
-
-const publishJj = (
-	fs: FileSystemService,
-	checkout: string,
-	remote: string,
-	branch: string,
-	base: string,
-	onProgress?: (stage: PushStage) => void,
-) =>
-	Effect.gen(function* () {
-		onProgress?.("fetch")
-		yield* jj(
-			fs,
-			checkout,
-			["git", "fetch", "--remote", remote],
-			`Failed to fetch remote '${remote}'`,
-		)
-		onProgress?.("inspect")
-		const workingCopy = yield* jjRevision(fs, checkout, "@")
-		if (!workingCopy) {
-			return yield* new PushError({
-				message: "jj working copy commit was not found",
-			})
-		}
-		const canonicalPostCommit =
-			workingCopy.empty &&
-			!workingCopy.description.trim() &&
-			workingCopy.parents.length === 1
-		const tip = canonicalPostCommit
-			? yield* jjRevision(fs, checkout, "@-")
-			: workingCopy
-		if (!tip) {
-			return yield* new PushError({
-				message: "jj publication tip was not found",
-			})
-		}
-
-		const baseBookmark = `${base}@${remote}`
-		const [baseRevision, localBookmark, remoteBookmark] = yield* Effect.all(
-			[
-				optionalJjRevision(
-					fs,
-					checkout,
-					`remote_bookmarks(exact:"${jjExact(base)}", exact:"${jjExact(remote)}")`,
-				),
-				optionalJjRevision(
-					fs,
-					checkout,
-					`bookmarks(exact:"${jjExact(branch)}")`,
-				),
-				optionalJjRevision(
-					fs,
-					checkout,
-					`remote_bookmarks(exact:"${jjExact(branch)}", exact:"${jjExact(remote)}")`,
-				),
-			],
-			{ concurrency: "unbounded" },
-		)
-		if (!baseRevision) {
-			return yield* new PushError({
-				message: `Declared base '${base}' was not found on remote '${remote}'`,
-			})
-		}
-		if (
-			!(yield* jjAncestor(fs, checkout, baseRevision.commitId, tip.commitId))
-		) {
-			return yield* new PushError({
-				message: `Declared base '${base}' (${baseRevision.commitId}) is not an ancestor of jj tip ${tip.changeId} (${tip.commitId}). Rebase the stack with: jj rebase -s 'roots(${baseBookmark}..@)' -d ${baseBookmark}`,
-			})
-		}
-
-		onProgress?.("validate")
-		const outgoing = yield* jjCommits(
-			fs,
-			checkout,
-			`${baseRevision.commitId}..${tip.commitId}`,
-		)
-		yield* Effect.try({
-			try: () => validateJjCommits(outgoing, base),
-			catch: (cause) => cause as PushError,
-		})
-
-		const [localBookmarkIsAncestor, remoteBookmarkIsAncestor] =
-			yield* Effect.all(
-				[
-					localBookmark
-						? jjAncestor(fs, checkout, localBookmark.commitId, tip.commitId)
-						: Effect.succeed(true),
-					remoteBookmark
-						? jjAncestor(fs, checkout, remoteBookmark.commitId, tip.commitId)
-						: Effect.succeed(true),
-				],
-				{ concurrency: "unbounded" },
-			)
-		if (!localBookmarkIsAncestor) {
-			return yield* new PushError({
-				message: `Local bookmark '${branch}' is not an ancestor of jj tip ${tip.changeId}; refusing to move it`,
-			})
-		}
-		if (!remoteBookmarkIsAncestor) {
-			return yield* new PushError({
-				message: `Remote bookmark '${branch}@${remote}' is not an ancestor of jj tip ${tip.changeId}; refusing a non-fast-forward update`,
-			})
-		}
-
-		onProgress?.("publish")
-		yield* jj(
-			fs,
-			checkout,
-			["bookmark", "set", branch, "-r", tip.commitId],
-			`Failed to set declared bookmark '${branch}'`,
-		)
-		yield* jj(
-			fs,
-			checkout,
-			["git", "push", "--remote", remote, "--bookmark", branch],
-			`Failed to push declared bookmark '${branch}'`,
-		)
-		yield* jj(
-			fs,
-			checkout,
-			["bookmark", "track", `${branch}@${remote}`],
-			`Failed to track remote bookmark '${branch}@${remote}'`,
-		)
-		return { tip: tip.commitId, changeId: tip.changeId }
-	})
-
 export class PushService extends Effect.Service<PushService>()("PushService", {
 	sync: () => ({
 		publish: (startPath: string = process.cwd(), options: PushOptions = {}) =>
@@ -534,26 +315,16 @@ export class PushService extends Effect.Service<PushService>()("PushService", {
 				const checkout = context.authority.writable.checkoutPath
 				const { config } = yield* workbase.loadConfig(context.workbase.root)
 				const remote = config.delivery?.remote ?? "origin"
-				const published =
-					context.workbase.vcs === "jj"
-						? yield* publishJj(
-								fs,
-								checkout,
-								remote,
-								execution.branch,
-								execution.base,
-								options.onProgress,
-							)
-						: yield* publishGit(
-								fs,
-								checkout,
-								remote,
-								execution.branch,
-								execution.base,
-								options.onProgress,
-							)
+				const published = yield* publishGit(
+					fs,
+					checkout,
+					remote,
+					execution.branch,
+					execution.base,
+					options.onProgress,
+				)
 				return {
-					vcs: context.workbase.vcs,
+					vcs: "git",
 					taskId,
 					...(phaseId ? { phaseId } : {}),
 					branch: execution.branch,

package/src/services/RepositoryService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { mkdir, realpath, stat } from "node:fs/promises"
+import { mkdir, realpath } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { RepositoryService } from "./RepositoryService"
@@ -110,41 +110,6 @@ describe("RepositoryService", () => {
 		])
 	})
 
-	test("initializes a managed clone with jj for a jj workbase", async () => {
-		if (!Bun.which("jj")) return
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-		const source = join(root, "source")
-		await runGit(["init", "--initial-branch=main", source])
-		await runGit(["-C", source, "config", "user.email", "test@example.com"])
-		await runGit(["-C", source, "config", "user.name", "Test"])
-		await Bun.write(join(source, "README.md"), "example\n")
-		await runGit(["-C", source, "add", "README.md"])
-		await runGit(["-C", source, "commit", "-m", "initial"])
-		await setPortableOrigin(source, "jj-agency")
-
-		const destination = await runTestEffect(
-			RepositoryService.pipe(
-				Effect.flatMap((service) => service.add("agency", source, root)),
-			),
-		)
-		expect((await stat(join(destination, ".jj"))).isDirectory()).toBe(true)
-		expect(await Bun.file(join(destination, ".git")).exists()).toBe(false)
-		expect(
-			await runTestEffect(
-				RepositoryService.pipe(
-					Effect.flatMap((service) => service.show("agency", root)),
-				),
-			),
-		).toMatchObject({
-			kind: "repository",
-			remote: portableRemote("jj-agency"),
-			states: ["declared", "materialized"],
-		})
-	})
-
 	test("links an existing repository", async () => {
 		const target = join(root, "linked-repository")
 		await mkdir(target, { recursive: true })
@@ -380,31 +345,6 @@ status: working
 		).not.toContain(linkedWorktree)
 	})
 
-	test("refuses to materialize linked aliases in jj workbases", async () => {
-		if (!Bun.which("jj")) return
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-		const target = join(root, "linked-jj-repository")
-		await mkdir(target, { recursive: true })
-		await runGit(["init", "--initial-branch=main", target])
-		await setPortableOrigin(target, "linked-jj")
-		await runTestEffect(
-			RepositoryService.pipe(
-				Effect.flatMap((service) => service.link("linked", target, root)),
-			),
-		)
-
-		await expect(
-			runTestEffect(
-				RepositoryService.pipe(
-					Effect.flatMap((service) => service.materialize("linked", root)),
-				),
-			),
-		).rejects.toThrow("only supported for Git workbases")
-	})
-
 	test("rejects invalid and duplicate aliases", async () => {
 		const source = join(root, "source.git")
 		await runGit(["init", "--bare", "--initial-branch=main", source])

package/src/services/RepositoryService.ts

@@ -471,15 +471,9 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						})
 					}
 					const inspection = yield* backend.inspectRepository(resolvedTarget)
-					if (!inspection && backend.kind === "git") {
+					if (!inspection) {
 						return yield* new RepositoryError({
-							message: `Path is not a ${backend.kind} repository: ${resolvedTarget}`,
-						})
-					}
-					yield* backend.initializeRepository(resolvedTarget)
-					if (!(yield* backend.inspectRepository(resolvedTarget))) {
-						return yield* new RepositoryError({
-							message: `Path is not a ${backend.kind} repository: ${resolvedTarget}`,
+							message: `Path is not a Git repository: ${resolvedTarget}`,
 						})
 					}
 					const declaredRemote =
@@ -551,11 +545,6 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 
 					const state = yield* configState(startPath)
 					const backend = yield* versionControl.forWorkbase(state.root)
-					if (backend.kind !== "git") {
-						return yield* new RepositoryError({
-							message: `Repository alias materialization is only supported for Git workbases`,
-						})
-					}
 
 					const source = yield* fs.realPath(repository.path)
 					const registered = yield* backend.listWorkspaces(repository.path)

package/src/services/ReviewService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { mkdir, rm } from "node:fs/promises"
+import { mkdir } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { TaskService } from "./TaskService"
@@ -13,7 +13,6 @@ import { PhaseService } from "./PhaseService"
 import { ArchiveService } from "./ArchiveService"
 import { ClaimService } from "./ClaimService"
 import { SyncService } from "./SyncService"
-import { DoctorService } from "./DoctorService"
 import { task as taskCommand } from "../commands/task"
 
 const git = async (args: string[], cwd?: string) => {
@@ -27,16 +26,6 @@ const git = async (args: string[], cwd?: string) => {
 		throw new Error(await new Response(child.stderr).text())
 }
 
-const jj = async (args: string[]) => {
-	const child = Bun.spawn(["jj", ...args], {
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	await child.exited
-	if (child.exitCode !== 0)
-		throw new Error(await new Response(child.stderr).text())
-}
-
 describe("ReviewService", () => {
 	let root: string
 	let source: string
@@ -162,78 +151,6 @@ describe("ReviewService", () => {
 		expect(new TextDecoder().decode(oldPins.stdout).trim()).toBe("")
 	})
 
-	test("imports jj reviews for creation, diagnostics, materialization, and refresh", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		await git(["switch", "-c", "jj-review"], source)
-		await Bun.write(join(source, "README.md"), "jj review one\n")
-		await git(["commit", "-am", "jj review one"], source)
-		await jj(["git", "clone", "--no-colocate", source, repository])
-		expect(await Bun.file(join(repository, ".git")).exists()).toBe(false)
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-
-		await runTestEffect(
-			taskCommand({
-				subcommand: "create",
-				args: ["jj-review"],
-				review: "agency",
-				ref: "jj-review",
-				cwd: root,
-				silent: true,
-			}),
-		)
-		const created = await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) => service.show("jj-review", root)),
-			),
-		)
-		const original = "review" in created.data ? created.data.review.commit : ""
-
-		const context = await runTestEffect(
-			ContextService.pipe(
-				Effect.flatMap((service) =>
-					service.get({ target: "jj-review", cwd: root }),
-				),
-			),
-		)
-		expect(context.workspace!.warnings).toEqual([])
-		expect(context.review?.checkout?.resolvedCommit).toBe(original)
-
-		const doctor = await runTestEffect(
-			DoctorService.pipe(Effect.flatMap((service) => service.inspect(root))),
-		)
-		expect(
-			doctor.checks.find((check) => check.id === `ref.agency.${original}`),
-		).toMatchObject({ status: "pass" })
-
-		const workspace = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-review", undefined, root),
-				),
-			),
-		)
-		expect(
-			await Bun.file(join(workspace.reviewPath!, "README.md")).text(),
-		).toBe("jj review one\n")
-
-		await Bun.write(join(source, "README.md"), "jj review two\n")
-		await git(["commit", "-am", "jj review two"], source)
-		const refreshed = await runTestEffect(
-			ReviewService.pipe(
-				Effect.flatMap((service) => service.refresh("jj-review", root)),
-			),
-		)
-		expect(refreshed.changed).toBe(true)
-		expect(
-			await Bun.file(join(workspace.reviewPath!, "README.md")).text(),
-		).toBe("jj review two\n")
-	})
-
 	test("rejects delivery and phase operations even when forced", async () => {
 		await createReview()
 		await expect(

package/src/services/ReviewService.ts

@@ -1,4 +1,4 @@
-import { Data, Effect, Either, Layer } from "effect"
+import { Data, Effect, Layer } from "effect"
 import { randomUUID } from "node:crypto"
 import { lstat, mkdir } from "node:fs/promises"
 import { dirname } from "node:path"
@@ -13,9 +13,7 @@ import {
 } from "./WorktreeService"
 import {
 	GitVersionControlService,
-	JjVersionControlService,
 	VersionControlService,
-	type VersionControlBackend,
 } from "./VersionControlService"
 import { withWorktreeLocks } from "./WorktreeLock"
 import {
@@ -70,7 +68,6 @@ const WorktreeLayer = Layer.mergeAll(
 	FileSystemService.Default,
 	WorkbaseService.Default,
 	GitVersionControlService.Default,
-	JjVersionControlService.Default,
 	VersionControlService.Default,
 	TaskService.Default,
 	PhaseService.Default,
@@ -91,22 +88,6 @@ const restoreSnapshots = async (
 			continue
 		} catch {}
 		await mkdir(dirname(snapshot.path), { recursive: true })
-		if (snapshot.vcs === "jj") {
-			await runGit([
-				"jj",
-				"-R",
-				snapshot.repositoryPath,
-				"workspace",
-				"add",
-				"--name",
-				snapshot.workspaceName!,
-				"-r",
-				snapshot.head,
-				snapshot.path,
-			])
-			await runGit(["jj", "-R", snapshot.path, "edit", snapshot.head])
-			continue
-		}
 		await runGit(
 			snapshot.branch
 				? [
@@ -172,14 +153,9 @@ const normalizeBranch = (input: string) =>
 		return `refs/heads/${name}`
 	})
 
-const fetchCommit = (
-	repoPath: string,
-	sourceRef: string,
-	backend: VersionControlBackend,
-) =>
+const fetchCommit = (repoPath: string, sourceRef: string) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
-		const environment = yield* backend.gitEnvironment(repoPath)
 		const temporaryRef = `refs/agency/review-fetch/${process.pid}-${randomUUID()}`
 		const fetched = yield* fs.runCommand(
 			[
@@ -191,12 +167,12 @@ const fetchCommit = (
 				"origin",
 				`+${sourceRef}:${temporaryRef}`,
 			],
-			{ captureOutput: true, env: environment },
+			{ captureOutput: true },
 		)
 		if (fetched.exitCode !== 0) {
 			const cleanup = yield* fs.runCommand(
 				["git", "-C", repoPath, "update-ref", "-d", temporaryRef],
-				{ captureOutput: true, env: environment },
+				{ captureOutput: true },
 			)
 			return yield* new ReviewError({
 				message: `Review source '${sourceRef}' could not be fetched: ${fetched.stderr.trim()}${cleanup.exitCode === 0 ? "" : `; temporary ref cleanup failed: ${cleanup.stderr.trim()}`}`,
@@ -211,34 +187,27 @@ const fetchCommit = (
 				"--verify",
 				`${temporaryRef}^{commit}`,
 			],
-			{ captureOutput: true, env: environment },
+			{ captureOutput: true },
 		)
 		const commit = resolved.stdout.trim()
 		if (resolved.exitCode !== 0 || !/^[a-f0-9]{40}$/.test(commit)) {
 			yield* fs.runCommand(
 				["git", "-C", repoPath, "update-ref", "-d", temporaryRef],
-				{ captureOutput: true, env: environment },
+				{ captureOutput: true },
 			)
 			return yield* new ReviewError({
 				message: `Review source '${sourceRef}' did not resolve to a commit`,
 			})
 		}
-		const imported = yield* Effect.either(backend.importGitRefs(repoPath))
 		const cleanup = yield* fs.runCommand(
 			["git", "-C", repoPath, "update-ref", "-d", temporaryRef],
-			{ captureOutput: true, env: environment },
+			{ captureOutput: true },
 		)
 		if (cleanup.exitCode !== 0) {
 			return yield* new ReviewError({
 				message: `Failed to remove temporary review fetch ref: ${cleanup.stderr.trim()}`,
 			})
 		}
-		if (Either.isLeft(imported)) {
-			return yield* new ReviewError({
-				message: `Review source '${sourceRef}' was fetched but could not be imported into ${backend.kind}`,
-				cause: imported.left,
-			})
-		}
 		return commit
 	})
 
@@ -253,8 +222,6 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 			) =>
 				Effect.gen(function* () {
 					const repositories = yield* RepositoryService
-					const versionControl = yield* VersionControlService
-					const backend = yield* versionControl.forWorkbase(startPath)
 					const repository = yield* repositories.show(repo, startPath)
 					if (!repository.remote || repository.states.includes("missing")) {
 						return yield* new ReviewError({
@@ -303,7 +270,7 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 							message: "Exactly one review source is required",
 						})
 					}
-					const commit = yield* fetchCommit(repository.path, sourceRef, backend)
+					const commit = yield* fetchCommit(repository.path, sourceRef)
 					return {
 						repo,
 						source,
@@ -371,8 +338,6 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 									message: `Repository alias '${task.data.review.repo}' must be materialized with an origin remote`,
 								})
 							}
-							const versionControl = yield* VersionControlService
-							const backend = yield* versionControl.forWorkbase(root)
 							const latest = {
 								...task.data.review,
 								commit: yield* fetchCommit(
@@ -380,7 +345,6 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 									task.data.review.source.kind === "pull-request"
 										? task.data.review.source.fetchRef
 										: task.data.review.source.ref,
-									backend,
 								),
 								refreshedAt: new Date().toISOString(),
 							} satisfies ReviewRecord
@@ -389,9 +353,7 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 								{ ...task.data, review: latest },
 								parsed.body,
 							)
-							const gitEnvironment = yield* backend.gitEnvironment(
-								repository.path,
-							)
+							const gitEnvironment: Record<string, string> = {}
 							const hadCheckout = inspection.checkouts.some(
 								(checkout) => checkout.exists || checkout.registered,
 							)
@@ -405,7 +367,6 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 											worktrees.remove(taskId, undefined, root, {
 												snapshots,
 												lockHeld: true,
-												persistResume: false,
 											}),
 										).then(() => undefined),
 									rollback: () => restoreSnapshots(snapshots),