@markjaquith/agency 3.2.14 → 3.3.0

package/src/commands/integration.test.ts

@@ -1,165 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { mkdir } from "node:fs/promises"
-import { join } from "node:path"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import { integration } from "./integration"
-
-describe("integration command", () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	test("reports integration status as JSON", async () => {
-		const logs = await captureLogs(() =>
-			runTestEffect(
-				integration({ subcommand: "status", cwd: root, json: true }),
-			),
-		)
-
-		expect(JSON.parse(logs[0]!)).toMatchObject({
-			root,
-			files: [
-				{ name: "agents", state: "missing" },
-				{
-					name: "opencode",
-					state: "missing",
-					diagnostic: expect.stringContaining("cannot load"),
-					remediation: expect.stringContaining("integration sync"),
-				},
-				{
-					name: "opencode-plugin",
-					state: "missing",
-					remediation: expect.stringContaining("integration sync"),
-				},
-				{
-					name: "opencode-tui",
-					state: "missing",
-					remediation: expect.stringContaining("integration sync"),
-				},
-				{
-					name: "opencode-tui-plugin",
-					state: "missing",
-					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 its instructions")
-		expect(logs.join("\n")).toContain("global config")
-	})
-
-	test("formats integration status for people", async () => {
-		const logs = await captureLogs(() =>
-			runTestEffect(integration({ subcommand: "status", cwd: root })),
-		)
-
-		expect(logs.join("\n")).toBe(`Integration status: ${root}
-
-Agent instructions: missing
-  Path: .agency/AGENTS.md
-  Managed workbase instructions need synchronization.
-  Action: Run 'agency integration sync' to restore managed instructions.
-
-OpenCode config: missing
-  Path: .opencode/opencode.jsonc
-  Agency OpenCode launches cannot load current Agency instructions or whole-workbase access.
-  Action: Run 'agency integration sync' to install Agency instructions and whole-workbase OpenCode access.
-
-OpenCode workbase plugin: missing
-  Path: .opencode/plugins/agency-repository-skills.ts
-  The managed OpenCode workbase plugin needs synchronization.
-  Action: Run 'agency integration sync' to provide workbase access and expose writable-checkout skills in OpenCode.
-
-OpenCode TUI config: missing
-  Path: .opencode/tui.jsonc
-  The managed OpenCode TUI config needs synchronization.
-  Action: Run 'agency integration sync' to register /agency-debug.
-
-OpenCode /agency-debug: missing
-  Path: .opencode/tui/agency-debug.ts
-  The managed OpenCode TUI diagnostic companion needs synchronization.
-  Action: Run 'agency integration sync' to install /agency-debug.`)
-	})
-
-	test("explicitly synchronizes integration files", async () => {
-		const logs = await captureLogs(() =>
-			runTestEffect(integration({ subcommand: "sync", cwd: root, json: true })),
-		)
-
-		expect(JSON.parse(logs[0]!).files).toMatchObject([
-			{ name: "agents", state: "managed", changed: true },
-			{ name: "opencode", state: "managed", changed: true },
-			{ name: "opencode-plugin", state: "managed", changed: true },
-			{ name: "opencode-tui", state: "managed", changed: true },
-			{ name: "opencode-tui-plugin", state: "managed", changed: true },
-		])
-		expect(await Bun.file(join(root, "AGENTS.md")).exists()).toBe(false)
-		expect(await Bun.file(join(root, ".agency/AGENTS.md")).exists()).toBe(true)
-		expect(
-			await Bun.file(join(root, ".opencode/opencode.jsonc")).exists(),
-		).toBe(true)
-		expect(
-			await Bun.file(join(root, ".opencode/command/agency.md")).exists(),
-		).toBe(false)
-		expect(
-			await Bun.file(
-				join(root, ".opencode/plugins/agency-repository-skills.ts"),
-			).exists(),
-		).toBe(true)
-		expect(await Bun.file(join(root, ".opencode/tui.jsonc")).exists()).toBe(
-			true,
-		)
-		expect(
-			await Bun.file(join(root, ".opencode/tui/agency-debug.ts")).exists(),
-		).toBe(true)
-	})
-
-	test("formats integration sync results for people", async () => {
-		const logs = await captureLogs(() =>
-			runTestEffect(integration({ subcommand: "sync", cwd: root })),
-		)
-
-		expect(logs.join("\n")).toBe(`Integration sync: ${root}
-
-Agent instructions: synced
-  Path: .agency/AGENTS.md
-  Managed workbase instructions are current.
-
-OpenCode config: synced
-  Path: .opencode/opencode.jsonc
-  Agency's managed OpenCode launch config is ready to load Agency instructions and provide whole-workbase read access.
-
-OpenCode workbase plugin: synced
-  Path: .opencode/plugins/agency-repository-skills.ts
-  Agency's managed OpenCode plugin provides whole-workbase access and exposes writable-checkout skills.
-
-OpenCode TUI config: synced
-  Path: .opencode/tui.jsonc
-  Agency's managed OpenCode TUI config explicitly loads /agency-debug.
-
-OpenCode /agency-debug: synced
-  Path: .opencode/tui/agency-debug.ts
-  Agency's managed OpenCode TUI diagnostic companion is current.`)
-	})
-})

package/src/commands/pr.test.ts

@@ -1,248 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { chmod, mkdir, realpath } from "node:fs/promises"
-import { dirname, join } from "node:path"
-import { PullRequestService } from "../services/PullRequestService"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import { pr, prCreate } from "./pr"
-
-const write = async (root: string, path: string, content: string) => {
-	const fullPath = join(root, path)
-	await mkdir(dirname(fullPath), { recursive: true })
-	await Bun.write(fullPath, content)
-}
-
-describe("pr command", () => {
-	let tempRoot: string
-	let capturePath: string
-	let originalPath: string | undefined
-
-	beforeEach(async () => {
-		tempRoot = await createTempDir()
-		capturePath = join(tempRoot, "capture")
-		const bin = join(tempRoot, "bin")
-		await mkdir(bin)
-		await Bun.write(
-			join(bin, "gh"),
-			`#!/bin/sh
-printf '%s\n' "$PWD" "$@" > "$GH_CAPTURE"
-exit "\${GH_EXIT:-0}"
-`,
-		)
-		await chmod(join(bin, "gh"), 0o755)
-		originalPath = process.env.PATH
-		process.env.PATH = `${bin}:${originalPath ?? ""}`
-		process.env.GH_CAPTURE = capturePath
-	})
-
-	afterEach(async () => {
-		process.env.PATH = originalPath
-		delete process.env.GH_CAPTURE
-		delete process.env.GH_EXIT
-		await cleanupTempDir(tempRoot)
-	})
-
-	const captured = async () =>
-		(await Bun.file(capturePath).text()).trim().split("\n")
-
-	const createExecutionWorkbase = async () => {
-		const root = join(tempRoot, "workbase")
-		await write(
-			root,
-			"agency.json",
-			`${JSON.stringify({
-				version: 2,
-				repositories: {
-					agency: { remote: "https://github.com/example/agency.git" },
-				},
-			})}\n`,
-		)
-		await mkdir(join(root, "repos/agency"), { recursive: true })
-		await mkdir(join(root, "tasks/single/code/agency"), { recursive: true })
-		await write(
-			root,
-			"tasks/single/TASK.md",
-			`---
-ticketUrl: null
-repo: agency
-branch: feat/single
-base: main
-pr: null
-status: open
----
-
-# Single
-`,
-		)
-		await mkdir(join(root, "tasks/multi/phases/build/code/agency"), {
-			recursive: true,
-		})
-		await write(
-			root,
-			"tasks/multi/TASK.md",
-			`---
-ticketUrl: null
-phases:
-  - id: build
----
-
-# Multi
-`,
-		)
-		await write(
-			root,
-			"tasks/multi/phases/build/PHASE.md",
-			`---
-repo: agency
-branch: feat/build
-base: main
-pr: null
-status: open
----
-
-# Build
-`,
-		)
-		return root
-	}
-
-	const createReviewWorkbase = async () => {
-		const root = join(tempRoot, "review-workbase")
-		await write(root, "agency.json", '{"version":2}\n')
-		await mkdir(join(root, "repos/agency"), { recursive: true })
-		await mkdir(join(root, "tasks/review/code/agency"), { recursive: true })
-		await write(
-			root,
-			"tasks/review/TASK.md",
-			`---
-ticketUrl: null
-description: Review a branch
-review:
-  repo: agency
-  source:
-    kind: branch
-    ref: refs/heads/review
-  commit: 0123456789abcdef0123456789abcdef01234567
-  refreshedAt: 2026-08-19T00:00:00.000Z
-status: working
----
-
-# Review
-`,
-		)
-		return root
-	}
-
-	test("creates and records an Agency pull request", async () => {
-		const url = "https://github.com/markjaquith/agency/pull/123"
-		let received: unknown[] = []
-		const logs = await captureLogs(() =>
-			Effect.runPromise(
-				prCreate({
-					taskId: "example",
-					phaseId: "implementation",
-					draft: true,
-					force: true,
-					title: "Ship it",
-					head: "task/example",
-					base: "main",
-					labels: ["ai-assisted"],
-					cwd: "/workbase",
-					json: true,
-				}).pipe(
-					Effect.provideService(PullRequestService, {
-						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,
-				title: "Ship it",
-				head: "task/example",
-				base: "main",
-				labels: ["ai-assisted"],
-				json: true,
-			}),
-		])
-	})
-
-	test("focuses task and descendant invocations on the writable checkout", async () => {
-		const root = await createExecutionWorkbase()
-		const task = join(root, "tasks/single")
-		const descendant = join(task, "notes/deep")
-		await mkdir(descendant, { recursive: true })
-
-		for (const cwd of [task, descendant]) {
-			expect(await runTestEffect(pr(["view"], cwd))).toBe(0)
-			expect(await captured()).toEqual([
-				await realpath(join(task, "code/agency")),
-				"pr",
-				"view",
-			])
-		}
-	})
-
-	test("focuses a phase invocation on its writable checkout", async () => {
-		const root = await createExecutionWorkbase()
-		const phase = join(root, "tasks/multi/phases/build")
-
-		expect(await runTestEffect(pr(["status"], phase))).toBe(0)
-		expect(await captured()).toEqual([
-			await realpath(join(phase, "code/agency")),
-			"pr",
-			"status",
-		])
-	})
-
-	test("focuses a review task invocation on its review checkout", async () => {
-		const root = await createReviewWorkbase()
-		const task = join(root, "tasks/review")
-
-		expect(await runTestEffect(pr(["view", "--web"], task))).toBe(0)
-		expect(await captured()).toEqual([
-			await realpath(join(task, "code/agency")),
-			"pr",
-			"view",
-			"--web",
-		])
-	})
-
-	test("falls back to the invocation directory without execution authority", async () => {
-		const root = await createExecutionWorkbase()
-		const orchestration = join(root, "tasks/multi")
-		const outside = join(tempRoot, "outside")
-		await mkdir(outside)
-
-		for (const cwd of [orchestration, outside]) {
-			expect(await runTestEffect(pr(["list"], cwd))).toBe(0)
-			expect(await captured()).toEqual([await realpath(cwd), "pr", "list"])
-		}
-	})
-
-	test("forwards arguments unchanged and returns the gh exit code", async () => {
-		const outside = join(tempRoot, "outside")
-		await mkdir(outside)
-		process.env.GH_EXIT = "23"
-		const args = ["create", "--title", "two words", "--", "literal"]
-
-		expect(await runTestEffect(pr(args, outside))).toBe(23)
-		expect(await captured()).toEqual([await realpath(outside), "pr", ...args])
-	})
-})

package/src/commands/push.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { PushService } from "../services/PushService"
-import { captureLogs } from "../test-utils"
-import type { Progress } from "../utils/progress"
-import { push } from "./push"
-
-describe("push command", () => {
-	test("reports deterministic progress while preserving one JSON result", 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}`),
-		}
-		const result = {
-			vcs: "git" as const,
-			taskId: "example",
-			branch: "task/example",
-			base: "main",
-			remote: "origin",
-			tip: "abc123",
-		}
-		const logs = await captureLogs(() =>
-			Effect.runPromise(
-				push({ cwd: "/workbase", json: true }, progress).pipe(
-					Effect.provideService(PushService, {
-						publish: (_cwd: string, options: any) => {
-							for (const stage of [
-								"context",
-								"inspect",
-								"validate",
-								"fetch",
-								"validate",
-								"publish",
-							] as const)
-								options.onProgress(stage)
-							return Effect.succeed(result)
-						},
-					} as never),
-				) as Effect.Effect<void, unknown, never>,
-			),
-		)
-
-		expect(logs).toEqual([JSON.stringify(result, null, 2)])
-		expect(updates).toEqual([
-			"start:Inspecting Agency execution context",
-			"start:Selecting the publication tip",
-			"start:Validating outgoing changes",
-			"start:Fetching remote state",
-			"start:Validating outgoing changes",
-			"start:Publishing the declared branch",
-			"succeed:Published task/example to origin",
-		])
-	})
-})

package/src/commands/read-only.test.ts

@@ -1,161 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { chmod, lstat, mkdir, readdir } from "node:fs/promises"
-import { dirname, join } from "node:path"
-import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
-import { WorkbaseService } from "../services/WorkbaseService"
-import { epic } from "./epic"
-import { integration } from "./integration"
-import { phase } from "./phase"
-import { repo } from "./repo"
-import { status } from "./status"
-import { task } from "./task"
-import { validate } from "./validate"
-import { context } from "./context"
-import { graph } from "./graph"
-import { next } from "./next"
-import { doctor } from "./doctor"
-
-const write = async (root: string, path: string, content: string) => {
-	const fullPath = join(root, path)
-	await mkdir(dirname(fullPath), { recursive: true })
-	await Bun.write(fullPath, content)
-}
-
-const setReadOnly = async (path: string, readOnly: boolean): Promise<void> => {
-	const metadata = await lstat(path)
-	if (!metadata.isDirectory()) {
-		await chmod(path, readOnly ? 0o444 : 0o644)
-		return
-	}
-
-	if (!readOnly) await chmod(path, 0o755)
-	for (const entry of await readdir(path)) {
-		await setReadOnly(join(path, entry), readOnly)
-	}
-	if (readOnly) await chmod(path, 0o555)
-}
-
-describe("observational commands", () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		await write(root, "agency.json", '{"version":2}\n')
-		await mkdir(join(root, "repos/agency"), { recursive: true })
-		await write(
-			root,
-			"epics/example/EPIC.md",
-			`---
-ticketUrl: https://example.com/epics/example
-repos:
-  - repo: agency
-    ref: main
-tasks:
-  - id: example-task
----
-
-# Example
-`,
-		)
-		await write(
-			root,
-			"tasks/example-task/TASK.md",
-			`---
-ticketUrl: null
-epic: example
-phases:
-  - id: implementation
----
-
-# Example task
-`,
-		)
-		await write(
-			root,
-			"tasks/example-task/phases/implementation/PHASE.md",
-			`---
-repo: agency
-branch: feat/example
-base: main
-pr: null
-status: open
----
-
-# Implementation
-`,
-		)
-	})
-
-	afterEach(async () => {
-		await setReadOnly(root, false)
-		await cleanupTempDir(root)
-	})
-
-	test("remain usable when the workbase is read-only", async () => {
-		await setReadOnly(root, true)
-
-		await runTestEffect(
-			WorkbaseService.pipe(Effect.flatMap((service) => service.discover(root))),
-		)
-		await runTestEffect(
-			integration({ subcommand: "status", cwd: root, silent: true }),
-		)
-		await runTestEffect(
-			epic({ subcommand: "list", args: [], cwd: root, silent: true }),
-		)
-		await runTestEffect(
-			epic({ subcommand: "show", args: ["example"], cwd: root, silent: true }),
-		)
-		await runTestEffect(
-			task({ subcommand: "list", args: [], cwd: root, silent: true }),
-		)
-		await runTestEffect(
-			task({
-				subcommand: "show",
-				args: ["example-task"],
-				cwd: root,
-				silent: true,
-			}),
-		)
-		await runTestEffect(
-			phase({
-				subcommand: "list",
-				args: ["example-task"],
-				cwd: root,
-				silent: true,
-			}),
-		)
-		await runTestEffect(
-			phase({
-				subcommand: "show",
-				args: ["example-task", "implementation"],
-				cwd: root,
-				silent: true,
-			}),
-		)
-		await runTestEffect(
-			repo({ subcommand: "list", args: [], cwd: root, silent: true }),
-		)
-		await runTestEffect(status({ cwd: root, silent: true }))
-		await runTestEffect(validate({ path: root, silent: true }))
-		await runTestEffect(
-			context({
-				target: "tasks/example-task/phases/implementation",
-				cwd: root,
-				silent: true,
-			}),
-		)
-		await runTestEffect(graph({ cwd: root, silent: true }))
-		await runTestEffect(next({ cwd: root, silent: true }))
-		await runTestEffect(doctor({ cwd: root, silent: true }))
-
-		expect(await Bun.file(join(root, "AGENTS.md")).exists()).toBe(false)
-		expect(
-			await Bun.file(join(root, ".opencode/opencode.jsonc")).exists(),
-		).toBe(false)
-		expect(
-			await Bun.file(join(root, ".opencode/command/agency.md")).exists(),
-		).toBe(false)
-	})
-})