@markjaquith/agency 2.73.0 → 2.73.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.73.0",
+  "version": "2.73.2",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",

package/src/cli-parser.test.ts

@@ -229,7 +229,9 @@ describe("strict CLI parsing", () => {
 	test("parses addressable resource maintenance commands", () => {
 		for (const args of [
 			["doctor", "--json"],
+			["repo", "materialize", "--help"],
 			["repo", "show", "agency", "--json"],
+			["repo", "materialize", "agency", "--json"],
 			["repo", "fetch", "agency"],
 			["repo", "remove", "agency"],
 			["repo", "unlink", "agency"],
@@ -270,6 +272,7 @@ describe("strict CLI parsing", () => {
 			[["integration", "sync", "extra"], "agency integration sync"],
 			[["repo", "add", "a", "b", "extra"], "agency repo add"],
 			[["repo", "link", "a", "b", "extra"], "agency repo link"],
+			[["repo", "materialize", "a", "extra"], "agency repo materialize"],
 			[["repo", "list", "extra"], "agency repo list"],
 			[
 				[

package/src/cli-parser.ts

@@ -259,7 +259,7 @@ const commands = {
 	},
 	repo: {
 		usage:
-			"agency repo <setup|add|link|list|show|fetch|remove|unlink|rename|remote|verify>",
+			"agency repo <setup|add|link|materialize|list|show|fetch|remove|unlink|rename|remote|verify>",
 		options: {
 			...outputOptions,
 			"dry-run": { type: "boolean" },
@@ -285,6 +285,12 @@ const commands = {
 				maxArgs: 2,
 				options: ["json"],
 			},
+			materialize: {
+				usage: "agency repo materialize <alias> [--json]",
+				minArgs: 1,
+				maxArgs: 1,
+				options: ["json"],
+			},
 			list: {
 				usage: "agency repo list [--json]",
 				minArgs: 0,

package/src/cli.test.ts

@@ -934,6 +934,48 @@ status: open
 		})
 	})
 
+	test("materializes a linked repository through the CLI", async () => {
+		const parent = await createTempDir()
+		tempDirs.push(parent)
+		const root = join(parent, "workbase")
+		const source = join(parent, "source")
+		await runGit(["init", "--initial-branch=main", source])
+		await Bun.write(join(source, "README.md"), "materialize\n")
+		for (const args of [
+			["config", "user.email", "test@example.com"],
+			["config", "user.name", "Test"],
+			["add", "README.md"],
+			["-c", "commit.gpgsign=false", "commit", "-m", "initial"],
+			[
+				"remote",
+				"add",
+				"origin",
+				"https://example.com/agency-tests/source.git",
+			],
+		]) {
+			await runGit(["-C", source, ...args])
+		}
+
+		parseJson(await runCli(["init", root, "--json"], parent))
+		const configPath = join(root, "agency.json")
+		await Bun.write(
+			configPath,
+			JSON.stringify({ ...(await Bun.file(configPath).json()), vcs: "git" }),
+		)
+		parseJson(await runCli(["repo", "link", "agency", source, "--json"], root))
+		const materialized = parseJson(
+			await runCli(["repo", "materialize", "agency", "--json"], root),
+		)
+
+		expect(materialized).toMatchObject({
+			alias: "agency",
+			kind: "bare",
+			target: null,
+			states: ["declared", "materialized"],
+		})
+		expect(await Bun.file(join(root, "repos/agency/HEAD")).exists()).toBe(true)
+	})
+
 	test("prepares a workspace and reports a non-mutating dry-run", async () => {
 		const parent = await createTempDir()
 		tempDirs.push(parent)

package/src/services/RepositoryService.test.ts

@@ -212,6 +212,13 @@ status: working
 			"main",
 		])
 		await Bun.write(join(checkout, "dirty.txt"), "preserved\n")
+		await runGit([
+			"-C",
+			target,
+			"update-ref",
+			"refs/agency/reviews/active",
+			"main",
+		])
 
 		const result = await runTestEffect(
 			RepositoryService.pipe(
@@ -238,6 +245,96 @@ status: working
 		expect(await Bun.file(join(root, "tasks/active/TASK.md")).text()).toContain(
 			"repo: linked",
 		)
+		expect(
+			await gitOutput([
+				"--git-dir",
+				join(root, "repos/linked"),
+				"rev-parse",
+				"refs/agency/reviews/active",
+			]),
+		).toBe(await gitOutput(["-C", target, "rev-parse", "main"]))
+	})
+
+	test("preserves detached registered worktree commits from a shallow linked repository", async () => {
+		const upstream = join(root, "upstream")
+		const target = join(root, "shallow-linked-repository")
+		const checkout = join(root, "tasks/detached/code/linked")
+		await runGit(["init", "--bare", "--initial-branch=main", upstream])
+		const seed = join(root, "seed")
+		await runGit(["clone", upstream, seed])
+		await runGit(["-C", seed, "config", "user.email", "test@example.com"])
+		await runGit(["-C", seed, "config", "user.name", "Test"])
+		await Bun.write(join(seed, "README.md"), "shallow\n")
+		await runGit(["-C", seed, "add", "README.md"])
+		await runGit(["-C", seed, "commit", "-m", "initial"])
+		await runGit(["-C", seed, "push", "origin", "main"])
+		await runGit(["clone", "--depth=1", `file://${upstream}`, target])
+		await runGit(["-C", target, "config", "user.email", "test@example.com"])
+		await runGit(["-C", target, "config", "user.name", "Test"])
+		await runGit([
+			"-C",
+			target,
+			"remote",
+			"set-url",
+			"origin",
+			portableRemote("shallow-materialized"),
+		])
+		await mkdir(dirname(checkout), { recursive: true })
+		await runGit([
+			"-C",
+			target,
+			"worktree",
+			"add",
+			"--detach",
+			checkout,
+			"main",
+		])
+		await Bun.write(join(checkout, "detached.txt"), "preserved\n")
+		await runGit(["-C", checkout, "add", "detached.txt"])
+		await runGit(["-C", checkout, "commit", "-m", "detached work"])
+		const detachedCommit = await gitOutput([
+			"-C",
+			checkout,
+			"rev-parse",
+			"HEAD",
+		])
+		await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.link("linked", target, root)),
+			),
+		)
+
+		await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.materialize("linked", root)),
+			),
+		)
+
+		expect(await gitOutput(["-C", checkout, "rev-parse", "HEAD"])).toBe(
+			detachedCommit,
+		)
+		expect(await Bun.file(join(checkout, "detached.txt")).text()).toBe(
+			"preserved\n",
+		)
+		expect(
+			await gitOutput(["-C", checkout, "rev-parse", "--git-common-dir"]),
+		).toBe(await realpath(join(root, "repos/linked")))
+		await runGit([
+			"--git-dir",
+			join(root, "repos/linked"),
+			"cat-file",
+			"-e",
+			`${detachedCommit}^{commit}`,
+		])
+		expect(
+			await gitOutput([
+				"--git-dir",
+				join(root, "repos/linked"),
+				"for-each-ref",
+				"--format=%(refname)",
+				"refs/agency/materialize/",
+			]),
+		).toBe("")
 	})
 
 	test("materializes an alias linked through an existing worktree", async () => {

package/src/services/RepositoryService.ts

@@ -19,6 +19,7 @@ import {
 import { documentRevision } from "../workbase/document-revision"
 import {
 	VersionControlService,
+	type RegisteredWorkspace,
 	type VersionControlBackend,
 } from "./VersionControlService"
 
@@ -558,9 +559,9 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 
 					const source = yield* fs.realPath(repository.path)
 					const registered = yield* backend.listWorkspaces(repository.path)
-					const registeredPaths = registered
-						.map((workspace) => workspace.path)
-						.sort()
+					const registeredState = registered
+						.map(({ path, commit, branch }) => ({ path, commit, branch }))
+						.sort((left, right) => left.path.localeCompare(right.path))
 					const worktrees: (typeof registered)[number][] = []
 					for (const workspace of registered) {
 						if (!(yield* fs.isDirectory(workspace.path))) {
@@ -634,6 +635,77 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 							),
 						),
 					)
+					const reviewRefs = yield* fs.runCommand(
+						[
+							"git",
+							"-C",
+							source,
+							"for-each-ref",
+							"--format=%(refname)",
+							"refs/agency/reviews/",
+						],
+						{ captureOutput: true },
+					)
+					if (reviewRefs.exitCode !== 0) {
+						yield* fs.deleteDirectory(staging).pipe(Effect.ignore)
+						return yield* new RepositoryError({
+							message: `Failed to enumerate Agency review refs while materializing repository '${alias}'`,
+						})
+					}
+					const preservedReviewRefs = reviewRefs.stdout
+						.split("\n")
+						.map((ref) => ref.trim())
+						.filter(Boolean)
+					const worktreeCommits = [
+						...new Set(
+							worktrees
+								.map((workspace) => workspace.commit)
+								.filter((commit): commit is string => commit !== null),
+						),
+					]
+					const temporaryRefs = worktreeCommits.map(
+						(_, index) =>
+							`refs/agency/materialize/${suffix}/${String(index).padStart(4, "0")}`,
+					)
+					const preservationRefspecs = [
+						...preservedReviewRefs.map((ref) => `+${ref}:${ref}`),
+						...worktreeCommits.map(
+							(commit, index) => `+${commit}:${temporaryRefs[index]}`,
+						),
+					]
+					if (preservationRefspecs.length > 0) {
+						const preserved = yield* fs.runCommand(
+							[
+								"git",
+								"--git-dir",
+								staging,
+								"fetch",
+								"--no-tags",
+								"--no-write-fetch-head",
+								source,
+								...preservationRefspecs,
+							],
+							{ captureOutput: true },
+						)
+						if (preserved.exitCode !== 0) {
+							yield* fs.deleteDirectory(staging).pipe(Effect.ignore)
+							return yield* new RepositoryError({
+								message: `Failed to preserve Agency refs and registered worktree commits while materializing repository '${alias}': ${preserved.stderr.trim()}`,
+							})
+						}
+						for (const ref of temporaryRefs) {
+							const removed = yield* fs.runCommand(
+								["git", "--git-dir", staging, "update-ref", "-d", ref],
+								{ captureOutput: true },
+							)
+							if (removed.exitCode !== 0) {
+								yield* fs.deleteDirectory(staging).pipe(Effect.ignore)
+								return yield* new RepositoryError({
+									message: `Failed to remove temporary materialization ref '${ref}' for repository '${alias}': ${removed.stderr.trim()}`,
+								})
+							}
+						}
+					}
 					yield* backend
 						.setRemoteUrl(staging, "origin", repository.declaredRemote)
 						.pipe(
@@ -728,16 +800,16 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 									.pipe(
 										Effect.provideService(FileSystemService, fs),
 									) as unknown as Effect.Effect<
-									readonly { readonly path: string }[],
+									readonly RegisteredWorkspace[],
 									unknown,
 									never
 								>,
 							)
-							const currentPaths = current
-								.map((workspace) => workspace.path)
-								.sort()
+							const currentState = current
+								.map(({ path, commit, branch }) => ({ path, commit, branch }))
+								.sort((left, right) => left.path.localeCompare(right.path))
 							if (
-								JSON.stringify(currentPaths) !== JSON.stringify(registeredPaths)
+								JSON.stringify(currentState) !== JSON.stringify(registeredState)
 							)
 								throw new Error(
 									`Git worktree registrations changed during materialization`,