@markjaquith/agency 3.2.13 → 3.2.15

package/src/commands/workbase.test.ts

@@ -1,170 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { join } from "node:path"
-import {
-	captureLogs,
-	cleanupTempDir,
-	createTempDir,
-	runTestEffect,
-} from "../test-utils"
-import { workbase } from "./workbase"
-
-describe("workbase command", () => {
-	let root: string
-	let configDirectory: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		configDirectory = join(root, "config")
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	test("adds and lists workbases as JSON", async () => {
-		const added = await captureLogs(() =>
-			runTestEffect(
-				workbase({
-					subcommand: "add",
-					args: [root],
-					configDirectory,
-					json: true,
-				}),
-			),
-		)
-		const registration = JSON.parse(added[0]!)
-
-		const listed = await captureLogs(() =>
-			runTestEffect(
-				workbase({
-					subcommand: "list",
-					args: [],
-					configDirectory,
-					json: true,
-				}),
-			),
-		)
-
-		expect(JSON.parse(listed[0]!)).toEqual({
-			workbases: [registration],
-		})
-	})
-
-	test("sets, clears, and removes the default workbase", async () => {
-		const added = await captureLogs(() =>
-			runTestEffect(
-				workbase({
-					subcommand: "add",
-					args: [root],
-					name: "primary",
-					configDirectory,
-					json: true,
-				}),
-			),
-		)
-		const registration = JSON.parse(added[0]!)
-
-		await runTestEffect(
-			workbase({
-				subcommand: "default",
-				args: ["primary"],
-				configDirectory,
-				silent: true,
-			}),
-		)
-		const listed = await captureLogs(() =>
-			runTestEffect(
-				workbase({
-					subcommand: "list",
-					args: [],
-					configDirectory,
-					json: true,
-				}),
-			),
-		)
-		expect(JSON.parse(listed[0]!).defaultId).toBe(registration.id)
-		await runTestEffect(
-			workbase({
-				subcommand: "default",
-				args: [],
-				clear: true,
-				configDirectory,
-				silent: true,
-			}),
-		)
-		expect(
-			await Bun.file(join(configDirectory, "agency/workbases.json")).json(),
-		).toEqual({ version: 2, workbases: [registration] })
-
-		await runTestEffect(
-			workbase({
-				subcommand: "remove",
-				args: [registration.id],
-				configDirectory,
-				silent: true,
-			}),
-		)
-		expect(
-			await Bun.file(join(configDirectory, "agency/workbases.json")).json(),
-		).toEqual({ version: 2, workbases: [] })
-	})
-
-	test("names, shows, and clears a workbase name", async () => {
-		const added = await captureLogs(() =>
-			runTestEffect(
-				workbase({
-					subcommand: "add",
-					args: [root],
-					configDirectory,
-					json: true,
-				}),
-			),
-		)
-		const registration = JSON.parse(added[0]!)
-		await runTestEffect(
-			workbase({
-				subcommand: "name",
-				args: [registration.id, "primary"],
-				configDirectory,
-				silent: true,
-			}),
-		)
-
-		const shown = await captureLogs(() =>
-			runTestEffect(
-				workbase({
-					subcommand: "show",
-					args: ["primary"],
-					configDirectory,
-					json: true,
-				}),
-			),
-		)
-		expect(JSON.parse(shown[0]!).name).toBe("primary")
-
-		await runTestEffect(
-			workbase({
-				subcommand: "name",
-				args: [registration.id],
-				clear: true,
-				configDirectory,
-				silent: true,
-			}),
-		)
-		expect(
-			await Bun.file(join(configDirectory, "agency/workbases.json")).json(),
-		).toEqual({ version: 2, workbases: [registration] })
-	})
-
-	test("requires an add path", async () => {
-		await expect(
-			runTestEffect(
-				workbase({
-					subcommand: "add",
-					args: [],
-					configDirectory,
-					silent: true,
-				}),
-			),
-		).rejects.toThrow("Usage: agency workbase add <path>")
-	})
-})

