@markjaquith/agency 2.74.0 → 3.1.0

package/src/commands/context.test.ts

@@ -219,73 +219,6 @@ Phase prose.
 		)
 	})
 
-	test("reports the current jj change without inventing a missing bookmark", async () => {
-		if (!Bun.which("jj")) return
-		await cleanupTempDir(root)
-		root = await createTempDir()
-		const remote = join(root, "remote.git")
-		const seed = join(root, "seed")
-		const repository = join(root, "repos/agency")
-		const checkout = join(root, "tasks/example/code/agency")
-		await mkdir(join(root, "repos"), { recursive: true })
-		await write(root, "agency.json", '{"version":2,"vcs":"jj"}\n')
-		await run(root, ["git", "init", "--bare", "--initial-branch=main", remote])
-		await run(root, ["git", "init", "--initial-branch=main", seed])
-		await run(seed, ["git", "config", "user.email", "test@example.com"])
-		await run(seed, ["git", "config", "user.name", "Test"])
-		await Bun.write(join(seed, "README.md"), "example\n")
-		await run(seed, ["git", "add", "README.md"])
-		await run(seed, ["git", "commit", "-m", "initial"])
-		await run(seed, ["git", "remote", "add", "origin", remote])
-		await run(seed, ["git", "push", "origin", "main"])
-		await run(root, ["jj", "git", "clone", "--no-colocate", remote, repository])
-		await write(
-			root,
-			"tasks/example/TASK.md",
-			`---
-ticketUrl: null
-repo: agency
-branch: task/example
-base: main
-pr: null
-status: working
----
-
-# Example
-`,
-		)
-		await mkdir(dirname(checkout), { recursive: true })
-		await run(repository, [
-			"jj",
-			"workspace",
-			"add",
-			"--name",
-			"task-example",
-			"-r",
-			"main",
-			checkout,
-		])
-		await Bun.write(join(checkout, "feature.txt"), "current change\n")
-		const current = Bun.spawn(
-			["jj", "log", "--no-graph", "-r", "@", "-T", "commit_id"],
-			{ cwd: checkout, stdout: "pipe", stderr: "pipe" },
-		)
-		const currentCommit = (await new Response(current.stdout).text()).trim()
-		expect(await current.exited).toBe(0)
-
-		const result = await readContext(root, "tasks/example", false, true)
-		expect(result.workspace.writable).toMatchObject({
-			branchCommit: null,
-			checkoutCommit: currentCommit,
-			checkoutBranch: null,
-			detached: true,
-			dirty: false,
-		})
-		expect(result.workspace.warnings).toContain(
-			`Unable to resolve branch 'task/example' in ${repository}`,
-		)
-	})
-
 	test("defaults to compact while preserving explicit compact compatibility", async () => {
 		const result = await readContext(
 			root,

package/src/commands/init.test.ts

@@ -8,7 +8,6 @@ import {
 	runTestEffect,
 } from "../test-utils"
 import { init } from "./init"
-import { preferredVersionControl } from "../workbase/version-control"
 
 describe("init command", () => {
 	let parent: string
@@ -27,7 +26,7 @@ describe("init command", () => {
 
 		expect(await Bun.file(join(root, "agency.json")).json()).toEqual({
 			version: 2,
-			vcs: preferredVersionControl(),
+			vcs: "git",
 		})
 		for (const directory of ["repos", "epics", "tasks"]) {
 			expect((await stat(join(root, directory))).isDirectory()).toBe(true)

package/src/commands/pr.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { chmod, mkdir, realpath, rm } from "node:fs/promises"
+import { chmod, mkdir, realpath } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { PullRequestService } from "../services/PullRequestService"
 import {
@@ -31,7 +31,6 @@ describe("pr command", () => {
 			join(bin, "gh"),
 			`#!/bin/sh
 printf '%s\n' "$PWD" "$@" > "$GH_CAPTURE"
-if [ -n "$GIT_DIR" ]; then printf 'GIT_DIR=%s\n' "$GIT_DIR" >> "$GH_CAPTURE"; fi
 exit "\${GH_EXIT:-0}"
 `,
 		)
@@ -51,14 +50,13 @@ exit "\${GH_EXIT:-0}"
 	const captured = async () =>
 		(await Bun.file(capturePath).text()).trim().split("\n")
 
-	const createExecutionWorkbase = async (vcs: "git" | "jj" = "git") => {
+	const createExecutionWorkbase = async () => {
 		const root = join(tempRoot, "workbase")
 		await write(
 			root,
 			"agency.json",
 			`${JSON.stringify({
 				version: 2,
-				vcs,
 				repositories: {
 					agency: { remote: "https://github.com/example/agency.git" },
 				},
@@ -110,41 +108,6 @@ status: open
 # Build
 `,
 		)
-		if (vcs === "jj") {
-			const repository = join(root, "repos/agency")
-			await rm(join(root, "tasks/single/code/agency"), { recursive: true })
-			await rm(join(root, "tasks/multi/phases/build/code/agency"), {
-				recursive: true,
-			})
-			const initialized = Bun.spawn(
-				["jj", "git", "init", "--no-colocate", repository],
-				{ stdout: "pipe", stderr: "pipe" },
-			)
-			if ((await initialized.exited) !== 0)
-				throw new Error(await new Response(initialized.stderr).text())
-			for (const [name, path] of [
-				["single", join(root, "tasks/single/code/agency")],
-				["build", join(root, "tasks/multi/phases/build/code/agency")],
-			] as const) {
-				const workspace = Bun.spawn(
-					[
-						"jj",
-						"-R",
-						repository,
-						"workspace",
-						"add",
-						"--name",
-						name,
-						"-r",
-						"root()",
-						path,
-					],
-					{ stdout: "pipe", stderr: "pipe" },
-				)
-				if ((await workspace.exited) !== 0)
-					throw new Error(await new Response(workspace.stderr).text())
-			}
-		}
 		return root
 	}
 
@@ -261,54 +224,6 @@ status: working
 		])
 	})
 
-	test("injects the execution branch and repository for jj targets", async () => {
-		const root = await createExecutionWorkbase("jj")
-		const task = join(root, "tasks/single")
-		const phase = join(root, "tasks/multi/phases/build")
-
-		expect(await runTestEffect(pr(["view", "--web"], task))).toBe(0)
-		expect(await captured()).toEqual([
-			await realpath(join(task, "code/agency")),
-			"pr",
-			"view",
-			"feat/single",
-			"--repo",
-			"example/agency",
-			"--web",
-			expect.stringMatching(/^GIT_DIR=.*\.jj/),
-		])
-
-		expect(
-			await runTestEffect(pr(["create", "--title", "Example"], phase)),
-		).toBe(0)
-		expect(await captured()).toEqual([
-			await realpath(join(phase, "code/agency")),
-			"pr",
-			"create",
-			"--head",
-			"feat/build",
-			"--repo",
-			"example/agency",
-			"--title",
-			"Example",
-			expect.stringMatching(/^GIT_DIR=.*\.jj/),
-		])
-	})
-
-	test("preserves explicit jj PR and repository targets", async () => {
-		const root = await createExecutionWorkbase("jj")
-		const task = join(root, "tasks/single")
-		const args = ["view", "123", "--repo", "other/repository"]
-
-		expect(await runTestEffect(pr(args, task))).toBe(0)
-		expect(await captured()).toEqual([
-			await realpath(join(task, "code/agency")),
-			"pr",
-			...args,
-			expect.stringMatching(/^GIT_DIR=.*\.jj/),
-		])
-	})
-
 	test("falls back to the invocation directory without execution authority", async () => {
 		const root = await createExecutionWorkbase()
 		const orchestration = join(root, "tasks/multi")

package/src/commands/pr.ts

@@ -3,11 +3,8 @@ import { resolve } from "node:path"
 import { ContextService } from "../services/ContextService"
 import { FileSystemService } from "../services/FileSystemService"
 import { PullRequestService } from "../services/PullRequestService"
-import { VersionControlService } from "../services/VersionControlService"
-import { WorkbaseService } from "../services/WorkbaseService"
 import type { BaseCommandOptions } from "../utils/command"
 import { createLoggers } from "../utils/effect"
-import { repositoryFromRemote } from "../workbase/delivery-command"
 
 interface PrCreateOptions extends BaseCommandOptions {
 	readonly taskId: string
@@ -20,56 +17,6 @@ interface PrCreateOptions extends BaseCommandOptions {
 	readonly labels?: readonly string[]
 }
 
-const branchTargetCommands = new Set([
-	"checkout",
-	"checks",
-	"close",
-	"comment",
-	"diff",
-	"edit",
-	"lock",
-	"merge",
-	"ready",
-	"reopen",
-	"revert",
-	"review",
-	"unlock",
-	"update-branch",
-	"view",
-])
-
-const hasOption = (args: readonly string[], short: string, long: string) =>
-	args.some(
-		(argument) =>
-			argument === short ||
-			argument.startsWith(`${short}=`) ||
-			argument === long ||
-			argument.startsWith(`${long}=`),
-	)
-
-const withJjContext = (
-	args: readonly string[],
-	branch: string,
-	repository: string,
-) => {
-	const [command, ...rest] = args
-	if (!command) return args
-
-	const branchArgs =
-		(command === "create" || command === "new") &&
-		!hasOption(rest, "-H", "--head")
-			? ["--head", branch]
-			: branchTargetCommands.has(command) &&
-				  (rest.length === 0 || rest[0]?.startsWith("-"))
-				? [branch]
-				: []
-	const repositoryArgs = hasOption(rest, "-R", "--repo")
-		? []
-		: ["--repo", repository]
-
-	return [command, ...branchArgs, ...repositoryArgs, ...rest]
-}
-
 export const prCreate = (options: PrCreateOptions) =>
 	Effect.gen(function* () {
 		const pullRequests = yield* PullRequestService
@@ -88,8 +35,6 @@ export const pr = (args: readonly string[], cwd: string = process.cwd()) =>
 	Effect.gen(function* () {
 		const contexts = yield* ContextService
 		const fs = yield* FileSystemService
-		const workbase = yield* WorkbaseService
-		const versionControl = yield* VersionControlService
 		const invocationCwd = resolve(cwd)
 		const context = yield* contexts
 			.get({ cwd: invocationCwd, target: ".", compact: true })
@@ -104,30 +49,9 @@ export const pr = (args: readonly string[], cwd: string = process.cwd()) =>
 				: null
 		const focusedCheckout = writableCheckout ?? reviewCheckout
 		const focusedCwd = focusedCheckout ?? invocationCwd
-		let forwardedArgs = args
-		let environment: Record<string, string> = {}
-		if (focusedCheckout && context?.workbase.vcs === "jj") {
-			if (writableCheckout && context.authority.writable) {
-				const execution =
-					context.documents?.phase?.data ?? context.documents?.task?.data
-				const { config } = yield* workbase.loadConfig(context.workbase.root)
-				const remote =
-					config.repositories?.[context.authority.writable.repo]?.remote
-				if (execution && "branch" in execution && remote) {
-					forwardedArgs = withJjContext(
-						args,
-						execution.branch,
-						repositoryFromRemote(remote),
-					)
-				}
-			}
-			const backend = yield* versionControl.forWorkbase(context.workbase.root)
-			environment = yield* backend.gitEnvironment(focusedCheckout)
-		}
-		const result = yield* fs.runCommand(["gh", "pr", ...forwardedArgs], {
+		const result = yield* fs.runCommand(["gh", "pr", ...args], {
 			cwd: focusedCwd,
 			passthrough: true,
-			env: environment,
 		})
 		return result.exitCode
 	})
@@ -139,8 +63,7 @@ Usage: agency pr create <task-id> [phase-id] [options]
 Create records a pull request for an Agency execution unit and accepts the
 options listed below. Invocations without an Agency task target run gh pr
 unchanged, focusing the writable repository checkout when invoked from
-an Agency execution task or phase. In jj workbases, Agency supplies the declared
-branch and repository to gh subcommands that would otherwise infer Git context.
+an Agency execution task or phase.
 
 Options:
   --draft                   Create the pull request as a draft

package/src/commands/push.test.ts

@@ -14,13 +14,12 @@ describe("push command", () => {
 			fail: (message) => updates.push(`fail:${message}`),
 		}
 		const result = {
-			vcs: "jj" as const,
+			vcs: "git" as const,
 			taskId: "example",
 			branch: "task/example",
 			base: "main",
 			remote: "origin",
 			tip: "abc123",
-			changeId: "change",
 		}
 		const logs = await captureLogs(() =>
 			Effect.runPromise(

package/src/graph-schema.ts

@@ -57,7 +57,7 @@ export const GraphReadiness = Schema.Struct({
 
 export const GraphWorkbase = Schema.Struct({
 	version: Schema.Literal(2),
-	vcs: Schema.optional(Schema.Literal("git", "jj")),
+	vcs: Schema.optional(Schema.Literal("git")),
 	root: Schema.optional(Schema.String),
 })
 

package/src/services/ArchiveBulkService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { chmod, mkdir, rm } from "node:fs/promises"
+import { chmod, mkdir } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { ArchiveService } from "./ArchiveService"
@@ -17,13 +17,6 @@ const git = (args: readonly string[], cwd?: string) => {
 	}
 }
 
-const jj = (args: readonly string[], cwd?: string) => {
-	const result = Bun.spawnSync(["jj", ...args], { cwd })
-	if (result.exitCode !== 0) {
-		throw new Error(new TextDecoder().decode(result.stderr))
-	}
-}
-
 describe("ArchiveService bulk task archive", () => {
 	let root: string
 	let source: string
@@ -430,140 +423,6 @@ claim:
 		])
 	})
 
-	test("skips a dirty jj workspace", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		git(["clone", source, repository])
-		const initialized = Bun.spawnSync([
-			"jj",
-			"git",
-			"init",
-			"--colocate",
-			repository,
-		])
-		if (initialized.exitCode !== 0) {
-			throw new Error(new TextDecoder().decode(initialized.stderr))
-		}
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-		await createTask("jj-dirty")
-		await dropTask("jj-dirty")
-		const workspace = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-dirty", undefined, root),
-				),
-			),
-		)
-		await Bun.write(join(workspace.writablePath!, "dirty.txt"), "keep\n")
-
-		const result = await archiveTasks()
-
-		expect(result.tasks[0]).toMatchObject({
-			id: "jj-dirty",
-			disposition: "skipped",
-			reason: { code: "dirty-worktree" },
-		})
-		expect(
-			await Bun.file(join(workspace.writablePath!, "dirty.txt")).exists(),
-		).toBe(true)
-	})
-
-	test("archives a jj working-copy commit preserved by its task bookmark", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		git(["clone", source, repository])
-		jj(["git", "init", "--colocate", repository])
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-		await createTask("jj-bookmarked")
-		await dropTask("jj-bookmarked")
-		const workspace = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-bookmarked", undefined, root),
-				),
-			),
-		)
-		await Bun.write(join(workspace.writablePath!, "preserved.txt"), "keep\n")
-		jj(
-			["bookmark", "set", "task/jj-bookmarked", "-r", "@"],
-			workspace.writablePath!,
-		)
-
-		const preview = await archiveTasks(true)
-		expect(preview.tasks[0]).toMatchObject({
-			id: "jj-bookmarked",
-			disposition: "planned",
-			removedWorktrees: [workspace.writablePath!],
-		})
-		expect(
-			await Bun.file(join(workspace.writablePath!, "preserved.txt")).text(),
-		).toBe("keep\n")
-
-		const result = await archiveTasks()
-		expect(result.tasks[0]).toMatchObject({
-			id: "jj-bookmarked",
-			disposition: "archived",
-		})
-		expect(await Bun.file(workspace.writablePath!).exists()).toBe(false)
-		const preserved = Bun.spawnSync([
-			"jj",
-			"-R",
-			repository,
-			"file",
-			"show",
-			"-r",
-			"task/jj-bookmarked",
-			'root:"preserved.txt"',
-		])
-		if (preserved.exitCode !== 0) {
-			throw new Error(preserved.stderr.toString())
-		}
-		expect(preserved.stdout.toString()).toBe("keep\n")
-	})
-
-	test("archives a forgotten jj workspace preserved by its task bookmark", async () => {
-		if (!Bun.which("jj")) return
-		const repository = join(root, "repos/agency")
-		await rm(repository, { recursive: true, force: true })
-		git(["clone", source, repository])
-		jj(["git", "init", "--colocate", repository])
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-		await createTask("jj-stale")
-		await dropTask("jj-stale")
-		const workspace = await runTestEffect(
-			WorktreeService.pipe(
-				Effect.flatMap((service) =>
-					service.materialize("jj-stale", undefined, root),
-				),
-			),
-		)
-		await Bun.write(join(workspace.writablePath!, "preserved.txt"), "keep\n")
-		jj(["bookmark", "set", "task/jj-stale", "-r", "@"], workspace.writablePath!)
-		jj(["-R", repository, "workspace", "forget", "agency-jj-stale-task-agency"])
-
-		const result = await archiveTasks(true)
-
-		expect(result.tasks[0]).toMatchObject({
-			id: "jj-stale",
-			disposition: "planned",
-			removedWorktrees: [workspace.writablePath!],
-		})
-		expect(
-			await Bun.file(join(workspace.writablePath!, "preserved.txt")).text(),
-		).toBe("keep\n")
-	})
-
 	test("rolls back the entire cohort when application fails", async () => {
 		await runTestEffect(
 			EpicService.pipe(