@markjaquith/agency 2.56.0 → 2.57.0

package/README.md

@@ -142,9 +142,17 @@ or credential:
 
 New workbases select `"jj"` when the `jj` executable is available and otherwise
 select `"git"`. Existing version 2 workbases without `vcs` remain Git workbases.
-The selected backend is a workbase-level invariant: jj workbases initialize
-managed clones with `jj git init` and create jj workspaces, while Git workbases
-continue to use Git worktrees.
+The selected backend is a workbase-level invariant: jj workbases create
+non-colocated managed clones and jj workspaces, while Git workbases continue to
+use bare repositories and Git worktrees. Existing colocated jj repositories are
+also supported.
+
+Agency uses jj-native commands for repository validity, workspace registration,
+working-copy state, revisions, bookmarks, ancestry, fetch, and push. Raw Git is
+limited to backing-store plumbing such as durable review refs and integrations
+that require Git, including GitHub CLI commit discovery. For those operations,
+Agency obtains the backing repository with `jj git root` and supplies it as
+`GIT_DIR`; it does not use raw Git to infer jj workspace state.
 
 Inspect the current backend and migration readiness with:
 
@@ -162,6 +170,9 @@ target backend, and updates `agency.json` last. Migration from jj to Git also
 blocks jj-only heads that are not preserved by a bookmark or workspace. Failed
 migrations restore the source repositories and workspaces when rollback is
 possible and report explicit manual recovery paths otherwise.
+Converting a non-colocated jj workbase to Git is currently blocked before any
+mutation because its backing Git object store is inside `.jj`; first convert the
+repositories to colocated jj so the Git store survives metadata removal.
 
 Existing version 2 workbases without `repositories` remain valid. Run
 `agency repo setup` to preview deterministic adoption of legacy local aliases;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.56.0",
