@markjaquith/agency 2.29.0 → 2.30.1

package/src/cli-parser.ts

@@ -205,9 +205,20 @@ const commands = {
 	},
 	repo: {
 		usage:
-			"agency repo <add|link|list|show|fetch|remove|unlink|rename|remote|verify>",
-		options: outputOptions,
+			"agency repo <setup|add|link|list|show|fetch|remove|unlink|rename|remote|verify>",
+		options: {
+			...outputOptions,
+			"dry-run": { type: "boolean" },
+			apply: { type: "boolean" },
+		},
 		subcommands: {
+			setup: {
+				usage: "agency repo setup [--dry-run | --apply] [--json]",
+				minArgs: 0,
+				maxArgs: 0,
+				options: ["dry-run", "apply", "json"],
+				conflicts: [["dry-run", "apply"]],
+			},
 			add: {
 				usage: "agency repo add <alias> <remote> [--json]",
 				minArgs: 2,

package/src/cli.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, test } from "bun:test"
+import { afterAll, afterEach, describe, expect, test } from "bun:test"
 import { access, mkdir, realpath } from "node:fs/promises"
 import { join } from "node:path"
 import errorFixture from "../fixtures/protocol/error.json"
@@ -7,6 +7,9 @@ import { cleanupTempDir, createTempDir } from "./test-utils"
 
 const projectRoot = join(import.meta.dir, "..")
 const cliPath = join(projectRoot, "cli.ts")
+const isolatedConfigHome = await createTempDir()
+
+afterAll(() => cleanupTempDir(isolatedConfigHome))
 
 interface CliResult {
 	exitCode: number
@@ -21,7 +24,11 @@ async function runCli(
 ): Promise<CliResult> {
 	const subprocess = Bun.spawn([process.execPath, cliPath, ...args], {
 		cwd,
-		env: env ? { ...process.env, ...env } : undefined,
+		env: {
+			...process.env,
+			XDG_CONFIG_HOME: isolatedConfigHome,
+			...env,
+		},
 		stdout: "pipe",
 		stderr: "pipe",
 	})
@@ -34,13 +41,55 @@ async function runCli(
 }
 
 function parseJson(result: CliResult) {
-	expect(result.exitCode).toBe(0)
+	expect(result.exitCode, JSON.stringify(result)).toBe(0)
 	expect(result.stderr).toBe("")
 	const envelope = JSON.parse(result.stdout)
 	expect(envelope).toMatchObject({ version: 1, ok: true })
 	return envelope.result
 }
 
+async function runGit(args: string[]) {
+	const subprocess = Bun.spawn(["git", ...args], {
+		stdout: "pipe",
+		stderr: "pipe",
+	})
+	const [exitCode, stdout, stderr] = await Promise.all([
+		subprocess.exited,
+		new Response(subprocess.stdout).text(),
+		new Response(subprocess.stderr).text(),
+	])
+	if (exitCode !== 0) throw new Error(stderr)
+	return stdout
+}
+
+async function startGitDaemon(basePath: string) {
+	const port = 20000 + Math.floor(Math.random() * 20000)
+	const process = Bun.spawn(
+		[
+			"git",
+			"daemon",
+			"--reuseaddr",
+			"--export-all",
+			`--base-path=${basePath}`,
+			"--listen=127.0.0.1",
+			`--port=${port}`,
+			basePath,
+		],
+		{ stdout: "pipe", stderr: "pipe" },
+	)
+	const remote = `git://127.0.0.1:${port}/source.git`
+	for (let attempt = 0; attempt < 40; attempt++) {
+		const probe = Bun.spawn(["git", "ls-remote", remote], {
+			stdout: "ignore",
+			stderr: "ignore",
+		})
+		if ((await probe.exited) === 0) return { process, remote }
+		await Bun.sleep(25)
+	}
+	process.kill()
+	throw new Error("Git daemon did not start")
+}
+
 describe("CLI", () => {
 	const tempDirs: string[] = []
 
@@ -550,6 +599,22 @@ describe("CLI", () => {
 			kind: "task",
 			taskId: "explicit",
 		})
+		const nextByCwd = parseJson(
+			await runCli(
+				["next", "--cwd", root, "--select", "--json"],
+				projectRoot,
+				env,
+			),
+		)
+		expect(nextByCwd.selected.key).toBe("task/explicit")
+		const nextByRegistration = parseJson(
+			await runCli(
+				["next", "--workbase", "primary", "--select", "--json"],
+				projectRoot,
+				env,
+			),
+		)
+		expect(nextByRegistration.selected.key).toBe("task/explicit")
 
 		parseJson(
 			await runCli(["workbase", "default", "primary", "--json"], parent, env),
@@ -662,11 +727,23 @@ status: open
 			["config", "user.name", "Test"],
 			["add", "README.md"],
 			["-c", "commit.gpgsign=false", "commit", "-m", "initial"],
+			["remote", "add", "origin", source],
 		]) {
 			expect(Bun.spawnSync(["git", "-C", source, ...args]).exitCode).toBe(0)
 		}
 
 		parseJson(await runCli(["init", root, "--json"], parent))
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({
+				version: 2,
+				repositories: {
+					agency: {
+						remote: "https://example.com/agency-tests/source.git",
+					},
+				},
+			}),
+		)
 		parseJson(await runCli(["repo", "link", "agency", source, "--json"], root))
 		parseJson(
 			await runCli(
@@ -752,6 +829,223 @@ status: open
 		).toBe("example\n")
 	})
 
+	test.skipIf(Bun.which("opencode") === null)(
+		"provides effective whole-workbase OpenCode access from every launch topology",
+		async () => {
+			const parent = await createTempDir()
+			tempDirs.push(parent)
+			const root = join(parent, "workbase")
+			const source = join(parent, "source")
+			expect(
+				Bun.spawnSync(["git", "init", "--initial-branch=main", source])
+					.exitCode,
+			).toBe(0)
+			await Bun.write(join(source, "README.md"), "example\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"],
+			]) {
+				expect(Bun.spawnSync(["git", "-C", source, ...args]).exitCode).toBe(0)
+			}
+
+			parseJson(await runCli(["init", root, "--json"], parent))
+			parseJson(
+				await runCli(["repo", "link", "agency", source, "--json"], root),
+			)
+			parseJson(
+				await runCli(
+					[
+						"epic",
+						"create",
+						"delivery",
+						"--ticket-url",
+						"https://example.com/delivery",
+						"--repo",
+						"agency:main",
+						"--json",
+					],
+					root,
+				),
+			)
+			for (const [id, branch] of [
+				["example", "feat/example"],
+				["sibling", "feat/sibling"],
+			] as const) {
+				parseJson(
+					await runCli(
+						[
+							"task",
+							"create",
+							id,
+							"--repo",
+							"agency",
+							"--branch",
+							branch,
+							"--base",
+							"main",
+							"--epic",
+							"delivery",
+							"--json",
+						],
+						root,
+					),
+				)
+			}
+			parseJson(
+				await runCli(
+					["task", "create", "pipeline", "--multi-phase", "--json"],
+					root,
+				),
+			)
+			parseJson(
+				await runCli(
+					[
+						"phase",
+						"create",
+						"pipeline",
+						"build",
+						"--repo",
+						"agency",
+						"--branch",
+						"feat/pipeline-build",
+						"--base",
+						"main",
+						"--json",
+					],
+					root,
+				),
+			)
+
+			const taskWorkspace = parseJson(
+				await runCli(["work", "prepare", "example", "--json"], root),
+			)
+			const phaseWorkspace = parseJson(
+				await runCli(
+					[
+						"work",
+						"prepare",
+						"--task",
+						"pipeline",
+						"--phase",
+						"build",
+						"--json",
+					],
+					root,
+				),
+			)
+			const synced = parseJson(
+				await runCli(["integration", "sync", "--json"], root),
+			)
+			expect(
+				synced.files.every((file: { changed: boolean }) => !file.changed),
+			).toBe(true)
+
+			const workbaseRoot = await realpath(root)
+			const config = await Bun.file(
+				join(workbaseRoot, ".opencode/opencode.jsonc"),
+			).text()
+			expect(config).not.toContain(workbaseRoot)
+			const documents = [
+				join(workbaseRoot, "tasks/example/TASK.md"),
+				join(workbaseRoot, "epics/delivery/EPIC.md"),
+				join(workbaseRoot, "tasks/sibling/TASK.md"),
+			]
+			for (const document of documents) {
+				expect(await Bun.file(document).exists()).toBe(true)
+			}
+
+			const launches = [
+				{
+					args: ["--task", "example"],
+					cwd: taskWorkspace.writablePath,
+					writable: true,
+				},
+				{
+					args: ["--task", "pipeline", "--phase", "build"],
+					cwd: phaseWorkspace.writablePath,
+					writable: true,
+				},
+				{
+					args: ["--epic", "delivery"],
+					cwd: join(workbaseRoot, "epics/delivery"),
+					writable: false,
+				},
+				{
+					args: ["--task", "pipeline"],
+					cwd: join(workbaseRoot, "tasks/pipeline"),
+					writable: false,
+				},
+			]
+			for (const launch of launches) {
+				const printed = await runCli(
+					["work", ...launch.args, "--opencode", "--print-command", "--force"],
+					root,
+				)
+				expect(printed.exitCode).toBe(0)
+				expect(printed.stderr).toBe("")
+				const contract = JSON.parse(printed.stdout)
+				expect(contract.cwd).toBe(launch.cwd)
+				expect(contract.environment.OPENCODE_CONFIG).toBe(
+					join(workbaseRoot, ".opencode/opencode.jsonc"),
+				)
+				const environment = {
+					...process.env,
+					...contract.environment,
+					XDG_CONFIG_HOME: isolatedConfigHome,
+					OPENCODE_DISABLE_EXTERNAL_SKILLS: "1",
+				}
+				const probe = Bun.spawnSync(["opencode", "debug", "agent", "build"], {
+					cwd: contract.cwd,
+					env: environment,
+				})
+				expect(probe.exitCode).toBe(0)
+				const agent = JSON.parse(probe.stdout.toString())
+				expect(agent.permission).toEqual(
+					expect.arrayContaining([
+						expect.objectContaining({
+							permission: "external_directory",
+							pattern: join(workbaseRoot, "**"),
+							action: "allow",
+						}),
+					]),
+				)
+				expect(agent.permission).toEqual(
+					expect.arrayContaining([
+						expect.objectContaining({
+							permission: "edit",
+							pattern: launch.writable ? "../**" : "*",
+							action: "deny",
+						}),
+					]),
+				)
+
+				if (launch === launches[0]) {
+					for (const document of documents) {
+						const read = Bun.spawnSync(
+							[
+								"opencode",
+								"debug",
+								"agent",
+								"build",
+								"--tool",
+								"read",
+								"--params",
+								JSON.stringify({ filePath: document }),
+							],
+							{ cwd: contract.cwd, env: environment },
+						)
+						expect(read.exitCode).toBe(0)
+						const result = JSON.parse(read.stdout.toString())
+						expect(result.result.output).toContain(`<path>${document}</path>`)
+					}
+				}
+			}
+		},
+		30_000,
+	)
+
 	test("envelopes help and version output in machine mode", async () => {
 		const help = await runCli(["status", "--help", "--json"])
 		expect(parseJson(help)).toContain("Usage: agency status")
@@ -789,6 +1083,14 @@ status: open
 			stderr: "pipe",
 		})
 		expect(await git.exited).toBe(0)
+		await runGit([
+			"-C",
+			source,
+			"remote",
+			"add",
+			"origin",
+			"https://example.com/agency-tests/source.git",
+		])
 
 		expect(parseJson(await runCli(["init", root, "--json"]))).toEqual({
 			root,
@@ -981,4 +1283,121 @@ status: open
 			valid: true,
 		})
 	}, 30_000)