package/src/graph-schema.test.ts

@@ -1,124 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Schema } from "@effect/schema"
-import jsonSchema from "../schemas/agency-graph-v1.schema.json"
-import { AgencyGraph, graphJsonlRecords } from "./graph-schema"
-
-describe("graph contract", () => {
-	test("publishes the v1 JSON Schema", () => {
-		expect(jsonSchema).toMatchObject({
-			$schema: "https://json-schema.org/draft/2020-12/schema",
-			title: "Agency workbase graph v1",
-			properties: { version: { const: 1 } },
-		})
-		expect(jsonSchema.properties.filters).toMatchObject({
-			additionalProperties: false,
-			required: ["ready", "blocked", "statuses", "repositories", "kinds"],
-		})
-		expect(jsonSchema.$defs.node.allOf).toHaveLength(5)
-		expect(jsonSchema.$defs.readiness.required).toEqual([
-			"ready",
-			"blocked",
-			"blockedBy",
-			"terminal",
-			"blockers",
-		])
-		expect(jsonSchema.$defs.node.allOf[3]?.then?.properties).toMatchObject({
-			status: { type: "null" },
-			readiness: { type: "null" },
-			aggregate: { type: "null" },
-		})
-		expect(jsonSchema.$defs.taskHandoff).toMatchObject({
-			additionalProperties: false,
-			required: ["source", "sourceRevision"],
-		})
-		expect(jsonSchema.$defs.singleTaskData.properties).toMatchObject({
-			purpose: { $ref: "#/$defs/taskPurpose" },
-			handoff: { $ref: "#/$defs/taskHandoff" },
-		})
-	})
-
-	test("streams records that reconstruct graph semantics", () => {
-		const nodes = [
-			{
-				id: "repository:agency",
-				key: "agency",
-				kind: "repository" as const,
-				dependents: ["repository:effect"],
-				repositories: ["agency"],
-				status: null,
-				readiness: null,
-				aggregate: null,
-				data: { alias: "agency" },
-			},
-			{
-				id: "repository:effect",
-				key: "effect",
-				kind: "repository" as const,
-				dependents: [],
-				repositories: ["effect"],
-				status: null,
-				readiness: null,
-				aggregate: null,
-				data: { alias: "effect" },
-			},
-		]
-		const edges = [
-			{
-				id: "references:repository:agency:repository:effect",
-				kind: "references" as const,
-				from: "repository:agency",
-				to: "repository:effect",
-			},
-		]
-		const graph = {
-			version: 1,
-			workbase: { version: 2, vcs: "git" },
-			filters: {
-				ready: null,
-				blocked: null,
-				statuses: [],
-				repositories: [],
-				kinds: [],
-			},
-			includes: [],
-			nodes,
-			edges,
-			summary: {
-				status: "open",
-				total: 0,
-				open: 0,
-				working: 0,
-				delegated: 0,
-				done: 0,
-				dropped: 0,
-				terminal: 0,
-			},
-			validation: { valid: true, issues: [] },
-		} satisfies AgencyGraph
-		expect(
-			Schema.decodeUnknownSync(AgencyGraph, { onExcessProperty: "error" })(
-				graph,
-			),
-		).toEqual(graph)
-		const records = [...graphJsonlRecords(graph)]
-		const { nodes: _nodes, edges: _edges, ...metadata } = graph
-		expect(records).toEqual([
-			{
-				version: 1,
-				type: "meta",
-				graph: metadata,
-			},
-			...nodes.map((node) => ({
-				version: 1 as const,
-				type: "node" as const,
-				node,
-			})),
-			...edges.map((edge) => ({
-				version: 1 as const,
-				type: "edge" as const,
-				edge,
-			})),
-			{ version: 1, type: "end", nodeCount: 2, edgeCount: 1 },
-		])
-	})
-})

package/src/protocol.test.ts

