@markjaquith/agency 2.56.1 → 2.58.0

package/src/services/GraphService.ts

@@ -33,6 +33,10 @@ import {
 	type WorkStatus,
 } from "../workbase/schemas"
 import { FileSystemService } from "./FileSystemService"
+import {
+	VersionControlService,
+	type VersionControlBackend,
+} from "./VersionControlService"
 import { WorkbaseService, type ValidationReport } from "./WorkbaseService"
 
 class GraphError extends Data.TaggedError("GraphError")<{
@@ -68,6 +72,7 @@ export interface GraphOptions {
 	readonly repositories?: readonly string[]
 	readonly kinds?: readonly GraphNodeKind[]
 	readonly include?: readonly GraphInclude[]
+	readonly backend?: VersionControlBackend
 }
 
 const epicNodeId = (id: string) => `epic:${id}`
@@ -127,6 +132,11 @@ export class GraphService extends Effect.Service<GraphService>()(
 					const fs = yield* FileSystemService
 					const workbase = yield* WorkbaseService
 					const { root, config } = yield* workbase.loadConfig(options.cwd)
+					const backend =
+						options.backend ??
+						(yield* VersionControlService.pipe(
+							Effect.flatMap((service) => service.forWorkbase(root)),
+						))
 					const includes = [...new Set(options.include ?? [])].sort()
 					const include = new Set(includes)
 					const epics = new Map<string, Document<EpicData>>()
@@ -623,38 +633,20 @@ export class GraphService extends Effect.Service<GraphService>()(
 
 					const inspectGit = (path: string) =>
 						Effect.gen(function* () {
-							const bare = yield* run(fs, [
-								"git",
-								"-C",
-								path,
-								"rev-parse",
-								"--is-bare-repository",
-							])
+							const inspection = yield* backend.inspectRepository(path)
+							const workspaces = inspection
+								? yield* backend
+										.listWorkspaces(path)
+										.pipe(Effect.catchAll(() => Effect.succeed([])))
+								: []
+							const primary = workspaces.find(
+								(workspace) => workspace.path === path,
+							)
 							return {
-								kind:
-									bare === null
-										? null
-										: bare === "true"
-											? "bare"
-											: "repository",
-								remote: yield* run(fs, [
-									"git",
-									"-C",
-									path,
-									"remote",
-									"get-url",
-									"origin",
-								]),
-								head: yield* run(fs, ["git", "-C", path, "rev-parse", "HEAD"]),
-								branch: yield* run(fs, [
-									"git",
-									"-C",
-									path,
-									"symbolic-ref",
-									"--quiet",
-									"--short",
-									"HEAD",
-								]),
+								kind: inspection?.kind ?? null,
+								remote: inspection?.remote ?? null,
+								head: inspection ? yield* backend.workspaceHead(path) : null,
+								branch: primary?.branch?.replace(/^refs\/heads\//, "") ?? null,
 							} satisfies GraphRepositoryGit
 						})
 
@@ -678,6 +670,27 @@ export class GraphService extends Effect.Service<GraphService>()(
 								}
 							}
 							if (include.has("git")) {
+								const remote = yield* backend.remoteUrl(
+									repositoryPath,
+									"origin",
+								)
+								const canonicalCheckoutPath = materialized
+									? yield* fs.realPath(checkoutPath)
+									: checkoutPath
+								const actualBranch = materialized
+									? yield* backend.listWorkspaces(repositoryPath).pipe(
+											Effect.map(
+												(workspaces) =>
+													workspaces
+														.find(
+															(workspace) =>
+																workspace.path === canonicalCheckoutPath,
+														)
+														?.branch?.replace(/^refs\/heads\//, "") ?? null,
+											),
+											Effect.catchAll(() => Effect.succeed(null)),
+										)
+									: null
 								result.git =
 									"review" in data
 										? {
@@ -686,10 +699,8 @@ export class GraphService extends Effect.Service<GraphService>()(
 													value?.split(/\s+/)[0] ?? null)(
 													yield* run(fs, [
 														"git",
-														"-C",
-														repositoryPath,
 														"ls-remote",
-														"origin",
+														remote ?? "origin",
 														data.review.source.kind === "pull-request"
 															? data.review.source.fetchRef
 															: data.review.source.ref
@@ -698,86 +709,33 @@ export class GraphService extends Effect.Service<GraphService>()(
 													]),
 												),
 												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",
-														])
+													? yield* backend.workspaceHead(checkoutPath)
 													: null,
+												checkoutBranch: null,
 												dirty: materialized
-													? ((status) =>
-															status === null ? null : status.length > 0)(
-															yield* runText(fs, [
-																"git",
-																"-C",
-																checkoutPath,
-																"status",
-																"--porcelain",
-															]),
-														)
+													? yield* backend.workspaceDirty(checkoutPath)
 													: null,
 											}
 										: {
 												branch: data.branch,
 												base: data.base,
-												branchCommit: yield* run(fs, [
-													"git",
-													"-C",
+												branchCommit: yield* backend.resolveRevision(
 													repositoryPath,
-													"rev-parse",
-													`${data.branch}^{commit}`,
-												]),
-												baseCommit: yield* run(fs, [
-													"git",
-													"-C",
+													data.branch,
+												),
+												baseCommit: yield* backend.resolveRevision(
 													repositoryPath,
-													"rev-parse",
-													`${data.base}^{commit}`,
-												]),
+													data.base,
+												),
 												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",
-														])
+													? yield* backend.workspaceHead(checkoutPath)
 													: null,
+												checkoutBranch:
+													backend.kind === "jj" && materialized
+														? data.branch
+														: actualBranch,
 												dirty: materialized
-													? ((status) =>
-															status === null ? null : status.length > 0)(
-															yield* runText(fs, [
-																"git",
-																"-C",
-																checkoutPath,
-																"status",
-																"--porcelain",
-															]),
-														)
+													? yield* backend.workspaceDirty(checkoutPath)
 													: null,
 											}
 							}

package/src/services/PullRequestService.test.ts

@@ -97,7 +97,7 @@ describe("PullRequestService", () => {
 		await Bun.write(
 			path,
 			`#!/usr/bin/env bun
-await Bun.write(${JSON.stringify(ghCallPath)}, JSON.stringify({ args: Bun.argv.slice(2), cwd: process.cwd() }))
+await Bun.write(${JSON.stringify(ghCallPath)}, JSON.stringify({ args: Bun.argv.slice(2), cwd: process.cwd(), ...(process.env.GIT_DIR ? { gitDir: process.env.GIT_DIR } : {}) }))
 process.stdout.write(${JSON.stringify(stdout)})
 process.stderr.write(${JSON.stringify(stderr)})
 process.exit(${exitCode})
@@ -110,6 +110,7 @@ process.exit(${exitCode})
 		(await Bun.file(ghCallPath).json()) as {
 			args: string[]
 			cwd: string
+			gitDir?: string
 		}
 
 	const expectRemoteBranch = async (branch: string, exists = true) => {
@@ -241,6 +242,49 @@ process.exit(${exitCode})
 		expect(updated.endsWith(`${body}\n`)).toBe(true)
 	})
 
+	test("creates a PR from a non-colocated jj workspace with backing Git context", async () => {
+		if (!Bun.which("jj")) return
+		await rm(join(root, "repos/agency"), { recursive: true, force: true })
+		await requireCommand([
+			"jj",
+			"git",
+			"clone",
+			"--no-colocate",
+			remotePath,
+			join(root, "repos/agency"),
+		])
+		await requireCommand(
+			["jj", "config", "set", "--repo", "user.name", "Agency Test"],
+			join(root, "repos/agency"),
+		)
+		await requireCommand(
+			["jj", "config", "set", "--repo", "user.email", "agency@example.com"],
+			join(root, "repos/agency"),
+		)
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({ version: 2, vcs: "jj" }),
+		)
+		await createTask("jj-example", "task/jj-example")
+		const workspace = await materialize("jj-example")
+		await Bun.write(join(workspace.writablePath!, "CHANGE.md"), "jj change\n")
+		await requireCommand(
+			["jj", "describe", "-m", "feat: add jj example"],
+			workspace.writablePath!,
+		)
+		await requireCommand(["jj", "new"], workspace.writablePath!)
+		const url = "https://github.com/example/agency/pull/44"
+		await writeFakeGh({ stdout: `${url}\n` })
+
+		expect(await createPullRequest("jj-example")).toBe(url)
+		await expectRemoteBranch("task/jj-example")
+		const ghCall = await readGhCall()
+		expect(ghCall.args).toContain("--head")
+		expect(ghCall.args).toContain("--repo")
+		expect(ghCall.gitDir).toContain(".jj")
+		expect(await Bun.file(join(root, "repos/agency/.git")).exists()).toBe(false)
+	})
+
 	test("passes --draft to gh", async () => {
 		await createTask()
 		await writeFakeGh({

package/src/services/PullRequestService.ts

@@ -172,6 +172,19 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 					}
 
 					yield* backend.push(workspace.writablePath, remote, execution.branch)
+					const defaults =
+						backend.kind === "jj"
+							? yield* backend.pullRequestDefaults(
+									workspace.writablePath,
+									execution.base,
+								)
+							: null
+					if (backend.kind === "jj" && !defaults) {
+						return yield* new PullRequestError({
+							message:
+								"Failed to derive pull request title and body from jj commits",
+						})
+					}
 
 					const remoteUrl = yield* backend.remoteUrl(
 						workspace.writablePath,
@@ -198,11 +211,15 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 								repository,
 								draft,
 								vcs: config.vcs ?? "git",
+								...(defaults ? { defaults } : {}),
 							})
+					const gitEnvironment = config.delivery
+						? {}
+						: yield* backend.gitEnvironment(workspace.writablePath)
 					const created = yield* fs.runCommand(resolved.argv, {
 						cwd: workspace.writablePath,
 						captureOutput: true,
-						env: resolved.environment,
+						env: { ...gitEnvironment, ...resolved.environment },
 					})
 					if (created.exitCode !== 0) {
 						return yield* new PullRequestError({

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,