@markjaquith/agency 2.50.0 → 2.52.0

package/src/services/VersionControlService.test.ts

@@ -0,0 +1,100 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { mkdir, realpath, stat } from "node:fs/promises"
+import { join } from "node:path"
+import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
+import { VersionControlService } from "./VersionControlService"
+import { preferredVersionControl } from "../workbase/version-control"
+
+const run = async (args: string[], cwd?: string) => {
+	const child = Bun.spawn(args, { cwd, stdout: "pipe", stderr: "pipe" })
+	const exitCode = await child.exited
+	if (exitCode !== 0) throw new Error(await new Response(child.stderr).text())
+}
+
+describe("VersionControlService", () => {
+	const roots: string[] = []
+
+	afterEach(async () => {
+		await Promise.all(roots.splice(0).map(cleanupTempDir))
+	})
+
+	test("prefers jj when available and falls back to Git", () => {
+		expect(preferredVersionControl(() => "/usr/bin/jj")).toBe("jj")
+		expect(preferredVersionControl(() => null)).toBe("git")
+	})
+
+	test("selects the backend persisted by the workbase", async () => {
+		for (const kind of ["git", "jj"] as const) {
+			const root = await createTempDir()
+			roots.push(root)
+			await Bun.write(
+				join(root, "agency.json"),
+				JSON.stringify({ version: 2, vcs: kind }),
+			)
+			const selected = await runTestEffect(
+				VersionControlService.pipe(
+					Effect.flatMap((service) => service.forWorkbase(root)),
+				),
+			)
+			expect(selected.kind).toBe(kind)
+		}
+	})
+
+	test("initializes and manages jj workspaces", 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 repository = join(root, "repository")
+		const workspace = join(root, "workspace")
+		await mkdir(repository)
+		await run(["git", "init", "--initial-branch=main"], repository)
+		await run(["git", "config", "user.email", "test@example.com"], repository)
+		await run(["git", "config", "user.name", "Test"], repository)
+		await Bun.write(join(repository, "README.md"), "example\n")
+		await run(["git", "add", "README.md"], repository)
+		await run(["git", "commit", "-m", "initial"], repository)
+
+		const backend = await runTestEffect(
+			VersionControlService.pipe(
+				Effect.flatMap((service) => service.forWorkbase(root)),
+			),
+		)
+		await runTestEffect(backend.initializeRepository(repository))
+		expect((await stat(join(repository, ".jj"))).isDirectory()).toBe(true)
+
+		const revision = await runTestEffect(
+			backend.resolveRevision(repository, "main"),
+		)
+		expect(revision).toMatch(/^[0-9a-f]{40}$/)
+		await runTestEffect(
+			backend.createWorkspace({
+				repositoryPath: repository,
+				workspacePath: workspace,
+				workspaceName: "agency-test",
+				revision: revision!,
+				branch: "task/test",
+			}),
+		)
+		const canonicalWorkspace = await realpath(workspace)
+		expect(
+			(await runTestEffect(backend.listWorkspaces(repository))).some(
+				(item) =>
+					item.name === "agency-test" && item.path === canonicalWorkspace,
+			),
+		).toBe(true)
+
+		await runTestEffect(
+			backend.removeWorkspace({
+				repositoryPath: repository,
+				workspacePath: workspace,
+				workspaceName: "agency-test",
+			}),
+		)
+		expect(await Bun.file(workspace).exists()).toBe(false)
+	})
+})

package/src/services/VersionControlService.ts