+
+	test("restores portable repositories in a fresh workbase clone", async () => {
+		const parent = await createTempDir()
+		tempDirs.push(parent)
+		const sourceWorktree = join(parent, "source-worktree")
+		const source = join(parent, "source.git")
+		const root = join(parent, "workbase")
+		const restored = join(parent, "restored")
+
+		await runGit(["init", "--initial-branch=main", sourceWorktree])
+		await Bun.write(join(sourceWorktree, "README.md"), "portable\n")
+		await runGit([
+			"-C",
+			sourceWorktree,
+			"config",
+			"user.email",
+			"test@example.com",
+		])
+		await runGit(["-C", sourceWorktree, "config", "user.name", "Test"])
+		await runGit(["-C", sourceWorktree, "add", "README.md"])
+		await runGit([
+			"-C",
+			sourceWorktree,
+			"-c",
+			"commit.gpgsign=false",
+			"commit",
+			"-m",
+			"initial",
+		])
+		await runGit(["clone", "--bare", sourceWorktree, source])
+		const daemon = await startGitDaemon(parent)
+
+		try {
+			parseJson(await runCli(["init", root, "--json"], parent))
+			parseJson(
+				await runCli(["repo", "add", "agency", daemon.remote, "--json"], root),
+			)
+			parseJson(
+				await runCli(
+					[
+						"task",
+						"create",
+						"portable",
+						"--repo",
+						"agency",
+						"--branch",
+						"feat/portable",
+						"--base",
+						"main",
+						"--json",
+					],
+					root,
+				),
+			)
+
+			await runGit(["init", "--initial-branch=main", root])
+			await runGit(["-C", root, "config", "user.email", "test@example.com"])
+			await runGit(["-C", root, "config", "user.name", "Test"])
+			await runGit(["-C", root, "add", "."])
+			await runGit([
+				"-C",
+				root,
+				"-c",
+				"commit.gpgsign=false",
+				"commit",
+				"-m",
+				"portable workbase",
+			])
+			const tracked = await runGit(["-C", root, "ls-files"])
+			expect(tracked).toContain("agency.json")
+			expect(tracked).not.toContain("repos/agency")
+
+			await runGit(["clone", root, restored])
+			const planned = parseJson(
+				await runCli(["repo", "setup", "--dry-run", "--json"], restored),
+			)
+			expect(planned.actions).toEqual([
+				expect.objectContaining({
+					alias: "agency",
+					kind: "materialize",
+					status: "planned",
+				}),
+			])
+			expect(await Bun.file(join(restored, "repos/agency/HEAD")).exists()).toBe(
+				false,
+			)
+
+			const applied = parseJson(
+				await runCli(["repo", "setup", "--apply", "--json"], restored),
+			)
+			expect(applied.actions[0]).toMatchObject({
+				alias: "agency",
+				status: "applied",
+			})
+			expect(await Bun.file(join(restored, "repos/agency/HEAD")).exists()).toBe(
+				true,
+			)
+
+			const prepared = parseJson(
+				await runCli(["work", "prepare", "portable", "--json"], restored),
+			)
+			expect(prepared.checkouts).toEqual([
+				expect.objectContaining({
+					repo: "agency",
+					action: "created",
+				}),
+			])
+			expect(
+				await Bun.file(
+					join(restored, "tasks/portable/code/agency/README.md"),
+				).text(),
+			).toBe("portable\n")
+		} finally {
+			daemon.process.kill()
+			await daemon.process.exited
+		}
+	}, 30_000)
 })