+  "version": "2.57.0",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -58,6 +58,7 @@
     "tag": "latest"
   },
   "scripts": {
+    "benchmark:sync": "bun scripts/benchmark-sync.ts",
     "test": "find src \\( -name '*.test.ts' -o -name '*.test.tsx' \\) -print0 | xargs -0 -n 1 -P 4 bun test",
     "test:opencode": "AGENCY_TEST_OPENCODE=1 bun test src/cli.test.ts --test-name-pattern 'provides effective whole-workbase OpenCode access'",
     "format": "oxfmt",

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 } from "node:fs/promises"
+import { chmod, mkdir, realpath, rm } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { PullRequestService } from "../services/PullRequestService"
 import {
@@ -31,6 +31,7 @@ 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}"
 `,
 		)
@@ -109,6 +110,41 @@ 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
 	}
 
@@ -187,6 +223,7 @@ status: open
 			"--repo",
 			"example/agency",
 			"--web",
+			expect.stringMatching(/^GIT_DIR=.*\.jj/),
 		])
 
 		expect(
@@ -202,6 +239,7 @@ status: open
 			"example/agency",
 			"--title",
 			"Example",
+			expect.stringMatching(/^GIT_DIR=.*\.jj/),
 		])
 	})
 
@@ -215,6 +253,7 @@ status: open
 			await realpath(join(task, "code/agency")),
 			"pr",
 			...args,
+			expect.stringMatching(/^GIT_DIR=.*\.jj/),
 		])
 	})
 

package/src/commands/pr.ts

@@ -3,6 +3,7 @@ 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"
@@ -84,6 +85,7 @@ export const pr = (args: readonly string[], cwd: string = process.cwd()) =>
 		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 })
@@ -94,6 +96,7 @@ export const pr = (args: readonly string[], cwd: string = process.cwd()) =>
 				: null
 		const focusedCwd = writableCheckout ?? invocationCwd
 		let forwardedArgs = args
+		let environment: Record<string, string> = {}
 		if (
 			writableCheckout &&
 			context?.workbase.vcs === "jj" &&
@@ -111,10 +114,13 @@ export const pr = (args: readonly string[], cwd: string = process.cwd()) =>
 					repositoryFromRemote(remote),
 				)
 			}
+			const backend = yield* versionControl.forWorkbase(context.workbase.root)
+			environment = yield* backend.gitEnvironment(writableCheckout)
 		}
 		const result = yield* fs.runCommand(["gh", "pr", ...forwardedArgs], {
 			cwd: focusedCwd,
 			passthrough: true,
+			env: environment,
 		})
 		return result.exitCode
 	})

package/src/commands/sync.test.ts

@@ -9,6 +9,7 @@ import {
 	createTempDir,
 	runTestEffect,
 } from "../test-utils"
+import type { Progress } from "../utils/progress"
 import { sync } from "./sync"
 
 const git = async (args: string[], cwd: string) => {
@@ -97,4 +98,30 @@ describe("sync command", () => {
 			],
 		})
 	})
+
+	test("reports human-readable progress without polluting JSON output", async () => {
+		const updates: string[] = []
+		const progress: Progress = {
+			start: (message) => updates.push(`start:${message}`),
+			succeed: (message) => updates.push(`succeed:${message}`),
+			fail: (message) => updates.push(`fail:${message}`),
+		}
+
+		await captureLogs(() =>
+			runTestEffect(sync({ cwd: root, silent: false }, progress)),
+		)
+		expect(updates).toEqual([
+			"start:Validating workbase",
+			"start:Inspected 1 repositories",
+			"start:Queried pull requests 1/1 (task:example)",
+			"start:Reconciled execution units 1/1 (task:example)",
+			"succeed:Synchronized 1 execution units",
+		])
+
+		updates.length = 0
+		await captureLogs(() =>
+			runTestEffect(sync({ cwd: root, dryRun: true, json: true }, progress)),
+		)
+		expect(updates).toEqual([])
+	})
 })

package/src/commands/sync.ts

@@ -2,19 +2,54 @@ import { Effect } from "effect"
 import { SyncService } from "../services/SyncService"
 import type { BaseCommandOptions } from "../utils/command"
 import { createLoggers } from "../utils/effect"
+import { createProgress, type Progress } from "../utils/progress"
 
 interface SyncCommandOptions extends BaseCommandOptions {
 	readonly dryRun?: boolean
 }
 
-export const sync = (options: SyncCommandOptions = {}) =>
+export const sync = (
+	options: SyncCommandOptions = {},
+	progress: Progress = createProgress({
+		silent: options.silent || options.json,
+	}),
+) =>
 	Effect.gen(function* () {
 		const service = yield* SyncService
 		const { log } = createLoggers(options)
-		const result = yield* service.reconcile({
-			cwd: options.cwd,
-			apply: options.dryRun !== true,
-		})
+		const showProgress = !options.silent && !options.json
+		if (showProgress) progress.start("Validating workbase")
+		const result = yield* service
+			.reconcile({
+				cwd: options.cwd,
+				apply: options.dryRun !== true,
+				onProgress: showProgress
+					? ({ stage, current, total, target }) => {
+							if (stage === "repositories") {
+								progress.start(`Inspected ${total} repositories`)
+							} else if (stage === "pull-requests") {
+								progress.start(
+									`Queried pull requests ${current}/${total}${target ? ` (${target})` : ""}`,
+								)
+							} else {
+								progress.start(
+									`Reconciled execution units ${current}/${total}${target ? ` (${target})` : ""}`,
+								)
+							}
+						}
+					: undefined,
+			})
+			.pipe(
+				Effect.tapError(() =>
+					Effect.sync(() => {
+						if (showProgress) progress.fail("Workbase sync failed")
+					}),
+				),
+			)
+		if (showProgress)
+			progress.succeed(
+				`Synchronized ${result.executions.length} execution units`,
+			)
 		if (options.json) return log(JSON.stringify(result, null, 2))
 
 		for (const action of result.repositories.actions) {

package/src/services/ContextService.ts

@@ -973,17 +973,34 @@ export class ContextService extends Effect.Service<ContextService>()(
 							...(yield* inspectCheckout(repositoryPath, checkoutPath)),
 						})
 					}
-					const reviewSourceCommit = reviewData
-						? yield* runGit(fs, join(root, "repos", reviewData.repo), [
-								"ls-remote",
-								"origin",
-								reviewData.source.kind === "pull-request"
-									? reviewData.source.fetchRef
-									: reviewData.source.ref
-											.replace(/^refs\/remotes\/origin\//, "")
-											.replace(/^origin\//, ""),
-							])
+					const reviewRepository = reviewData
+						? repositories.get(reviewData.repo)
 						: null
+					const reviewSourceCommit =
+						reviewData && reviewRepository?.remote
+							? yield* fs
+									.runCommand(
+										[
+											"git",
+											"ls-remote",
+											reviewRepository.remote,
+											reviewData.source.kind === "pull-request"
+												? reviewData.source.fetchRef
+												: reviewData.source.ref
+														.replace(/^refs\/remotes\/origin\//, "")
+														.replace(/^origin\//, ""),
+										],
+										{ captureOutput: true },
+									)
+									.pipe(
+										Effect.map((result) =>
+											result.exitCode === 0
+												? result.stdout.trim() || null
+												: null,
+										),
+										Effect.catchAll(() => Effect.succeed(null)),
+									)
+							: null
 
 					const checkoutStates = [writable, ...referenceCheckouts].filter(
 						(value): value is NonNullable<typeof value> => value !== null,

package/src/services/DoctorService.ts

@@ -396,17 +396,12 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 						for (const source of reviewSources.filter(
 							(item) => item.repo === repository.alias,
 						)) {
-							const observed = yield* fs.runCommand(
-								[
-									"git",
-									"-C",
-									repository.path,
-									"ls-remote",
-									"origin",
-									source.ref,
-								],
-								{ captureOutput: true },
-							)
+							const observed = repository.remote
+								? yield* fs.runCommand(
+										["git", "ls-remote", repository.remote, source.ref],
+										{ captureOutput: true },
+									)
+								: { exitCode: -1, stdout: "", stderr: "origin unavailable" }
 							const available =
 								observed.exitCode === 0 && Boolean(observed.stdout.trim())
 							add({

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({