@@ -0,0 +1,479 @@
+import { Data, Effect } from "effect"
+import { FileSystemService } from "./FileSystemService"
+import { WorkbaseService } from "./WorkbaseService"
+import type { VersionControlKind } from "../workbase/version-control"
+
+interface RegisteredWorkspace {
+	readonly name: string | null
+	readonly path: string
+	readonly commit: string | null
+	readonly branch: string | null
+}
+
+export interface VersionControlBackend {
+	readonly kind: VersionControlKind
+	readonly initializeRepository: (
+		path: string,
+	) => Effect.Effect<void, unknown, any>
+	readonly listWorkspaces: (
+		repositoryPath: string,
+	) => Effect.Effect<readonly RegisteredWorkspace[], unknown, any>
+	readonly resolveRevision: (
+		repositoryPath: string,
+		revision: string,
+	) => Effect.Effect<string | null, unknown, any>
+	readonly workspaceHead: (
+		workspacePath: string,
+	) => Effect.Effect<string | null, unknown, any>
+	readonly workspaceDirty: (
+		workspacePath: string,
+	) => Effect.Effect<boolean | null, unknown, any>
+	readonly createWorkspace: (options: {
+		readonly repositoryPath: string
+		readonly workspacePath: string
+		readonly workspaceName: string
+		readonly revision: string
+		readonly branch?: string
+	}) => Effect.Effect<void, unknown, any>
+	readonly removeWorkspace: (options: {
+		readonly repositoryPath: string
+		readonly workspacePath: string
+		readonly workspaceName: string | null
+	}) => Effect.Effect<void, unknown, any>
+	readonly fetch: (
+		repositoryPath: string,
+		remote?: string,
+		branch?: string,
+	) => Effect.Effect<void, unknown, any>
+	readonly push: (
+		workspacePath: string,
+		remote: string,
+		branch: string,
+	) => Effect.Effect<void, unknown, any>
+	readonly remoteUrl: (
+		repositoryPath: string,
+		remote: string,
+	) => Effect.Effect<string | null, unknown, any>
+}
+
+class VersionControlError extends Data.TaggedError("VersionControlError")<{
+	readonly message: string
+}> {}
+
+const requireSuccess = (
+	label: string,
+	effect: Effect.Effect<
+		{
+			readonly exitCode: number
+			readonly stdout: string
+			readonly stderr: string
+		},
+		unknown,
+		any
+	>,
+) =>
+	effect.pipe(
+		Effect.flatMap((result) =>
+			result.exitCode === 0
+				? Effect.succeed(result)
+				: Effect.fail(
+						new VersionControlError({
+							message: `${label}: ${result.stderr.trim() || result.stdout.trim()}`,
+						}),
+					),
+		),
+	)
+
+const parseGitWorktrees = (output: string): readonly RegisteredWorkspace[] => {
+	const workspaces: RegisteredWorkspace[] = []
+	let current: RegisteredWorkspace | null = null
+	for (const field of output.split("\0")) {
+		if (field.startsWith("worktree ")) {
+			if (current) workspaces.push(current)
+			current = {
+				name: null,
+				path: field.slice("worktree ".length),
+				commit: null,
+				branch: null,
+			}
+		} else if (current && field.startsWith("HEAD ")) {
+			const workspace: RegisteredWorkspace = current
+			current = { ...workspace, commit: field.slice("HEAD ".length) }
+		} else if (current && field.startsWith("branch ")) {
+			const workspace: RegisteredWorkspace = current
+			current = {
+				...workspace,
+				branch: field.slice("branch ".length),
+			}
+		}
+	}
+	if (current) workspaces.push(current)
+	return workspaces
+}
+
+export class GitVersionControlService extends Effect.Service<GitVersionControlService>()(
+	"GitVersionControlService",
+	{
+		sync: () =>
+			({
+				kind: "git",
+				initializeRepository: () => Effect.void,
+				listWorkspaces: (repositoryPath) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const result = yield* requireSuccess(
+							"Failed to inspect Git worktrees",
+							fs.runCommand(
+								[
+									"git",
+									"-C",
+									repositoryPath,
+									"worktree",
+									"list",
+									"--porcelain",
+									"-z",
+								],
+								{ captureOutput: true },
+							),
+						)
+						return parseGitWorktrees(result.stdout)
+					}),
+				resolveRevision: (repositoryPath, revision) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const result = yield* fs.runCommand(
+							[
+								"git",
+								"-C",
+								repositoryPath,
+								"rev-parse",
+								"--verify",
+								`${revision}^{commit}`,
+							],
+							{ captureOutput: true },
+						)
+						return result.exitCode === 0 ? result.stdout.trim() : null
+					}),
+				workspaceHead: (workspacePath) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const result = yield* fs.runCommand(
+							["git", "-C", workspacePath, "rev-parse", "HEAD"],
+							{ captureOutput: true },
+						)
+						return result.exitCode === 0 ? result.stdout.trim() : null
+					}),
+				workspaceDirty: (workspacePath) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const result = yield* fs.runCommand(
+							["git", "-C", workspacePath, "status", "--porcelain"],
+							{ captureOutput: true },
+						)
+						return result.exitCode === 0 ? result.stdout.length > 0 : null
+					}),
+				createWorkspace: (options) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const command = options.branch
+							? [
+									"git",
+									"-C",
+									options.repositoryPath,
+									"worktree",
+									"add",
+									"-b",
+									options.branch,
+									options.workspacePath,
+									options.revision,
+								]
+							: [
+									"git",
+									"-C",
+									options.repositoryPath,
+									"worktree",
+									"add",
+									"--detach",
+									options.workspacePath,
+									options.revision,
+								]
+						yield* requireSuccess(
+							"Failed to create Git worktree",
+							fs.runCommand(command, { captureOutput: true }),
+						)
+					}),
+				removeWorkspace: (options) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						yield* requireSuccess(
+							"Failed to remove Git worktree",
+							fs.runCommand(
+								[
+									"git",
+									"-C",
+									options.repositoryPath,
+									"worktree",
+									"remove",
+									options.workspacePath,
+								],
+								{ captureOutput: true },
+							),
+						)
+					}),
+				fetch: (repositoryPath, remote = "origin", branch) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						yield* requireSuccess(
+							"Failed to fetch Git repository",
+							fs.runCommand(
+								[
+									"git",
+									"-C",
+									repositoryPath,
+									"fetch",
+									remote,
+									...(branch ? [branch] : []),
+								],
+								{ captureOutput: true },
+							),
+						)
+					}),
+				push: (workspacePath, remote, branch) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						yield* requireSuccess(
+							"Failed to push branch",
+							fs.runCommand(
+								[
+									"git",
+									"-C",
+									workspacePath,
+									"push",
+									"--set-upstream",
+									remote,
+									branch,
+								],
+								{ captureOutput: true },
+							),
+						)
+					}),
+				remoteUrl: (repositoryPath, remote) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const result = yield* fs.runCommand(
+							["git", "-C", repositoryPath, "remote", "get-url", remote],
+							{ captureOutput: true },
+						)
+						return result.exitCode === 0 ? result.stdout.trim() : null
+					}),
+			}) satisfies VersionControlBackend,
+	},
+) {}
+
+const jjCommand = (repositoryPath: string, args: readonly string[]) => [
+	"jj",
+	"-R",
+	repositoryPath,
+	"--no-pager",
+	...args,
+]
+
+export class JjVersionControlService extends Effect.Service<JjVersionControlService>()(
+	"JjVersionControlService",
+	{
+		sync: () =>
+			({
+				kind: "jj",
+				initializeRepository: (path) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						if (yield* fs.exists(`${path}/.jj`)) return
+						yield* requireSuccess(
+							"Failed to initialize jj repository",
+							fs.runCommand(["jj", "git", "init", "--colocate", path], {
+								captureOutput: true,
+							}),
+						)
+					}),
+				listWorkspaces: (repositoryPath) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const result = yield* requireSuccess(
+							"Failed to inspect jj workspaces",
+							fs.runCommand(
+								jjCommand(repositoryPath, [
+									"workspace",
+									"list",
+									"-T",
+									'name ++ "\\t" ++ root ++ "\\t" ++ target.commit_id() ++ "\\n"',
+								]),
+								{ captureOutput: true },
+							),
+						)
+						return result.stdout
+							.trim()
+							.split("\n")
+							.filter(Boolean)
+							.map((line) => {
+								const [name, path, commit] = line.split("\t")
+								return {
+									name: name || null,
+									path: path!,
+									commit: commit || null,
+									branch: null,
+								}
+							})
+					}),
+				resolveRevision: (repositoryPath, revision) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const result = yield* fs.runCommand(
+							jjCommand(repositoryPath, [
+								"log",
+								"--ignore-working-copy",
+								"--no-graph",
+								"-r",
+								revision,
+								"-T",
+								'commit_id ++ "\\n"',
+							]),
+							{ captureOutput: true },
+						)
+						return result.exitCode === 0 ? result.stdout.trim() || null : null
+					}),
+				workspaceHead: (workspacePath) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const result = yield* fs.runCommand(
+							jjCommand(workspacePath, [
+								"log",
+								"--ignore-working-copy",
+								"--no-graph",
+								"-r",
+								"@-",
+								"-T",
+								'commit_id ++ "\\n"',
+							]),
+							{ captureOutput: true },
+						)
+						return result.exitCode === 0 ? result.stdout.trim() || null : null
+					}),
+				workspaceDirty: (workspacePath) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const result = yield* fs.runCommand(
+							jjCommand(workspacePath, ["diff", "--summary", "-r", "@"]),
+							{ captureOutput: true },
+						)
+						return result.exitCode === 0 ? result.stdout.length > 0 : null
+					}),
+				createWorkspace: (options) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						yield* requireSuccess(
+							"Failed to create jj workspace",
+							fs.runCommand(
+								jjCommand(options.repositoryPath, [
+									"workspace",
+									"add",
+									"--name",
+									options.workspaceName,
+									"-r",
+									options.revision,
+									options.workspacePath,
+								]),
+								{ captureOutput: true },
+							),
+						)
+					}),
+				removeWorkspace: (options) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						if (!options.workspaceName) {
+							return yield* new VersionControlError({
+								message: `Cannot remove unregistered jj workspace ${options.workspacePath}`,
+							})
+						}
+						yield* requireSuccess(
+							"Failed to forget jj workspace",
+							fs.runCommand(
+								jjCommand(options.repositoryPath, [
+									"workspace",
+									"forget",
+									options.workspaceName,
+								]),
+								{ captureOutput: true },
+							),
+						)
+						yield* fs.deleteDirectory(options.workspacePath)
+					}),
+				fetch: (repositoryPath, remote = "origin", branch) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						yield* requireSuccess(
+							"Failed to fetch jj repository",
+							fs.runCommand(
+								jjCommand(repositoryPath, [
+									"git",
+									"fetch",
+									"--remote",
+									remote,
+									...(branch ? ["--branch", branch] : []),
+								]),
+								{ captureOutput: true },
+							),
+						)
+					}),
+				push: (workspacePath, remote, branch) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						yield* requireSuccess(
+							"Failed to push branch",
+							fs.runCommand(
+								jjCommand(workspacePath, [
+									"git",
+									"push",
+									"--remote",
+									remote,
+									"--named",
+									`${branch}=@-`,
+								]),
+								{ captureOutput: true },
+							),
+						)
+					}),
+				remoteUrl: (repositoryPath, remote) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						const result = yield* fs.runCommand(
+							jjCommand(repositoryPath, ["git", "remote", "list"]),
+							{ captureOutput: true },
+						)
+						if (result.exitCode !== 0) return null
+						return (
+							result.stdout
+								.split("\n")
+								.find((line) => line.startsWith(`${remote} `))
+								?.slice(remote.length + 1)
+								.trim() ?? null
+						)
+					}),
+			}) satisfies VersionControlBackend,
+	},
+) {}
+
+export class VersionControlService extends Effect.Service<VersionControlService>()(
+	"VersionControlService",
+	{
+		sync: () => ({
+			forWorkbase: (root: string) =>
+				Effect.gen(function* () {
+					const workbase = yield* WorkbaseService
+					const git = yield* GitVersionControlService
+					const jj = yield* JjVersionControlService
+					const { config } = yield* workbase.loadConfig(root)
+					return config.vcs === "jj" ? jj : git
+				}),
+		}),
+	},
+) {}

