@markjaquith/agency 3.2.14 → 3.3.0

package/src/workbase/dependency-graph.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { findDependencyCycles, validateDependencies } from "./dependency-graph"
-
-describe("dependency graph", () => {
-	test("accepts empty and acyclic dependency graphs", () => {
-		expect(validateDependencies([], "Tasks")).toBeUndefined()
-		expect(
-			validateDependencies(
-				[
-					{ id: "build" },
-					{ id: "test", dependsOn: ["build"] },
-					{ id: "ship", dependsOn: ["build", "test"] },
-				],
-				"Tasks",
-			),
-		).toBeUndefined()
-		expect(
-			findDependencyCycles([
-				{ id: "build" },
-				{ id: "test", dependsOn: ["build"] },
-			]),
-		).toEqual([])
-	})
-
-	test("reports duplicate, self, and unknown dependencies precisely", () => {
-		expect(validateDependencies([{ id: "one" }, { id: "one" }], "Tasks")).toBe(
-			"Tasks IDs must be unique",
-		)
-		expect(
-			validateDependencies([{ id: "one", dependsOn: ["one"] }], "Tasks"),
-		).toBe("Task 'one' cannot depend on itself")
-		expect(
-			validateDependencies([{ id: "one", dependsOn: ["missing"] }], "Phases"),
-		).toBe("Unknown phase dependency 'missing'")
-	})
-
-	test("detects cycles deterministically across disconnected graphs", () => {
-		const nodes = [
-			{ id: "delta", dependsOn: ["charlie"] },
-			{ id: "bravo", dependsOn: ["alpha"] },
-			{ id: "charlie", dependsOn: ["delta"] },
-			{ id: "alpha", dependsOn: ["bravo"] },
-		]
-
-		expect(findDependencyCycles(nodes)).toEqual(["bravo", "delta"])
-		expect(validateDependencies(nodes, "Tasks")).toBe(
-			"Task dependency cycle includes 'bravo'",
-		)
-	})
-})

package/src/workbase/execution-contract.test.ts

@@ -1,161 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { mkdir } from "node:fs/promises"
-import { dirname, join } from "node:path"
-import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
-import { documentRevision } from "./document-revision"
-import {
-	assessValidationEvidence,
-	buildExecutionContract,
-	buildValidationEvidence,
-	EXECUTION_SOURCE_LOCATIONS,
-	normalizeRecalledContext,
-	parseValidationEvidence,
-	readValidationEvidence,
-} from "./execution-contract"
-
-describe("execution contract", () => {
-	let root: string
-	let taskPath: string
-	let taskContent: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		taskPath = join(root, "tasks/example/TASK.md")
-		taskContent =
-			"---\nticketUrl: null\nrepo: agency\nbranch: task/example\nbase: main\npr: null\nstatus: open\n---\n\n# Example\n"
-		await mkdir(join(root, "repos/agency"), { recursive: true })
-		await mkdir(join(root, "tasks/example"), { recursive: true })
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-		await Bun.write(taskPath, taskContent)
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	const createEvidence = () =>
-		runTestEffect(
-			buildValidationEvidence({
-				startPath: root,
-				target: "execution-unit:task/example",
-				documentPath: taskPath,
-				documentRevision: documentRevision(taskContent),
-				recalledContext: normalizeRecalledContext({
-					id: "example",
-					repo: "agency",
-					base: "main",
-				}),
-			}),
-		)
-
-	test("reuses evidence only for the same workbase and revision", async () => {
-		const evidence = await createEvidence()
-		expect(parseValidationEvidence(evidence)).toEqual(evidence)
-		const assessment = await runTestEffect(
-			assessValidationEvidence({
-				evidence,
-				startPath: root,
-				target: evidence.target,
-				documentPath: taskPath,
-				documentRevision: evidence.documentRevision,
-			}),
-		)
-		expect(assessment.disposition).toEqual({ status: "reused", reasons: [] })
-	})
-
-	test("treats legacy creation output as a validation refresh", async () => {
-		expect(
-			await runTestEffect(
-				readValidationEvidence(
-					JSON.stringify({ version: 1, ok: true, result: { id: "example" } }),
-					root,
-				),
-			),
-		).toBeUndefined()
-	})
-
-	test("refreshes evidence after document, config, mapping, or payload changes", async () => {
-		const evidence = await createEvidence()
-		const changedContent = `${taskContent}\nChanged\n`
-		await Bun.write(taskPath, changedContent)
-		await mkdir(join(root, "repos/other"), { recursive: true })
-		await Bun.write(
-			join(root, "agency.json"),
-			'{"version":2,"repositories":{"other":{"remote":"https://example.com/other.git"}}}\n',
-		)
-		const assessment = await runTestEffect(
-			assessValidationEvidence({
-				evidence: { ...evidence, digest: "0".repeat(64) },
-				startPath: root,
-				target: evidence.target,
-				documentPath: taskPath,
-				documentRevision: documentRevision(changedContent),
-			}),
-		)
-		expect(assessment.disposition.status).toBe("refreshed")
-		expect(assessment.disposition.reasons).toEqual(
-			expect.arrayContaining([
-				"digest-mismatch",
-				"document-revision-changed",
-				"workbase-revision-changed",
-				"configuration-changed",
-				"repository-mapping-changed",
-			]),
-		)
-	})
-
-	test("describes prepared execution without prescribing orchestration", () => {
-		const checkoutPath = join(root, "tasks/example/code/agency")
-		const applied = buildExecutionContract({
-			workbaseRoot: root,
-			target: "execution-unit:task/example",
-			taskPath,
-			checkoutPath,
-			documentRevision: "a".repeat(64),
-			dryRun: false,
-		})
-		const phasePath = join(root, "tasks/example/phases/implementation/PHASE.md")
-		const preview = buildExecutionContract({
-			workbaseRoot: root,
-			target: "execution-unit:phase/example/implementation",
-			taskPath,
-			phasePath,
-			checkoutPath: join(
-				root,
-				"tasks/example/phases/implementation/code/agency",
-			),
-			documentRevision: "b".repeat(64),
-			dryRun: true,
-		})
-		expect(applied).toMatchObject({
-			capability: "agency-execution-v1",
-			mode: "applied",
-			workspace: {
-				state: "materialized",
-				checkoutPath,
-			},
-			commands: {
-				work: {
-					cwd: dirname(taskPath),
-					argv: ["agency", "work", ".", "--auto"],
-				},
-			},
-		})
-		expect(applied.sourceLocations).toEqual(EXECUTION_SOURCE_LOCATIONS)
-		expect(preview).toMatchObject({
-			mode: "preview",
-			workspace: { state: "planned" },
-			plannedActions: [{ kind: "workspace-materialization" }],
-			commands: {
-				context: { cwd: dirname(phasePath) },
-			},
-		})
-		expect(applied.executionIdentity.key).toBe(
-			buildExecutionContract({
-				workbaseRoot: root,
-				target: "execution-unit:task/example",
-				taskPath,
-				documentRevision: "a".repeat(64),
-				dryRun: true,
-			}).executionIdentity.key,
-		)
-	})
-})