package/src/commands/doctor.test.ts

@@ -129,6 +129,28 @@ status: open
 		)
 	})
 
+	test("warns when customized OpenCode config cannot guarantee access", async () => {
+		const custom = '{"references":{}}\n'
+		await write(root, ".opencode/opencode.jsonc", custom)
+
+		const logs = await captureLogs(() =>
+			runTestEffect(doctor({ cwd: root, json: true })),
+		)
+		const check = JSON.parse(logs[0]!).checks.find(
+			(value: { id: string }) => value.id === "integration.file.opencode",
+		)
+
+		expect(check).toMatchObject({
+			level: "warning",
+			status: "fail",
+			message: expect.stringContaining("cannot guarantee whole-workbase"),
+			remediation: expect.stringContaining("global config"),
+		})
+		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
+			custom,
+		)
+	})
+
 	test("is safe when the workbase is read-only", async () => {
 		for (const path of [
 			join(root, "agency.json"),

package/src/commands/init.test.ts

@@ -38,9 +38,10 @@ describe("init command", () => {
 			join(root, ".opencode/opencode.jsonc"),
 		).text()
 		const config = JSON.parse(opencode.slice(opencode.indexOf("\n\n") + 2))
-		expect(config.permission.external_directory).toEqual({
-			"../**": "allow",
+		expect(config.references).toEqual({
+			workbase: expect.objectContaining({ path: ".." }),
 		})
+		expect(config.permission).toBeUndefined()
 	})
 
 	test("preserves existing gitignore entries", async () => {

package/src/commands/integration.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { mkdir } from "node:fs/promises"
 import { join } from "node:path"
 import {
 	captureLogs,
@@ -29,11 +30,30 @@ describe("integration command", () => {
 			root,
 			files: [
 				{ name: "agents", state: "missing" },
-				{ name: "opencode", state: "missing" },
+				{
+					name: "opencode",
+					state: "missing",
+					diagnostic: expect.stringContaining("cannot load"),
+					remediation: expect.stringContaining("integration sync"),
+				},
 			],
 		})
 	})
 
+	test("explains remediation for customized OpenCode config", async () => {
+		await mkdir(join(root, ".opencode"))
+		await Bun.write(
+			join(root, ".opencode", "opencode.json"),
+			'{"model":"test/model"}\n',
+		)
+		const logs = await captureLogs(() =>
+			runTestEffect(integration({ subcommand: "status", cwd: root })),
+		)
+
+		expect(logs.join("\n")).toContain("cannot guarantee whole-workbase")
+		expect(logs.join("\n")).toContain("global config")
+	})
+
 	test("explicitly synchronizes integration files", async () => {
 		const logs = await captureLogs(() =>
 			runTestEffect(integration({ subcommand: "sync", cwd: root, json: true })),

package/src/commands/integration.ts

@@ -22,7 +22,8 @@ export const integration = (options: IntegrationOptions) =>
 					return
 				}
 				for (const file of result.files) {
-					log(`${file.name}\t${file.state}\t${file.path}`)
+					log(`${file.name}\t${file.state}\t${file.path}\t${file.diagnostic}`)
+					if (file.remediation) log(`  Remediation: ${file.remediation}`)
 				}
 				return
 			}
@@ -35,8 +36,9 @@ export const integration = (options: IntegrationOptions) =>
 				}
 				for (const file of result.files) {
 					log(
-						`${file.name}\t${file.changed ? "synced" : file.state}\t${file.path}`,
+						`${file.name}\t${file.changed ? "synced" : file.state}\t${file.path}\t${file.diagnostic}`,
 					)
+					if (file.remediation) log(`  Remediation: ${file.remediation}`)
 				}
 				return
 			}
@@ -51,10 +53,12 @@ export const integration = (options: IntegrationOptions) =>
 export const help = `
 Usage: agency integration <subcommand>
 
-Inspect or explicitly synchronize managed agent integration files.
+Inspect or explicitly synchronize managed agent integration files. OpenCode
+launches load the managed file at runtime to provide whole-workbase read
+access without changing Agency write authority.
 
 Subcommands:
-  status  Report managed, customized, missing, and drifted files
+  status  Report file state, access diagnostics, and safe remediation
   sync    Create or update checksum-safe managed files
 
 Options:

package/src/commands/pr.test.ts

@@ -7,20 +7,39 @@ import { pr } from "./pr"
 describe("pr command", () => {
 	test("outputs the created pull request URL as JSON", async () => {
 		const url = "https://github.com/markjaquith/agency/pull/123"
+		let received: unknown[] = []
 		const logs = await captureLogs(() =>
 			Effect.runPromise(
 				pr({
 					subcommand: "create",
 					taskId: "example",
+					phaseId: "implementation",
+					draft: true,
+					force: true,
+					cwd: "/workbase",
 					json: true,
 				}).pipe(
 					Effect.provideService(PullRequestService, {
-						create: () => Effect.succeed(url),
+						create: (...args: unknown[]) => {
+							received = args
+							return Effect.succeed(url)
+						},
 					} as never),
 				) as Effect.Effect<void, unknown, never>,
 			),
 		)
 
 		expect(JSON.parse(logs[0]!)).toEqual({ url })
+		expect(received).toEqual([
+			"example",
+			"implementation",
+			true,
+			"/workbase",
+			expect.objectContaining({
+				force: true,
+				draft: true,
+				json: true,
+			}),
+		])
 	})
 })