@markjaquith/agency 2.73.2 → 3.0.0

package/src/services/SyncService.test.ts

@@ -22,18 +22,6 @@ const git = async (args: string[], cwd?: string) => {
 	}
 }
 
-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("SyncService", () => {
 	let root: string
 	let originalPath: string | undefined
@@ -126,75 +114,6 @@ pr: null
 		expect(await Bun.file(join(root, "repos/agency")).exists()).toBe(false)
 	})
 
-	test("reconciles jj workspaces through the jj backend", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		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" }),
-		)
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							id: "jj-sync",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/jj-sync",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-		const capture = join(root, "gh-capture")
-		process.env.GH_CAPTURE = capture
-
-		const planned = await runTestEffect(
-			SyncService.pipe(
-				Effect.flatMap((service) => service.reconcile({ cwd: root })),
-			),
-		)
-		expect(planned.changes).toContainEqual(
-			expect.objectContaining({
-				kind: "materialize-workspace",
-				target: "task:jj-sync",
-				status: "planned",
-			}),
-		)
-		const invocation = await Bun.file(capture).text()
-		expect(invocation).toContain("--repo\n")
-		expect(invocation).not.toContain("baseRepository")
-		expect(invocation).toContain("GIT_DIR=")
-		expect(invocation).toContain(".jj")
-
-		const applied = await runTestEffect(
-			SyncService.pipe(
-				Effect.flatMap((service) =>
-					service.reconcile({ cwd: root, apply: true }),
-				),
-			),
-		)
-		expect(applied.executions[0]?.checkouts[0]).toMatchObject({
-			exists: true,
-			registered: true,
-			branch: "task/jj-sync",
-			dirty: false,
-		})
-		delete process.env.GH_CAPTURE
-	})
-
 	test("observes drift without mutation and applies only safe transitions", async () => {
 		await runTestEffect(
 			TaskService.pipe(

package/src/services/SyncService.ts

@@ -352,7 +352,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						const registered: RegisteredWorktree[] = []
 						for (const item of listed.right) {
 							registered.push({
-								head: backend.kind === "jj" ? (item.head ?? null) : item.commit,
+								head: item.commit,
 								branch: item.branch,
 								path: (yield* fs.exists(item.path))
 									? yield* fs.realPath(item.path)
@@ -421,9 +421,6 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 										env: resolved.environment,
 									})
 								} else if (!config.delivery && existing) {
-									const environment = yield* Effect.either(
-										backend.gitEnvironment(repositoryPath),
-									)
 									result = yield* runExternal(
 										[
 											"gh",
@@ -435,13 +432,10 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 										],
 										{
 											cwd: repositoryPath,
-											env: Either.isRight(environment) ? environment.right : {},
+											env: {},
 										},
 									)
 								} else if (!config.delivery) {
-									const environment = yield* Effect.either(
-										backend.gitEnvironment(repositoryPath),
-									)
 									result = yield* runExternal(
 										[
 											"gh",
@@ -458,7 +452,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 										],
 										{
 											cwd: repositoryPath,
-											env: Either.isRight(environment) ? environment.right : {},
+											env: {},
 										},
 									)
 								}
@@ -550,34 +544,15 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							: (yield* fs.isDirectory(codePath))
 								? join(yield* fs.realPath(codePath), checkout.repo)
 								: resolve(checkoutPath)
-						let atPath = registered.find((item) => item.path === expectedPath)
-						if (backend.kind === "jj" && atPath && "branch" in checkout) {
-							atPath = { ...atPath, branch: checkout.branch }
-						}
-						if (
-							backend.kind === "jj" &&
-							atPath &&
-							exists &&
-							atPath.head === null
-						) {
-							atPath = {
-								...atPath,
-								head: yield* backend.workspaceHead(checkoutPath),
-							}
-						}
+						const atPath = registered.find((item) => item.path === expectedPath)
 						const branchRef =
-							"branch" in checkout
-								? backend.kind === "jj"
-									? checkout.branch
-									: `refs/heads/${checkout.branch}`
-								: null
-						const branchElsewhere =
-							branchRef && backend.kind !== "jj"
-								? registered.find(
-										(item) =>
-											item.branch === branchRef && item.path !== expectedPath,
-									)
-								: undefined
+							"branch" in checkout ? `refs/heads/${checkout.branch}` : null
+						const branchElsewhere = branchRef
+							? registered.find(
+									(item) =>
+										item.branch === branchRef && item.path !== expectedPath,
+								)
+							: undefined
 						if ("branch" in checkout && !exists && !branchElsewhere) {
 							const branch = yield* backend.resolveRevision(
 								repositoryPath,
@@ -773,9 +748,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 											head: checkout.resolvedCommit,
 											branch:
 												checkout.kind === "writable"
-													? backend.kind === "jj"
-														? checkout.requestedRef
-														: `refs/heads/${checkout.requestedRef}`
+													? `refs/heads/${checkout.requestedRef}`
 													: null,
 											dirty: false,
 										})

package/src/services/TaskPhaseService.test.ts

@@ -7,13 +7,6 @@ import { EpicService } from "./EpicService"
 import { TaskService } from "./TaskService"
 import { PhaseService } from "./PhaseService"
 import { PullRequestService } from "./PullRequestService"
-import { WorktreeService } from "./WorktreeService"
-
-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("task and phase services", () => {
 	let root: string
@@ -528,79 +521,6 @@ describe("task and phase services", () => {
 		})
 	})
 
-	test("recreates jj workspaces when converting a task to phases", async () => {
-		if (!Bun.which("jj")) return
-		const source = join(root, "source")
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		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)
-		await run(["git", "clone", source, repository])
-		await run(["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-single",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/jj-single",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-		const workspace = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-single", undefined, root),
-				),
-			),
-		)
-
-		await runTestEffect(
-			PhaseService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							taskId: "jj-single",
-							id: "extra",
-							firstPhase: "implementation",
-							repo: "agency",
-							branch: "task/extra",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-
-		const moved = join(
-			root,
-			"tasks/jj-single/phases/implementation/code/agency",
-		)
-		expect(await Bun.file(workspace.codePath).exists()).toBe(false)
-		expect(await Bun.file(join(moved, "README.md")).text()).toBe("example\n")
-		const listed = Bun.spawnSync(
-			["jj", "-R", repository, "workspace", "list", "-T", 'root ++ "\\n"'],
-			{ stdout: "pipe" },
-		)
-		expect(new TextDecoder().decode(listed.stdout)).toContain(moved)
-	})
-
 	test("preserves non-PR completion when converting a task to phases", async () => {
 		await runTestEffect(
 			TaskService.pipe(

package/src/services/TaskService.ts

@@ -4,7 +4,6 @@ import { readdir } from "node:fs/promises"
 import { join } from "node:path"
 import { FileSystemService } from "./FileSystemService"
 import { WorkbaseService, type ValidationReport } from "./WorkbaseService"
-import { VersionControlService } from "./VersionControlService"
 import { EpicService, type EpicRecord } from "./EpicService"
 import {
 	EntityId,
@@ -231,7 +230,6 @@ 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)
@@ -375,13 +373,7 @@ 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),
-					)
-				}
+				const reviewEnvironment: Record<string, string> = {}
 				yield* runLifecycleTransaction({
 					root,
 					preconditions: [

package/src/services/VersionControlService.test.ts

@@ -1,6 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test"
 import { Effect, Layer } from "effect"
-import { mkdir, realpath, stat } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import {
@@ -8,13 +7,6 @@ import {
 	VersionControlService,
 } from "./VersionControlService"
 import { FileSystemService } from "./FileSystemService"
-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[] = []
@@ -23,11 +15,6 @@ describe("VersionControlService", () => {
 		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("inspects a Git repository with one subprocess", async () => {
 		const commands: readonly string[][] = []
 		const fileSystem = {
@@ -61,115 +48,15 @@ describe("VersionControlService", () => {
 		})
 	})
 
-	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)
-	})
-
-	test("clones non-colocated jj repositories and exposes their backing Git directory", async () => {
-		if (!Bun.which("jj")) return
+	test("selects Git for legacy and explicit Git workbases", async () => {
 		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(
+		await Bun.write(join(root, "agency.json"), JSON.stringify({ version: 2 }))
+		const selected = 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),
-		})
+		expect(selected.kind).toBe("git")
 	})
 })