@markjaquith/agency 2.19.0 → 2.21.0

package/src/commands/work.ts

@@ -23,6 +23,11 @@ import {
 	resolveWorkbase,
 	type PickWorkbase,
 } from "../workbase/workbase-choice"
+import {
+	printableEnvironment,
+	resolveRunnerCommand,
+	runnerEnvironment,
+} from "../workbase/runner-command"
 
 interface WorkOptions extends BaseCommandOptions {
 	readonly directory?: string
@@ -31,10 +36,17 @@ interface WorkOptions extends BaseCommandOptions {
 	readonly epicId?: string
 	readonly opencode?: boolean
 	readonly claude?: boolean
+	readonly runner?: string
+	readonly printCommand?: boolean
 	readonly force?: boolean
 }
 
-type LaunchAgent = (cli: string, args: readonly string[], cwd: string) => void
+type LaunchAgent = (
+	cli: string,
+	args: readonly string[],
+	cwd: string,
+	environment: Readonly<Record<string, string>>,
+) => void
 
 const formatCommand = (args: readonly string[]) =>
 	args
@@ -68,13 +80,15 @@ export const work = (
 	pickBase: PickWorkbase = pickWorkbase,
 ) =>
 	Effect.gen(function* () {
-		if (options.opencode && options.claude) {
+		if (
+			(options.opencode && options.claude) ||
+			(options.runner && (options.opencode || options.claude))
+		) {
 			return yield* Effect.fail(
-				new Error("Cannot use both --opencode and --claude"),
+				new Error("Cannot combine --runner, --opencode, and --claude"),
 			)
 		}
-		const previousSessionId = process.env.AGENCY_SESSION_ID
-		const previousClaimRevision = process.env.AGENCY_CLAIM_REVISION
+		const previousEnvironment = { ...process.env }
 		if (
 			options.epicId &&
 			(options.directory || options.taskId || options.phaseId)
@@ -104,6 +118,7 @@ export const work = (
 		const inputAllowed = options.inputAllowed ?? true
 		const root = yield* resolveWorkbase(startPath, pickBase, inputAllowed)
 		if (!root) return
+		const { config } = yield* workbase.loadConfig(root)
 
 		let target: WorkTarget | null = null
 		if (options.epicId) {
@@ -199,7 +214,6 @@ export const work = (
 					new Error("No ready work targets found in this workbase"),
 				)
 			}
-			const { config } = yield* workbase.loadConfig(root)
 			target = yield* pick(choices, config.chooserCommand)
 			if (!target) return
 		}
@@ -233,13 +247,49 @@ export const work = (
 			launchPath = workspace.writablePath
 		}
 
-		const requested = options.claude ? "claude" : "opencode"
-		let cli = requested
+		const explicitlyRequested = Boolean(
+			options.runner ||
+			options.opencode ||
+			options.claude ||
+			process.env.AGENCY_RUNNER,
+		)
+		let runner =
+			options.runner ??
+			process.env.AGENCY_RUNNER ??
+			(options.claude ? "claude" : "opencode")
+		const claimant = process.env.AGENCY_CLAIMANT ?? process.env.USER ?? "agency"
+		const sessionId =
+			process.env.AGENCY_SESSION_ID ?? `${process.pid}-${Date.now()}`
+		const resume = process.env.AGENCY_SESSION_ID !== undefined
+		let claimRevision = ""
+		let variables = {
+			prompt,
+			workbase: root,
+			target: targetNodeId(target),
+			task: target.kind === "epic" ? "" : target.taskId,
+			phase: target.kind === "phase" ? target.phaseId : "",
+			claimant,
+			sessionId,
+			claimRevision,
+		}
+		let resolved = resolveRunnerCommand(
+			runner,
+			config.runners,
+			variables,
+			resume,
+		)
+		let cli = resolved.argv[0]!
 		let available = yield* fs.runCommand(["which", cli], {
 			captureOutput: true,
 		})
-		if (available.exitCode !== 0 && !options.opencode && !options.claude) {
-			cli = "claude"
+		if (
+			available.exitCode !== 0 &&
+			!explicitlyRequested &&
+			runner === "opencode"
+		) {
+			runner = "claude"
+			resolved = resolveRunnerCommand(runner, config.runners, variables, resume)
+			cli = resolved.argv[0]!
 			available = yield* fs.runCommand(["which", cli], { captureOutput: true })
 		}
 		if (available.exitCode !== 0) {
@@ -251,36 +301,55 @@ export const work = (
 		) {
 			const phaseId = target.kind === "phase" ? target.phaseId : undefined
 			const current = yield* claims.inspect(target.taskId, phaseId, root)
-			const sessionId =
-				process.env.AGENCY_SESSION_ID ?? `${process.pid}-${Date.now()}`
 			const acquired = yield* claims.claim(
 				{
 					taskId: target.taskId,
 					...(phaseId ? { phaseId } : {}),
-					claimant: process.env.AGENCY_CLAIMANT ?? process.env.USER ?? "agency",
-					runner: process.env.AGENCY_RUNNER ?? cli,
+					claimant,
+					runner,
 					sessionId,
 					revision: current.revision,
 				},
 				root,
 			)
-			process.env.AGENCY_SESSION_ID = sessionId
-			process.env.AGENCY_CLAIM_REVISION = acquired.revision
+			claimRevision = acquired.revision
 		}
 
-		const args =
-			cli === "opencode" ? ["--continue", "--prompt", prompt] : [prompt]
+		variables = { ...variables, claimRevision }
+		resolved = resolveRunnerCommand(runner, config.runners, variables, resume)
+		cli = resolved.argv[0]!
+		const environment = {
+			...resolved.environment,
+			...runnerEnvironment(runner, variables),
+		}
+		if (options.printCommand) {
+			log(
+				JSON.stringify(
+					{
+						cwd: launchPath,
+						argv: resolved.argv,
+						environment: printableEnvironment(environment),
+					},
+					null,
+					2,
+				),
+			)
+			return
+		}
+		for (const [key, value] of Object.entries(environment)) {
+			process.env[key] = value
+		}
 		verboseLog(
-			`Launching command: ${formatCommand([cli, ...args])} (cwd: ${launchPath})`,
+			`Launching command: ${formatCommand(resolved.argv)} (cwd: ${launchPath})`,
 		)
 		try {
-			launch(cli, [cli, ...args], launchPath)
+			launch(cli, resolved.argv, launchPath, environment)
 		} finally {
-			if (previousSessionId === undefined) delete process.env.AGENCY_SESSION_ID
-			else process.env.AGENCY_SESSION_ID = previousSessionId
-			if (previousClaimRevision === undefined)
-				delete process.env.AGENCY_CLAIM_REVISION
-			else process.env.AGENCY_CLAIM_REVISION = previousClaimRevision
+			for (const key of Object.keys(environment)) {
+				const previous = previousEnvironment[key]
+				if (previous === undefined) delete process.env[key]
+				else process.env[key] = previous
+			}
 		}
 	})
 
@@ -344,7 +413,7 @@ export const workPrepare = (options: WorkOptions = {}) =>
 	})
 
 export const help = `
-Usage: agency work [<directory-or-task-id> | --epic <epic-id>]
+Usage: agency work [<directory-or-task-id> | --epic <epic-id>] [--runner <name>]
        agency work prepare [target] [--dry-run] [--json]
 
 Launch an agent for an epic, task, or phase. With no directory, select one
@@ -362,8 +431,10 @@ Options:
   --phase <id>         Work on a phase selected with --task
   --workbase <target>  Select a workbase by ID, name, or path
   --cwd <path>         Resolve context from a specific directory
-  --opencode           Require OpenCode
-  --claude             Require Claude Code
+  --runner <name>      Select a configured runner or built-in preset
+  --print-command      Print cwd, argv, and non-secret environment without launch
+  --opencode           Require the OpenCode preset
+  --claude             Require the Claude Code preset
   --force              Override readiness and terminal-state guards
   --no-input           Never open an interactive selector
 

package/src/services/GraphMutationService.test.ts

@@ -0,0 +1,336 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import { Effect } from "effect"
+import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
+import { EpicService } from "./EpicService"
+import { GraphMutationService } from "./GraphMutationService"
+import { PhaseService } from "./PhaseService"
+import { TaskService } from "./TaskService"
+import {
+	formatMarkdownDocument,
+	parseFrontmatter,
+} from "../workbase/frontmatter"
+
+describe("GraphMutationService", () => {
+	let root: string
+
+	beforeEach(async () => {
+		root = await createTempDir()
+		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
+		await mkdir(join(root, "repos/agency"), { recursive: true })
+		await mkdir(join(root, "repos/docs"), { recursive: true })
+		await runTestEffect(
+			Effect.gen(function* () {
+				const epics = yield* EpicService
+				const tasks = yield* TaskService
+				const phases = yield* PhaseService
+				yield* epics.create(
+					"first-epic",
+					"https://example.com/first",
+					[{ repo: "agency", ref: "main" }],
+					root,
+				)
+				yield* epics.create(
+					"second-epic",
+					"https://example.com/second",
+					[{ repo: "agency", ref: "main" }],
+					root,
+				)
+				for (const id of ["alpha", "beta", "gamma"]) {
+					yield* tasks.create(
+						{
+							id,
+							ticketUrl: null,
+							epic: "first-epic",
+							repo: "agency",
+							branch: `task/${id}`,
+							base: "main",
+						},
+						root,
+					)
+				}
+				yield* tasks.create(
+					{
+						id: "multi",
+						ticketUrl: "https://example.com/multi",
+						multiPhase: true,
+					},
+					root,
+				)
+				yield* phases.create(
+					{
+						taskId: "multi",
+						id: "build",
+						repo: "agency",
+						branch: "task/multi-build",
+						base: "main",
+					},
+					root,
+				)
+				yield* phases.create(
+					{
+						taskId: "multi",
+						id: "ship",
+						repo: "agency",
+						branch: "task/multi-ship",
+						base: "main",
+					},
+					root,
+				)
+			}),
+		)
+	})
+
+	afterEach(async () => cleanupTempDir(root))
+
+	test("updates descriptions, tickets, repositories, and execution metadata", async () => {
+		const output = await runTestEffect(
+			Effect.gen(function* () {
+				const mutations = yield* GraphMutationService
+				yield* mutations.updateEpic(
+					"first-epic",
+					{
+						description: "Updated epic",
+						ticketUrl: "https://example.com/revised",
+						repos: [{ repo: "docs", ref: "trunk" }],
+					},
+					root,
+				)
+				yield* mutations.updateTask(
+					"alpha",
+					{
+						description: "Updated task",
+						ticketUrl: "https://example.com/alpha",
+						repos: [{ repo: "docs", ref: "main" }],
+						branch: "feature/alpha",
+						base: "develop",
+						pr: "https://github.com/example/agency/pull/12",
+					},
+					root,
+				)
+				return yield* mutations.updatePhase(
+					"multi",
+					"build",
+					{
+						description: "Updated phase",
+						repo: "docs",
+						branch: "feature/build",
+						base: "develop",
+					},
+					root,
+				)
+			}),
+		)
+
+		expect(output).toMatchObject({
+			operation: "phase.update",
+			changed: true,
+			validation: { valid: true },
+		})
+		await runTestEffect(
+			Effect.gen(function* () {
+				const epics = yield* EpicService
+				const tasks = yield* TaskService
+				const phases = yield* PhaseService
+				expect((yield* epics.show("first-epic", root)).data).toMatchObject({
+					description: "Updated epic",
+					ticketUrl: "https://example.com/revised",
+					repos: [{ repo: "docs", ref: "trunk" }],
+				})
+				expect((yield* tasks.show("alpha", root)).data).toMatchObject({
+					description: "Updated task",
+					ticketUrl: "https://example.com/alpha",
+					repos: [{ repo: "docs", ref: "main" }],
+					branch: "feature/alpha",
+					base: "develop",
+					pr: "https://github.com/example/agency/pull/12",
+				})
+				expect((yield* phases.show("multi", "build", root)).data).toMatchObject(
+					{
+						description: "Updated phase",
+						repo: "docs",
+						branch: "feature/build",
+						base: "develop",
+					},
+				)
+			}),
+		)
+	})
+
+	test("preserves dependency order and rejects cycles", async () => {
+		await runTestEffect(
+			Effect.gen(function* () {
+				const mutations = yield* GraphMutationService
+				yield* mutations.mutateTaskDependency("add", "beta", "alpha", root)
+				yield* mutations.mutateTaskDependency("add", "beta", "gamma", root)
+				yield* mutations.mutateTaskDependency("remove", "beta", "alpha", root)
+				yield* mutations.mutatePhaseDependency(
+					"add",
+					"multi",
+					"ship",
+					"build",
+					root,
+				)
+			}),
+		)
+		await expect(
+			runTestEffect(
+				Effect.gen(function* () {
+					return yield* (yield* GraphMutationService).mutateTaskDependency(
+						"add",
+						"gamma",
+						"beta",
+						root,
+					)
+				}),
+			),
+		).rejects.toThrow("dependency cycle")
+
+		await expect(
+			runTestEffect(
+				Effect.gen(function* () {
+					return yield* (yield* GraphMutationService).mutateTaskDependency(
+						"add",
+						"beta",
+						"gamma",
+						root,
+					)
+				}),
+			),
+		).rejects.toThrow("already depends")
+
+		await runTestEffect(
+			Effect.gen(function* () {
+				const epics = yield* EpicService
+				const tasks = yield* TaskService
+				const declarations = (yield* epics.show("first-epic", root)).data.tasks
+				expect(
+					declarations.find((item) => item.id === "beta")?.dependsOn,
+				).toEqual(["gamma"])
+				expect((yield* tasks.show("multi", root)).data).toMatchObject({
+					phases: [{ id: "build" }, { id: "ship", dependsOn: ["build"] }],
+				})
+			}),
+		)
+	})
+
+	test("renames entities and rewrites every structured reference", async () => {
+		await runTestEffect(
+			Effect.gen(function* () {
+				const mutations = yield* GraphMutationService
+				yield* mutations.mutateTaskDependency("add", "beta", "alpha", root)
+				yield* mutations.mutatePhaseDependency(
+					"add",
+					"multi",
+					"ship",
+					"build",
+					root,
+				)
+				yield* mutations.renameTask("alpha", "renamed-alpha", root)
+				yield* mutations.renamePhase("multi", "build", "compile", root)
+				yield* mutations.renameEpic("first-epic", "renamed-epic", root)
+			}),
+		)
+
+		await runTestEffect(
+			Effect.gen(function* () {
+				const epics = yield* EpicService
+				const tasks = yield* TaskService
+				const phases = yield* PhaseService
+				const epic = yield* epics.show("renamed-epic", root)
+				expect(
+					epic.data.tasks.find((item) => item.id === "beta")?.dependsOn,
+				).toEqual(["renamed-alpha"])
+				expect((yield* tasks.show("renamed-alpha", root)).data.epic).toBe(
+					"renamed-epic",
+				)
+				expect((yield* tasks.show("multi", root)).data).toMatchObject({
+					phases: [{ id: "compile" }, { id: "ship", dependsOn: ["compile"] }],
+				})
+				expect((yield* phases.show("multi", "compile", root)).id).toBe(
+					"compile",
+				)
+			}),
+		)
+	})
+
+	test("moves task membership in both directions", async () => {
+		await runTestEffect(
+			Effect.gen(function* () {
+				yield* (yield* GraphMutationService).moveTask(
+					"alpha",
+					"second-epic",
+					root,
+				)
+				const epics = yield* EpicService
+				const tasks = yield* TaskService
+				expect(
+					(yield* epics.show("first-epic", root)).data.tasks.map(
+						(item) => item.id,
+					),
+				).not.toContain("alpha")
+				expect(
+					(yield* epics.show("second-epic", root)).data.tasks.map(
+						(item) => item.id,
+					),
+				).toEqual(["alpha"])
+				expect((yield* tasks.show("alpha", root)).data.epic).toBe("second-epic")
+			}),
+		)
+	})
+
+	test("refuses a rename that would invalidate a materialized worktree", async () => {
+		await mkdir(join(root, "tasks/alpha/code/agency"), { recursive: true })
+		await expect(
+			runTestEffect(
+				Effect.gen(function* () {
+					return yield* (yield* GraphMutationService).renameTask(
+						"alpha",
+						"renamed-alpha",
+						root,
+					)
+				}),
+			),
+		).rejects.toThrow("materialized worktree")
+		expect(await Bun.file(join(root, "tasks/alpha/TASK.md")).exists()).toBe(
+			true,
+		)
+		expect(
+			await Bun.file(join(root, "tasks/renamed-alpha/TASK.md")).exists(),
+		).toBe(false)
+	})
+
+	test("refuses rename when the parent backlink is inconsistent", async () => {
+		await runTestEffect(
+			Effect.gen(function* () {
+				const epic = yield* (yield* EpicService).show("first-epic", root)
+				const parsed = yield* parseFrontmatter(epic.content, epic.path)
+				yield* Effect.promise(() =>
+					Bun.write(
+						epic.path,
+						formatMarkdownDocument(
+							{
+								...epic.data,
+								tasks: epic.data.tasks.filter((item) => item.id !== "alpha"),
+							},
+							parsed.body,
+						),
+					),
+				)
+			}),
+		)
+
+		await expect(
+			runTestEffect(
+				Effect.gen(function* () {
+					return yield* (yield* GraphMutationService).renameTask(
+						"alpha",
+						"renamed-alpha",
+						root,
+					)
+				}),
+			),
+		).rejects.toThrow("parent epic 'first-epic' does not list it")
+	})
+})