package/src/workbase/frontmatter.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { formatWorkDocumentBody, parseFrontmatter } from "./frontmatter"
-
-describe("parseFrontmatter", () => {
-	test("parses YAML 1.2 frontmatter and body", async () => {
-		const parsed = await Effect.runPromise(
-			parseFrontmatter(
-				"---\nrepo: agency\npr: null\n---\n\n# Task\n",
-				"TASK.md",
-			),
-		)
-
-		expect(parsed.data).toEqual({ repo: "agency", pr: null })
-		expect(parsed.body).toBe("\n# Task\n")
-	})
-
-	test("rejects duplicate keys", async () => {
-		await expect(
-			Effect.runPromise(
-				parseFrontmatter("---\nrepo: agency\nrepo: effect\n---\n", "TASK.md"),
-			),
-		).rejects.toThrow("Map keys must be unique")
-	})
-
-	test("rejects anchors and aliases", async () => {
-		await expect(
-			Effect.runPromise(
-				parseFrontmatter(
-					"---\nrepo: &repo agency\nrepos:\n  - *repo\n---\n",
-					"TASK.md",
-				),
-			),
-		).rejects.toThrow("not supported")
-	})
-
-	test("rejects custom tags", async () => {
-		await expect(
-			Effect.runPromise(
-				parseFrontmatter("---\nrepo: !custom agency\n---\n", "TASK.md"),
-			),
-		).rejects.toThrow()
-	})
-
-	test("requires frontmatter at the start of the document", async () => {
-		await expect(
-			Effect.runPromise(parseFrontmatter("# Task\n", "TASK.md")),
-		).rejects.toThrow("must begin with YAML frontmatter")
-	})
-})
-
-describe("formatWorkDocumentBody", () => {
-	test("generates explicit investigation sections", () => {
-		const body = formatWorkDocumentBody(
-			"Investigate Checkout",
-			"task",
-			"investigation",
-		)
-
-		expect(body).toContain("## Investigation Boundary")
-		expect(body).toContain("## Evidence")
-		expect(body).toContain("## Findings")
-		expect(body).toContain("## Recommendation")
-		expect(body).toContain("## Implementation Handoff")
-		expect(body).not.toContain("Describe the task outcome")
-	})
-})

package/src/workbase/repository-reference.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { parseRepositoryReferences } from "./repository-reference"
-
-describe("repository references", () => {
-	test("parses alias and ref CLI values", () => {
-		expect(parseRepositoryReferences(["web:origin/main"])[0]).toEqual({
-			repo: "web",
-			ref: "origin/main",
-		})
-		expect(
-			parseRepositoryReferences(["web:main", "zenpayroll:v1.2.3"]),
-		).toEqual([
-			{ repo: "web", ref: "main" },
-			{ repo: "zenpayroll", ref: "v1.2.3" },
-		])
-	})
-
-	test("rejects references without both parts", () => {
-		for (const value of ["web", ":main", "web:"]) {
-			expect(() => parseRepositoryReferences([value])).toThrow(
-				"expected <alias>:<ref>",
-			)
-		}
-	})
-})