@@ -1,163 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Schema } from "@effect/schema"
-import errorFixture from "../fixtures/protocol/error.json"
-import successFixture from "../fixtures/protocol/success.json"
-import jsonSchema from "../schemas/agency-envelope-v1.schema.json"
-import {
-	AgencyEnvelope,
-	collectCommandResult,
-	emitCommandResult,
-	errorEnvelope,
-	successEnvelope,
-} from "./protocol"
-
-describe("machine protocol", () => {
-	test("accepts the representative success and error fixtures", () => {
-		for (const fixture of [successFixture, errorFixture]) {
-			const decoded = Schema.decodeUnknownSync(AgencyEnvelope, {
-				onExcessProperty: "error",
-			})(fixture)
-			expect(JSON.stringify(decoded)).toBe(JSON.stringify(fixture))
-		}
-	})
-
-	test("publishes the matching v1 JSON Schema", () => {
-		expect(jsonSchema).toMatchObject({
-			$schema: "https://json-schema.org/draft/2020-12/schema",
-			title: "Agency machine result envelope v1",
-			oneOf: [
-				{ properties: { version: { const: 1 }, ok: { const: true } } },
-				{ properties: { version: { const: 1 }, ok: { const: false } } },
-			],
-		})
-	})
-
-	test("collects one command result without writing it", async () => {
-		const result = await collectCommandResult(async () => {
-			emitCommandResult('{"value":42}')
-		})
-		expect(successEnvelope(result)).toEqual({
-			version: 1,
-			ok: true,
-			result: { value: 42 },
-		})
-		expect(successEnvelope(undefined).result).toBeNull()
-	})
-
-	test("rejects commands that emit multiple machine results", async () => {
-		await expect(
-			collectCommandResult(async () => {
-				emitCommandResult("first")
-				emitCommandResult("second")
-			}),
-		).rejects.toThrow("more than one result")
-	})
-
-	test("restores collection state after a command throws", async () => {
-		const originalLog = console.log
-		await expect(
-			collectCommandResult(async () => {
-				emitCommandResult("partial")
-				throw new Error("command failed")
-			}),
-		).rejects.toThrow("command failed")
-		expect(console.log).toBe(originalLog)
-
-		await expect(
-			collectCommandResult(async () => {
-				emitCommandResult("recovered")
-			}),
-		).resolves.toBe("recovered")
-	})
-
-	test("rejects nested result collectors without disrupting the outer one", async () => {
-		const result = await collectCommandResult(async () => {
-			await expect(collectCommandResult(async () => {})).rejects.toThrow(
-				"already active",
-			)
-			emitCommandResult("outer")
-		})
-
-		expect(result).toBe("outer")
-	})
-
-	test("normalizes unknown failures into stable error details", () => {
-		expect(errorEnvelope(new Error("boom"))).toEqual({
-			version: 1,
-			ok: false,
-			error: {
-				code: "COMMAND_FAILED",
-				message: "boom",
-				fields: {},
-				retryable: false,
-			},
-		})
-	})
-
-	test("preserves relevant fields from classified errors", () => {
-		const validation = errorEnvelope({
-			_tag: "ValidationFailedError",
-			message: "invalid workbase",
-			cause: new Error("private cause"),
-			optional: undefined,
-			root: "/work/agency",
-			issues: [{ path: "TASK.md", message: "invalid status" }],
-		})
-		expect(validation).toMatchObject({
-			error: {
-				code: "VALIDATION_FAILED",
-				fields: {
-					root: "/work/agency",
-					issues: [{ path: "TASK.md", message: "invalid status" }],
-				},
-			},
-		})
-		expect(Object.keys(validation.error.fields).sort()).toEqual([
-			"issues",
-			"root",
-		])
-		expect(
-			errorEnvelope({
-				_tag: "RevisionConflictError",
-				message: "revision conflict",
-				path: "tasks/example/TASK.md",
-				expectedRevision: "a".repeat(64),
-				currentRevision: "b".repeat(64),
-			}),
-		).toMatchObject({
-			error: {
-				code: "REVISION_CONFLICT",
-				retryable: true,
-				fields: {
-					path: "tasks/example/TASK.md",
-					expectedRevision: "a".repeat(64),
-					currentRevision: "b".repeat(64),
-				},
-			},
-		})
-	})
-
-	test("uses dynamic protocol metadata without duplicating it in fields", () => {
-		expect(
-			errorEnvelope({
-				_tag: "PushError",
-				message: "remote timed out",
-				protocolCode: "PUSH_TIMEOUT",
-				retryable: true,
-				remediation: "Retry after checking connectivity.",
-				category: "timeout",
-				stage: "fetch",
-			}),
-		).toEqual({
-			version: 1,
-			ok: false,
-			error: {
-				code: "PUSH_TIMEOUT",
-				message: "remote timed out",
-				fields: { category: "timeout", stage: "fetch" },
-				retryable: true,
-				remediation: "Retry after checking connectivity.",
-			},
-		})
-	})
-})

