@markjaquith/agency 2.56.1 → 2.57.0

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),
+		})
+	})
 })

package/src/services/VersionControlService.ts

@@ -12,11 +12,35 @@ export interface RegisteredWorkspace {
 	readonly dirty?: boolean
 }
 
+interface PullRequestDefaults {
+	readonly title: string
+	readonly body: string
+}
+
+interface RepositoryInspection {
+	readonly kind: "bare" | "repository"
+	readonly remote: string | null
+}
+
 export interface VersionControlBackend {
 	readonly kind: VersionControlKind
+	readonly cloneRepository: (
+		source: string,
+		destination: string,
+	) => Effect.Effect<void, unknown, any>
 	readonly initializeRepository: (
 		path: string,
 	) => Effect.Effect<void, unknown, any>
+	readonly inspectRepository: (
+		path: string,
+	) => Effect.Effect<RepositoryInspection | null, unknown, any>
+	readonly gitEnvironment: (
+		path: string,
+	) => Effect.Effect<Record<string, string>, unknown, any>
+	readonly pullRequestDefaults: (
+		workspacePath: string,
+		base: string,
+	) => Effect.Effect<PullRequestDefaults | null, unknown, any>
 	readonly listWorkspaces: (
 		repositoryPath: string,
 	) => Effect.Effect<readonly RegisteredWorkspace[], unknown, any>
@@ -59,6 +83,11 @@ export interface VersionControlBackend {
 		repositoryPath: string,
 		remote: string,
 	) => Effect.Effect<string | null, unknown, any>
+	readonly setRemoteUrl: (
+		repositoryPath: string,
+		remote: string,
+		url: string | null,
+	) => Effect.Effect<void, unknown, any>
 }
 
 class VersionControlError extends Data.TaggedError("VersionControlError")<{
@@ -122,7 +151,43 @@ export class GitVersionControlService extends Effect.Service<GitVersionControlSe
 		sync: () =>
 			({
 				kind: "git",
+				cloneRepository: (source, destination) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						yield* requireSuccess(
+							"Failed to clone Git repository",
+							fs.runCommand(
+								["git", "clone", "--bare", "--", source, destination],
+								{
+									captureOutput: true,
+								},
+							),
+						)
+					}),
 				initializeRepository: () => Effect.void,
+				inspectRepository: (path) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const valid = yield* fs.runCommand(
+							["git", "-C", path, "rev-parse", "--git-dir"],
+							{ captureOutput: true },
+						)
+						if (valid.exitCode !== 0) return null
+						const bare = yield* fs.runCommand(
+							["git", "-C", path, "rev-parse", "--is-bare-repository"],
+							{ captureOutput: true },
+						)
+						const remote = yield* fs.runCommand(
+							["git", "-C", path, "remote", "get-url", "origin"],
+							{ captureOutput: true },
+						)
+						return {
+							kind: bare.stdout.trim() === "true" ? "bare" : "repository",
+							remote: remote.exitCode === 0 ? remote.stdout.trim() : null,
+						} as const
+					}),
+				gitEnvironment: () => Effect.succeed({}),
+				pullRequestDefaults: () => Effect.succeed(null),
 				listWorkspaces: (repositoryPath) =>
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService
@@ -272,6 +337,30 @@ export class GitVersionControlService extends Effect.Service<GitVersionControlSe
 						)
 						return result.exitCode === 0 ? result.stdout.trim() : null
 					}),
+				setRemoteUrl: (repositoryPath, remote, url) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const previous = yield* fs.runCommand(
+							["git", "-C", repositoryPath, "remote", "get-url", remote],
+							{ captureOutput: true },
+						)
+						const command =
+							url === null
+								? ["git", "-C", repositoryPath, "remote", "remove", remote]
+								: [
+										"git",
+										"-C",
+										repositoryPath,
+										"remote",
+										previous.exitCode === 0 ? "set-url" : "add",
+										remote,
+										url,
+									]
+						yield* requireSuccess(
+							`Failed to update Git remote '${remote}'`,
+							fs.runCommand(command, { captureOutput: true }),
+						)
+					}),
 			}) satisfies VersionControlBackend,
 	},
 ) {}
@@ -290,6 +379,25 @@ export class JjVersionControlService extends Effect.Service<JjVersionControlServ
 		sync: () =>
 			({
 				kind: "jj",
+				cloneRepository: (source, destination) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						yield* requireSuccess(
+							"Failed to clone jj repository",
+							fs.runCommand(
+								[
+									"jj",
+									"git",
+									"clone",
+									"--no-colocate",
+									"--",
+									source,
+									destination,
+								],
+								{ captureOutput: true },
+							),
+						)
+					}),
 				initializeRepository: (path) =>
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService
@@ -301,6 +409,72 @@ export class JjVersionControlService extends Effect.Service<JjVersionControlServ
 							}),
 						)
 					}),