package/src/services/WorkbaseService.ts

@@ -23,6 +23,7 @@ import { validateWorktreeCreateCommand } from "../workbase/worktree-command"
 import { validateRunners } from "../workbase/runner-command"
 import { findDependencyCycles } from "../workbase/dependency-graph"
 import { validateDelivery } from "../workbase/delivery-command"
+import { preferredVersionControl } from "../workbase/version-control"
 
 class WorkbaseNotFoundError extends Data.TaggedError("WorkbaseNotFoundError")<{
 	readonly message: string
@@ -189,7 +190,10 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 					}
 
 					yield* fs.createDirectory(root)
-					yield* fs.writeJSON(configPath, { version: 2 })
+					yield* fs.writeJSON(configPath, {
+						version: 2,
+						vcs: preferredVersionControl(),
+					})
 					for (const directory of ["repos", "epics", "tasks"]) {
 						yield* fs.createDirectory(join(root, directory))
 					}

package/src/services/WorktreeService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { mkdir, realpath, rename, rm } from "node:fs/promises"
+import { mkdir, realpath, rename, rm, stat } from "node:fs/promises"
 import { join } from "node:path"
 import {
 	captureErrors,
@@ -23,6 +23,17 @@ const git = async (args: string[], cwd?: string) => {
 		throw new Error(await new Response(process.stderr).text())
 }
 
+const jj = async (args: string[], cwd?: string) => {
+	const process = Bun.spawn(["jj", ...args], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	})
+	await process.exited
+	if (process.exitCode !== 0)
+		throw new Error(await new Response(process.stderr).text())
+}
+
 describe("WorktreeService", () => {
 	let root: string
 	let source: string
@@ -93,6 +104,66 @@ describe("WorktreeService", () => {
 		expect(new TextDecoder().decode(branch.stdout).trim()).toBe("task/example")
 	})
 
+	test("materializes and removes a jj workspace for a jj workbase", async () => {
+		if (!Bun.which("jj")) return
+		const repository = join(root, "repos/agency")
+		await rm(repository, { recursive: true, force: true })
+		await git(["clone", source, repository])
+		await jj(["git", "init", "--colocate", repository])
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({ version: 2, vcs: "jj" }),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "jj-example",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/jj-example",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("jj-example", undefined, root),
+				),
+			),
+		)
+		const jjMetadata = await stat(join(workspace.writablePath!, ".jj"))
+		expect(jjMetadata.isFile() || jjMetadata.isDirectory()).toBe(true)
+		const inspection = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.inspect("jj-example", undefined, root),
+				),
+			),
+		)
+		expect(inspection.conflicts).toEqual([])
+		expect(inspection.checkouts[0]).toMatchObject({
+			exists: true,
+			registered: true,
+			actualBranch: "task/jj-example",
+		})
+
+		await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.remove("jj-example", undefined, root),
+				),
+			),
+		)
+		expect(await Bun.file(workspace.writablePath!).exists()).toBe(false)
+	})
+
 	test("does not fetch the origin for an existing writable worktree", async () => {
 		await runTestEffect(
 			TaskService.pipe(