package/src/readiness.test.ts

@@ -1,105 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-	WORK_STATUS_TRANSITIONS,
-	aggregateProgress,
-	canTransitionStatus,
-	isDependencySatisfied,
-	isTerminalStatus,
-	readinessState,
-} from "./readiness"
-import type { WorkStatus } from "./workbase/schemas"
-
-const statuses: readonly WorkStatus[] = [
-	"open",
-	"working",
-	"delegated",
-	"done",
-	"dropped",
-]
-
-describe("readiness model", () => {
-	test("only done satisfies dependencies and terminal states remain distinct", () => {
-		expect(isDependencySatisfied("done")).toBe(true)
-		expect(isDependencySatisfied("dropped")).toBe(false)
-		expect(readinessState("done", [{ id: "task:one" }])).toEqual({
-			ready: false,
-			blocked: true,
-			blockedBy: ["task:one"],
-			terminal: true,
-		})
-		expect(readinessState("working", [{ id: "dependency:self" }])).toEqual({
-			ready: false,
-			blocked: true,
-			blockedBy: ["dependency:self"],
-			terminal: false,
-		})
-	})
-
-	test("classifies every status and dependency state", () => {
-		expect(statuses.map(isTerminalStatus)).toEqual([
-			false,
-			false,
-			false,
-			true,
-			true,
-		])
-		expect([...statuses, undefined].map(isDependencySatisfied)).toEqual([
-			false,
-			false,
-			false,
-			true,
-			false,
-			false,
-		])
-	})
-
-	test("covers the complete status transition matrix", () => {
-		for (const from of statuses) {
-			for (const to of statuses) {
-				expect(canTransitionStatus(from, to), `${from} -> ${to}`).toBe(
-					WORK_STATUS_TRANSITIONS[from].includes(to as never),
-				)
-			}
-		}
-	})
-
-	test("rolls every status-precedence branch into aggregate progress", () => {
-		const cases: readonly [readonly WorkStatus[], WorkStatus][] = [
-			[[], "open"],
-			[["done", "done"], "done"],
-			[["done", "dropped"], "dropped"],
-			[["open", "working", "delegated"], "working"],
-			[["open", "delegated"], "delegated"],
-			[["open", "done"], "open"],
-		]
-
-		for (const [input, status] of cases) {
-			const result = aggregateProgress(input)
-			expect(result.status, input.join(",") || "empty").toBe(status)
-			expect(result.total).toBe(input.length)
-			expect(result.terminal).toBe(
-				input.filter((value) => value === "done" || value === "dropped").length,
-			)
-			for (const value of statuses) {
-				expect(result[value]).toBe(
-					input.filter((candidate) => candidate === value).length,
-				)
-			}
-		}
-	})
-
-	test("deduplicates and sorts blockers while honoring explicit readiness", () => {
-		expect(
-			readinessState(
-				"open",
-				[{ id: "task:z" }, { id: "task:a" }, { id: "task:z" }],
-				true,
-			),
-		).toEqual({
-			ready: true,
-			blocked: false,
-			blockedBy: ["task:a", "task:z"],
-			terminal: false,
-		})
-	})
-})