+				inspectRepository: (path) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const root = yield* fs.runCommand(jjCommand(path, ["root"]), {
+							captureOutput: true,
+						})
+						if (root.exitCode !== 0) return null
+						const remote = yield* fs.runCommand(
+							jjCommand(path, ["git", "remote", "list"]),
+							{ captureOutput: true },
+						)
+						return {
+							kind: "repository",
+							remote:
+								remote.exitCode === 0
+									? (remote.stdout
+											.split("\n")
+											.find((line) => line.startsWith("origin "))
+											?.slice("origin ".length)
+											.trim() ?? null)
+									: null,
+						} as const
+					}),
+				gitEnvironment: (path) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const result = yield* requireSuccess(
+							"Failed to locate jj backing Git repository",
+							fs.runCommand(jjCommand(path, ["git", "root"]), {
+								captureOutput: true,
+							}),
+						)
+						return { GIT_DIR: result.stdout.trim() }
+					}),
+				pullRequestDefaults: (workspacePath, base) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const result = yield* fs.runCommand(
+							jjCommand(workspacePath, [
+								"log",
+								"--ignore-working-copy",
+								"--no-graph",
+								"-r",
+								`${base}..@-`,
+								"-T",
+								'description.first_line() ++ "\\n"',
+							]),
+							{ captureOutput: true },
+						)
+						if (result.exitCode !== 0) return null
+						const commits = result.stdout
+							.split("\n")
+							.map((line) => line.trim())
+							.filter(Boolean)
+						if (commits.length === 0) return null
+						return {
+							title: commits.at(-1)!,
+							body:
+								commits.length === 1
+									? ""
+									: `Commits:\n${commits
+											.toReversed()
+											.map((commit) => `- ${commit}`)
+											.join("\n")}`,
+						} satisfies PullRequestDefaults
+					}),
 				listWorkspaces: (repositoryPath) =>
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService
@@ -456,6 +630,20 @@ export class JjVersionControlService extends Effect.Service<JjVersionControlServ
 				push: (workspacePath, remote, branch) =>
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService
+						yield* requireSuccess(
+							"Failed to set jj delivery bookmark",
+							fs.runCommand(
+								jjCommand(workspacePath, [
+									"bookmark",
+									"set",
+									"--allow-backwards",
+									branch,
+									"-r",
+									"@-",
+								]),
+								{ captureOutput: true },
+							),
+						)
 						yield* requireSuccess(
 							"Failed to push branch",
 							fs.runCommand(
@@ -464,8 +652,8 @@ export class JjVersionControlService extends Effect.Service<JjVersionControlServ
 									"push",
 									"--remote",
 									remote,
-									"--named",
-									`${branch}=@-`,
+									"--bookmark",
+									branch,
 								]),
 								{ captureOutput: true },
 							),
@@ -487,6 +675,27 @@ export class JjVersionControlService extends Effect.Service<JjVersionControlServ
 								.trim() ?? null
 						)
 					}),
+				setRemoteUrl: (repositoryPath, remote, url) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const previous = yield* fs.runCommand(
+							jjCommand(repositoryPath, ["git", "remote", "list"]),
+							{ captureOutput: true },
+						)
+						const exists = previous.stdout
+							.split("\n")
+							.some((line) => line.startsWith(`${remote} `))
+						const args =
+							url === null
+								? ["git", "remote", "remove", remote]
+								: ["git", "remote", exists ? "set-url" : "add", remote, url]
+						yield* requireSuccess(
+							`Failed to update jj Git remote '${remote}'`,
+							fs.runCommand(jjCommand(repositoryPath, args), {
+								captureOutput: true,
+							}),
+						)
+					}),
 			}) satisfies VersionControlBackend,
 	},
 ) {}

package/src/vcs-status-fast.ts

@@ -132,19 +132,14 @@ const inspectRepository = async (root: string, alias: string) => {
 		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
+	const jj = await run(["jj", "-R", path, "root"])
+	if (jj.exitCode !== 0) return null
 	return {
 		alias,
 		path,
 		kind: stats.isSymbolicLink()
 			? ("symlink" as const)
-			: bare.stdout === "true"
-				? ("bare" as const)
-				: ("repository" as const),
+			: ("repository" as const),
 		initialized: await directoryExists(join(path, ".jj")),
 	}
 }

package/src/workbase/delivery-command.test.ts

@@ -39,12 +39,21 @@ describe("delivery commands", () => {
 			repository: "example/agency",
 			draft: false,
 		} as const
-		expect(resolveGitHubCreateCommand({ ...input, vcs: "jj" })).toEqual({
+		expect(
+			resolveGitHubCreateCommand({
+				...input,
+				vcs: "jj",
+				defaults: { title: "Add example", body: "Details" },
+			}),
+		).toEqual({
 			argv: [
 				"gh",
 				"pr",
 				"create",
-				"--fill",
+				"--title",
+				"Add example",
+				"--body",
+				"Details",
 				"--base",
 				"main",
 				"--head",

package/src/workbase/delivery-command.ts

@@ -24,18 +24,22 @@ export const resolveGitHubCreateCommand = ({
 	repository,
 	draft,
 	vcs,
+	defaults,
 }: {
 	readonly base: string
 	readonly branch: string
 	readonly repository: string
 	readonly draft: boolean
 	readonly vcs: "git" | "jj"
+	readonly defaults?: { readonly title: string; readonly body: string }
 }) => ({
 	argv: [
 		"gh",
 		"pr",
 		"create",
-		"--fill",
+		...(defaults
+			? ["--title", defaults.title, "--body", defaults.body]
+			: ["--fill"]),
 		"--base",
 		base,
 		...(vcs === "jj" ? ["--head", branch, "--repo", repository] : []),