@markjaquith/agency 2.56.0 → 2.57.0

package/src/services/PushService.test.ts

@@ -74,21 +74,16 @@ describe("PushService", () => {
 		await requireCommand(["git", "commit", "-m", "Initial commit"], seed)
 		await requireCommand(["git", "remote", "add", "origin", remote], seed)
 		await requireCommand(["git", "push", "-u", "origin", "main"], seed)
-		await requireCommand(["git", "clone", "--bare", remote, repository])
 		if (vcs === "jj") {
-			await requireCommand(["jj", "git", "init", "--colocate", repository])
-			await requireCommand(
-				["jj", "git", "remote", "add", "origin", remote],
-				repository,
-			)
-			await requireCommand(
-				["jj", "git", "fetch", "--remote", "origin"],
-				repository,
-			)
-			await requireCommand(
-				["jj", "bookmark", "create", "main", "-r", "main@origin"],
+			await requireCommand([
+				"jj",
+				"git",
+				"clone",
+				"--no-colocate",
+				remote,
 				repository,
-			)
+			])
+			expect(await Bun.file(join(repository, ".git")).exists()).toBe(false)
 			await requireCommand(
 				["jj", "config", "set", "--repo", "user.name", "Agency Test"],
 				repository,
@@ -97,6 +92,8 @@ describe("PushService", () => {
 				["jj", "config", "set", "--repo", "user.email", "agency@example.com"],
 				repository,
 			)
+		} else {
+			await requireCommand(["git", "clone", "--bare", remote, repository])
 		}
 
 		await runTestEffect(

package/src/services/RepositoryService.test.ts

@@ -119,13 +119,18 @@ describe("RepositoryService", () => {
 			),
 		)
 		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" })
+		).toMatchObject({
+			kind: "repository",
+			remote: portableRemote("jj-agency"),
+			states: ["declared", "materialized"],
+		})
 	})
 
 	test("links an existing repository", async () => {

package/src/services/RepositoryService.ts

@@ -171,9 +171,12 @@ const inspectRemote = (path: string) =>
 		return result.exitCode === 0 ? result.stdout.trim() : null
 	})
 
-const portableRemote = (path: string) =>
+const portableRemote = (path: string, backend?: VersionControlBackend) =>
 	Effect.gen(function* () {
-		const remote = yield* inspectRemote(path)
+		const backendRemote = backend
+			? yield* backend.remoteUrl(path, "origin")
+			: null
+		const remote = backendRemote ?? (yield* inspectRemote(path))
 		if (!remote) {
 			return yield* new RepositoryError({
 				message: `Repository '${path}' has no portable origin remote`,
@@ -219,7 +222,7 @@ const removalBlockers = (
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
 		const graph = yield* GraphService
-		const report = yield* graph.get({ cwd: startPath })
+		const report = yield* graph.get({ cwd: startPath, backend })
 		const repositoryId = `repository:${repository.alias}`
 		const references = report.edges
 			.filter(
@@ -373,50 +376,30 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						: resolve(startPath, remote)
 					const declaredRemote = inputIsPortable
 						? yield* validateRemote(remote)
-						: yield* portableRemote(cloneSource)
+						: yield* portableRemote(cloneSource, backend)
 					const staging = join(
 						state.root,
 						"repos",
 						`.agency-clone-${validAlias}-${process.pid}-${Date.now()}`,
 					)
 					yield* fs.createDirectory(join(state.root, "repos"))
-					const cloned = yield* fs.runCommand(
-						[
-							"git",
-							"clone",
-							...(backend.kind === "git" ? ["--bare"] : []),
-							"--",
-							cloneSource,
-							staging,
-						],
-						{ captureOutput: true },
+					yield* backend.cloneRepository(cloneSource, staging).pipe(
+						Effect.catchAll((cause) =>
+							fs.deleteDirectory(staging).pipe(
+								Effect.ignore,
+								Effect.zipRight(
+									Effect.fail(
+										new RepositoryError({
+											message: `Failed to clone repository '${remote}': ${cause instanceof Error ? cause.message : String(cause)}`,
+											cause,
+										}),
+									),
+								),
+							),
+						),
 					)
-					if (cloned.exitCode !== 0) {
-						yield* fs.deleteDirectory(staging).pipe(Effect.ignore)
-						return yield* new RepositoryError({
-							message: `Failed to clone repository '${remote}': ${cloned.stderr.trim()}`,
-						})
-					}
-					yield* backend.initializeRepository(staging)
 					if (declaredRemote !== remote) {
-						const setRemote = yield* fs.runCommand(
-							[
-								"git",
-								"-C",
-								staging,
-								"remote",
-								"set-url",
-								"origin",
-								declaredRemote,
-							],
-							{ captureOutput: true },
-						)
-						if (setRemote.exitCode !== 0) {
-							yield* fs.deleteDirectory(staging).pipe(Effect.ignore)
-							return yield* new RepositoryError({
-								message: `Failed to record portable remote for repository '${validAlias}': ${setRemote.stderr.trim()}`,
-							})
-						}
+						yield* backend.setRemoteUrl(staging, "origin", declaredRemote)
 					}
 					const config = withDeclarations(state.config, {
 						...(state.config.repositories ?? {}),
@@ -465,19 +448,21 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 							message: `Repository path does not exist: ${resolvedTarget}`,
 						})
 					}
-					const git = yield* fs.runCommand(
-						["git", "-C", resolvedTarget, "rev-parse", "--git-dir"],
-						{ captureOutput: true },
-					)
-					if (git.exitCode !== 0) {
+					const inspection = yield* backend.inspectRepository(resolvedTarget)
+					if (!inspection && backend.kind === "git") {
 						return yield* new RepositoryError({
-							message: `Path is not a Git repository: ${resolvedTarget}`,
+							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}`,
+						})
+					}
 					const declaredRemote =
 						state.config.repositories?.[validAlias]?.remote ??
-						(yield* portableRemote(resolvedTarget))
+						(yield* portableRemote(resolvedTarget, backend))
 					const staging = join(
 						state.root,
 						"repos",
@@ -522,6 +507,8 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 					const { root, config } = yield* WorkbaseService.pipe(
 						Effect.flatMap((service) => service.loadConfig(startPath)),
 					)
+					const versionControl = yield* VersionControlService
+					const backend = yield* versionControl.forWorkbase(root)
 					const reposPath = join(root, "repos")
 					const entries = (yield* fs.isDirectory(reposPath))
 						? (yield* fs.readDirectory(reposPath)).filter(
@@ -569,20 +556,12 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						const target = entry.isSymlink
 							? yield* fs.readSymlinkTarget(path)
 							: null
-						const git = yield* fs.runCommand(
-							["git", "-C", path, "rev-parse", "--git-dir"],
-							{ captureOutput: true },
-						)
-						const bare = yield* fs.runCommand(
-							["git", "-C", path, "rev-parse", "--is-bare-repository"],
-							{ captureOutput: true },
-						)
-						const remote =
-							git.exitCode === 0 ? yield* inspectRemote(path) : null
+						const inspection = yield* backend.inspectRepository(path)
+						const remote = inspection?.remote ?? null
 						const states: RepositoryState[] = []
 						if (declaredRemote) states.push("declared")
 						states.push(entry.isSymlink ? "linked" : "materialized")
-						if (git.exitCode !== 0) states.push("invalid")
+						if (!inspection) states.push("invalid")
 						if (declaredRemote && remote !== declaredRemote)
 							states.push("remote-drifted")
 						repositories.push({
@@ -590,9 +569,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 							path,
 							kind: entry.isSymlink
 								? "symlink"
-								: bare.stdout.trim() === "true"
-									? "bare"
-									: "repository",
+								: (inspection?.kind ?? "repository"),
 							remote,
 							declaredRemote,
 							target,
@@ -760,10 +737,12 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 			) =>
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
+					const versionControl = yield* VersionControlService
 					const repository = yield* find(alias, startPath)
 					if (remote === undefined) return repository
 					const portable = yield* validateRemote(remote)
 					const state = yield* configState(startPath)
+					const backend = yield* versionControl.forWorkbase(state.root)
 					const config = withDeclarations(state.config, {
 						...(state.config.repositories ?? {}),
 						[repository.alias]: { remote: portable },
@@ -777,30 +756,12 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						const previous = repository.remote
 						const update = (value: string | null) =>
 							Effect.runPromise(
-								fs.runCommand(
-									value === null
-										? [
-												"git",
-												"-C",
-												repository.path,
-												"remote",
-												"remove",
-												"origin",
-											]
-										: [
-												"git",
-												"-C",
-												repository.path,
-												"remote",
-												previous === null ? "add" : "set-url",
-												"origin",
-												value,
-											],
-									{ captureOutput: true },
-								),
-							).then((result) => {
-								if (result.exitCode !== 0) throw new Error(result.stderr.trim())
-							})
+								backend
+									.setRemoteUrl(repository.path, "origin", value)
+									.pipe(
+										Effect.provideService(FileSystemService, fs),
+									) as Effect.Effect<void, unknown, never>,
+							)
 						steps.push({
 							label: `update origin for repos/${repository.alias}`,
 							preflight: async () => {
@@ -810,21 +771,11 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 										`Repository alias '${repository.alias}' changed to a linked checkout; retry the remote update`,
 									)
 								}
-								const current = await Effect.runPromise(
-									fs.runCommand(
-										[
-											"git",
-											"-C",
-											repository.path,
-											"remote",
-											"get-url",
-											"origin",
-										],
-										{ captureOutput: true },
-									),
+								const currentRemote = await Effect.runPromise(
+									backend
+										.remoteUrl(repository.path, "origin")
+										.pipe(Effect.provideService(FileSystemService, fs)),
 								)
-								const currentRemote =
-									current.exitCode === 0 ? current.stdout.trim() : null
 								if (currentRemote !== previous) {
 									throw new Error(
 										`Origin for repository '${repository.alias}' changed; retry the remote update`,
@@ -847,7 +798,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 					if (repository.states.includes("missing"))
 						issues.push("Local materialization is missing")
 					if (repository.states.includes("invalid"))
-						issues.push("Path is not a Git repository")
+						issues.push("Path is not a valid repository")
 					if (!repository.declaredRemote)
 						issues.push("Portable remote is not declared")
 					if (repository.states.includes("remote-drifted"))
@@ -877,7 +828,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 							unresolved.push({
 								alias: repository.alias,
 								state: "invalid",
-								message: `Local path for '${repository.alias}' is not a valid Git repository`,
+								message: `Local path for '${repository.alias}' is not a valid repository`,
 								action: `Repair the path or run 'agency repo remove ${repository.alias}' before setup`,
 							})
 							continue
@@ -936,25 +887,17 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 								`.agency-setup-${action.alias}-${process.pid}-${Date.now()}`,
 							)
 							yield* fs.createDirectory(join(state.root, "repos"))
-							const cloned = yield* fs.runCommand(
-								[
-									"git",
-									"clone",
-									...(backend.kind === "git" ? ["--bare"] : []),
-									"--",
-									action.remote,
-									from,
-								],
-								{ captureOutput: true },
-							)
-							if (cloned.exitCode !== 0) {
+							const cloned = yield* backend
+								.cloneRepository(action.remote, from)
+								.pipe(Effect.either)
+							if (Either.isLeft(cloned)) {
 								for (const item of staging)
 									yield* fs.deleteDirectory(item.from).pipe(Effect.ignore)
 								return yield* new RepositoryError({
-									message: `Failed to materialize repository '${action.alias}': ${cloned.stderr.trim()}`,
+									message: `Failed to materialize repository '${action.alias}': ${cloned.left instanceof Error ? cloned.left.message : String(cloned.left)}`,
+									cause: cloned.left,
 								})
 							}
-							yield* backend.initializeRepository(from)
 							staging.push({
 								alias: action.alias,
 								from,

package/src/services/ReviewService.test.ts

@@ -166,11 +166,11 @@ describe("ReviewService", () => {
 		if (!Bun.which("jj")) return
 		const repository = join(root, "repos/agency")
 		await rm(repository, { recursive: true, force: true })
-		await git(["clone", source, repository])
 		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", "init", "--colocate", repository])
+		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" }),

package/src/services/ReviewService.ts

@@ -45,8 +45,15 @@ const githubRepository = (remote: string) => {
 const pinRef = (taskId: string) =>
 	`refs/agency/reviews/${Buffer.from(taskId).toString("hex")}`
 
-const runGit = async (args: readonly string[]) => {
-	const child = Bun.spawn([...args], { stdout: "pipe", stderr: "pipe" })
+const runGit = async (
+	args: readonly string[],
+	environment: Record<string, string> = {},
+) => {
+	const child = Bun.spawn([...args], {
+		stdout: "pipe",
+		stderr: "pipe",
+		env: { ...process.env, ...environment },
+	})
 	const [exitCode, stdout, stderr] = await Promise.all([
 		child.exited,
 		new Response(child.stdout).text(),
@@ -121,7 +128,7 @@ const restoreSnapshots = async (
 	}
 }
 
-const normalizeBranch = (input: string, repositoryPath: string) =>
+const normalizeBranch = (input: string) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
 		if (
@@ -150,7 +157,7 @@ const normalizeBranch = (input: string, repositoryPath: string) =>
 			})
 		}
 		const checked = yield* fs.runCommand(
-			["git", "-C", repositoryPath, "check-ref-format", "--branch", name],
+			["git", "check-ref-format", "--branch", name],
 			{ captureOutput: true },
 		)
 		if (checked.exitCode !== 0) {
@@ -168,6 +175,7 @@ const fetchCommit = (
 ) =>
 	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(
 			[
@@ -179,12 +187,12 @@ const fetchCommit = (
 				"origin",
 				`+${sourceRef}:${temporaryRef}`,
 			],
-			{ captureOutput: true },
+			{ captureOutput: true, env: environment },
 		)
 		if (fetched.exitCode !== 0) {
 			const cleanup = yield* fs.runCommand(
 				["git", "-C", repoPath, "update-ref", "-d", temporaryRef],
-				{ captureOutput: true },
+				{ captureOutput: true, env: environment },
 			)
 			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()}`}`,
@@ -199,13 +207,13 @@ const fetchCommit = (
 				"--verify",
 				`${temporaryRef}^{commit}`,
 			],
-			{ captureOutput: true },
+			{ captureOutput: true, env: environment },
 		)
 		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 },
+				{ captureOutput: true, env: environment },
 			)
 			return yield* new ReviewError({
 				message: `Review source '${sourceRef}' did not resolve to a commit`,
@@ -214,7 +222,7 @@ const fetchCommit = (
 		const imported = yield* Effect.either(backend.importGitRefs(repoPath))
 		const cleanup = yield* fs.runCommand(
 			["git", "-C", repoPath, "update-ref", "-d", temporaryRef],
-			{ captureOutput: true },
+			{ captureOutput: true, env: environment },
 		)
 		if (cleanup.exitCode !== 0) {
 			return yield* new ReviewError({
@@ -284,7 +292,7 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 							fetchRef: sourceRef,
 						}
 					} else if (input.ref) {
-						sourceRef = yield* normalizeBranch(input.ref, repository.path)
+						sourceRef = yield* normalizeBranch(input.ref)
 						source = { kind: "branch", ref: sourceRef }
 					} else {
 						return yield* new ReviewError({
@@ -366,6 +374,11 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 								task.data.review.repo,
 								root,
 							)
+							const versionControl = yield* VersionControlService
+							const backend = yield* versionControl.forWorkbase(root)
+							const gitEnvironment = yield* backend.gitEnvironment(
+								repository.path,
+							)
 							const hadCheckout = inspection.checkouts.some(
 								(checkout) => checkout.exists || checkout.registered,
 							)
@@ -391,25 +404,31 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 							steps.push({
 								label: `advance review pin for ${taskId}`,
 								apply: () =>
-									runGit([
-										"git",
-										"-C",
-										repository.path,
-										"update-ref",
-										pinRef(taskId),
-										latest.commit,
-										previousReview.commit,
-									]).then(() => undefined),
+									runGit(
+										[
+											"git",
+											"-C",
+											repository.path,
+											"update-ref",
+											pinRef(taskId),
+											latest.commit,
+											previousReview.commit,
+										],
+										gitEnvironment,
+									).then(() => undefined),
 								rollback: () =>
-									runGit([
-										"git",
-										"-C",
-										repository.path,
-										"update-ref",
-										pinRef(taskId),
-										previousReview.commit,
-										latest.commit,
-									]).then(() => undefined),
+									runGit(
+										[
+											"git",
+											"-C",
+											repository.path,
+											"update-ref",
+											pinRef(taskId),
+											previousReview.commit,
+											latest.commit,
+										],
+										gitEnvironment,
+									).then(() => undefined),
 								manualRecovery: `Reset ${pinRef(taskId)} to ${previousReview.commit}`,
 							})
 							if (hadCheckout) {