@markjaquith/agency 2.56.1 → 2.58.0

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) {

package/src/services/SyncService.test.ts

@@ -59,6 +59,7 @@ describe("SyncService", () => {
 		await Bun.write(
 			gh,
 			`#!/bin/sh
+if [ -n "$GH_CAPTURE" ]; then printf '%s\n' "$@" "GIT_DIR=$GIT_DIR" > "$GH_CAPTURE"; fi
 case "$*" in
 *mergeable*) ;;
 *) echo "mergeable field was not requested" >&2; exit 2 ;;
@@ -82,6 +83,7 @@ JSON
 	afterEach(async () => {
 		if (originalPath === undefined) delete process.env.PATH
 		else process.env.PATH = originalPath
+		delete process.env.GH_CAPTURE
 		await cleanupTempDir(root)
 	})
 
@@ -125,8 +127,14 @@ pr: null
 		if (!Bun.which("jj")) return
 		const repository = join(root, "repos/agency")
 		await rm(repository, { recursive: true, force: true })
-		await git(["clone", join(root, "source"), repository])
-		await jj(["git", "init", "--colocate", repository])
+		await jj([
+			"git",
+			"clone",
+			"--no-colocate",
+			join(root, "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" }),
@@ -147,6 +155,8 @@ pr: null
 				),
 			),
 		)
+		const capture = join(root, "gh-capture")
+		process.env.GH_CAPTURE = capture
 
 		const planned = await runTestEffect(
 			SyncService.pipe(
@@ -160,6 +170,10 @@ pr: null
 				status: "planned",
 			}),
 		)
+		const invocation = await Bun.file(capture).text()
+		expect(invocation).toContain("--repo\n")
+		expect(invocation).toContain("GIT_DIR=")
+		expect(invocation).toContain(".jj")
 
 		const applied = await runTestEffect(
 			SyncService.pipe(
@@ -174,6 +188,7 @@ pr: null
 			branch: "task/jj-sync",
 			dirty: false,
 		})
+		delete process.env.GH_CAPTURE
 	})
 
 	test("observes drift without mutation and applies only safe transitions", async () => {

package/src/services/SyncService.ts

@@ -339,20 +339,34 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 										env: resolved.environment,
 									})
 								} else if (!config.delivery && existing) {
-									result = yield* runExternal([
-										"gh",
-										"pr",
-										"view",
-										existing.url,
-										"--json",
-										"number,state,title,isDraft,headRefName,baseRefName,url,mergedAt,mergeCommit,mergeable",
-									])
+									const environment = yield* Effect.either(
+										backend.gitEnvironment(repositoryPath),
+									)
+									result = yield* runExternal(
+										[
+											"gh",
+											"pr",
+											"view",
+											existing.url,
+											"--json",
+											"number,state,title,isDraft,headRefName,baseRefName,url,mergedAt,mergeCommit,mergeable",
+										],
+										{
+											cwd: repositoryPath,
+											env: Either.isRight(environment) ? environment.right : {},
+										},
+									)
 								} else if (!config.delivery) {
+									const environment = yield* Effect.either(
+										backend.gitEnvironment(repositoryPath),
+									)
 									result = yield* runExternal(
 										[
 											"gh",
 											"pr",
 											"list",
+											"--repo",
+											remoteRepository,
 											"--head",
 											data.branch,
 											"--state",
@@ -360,7 +374,10 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 											"--json",
 											"number,state,title,isDraft,headRefName,baseRefName,url,mergedAt,mergeCommit,mergeable",
 										],
-										{ cwd: repositoryPath },
+										{
+											cwd: repositoryPath,
+											env: Either.isRight(environment) ? environment.right : {},
+										},
 									)
 								}
 								return [
@@ -531,14 +548,18 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						let resolvedCommit: string | null = null
 						if ("ref" in checkout) {
 							if (!isCommitId(checkout.ref)) {
-								const remoteRef = yield* runExternal([
-									"git",
-									"-C",
+								const remote = yield* backend.remoteUrl(
 									repositoryPath,
-									"ls-remote",
 									"origin",
-									originRef(checkout.ref),
-								])
+								)
+								const remoteRef = remote
+									? yield* runExternal([
+											"git",
+											"ls-remote",
+											remote,
+											originRef(checkout.ref),
+										])
+									: { exitCode: -1, stdout: "", stderr: "origin unavailable" }
 								resolvedCommit =
 									remoteRef.stdout.match(/^([0-9a-f]{40,64})\s/m)?.[1] ?? null
 								if (!resolvedCommit) {
@@ -998,12 +1019,14 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						})
 					}
 					const repositoryPath = join(root, "repos", data.review.repo)
+					const reviewRemote = yield* backend.remoteUrl(
+						repositoryPath,
+						"origin",
+					)
 					const source = yield* runExternal([
 						"git",
-						"-C",
-						repositoryPath,
 						"ls-remote",
-						"origin",
+						reviewRemote ?? "origin",
 						data.review.source.kind === "pull-request"
 							? data.review.source.fetchRef
 							: originRef(data.review.source.ref),

package/src/services/TaskService.ts

@@ -3,6 +3,7 @@ import { Data, Effect, Either } from "effect"
 import { join } from "node:path"
 import { FileSystemService } from "./FileSystemService"
 import { WorkbaseService } from "./WorkbaseService"
+import { VersionControlService } from "./VersionControlService"
 import { EpicService, type EpicRecord } from "./EpicService"
 import {
 	EntityId,
@@ -88,11 +89,16 @@ const reviewPinStep = (
 	root: string,
 	taskId: string,
 	review: ReviewRecord,
+	environment: Record<string, string>,
 ): TransactionStep => {
 	const repositoryPath = join(root, "repos", review.repo)
 	const ref = reviewPinRef(taskId)
 	const run = async (args: readonly string[]) => {
-		const child = Bun.spawn([...args], { stdout: "pipe", stderr: "pipe" })
+		const child = Bun.spawn([...args], {
+			stdout: "pipe",
+			stderr: "pipe",
+			env: { ...process.env, ...environment },
+		})
 		const [exitCode, stderr] = await Promise.all([
 			child.exited,
 			new Response(child.stderr).text(),
@@ -132,6 +138,7 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 				const fs = yield* FileSystemService
 				const workbase = yield* WorkbaseService
 				const epics = yield* EpicService
+				const versionControl = yield* VersionControlService
 				const root = yield* workbase.discover(startPath)
 				const id = yield* decodeId(input.id)
 				const directory = join(root, "tasks", id)
@@ -257,13 +264,22 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 					const updated = formatMarkdownDocument(epicData, parsed.body)
 					writes.push({ path: parentEpic.path, content: updated })
 				}
+				let reviewEnvironment: Record<string, string> = {}
+				if (input.review) {
+					const backend = yield* versionControl.forWorkbase(root)
+					reviewEnvironment = yield* backend.gitEnvironment(
+						join(root, "repos", input.review.repo),
+					)
+				}
 				yield* runLifecycleTransaction({
 					root,
 					preconditions: parentEpic
 						? [{ path: parentEpic.path, revision: parentEpic.revision }]
 						: [],
 					steps: [
-						...(input.review ? [reviewPinStep(root, id, input.review)] : []),
+						...(input.review
+							? [reviewPinStep(root, id, input.review, reviewEnvironment)]
+							: []),
 						documentWriteStep(root, writes),
 					],
 				})

package/src/services/VcsMigrationService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { lstat, mkdir } from "node:fs/promises"
+import { lstat, mkdir, rm } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { ClaimService } from "./ClaimService"
@@ -196,6 +196,63 @@ describe("VcsMigrationService", () => {
 		).toEqual([])
 	})
 
+	test("blocks non-colocated jj to Git migration before mutation", async () => {
+		if (!Bun.which("jj")) return
+		await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) => service.remove("example", undefined, root)),
+			),
+		)
+		for (const alias of ["agency", "effect"]) {
+			const repository = join(root, "repos", alias)
+			await rm(repository, { recursive: true, force: true })
+			await run([
+				"jj",
+				"git",
+				"clone",
+				"--no-colocate",
+				join(root, "source"),
+				repository,
+			])
+			expect(await exists(join(repository, ".git"))).toBe(false)
+		}
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({ version: 2, vcs: "jj" }),
+		)
+
+		const planned = await runTestEffect(
+			VcsMigrationService.pipe(
+				Effect.flatMap((service) => service.migrate("git", root)),
+			),
+		)
+		expect(planned.blockers).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					target: "repository:agency",
+					message: expect.stringContaining("non-colocated"),
+				}),
+				expect.objectContaining({
+					target: "repository:effect",
+					message: expect.stringContaining("non-colocated"),
+				}),
+			]),
+		)
+		expect((await Bun.file(join(root, "agency.json")).json()).vcs).toBe("jj")
+		expect(await exists(join(root, "repos/agency/.jj"))).toBe(true)
+		await expect(
+			runTestEffect(
+				VcsMigrationService.pipe(
+					Effect.flatMap((service) =>
+						service.migrate("git", root, { apply: true }),
+					),
+				),
+			),
+		).rejects.toThrow("non-colocated")
+		expect((await Bun.file(join(root, "agency.json")).json()).vcs).toBe("jj")
+		expect(await exists(join(root, "repos/agency/.jj"))).toBe(true)
+	})
+
 	test("allows clean unclaimed working workspaces", async () => {
 		if (!Bun.which("jj")) return
 		await runTestEffect(

package/src/services/VcsMigrationService.ts

@@ -309,6 +309,15 @@ const inspectMigration = (startPath: string, requestedTarget?: VcsKind) =>
 				remote: repository.declaredRemote ?? repository.remote,
 			})
 			if (source === "jj" && target === "git" && initialized) {
+				const gitEnvironment: Record<string, string> =
+					yield* sourceBackend.gitEnvironment(targetPath)
+				if (gitEnvironment.GIT_DIR?.includes(`${join(targetPath, ".jj")}/`)) {
+					blockers.push({
+						kind: "repository",
+						target: `repository:${repository.alias}`,
+						message: `Repository '${repository.alias}' is non-colocated; migrate it to colocated jj before converting the workbase to Git`,
+					})
+				}
 				const dirty = yield* sourceBackend.workspaceDirty(targetPath)
 				if (dirty !== false) {
 					blockers.push({

package/src/services/VersionControlService.test.ts

@@ -97,4 +97,42 @@ describe("VersionControlService", () => {
 		)
 		expect(await Bun.file(workspace).exists()).toBe(false)
 	})
+
+	test("clones non-colocated jj repositories and exposes their backing Git directory", async () => {
+		if (!Bun.which("jj")) return
+		const root = await createTempDir()
+		roots.push(root)
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({ version: 2, vcs: "jj" }),
+		)
+		const source = join(root, "source")
+		const repository = join(root, "repository")
+		await mkdir(source)
+		await run(["git", "init", "--initial-branch=main"], source)
+		await run(["git", "config", "user.email", "test@example.com"], source)
+		await run(["git", "config", "user.name", "Test"], source)
+		await Bun.write(join(source, "README.md"), "example\n")
+		await run(["git", "add", "README.md"], source)
+		await run(["git", "commit", "-m", "initial"], source)
+
+		const backend = await runTestEffect(
+			VersionControlService.pipe(
+				Effect.flatMap((service) => service.forWorkbase(root)),
+			),
+		)
+		await runTestEffect(backend.cloneRepository(source, repository))
+
+		expect((await stat(join(repository, ".jj"))).isDirectory()).toBe(true)
+		expect(await Bun.file(join(repository, ".git")).exists()).toBe(false)
+		const environment: Record<string, string> = await runTestEffect(
+			backend.gitEnvironment(repository),
+		)
+		expect(environment.GIT_DIR).toContain(join(repository, ".jj"))
+		expect((await stat(environment.GIT_DIR!)).isDirectory()).toBe(true)
+		expect(await runTestEffect(backend.inspectRepository(repository))).toEqual({
+			kind: "repository",
+			remote: await realpath(source),
+		})
+	})
 })