@markjaquith/agency 3.2.14 → 3.3.0

package/src/commands/task-phase.test.ts

@@ -1,410 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { mkdir } from "node:fs/promises"
-import { join } from "node:path"
-import { Effect, Layer } from "effect"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import { phase } from "./phase"
-import { task } from "./task"
-import { FileSystemService } from "../services/FileSystemService"
-import { PhaseService } from "../services/PhaseService"
-import { TaskService } from "../services/TaskService"
-import { WorkbaseService } from "../services/WorkbaseService"
-
-describe("task and phase command JSON output", () => {
-	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 runTestEffect(
-			task({
-				subcommand: "create",
-				args: ["multi"],
-				ticketUrl: "https://example.com/task",
-				multiPhase: true,
-				cwd: root,
-				silent: true,
-			}),
-		)
-		await runTestEffect(
-			phase({
-				subcommand: "create",
-				args: ["multi", "first"],
-				repo: "agency",
-				branch: "task/first",
-				base: "main",
-				cwd: root,
-				silent: true,
-			}),
-		)
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	test("lists and shows task metadata without Markdown content", async () => {
-		const listLogs = await captureLogs(() =>
-			runTestEffect(
-				task({ subcommand: "list", args: [], cwd: root, json: true }),
-			),
-		)
-		const listed = JSON.parse(listLogs[0]!)
-		expect(listed[0].revision).toMatch(/^[a-f0-9]{64}$/)
-		expect(listed).toEqual([
-			{
-				id: "multi",
-				path: join(root, "tasks/multi/TASK.md"),
-				revision: listed[0].revision,
-				data: {
-					ticketUrl: "https://example.com/task",
-					phases: [{ id: "first" }],
-				},
-			},
-		])
-
-		const showLogs = await captureLogs(() =>
-			runTestEffect(
-				task({
-					subcommand: "show",
-					args: ["multi"],
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-		const shown = JSON.parse(showLogs[0]!)
-		expect(shown.revision).toBe(listed[0].revision)
-		expect(shown).toEqual({
-			id: "multi",
-			path: join(root, "tasks/multi/TASK.md"),
-			revision: shown.revision,
-			data: {
-				ticketUrl: "https://example.com/task",
-				phases: [{ id: "first" }],
-			},
-		})
-	})
-
-	test("returns complete handoff JSON without preparing work", async () => {
-		await runTestEffect(
-			task({
-				subcommand: "create",
-				args: ["investigate"],
-				repo: "agency",
-				purpose: "investigation",
-				cwd: root,
-				silent: true,
-			}),
-		)
-		const logs = await captureLogs(() =>
-			runTestEffect(
-				task({
-					subcommand: "handoff",
-					args: ["investigate", "implement"],
-					repo: "agency",
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-		const output = JSON.parse(logs[0]!)
-		expect(output).toMatchObject({
-			task: {
-				id: "implement",
-				selector: "task/implement",
-				directory: join(root, "tasks/implement"),
-				documentPath: join(root, "tasks/implement/TASK.md"),
-				branch: "task/implement",
-				base: "main",
-			},
-			source: {
-				selector: "task/investigate",
-				documentPath: join(root, "tasks/investigate/TASK.md"),
-			},
-			validation: { valid: true },
-			worktreePrepare: {
-				target: "task/implement",
-				command: ["agency", "worktree", "prepare", "implement"],
-			},
-		})
-		expect(output.task.revision).toMatch(/^[a-f0-9]{64}$/)
-		expect(output.source.revision).toMatch(/^[a-f0-9]{64}$/)
-		expect(await Bun.file(join(root, "tasks/implement/code")).exists()).toBe(
-			false,
-		)
-	})
-
-	test("lists and shows phase metadata without Markdown content", async () => {
-		const listLogs = await captureLogs(() =>
-			runTestEffect(
-				phase({ subcommand: "list", args: ["multi"], cwd: root, json: true }),
-			),
-		)
-		const listed = JSON.parse(listLogs[0]!)
-		expect(listed[0].revision).toMatch(/^[a-f0-9]{64}$/)
-		expect(listed).toEqual([
-			{
-				taskId: "multi",
-				id: "first",
-				path: join(root, "tasks/multi/phases/first/PHASE.md"),
-				revision: listed[0].revision,
-				data: {
-					repo: "agency",
-					branch: "task/first",
-					base: "main",
-					pr: null,
-					status: "open",
-				},
-			},
-		])
-
-		const showLogs = await captureLogs(() =>
-			runTestEffect(
-				phase({
-					subcommand: "show",
-					args: ["multi", "first"],
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-		const shown = JSON.parse(showLogs[0]!)
-		expect(shown.revision).toBe(listed[0].revision)
-		expect(shown).toEqual({
-			taskId: "multi",
-			id: "first",
-			path: join(root, "tasks/multi/phases/first/PHASE.md"),
-			revision: shown.revision,
-			data: {
-				repo: "agency",
-				branch: "task/first",
-				base: "main",
-				pr: null,
-				status: "open",
-			},
-		})
-	})
-
-	test("shows one phase without reading sibling phase documents", async () => {
-		await runTestEffect(
-			phase({
-				subcommand: "create",
-				args: ["multi", "second"],
-				repo: "agency",
-				branch: "task/second",
-				base: "main",
-				cwd: root,
-				silent: true,
-			}),
-		)
-		const fs = await Effect.runPromise(
-			FileSystemService.pipe(Effect.provide(FileSystemService.Default)),
-		)
-		const readPaths: string[] = []
-		const countingFs = {
-			...fs,
-			readFile: (path: string) => {
-				readPaths.push(path)
-				return fs.readFile(path)
-			},
-		}
-		const program = PhaseService.pipe(
-			Effect.flatMap((service) => service.show("multi", "second", root)),
-			Effect.provide(PhaseService.Default),
-			Effect.provide(TaskService.Default),
-			Effect.provide(WorkbaseService.Default),
-			Effect.provide(Layer.succeed(FileSystemService, countingFs)),
-		)
-
-		const record = await Effect.runPromise(program)
-
-		expect(record.id).toBe("second")
-		expect(readPaths.filter((path) => path.endsWith("PHASE.md"))).toEqual([
-			join(root, "tasks/multi/phases/second/PHASE.md"),
-		])
-	})
-
-	test("renders task and phase operational tables", async () => {
-		const taskLogs = await captureLogs(() =>
-			runTestEffect(task({ subcommand: "list", args: [], cwd: root })),
-		)
-		expect(taskLogs[0]).toContain(
-			"TASK   PARENT  STATUS  READINESS  REPOSITORIES  BRANCH",
-		)
-		expect(taskLogs[0]).toContain("multi  -       open    ready")
-
-		const phaseLogs = await captureLogs(() =>
-			runTestEffect(phase({ subcommand: "list", args: ["multi"], cwd: root })),
-		)
-		expect(phaseLogs[0]).toContain(
-			"PHASE  PARENT  STATUS  READINESS  REPOSITORIES  BRANCH",
-		)
-		expect(phaseLogs[0]).toContain(
-			"first  multi   open    ready      agency        task/first  absent  absent",
-		)
-	})
-
-	test("outputs created task and phase records as JSON", async () => {
-		const taskLogs = await captureLogs(() =>
-			runTestEffect(
-				task({
-					subcommand: "create",
-					args: ["another"],
-					ticketUrl: "https://example.com/another",
-					multiPhase: true,
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-		expect(JSON.parse(taskLogs[0]!)).toMatchObject({
-			id: "another",
-			data: { ticketUrl: "https://example.com/another", phases: [] },
-		})
-
-		const phaseLogs = await captureLogs(() =>
-			runTestEffect(
-				phase({
-					subcommand: "create",
-					args: ["another", "first"],
-					repo: "agency",
-					branch: "task/another-first",
-					base: "main",
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-		expect(JSON.parse(phaseLogs[0]!)).toMatchObject({
-			taskId: "another",
-			id: "first",
-			data: {
-				repo: "agency",
-				branch: "task/another-first",
-				base: "main",
-				status: "open",
-			},
-		})
-	})
-
-	test("starts work on a newly created phase", async () => {
-		const launches: unknown[] = []
-
-		await runTestEffect(
-			phase(
-				{
-					subcommand: "new",
-					args: ["multi", "immediate"],
-					repo: "agency",
-					branch: "task/immediate",
-					base: "main",
-					work: true,
-					auto: true,
-					cwd: root,
-					silent: true,
-				},
-				(options) =>
-					Effect.sync(() => {
-						launches.push(options)
-						return undefined
-					}),
-			),
-		)
-
-		expect(launches).toEqual([
-			expect.objectContaining({
-				taskId: "multi",
-				phaseId: "immediate",
-				auto: true,
-				cwd: root,
-			}),
-		])
-	})
-
-	test("sets task and phase status", async () => {
-		const phaseLogs = await captureLogs(() =>
-			runTestEffect(
-				phase({
-					subcommand: "status",
-					args: ["multi", "first", "working"],
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-		expect(JSON.parse(phaseLogs[0]!).data.status).toBe("working")
-
-		await runTestEffect(
-			task({
-				subcommand: "create",
-				args: ["single-status"],
-				ticketUrl: "https://example.com/task",
-				repo: "agency",
-				branch: "task/single-status",
-				base: "main",
-				cwd: root,
-				silent: true,
-			}),
-		)
-		const taskLogs = await captureLogs(() =>
-			runTestEffect(
-				task({
-					subcommand: "status",
-					args: ["single-status", "working"],
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-		expect(JSON.parse(taskLogs[0]!).data.status).toBe("working")
-	})
-
-	test("converts a single-phase task with an explicit first phase ID", async () => {
-		await runTestEffect(
-			task({
-				subcommand: "create",
-				args: ["single"],
-				ticketUrl: "https://example.com/single",
-				repo: "agency",
-				branch: "task/single",
-				base: "main",
-				cwd: root,
-				silent: true,
-			}),
-		)
-
-		await runTestEffect(
-			phase({
-				subcommand: "create",
-				args: ["single", "follow-up"],
-				firstPhase: "implementation",
-				repo: "agency",
-				branch: "task/follow-up",
-				base: "main",
-				dependsOn: ["implementation"],
-				cwd: root,
-				silent: true,
-			}),
-		)
-
-		const logs = await captureLogs(() =>
-			runTestEffect(
-				task({
-					subcommand: "show",
-					args: ["single"],
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-		expect(JSON.parse(logs[0]!).data.phases).toEqual([
-			{ id: "implementation" },
-			{ id: "follow-up", dependsOn: ["implementation"] },
-		])
-	})
-})

package/src/commands/task.test.ts

@@ -1,281 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { mkdir } from "node:fs/promises"
-import { join } from "node:path"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import { task, type TaskInteraction } from "./task"
-
-describe("task creation input", () => {
-	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 })
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	test("guides task creation and defaults branch metadata", async () => {
-		await mkdir(join(root, "epics/delivery"), { recursive: true })
-		await Bun.write(
-			join(root, "epics/delivery/EPIC.md"),
-			"---\nticketUrl: https://example.com/delivery\nrepos:\n  - repo: agency\n    ref: main\ntasks: []\n---\n\n# Delivery\n",
-		)
-		const textAnswers = ["guided-task", "", ""]
-		const prompts: string[] = []
-		const interaction: TaskInteraction = {
-			text: (prompt) => {
-				prompts.push(prompt)
-				return Effect.succeed(textAnswers.shift() ?? "")
-			},
-			select: (prompt, choices) => {
-				prompts.push(`${prompt}: ${choices.join(",")}`)
-				return Effect.succeed(
-					prompt === "Parent epic"
-						? "(none)"
-						: prompt === "Task type"
-							? "single-phase"
-							: "agency",
-				)
-			},
-		}
-
-		await runTestEffect(
-			task(
-				{ subcommand: "new", args: [], cwd: root, silent: true },
-				interaction,
-			),
-		)
-
-		const content = await Bun.file(
-			join(root, "tasks/guided-task/TASK.md"),
-		).text()
-		expect(content).toContain("ticketUrl: null")
-		expect(content).toContain("repo: agency")
-		expect(content).toContain("branch: task/guided-task")
-		expect(content).toContain("base: main")
-		expect(prompts).toEqual([
-			"Task ID: ",
-			"Ticket URL (optional): ",
-			"Description (optional): ",
-			"Parent epic: (none),delivery",
-			"Task type: single-phase,multi-phase",
-		])
-	})
-
-	test("asks for a repository only when more than one is available", async () => {
-		await mkdir(join(root, "repos/web"), { recursive: true })
-		const prompts: string[] = []
-		const interaction: TaskInteraction = {
-			text: () => Effect.fail(new Error("unexpected text prompt")),
-			select: (prompt, choices) => {
-				prompts.push(`${prompt}: ${choices.join(",")}`)
-				return Effect.succeed(prompt === "Task type" ? "single-phase" : "web")
-			},
-		}
-
-		await runTestEffect(
-			task(
-				{
-					subcommand: "new",
-					args: ["multi-repo"],
-					ticketUrl: "",
-					description: "",
-					cwd: root,
-					silent: true,
-				},
-				interaction,
-			),
-		)
-
-		expect(prompts).toEqual([
-			"Task type: single-phase,multi-phase",
-			"Writable repository: agency,web",
-		])
-		expect(
-			await Bun.file(join(root, "tasks/multi-repo/TASK.md")).text(),
-		).toContain("repo: web")
-	})
-
-	test("keeps scripted creation non-interactive and permits no ticket URL", async () => {
-		const interaction: TaskInteraction = {
-			text: () => Effect.fail(new Error("unexpected text prompt")),
-			select: () => Effect.fail(new Error("unexpected selection prompt")),
-		}
-
-		await runTestEffect(
-			task(
-				{
-					subcommand: "create",
-					args: ["scripted-task"],
-					repo: "agency",
-					cwd: root,
-					silent: true,
-				},
-				interaction,
-			),
-		)
-
-		const content = await Bun.file(
-			join(root, "tasks/scripted-task/TASK.md"),
-		).text()
-		expect(content).toContain("ticketUrl: null")
-		expect(content).toContain("branch: task/scripted-task")
-		expect(content).toContain("base: main")
-	})
-
-	test("returns revision-bound validation evidence and normalized recalled context", async () => {
-		const [output] = await captureLogs(() =>
-			runTestEffect(
-				task({
-					subcommand: "create",
-					args: ["scripted-context"],
-					contextRepo: "agency",
-					contextBase: "main",
-					contextSlug: "scripted-context",
-					authoritativeSources: [
-						"https://example.com/spec",
-						join(root, "SOURCE.md"),
-					],
-					cwd: root,
-					json: true,
-				}),
-			),
-		)
-		const result = JSON.parse(output!)
-		expect(result.selector).toBe("execution-unit:task/scripted-context")
-		expect(result.documentPath).toBe(
-			join(root, "tasks/scripted-context/TASK.md"),
-		)
-		expect(result.validation.valid).toBe(true)
-		expect(result.evidence).toEqual(
-			expect.objectContaining({
-				version: 1,
-				target: "execution-unit:task/scripted-context",
-				documentRevision: result.revision,
-				valid: true,
-				digest: expect.any(String),
-			}),
-		)
-		expect(result.recalledContext).toEqual({
-			repo: "agency",
-			base: "main",
-			preferredSlug: "scripted-context",
-			authoritativeSources: [
-				join(root, "SOURCE.md"),
-				"https://example.com/spec",
-			],
-		})
-	})
-
-	test("rejects stale or conflicting recalled context", async () => {
-		await expect(
-			runTestEffect(
-				task({
-					subcommand: "create",
-					args: ["conflict"],
-					repo: "agency",
-					contextRepo: "other",
-					cwd: root,
-					silent: true,
-				}),
-			),
-		).rejects.toThrow("conflicts with --repo")
-		await expect(
-			runTestEffect(
-				task({
-					subcommand: "create",
-					args: ["conflict"],
-					contextRepo: "agency",
-					contextSlug: "stale-slug",
-					cwd: root,
-					silent: true,
-				}),
-			),
-		).rejects.toThrow("conflicts with task ID")
-	})
-
-	test("never prompts when scripted creation is incomplete", async () => {
-		const interaction: TaskInteraction = {
-			text: () => Effect.fail(new Error("unexpected text prompt")),
-			select: () => Effect.fail(new Error("unexpected selection prompt")),
-		}
-
-		await expect(
-			runTestEffect(
-				task(
-					{
-						subcommand: "create",
-						args: ["scripted-task"],
-						cwd: root,
-						silent: true,
-					},
-					interaction,
-				),
-			),
-		).rejects.toThrow("Writable repository is required")
-	})
-
-	test("refuses guided creation when input is disabled", async () => {
-		const interaction: TaskInteraction = {
-			text: () => Effect.fail(new Error("unexpected text prompt")),
-			select: () => Effect.fail(new Error("unexpected selection prompt")),
-		}
-
-		await expect(
-			runTestEffect(
-				task(
-					{
-						subcommand: "new",
-						args: [],
-						cwd: root,
-						silent: true,
-						inputAllowed: false,
-					},
-					interaction,
-				),
-			),
-		).rejects.toThrow("task new requires interactive input")
-	})
-
-	test("starts work on a newly created task", async () => {
-		const launches: unknown[] = []
-
-		await runTestEffect(
-			task(
-				{
-					subcommand: "new",
-					args: ["immediate"],
-					ticketUrl: "",
-					description: "",
-					multiPhase: false,
-					repo: "agency",
-					work: true,
-					auto: true,
-					cwd: root,
-					silent: true,
-				},
-				undefined,
-				(options) =>
-					Effect.sync(() => {
-						launches.push(options)
-						return undefined
-					}),
-			),
-		)
-
-		expect(launches).toEqual([
-			expect.objectContaining({
-				taskId: "immediate",
-				auto: true,
-				cwd: root,
-			}),
-		])
-	})
-})