pi-harness-runtime 1.1.439 → 1.1.441

package/packages/task-compiler/test/task-compiler.test.ts

@@ -1,628 +0,0 @@
-/**
- * Task Compiler - Tests
- *
- * Tests cover all 8 acceptance criteria from RFC-0044:
- * 1. Standard engineering flow produces correct task sequence.
- * 2. Cyclic dependencies fail with CYCLIC_DEPENDENCY.
- * 3. Exclusive file overlap serializes or fails.
- * 4. Every acceptance criterion maps to a task.
- * 5. Build/migrate/commit remain prohibited by default.
- * 6. E2E task is inserted for browser workflows.
- * 7. Provider preference is advisory (not hard dependency).
- * 8. Graph ordering is deterministic.
- */
-
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import { compileTasks } from "../src/index.js";
-import type {
-	CompiledRequirement,
-	ProjectProfile,
-	TaskCompileInput,
-} from "../src/types.js";
-import { TaskCompilerError, TaskCompilerErrorCode } from "../src/types.js";
-
-// --- Test utilities -----------------------------------------------------
-
-function makeRequirement(
-	text: string,
-	overrides?: Partial<CompiledRequirement>,
-): CompiledRequirement {
-	return {
-		id: "REQ-001",
-		title: "Test Requirement",
-		problemStatement: text,
-		goals: [{ id: "goal-1", description: text }],
-		constraints: [],
-		acceptanceCriteria: [{ id: "AC-001", outcome: ["goal achieved"] }],
-		riskTags: [],
-		...overrides,
-	};
-}
-
-function makeProject(overrides?: Partial<ProjectProfile>): ProjectProfile {
-	return {
-		projectPath: "/project",
-		projectName: "test-project",
-		frameworks: [],
-		testCapabilities: [],
-		commands: {},
-		rules: [],
-		...overrides,
-	};
-}
-
-async function compile(text: string, project?: ProjectProfile) {
-	return compileTasks({
-		requirement: makeRequirement(text),
-		project: project ?? makeProject(),
-		jobId: "JOB-001",
-	});
-}
-
-// --- Test 1: Standard engineering flow ---------------------------------
-
-describe("Standard engineering flow", () => {
-	it("produces analysis → implementation → test → review pipeline", async () => {
-		const result = await compile("Build a user login feature");
-		const types = result.tasks.map((t) => t.type);
-		assert.ok(types.length >= 4, "Should have at least 4 stages");
-		// Implementation should come before test
-		const implIdx = types.indexOf("implementation");
-		const testIdx = types.indexOf("test");
-		const reviewIdx = types.indexOf("review");
-		assert.ok(implIdx >= 0, "Should have implementation task");
-		assert.ok(testIdx >= 0, "Should have test task");
-		assert.ok(reviewIdx >= 0, "Should have review task");
-		assert.ok(implIdx < testIdx, "Implementation should come before test");
-		assert.ok(testIdx < reviewIdx, "Test should come before review");
-	});
-
-	it("inserts design stage for large requirements", async () => {
-		const result = await compile(
-			"Implement a comprehensive multi-module authentication and authorization system with RBAC, OAuth2, and session management across distributed microservices",
-		);
-		const types = result.tasks.map((t) => t.type);
-		assert.ok(
-			types.includes("design"),
-			"Should include design stage for large requirements",
-		);
-	});
-
-	it("each task has measurable completion outputs", async () => {
-		const result = await compile("Add user registration form");
-		for (const task of result.tasks) {
-			assert.ok(
-				task.expectedOutputs.length > 0,
-				`Task ${task.id} should have expected outputs`,
-			);
-			const hasRequired = task.expectedOutputs.some((o) => o.required);
-			assert.ok(
-				hasRequired,
-				`Task ${task.id} should have at least one required output`,
-			);
-		}
-	});
-});
-
-// --- Test 2: Cycle detection --------------------------------------------
-
-describe("Cyclic dependencies fail", () => {
-	it("throws CYCLIC_DEPENDENCY when cycle detected", async () => {
-		// Test assertNoCycles directly with a graph that has A→B→C→A
-		const { assertNoCycles } = await import("../src/validate.js");
-		const cyclicGraph = {
-			jobId: "JOB",
-			tasks: [
-				{
-					id: "task-A",
-					type: "implementation" as const,
-					title: "Task A",
-					objective: "Task A",
-					dependencies: ["task-C"],
-					priority: 1,
-					fileOwnership: {
-						taskId: "task-A",
-						mode: "exclusive" as const,
-						include: [],
-						exclude: [],
-					},
-					filesInScope: [],
-					estimatedComplexity: 1 as const,
-					expectedOutputs: [],
-					prohibitedCommands: [],
-					permittedCommands: [],
-					requiredCapabilities: [],
-					acceptanceCriteria: [],
-					jobId: "JOB",
-				},
-				{
-					id: "task-B",
-					type: "implementation" as const,
-					title: "Task B",
-					objective: "Task B",
-					dependencies: ["task-A"],
-					priority: 2,
-					fileOwnership: {
-						taskId: "task-B",
-						mode: "exclusive" as const,
-						include: [],
-						exclude: [],
-					},
-					filesInScope: [],
-					estimatedComplexity: 1 as const,
-					expectedOutputs: [],
-					prohibitedCommands: [],
-					permittedCommands: [],
-					requiredCapabilities: [],
-					acceptanceCriteria: [],
-					jobId: "JOB",
-				},
-				{
-					id: "task-C",
-					type: "implementation" as const,
-					title: "Task C",
-					objective: "Task C",
-					dependencies: ["task-B"],
-					priority: 3,
-					fileOwnership: {
-						taskId: "task-C",
-						mode: "exclusive" as const,
-						include: [],
-						exclude: [],
-					},
-					filesInScope: [],
-					estimatedComplexity: 1 as const,
-					expectedOutputs: [],
-					prohibitedCommands: [],
-					permittedCommands: [],
-					requiredCapabilities: [],
-					acceptanceCriteria: [],
-					jobId: "JOB",
-				},
-			],
-			roots: ["task-A"],
-			terminalTasks: ["task-C"],
-			topologicalOrder: [],
-		};
-		assert.throws(
-			() => assertNoCycles(cyclicGraph),
-			(err: unknown) => {
-				if (err instanceof TaskCompilerError) {
-					assert.strictEqual(
-						err.code,
-						TaskCompilerErrorCode.CYCLIC_DEPENDENCY,
-						"Should throw CYCLIC_DEPENDENCY",
-					);
-					const details = err.details as { cyclicTasks?: string[] } | undefined;
-					assert.ok(
-						details?.cyclicTasks && details.cyclicTasks.length > 0,
-						"Should report cyclic tasks",
-					);
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-
-	it("empty objective throws EMPTY_OBJECTIVE when no goals", async () => {
-		// An empty requirement with no problem statement and no goals
-		// triggers EMPTY_OBJECTIVE because decomposeRequirement produces no candidates
-		const req: CompiledRequirement = {
-			id: "REQ-EMPTY",
-			title: "",
-			problemStatement: "   ", // whitespace-only = effectively empty
-			goals: [{ id: "g0", description: "   " }], // whitespace-only goal
-			constraints: [],
-			acceptanceCriteria: [],
-			riskTags: [],
-		};
-		await assert.rejects(
-			async () =>
-				compileTasks({
-					requirement: req,
-					project: makeProject(),
-					jobId: "JOB-EMPTY",
-				}),
-			(err: unknown) => {
-				if (err instanceof TaskCompilerError) {
-					assert.ok(
-						err.code === TaskCompilerErrorCode.EMPTY_OBJECTIVE ||
-							err.code === TaskCompilerErrorCode.FILE_OVERLAP_CONFLICT,
-						`Expected error, got ${err.code}`,
-					);
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-});
-
-// --- Test 3: File ownership overlap -------------------------------------
-
-describe("File ownership overlap", () => {
-	it("parallel exclusive tasks on same files throw error", async () => {
-		// Directly test assertNoExclusiveFileOverlap with truly parallel exclusive tasks
-		const { assertNoExclusiveFileOverlap } = await import("../src/validate.js");
-		const overlapGraph = {
-			jobId: "JOB",
-			tasks: [
-				{
-					id: "impl-A",
-					type: "implementation" as const,
-					title: "Impl A",
-					objective: "Implement feature A",
-					dependencies: [], // parallel to impl-B
-					priority: 1,
-					fileOwnership: {
-						taskId: "impl-A",
-						mode: "exclusive" as const,
-						include: ["/project/src/**"],
-						exclude: [],
-					},
-					filesInScope: [],
-					estimatedComplexity: 1 as const,
-					expectedOutputs: [
-						{
-							kind: "file" as const,
-							description: "File a.ts",
-							path: "/project/src/a.ts",
-							required: true,
-						},
-					],
-					prohibitedCommands: [],
-					permittedCommands: [],
-					requiredCapabilities: [],
-					acceptanceCriteria: [],
-					jobId: "JOB",
-				},
-				{
-					id: "impl-B",
-					type: "implementation" as const,
-					title: "Impl B",
-					objective: "Implement feature B",
-					dependencies: [], // parallel to impl-A
-					priority: 1,
-					fileOwnership: {
-						taskId: "impl-B",
-						mode: "exclusive" as const,
-						include: ["/project/src/**"], // same file scope
-						exclude: [],
-					},
-					filesInScope: [],
-					estimatedComplexity: 1 as const,
-					expectedOutputs: [
-						{
-							kind: "file" as const,
-							description: "File b.ts",
-							path: "/project/src/b.ts",
-							required: true,
-						},
-					],
-					prohibitedCommands: [],
-					permittedCommands: [],
-					requiredCapabilities: [],
-					acceptanceCriteria: [],
-					jobId: "JOB",
-				},
-			],
-			roots: ["impl-A", "impl-B"],
-			terminalTasks: ["impl-A", "impl-B"],
-			topologicalOrder: [],
-		};
-		assert.throws(
-			() => assertNoExclusiveFileOverlap(overlapGraph),
-			(err: unknown) => {
-				if (err instanceof TaskCompilerError) {
-					assert.strictEqual(
-						err.code,
-						TaskCompilerErrorCode.FILE_OVERLAP_CONFLICT,
-						"Should throw FILE_OVERLAP_CONFLICT",
-					);
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-
-	it("exclusive tasks get file ownership set correctly", async () => {
-		const result = await compile("Build a feature");
-		const implTasks = result.tasks.filter((t) => t.type === "implementation");
-		for (const task of implTasks) {
-			assert.strictEqual(
-				task.fileOwnership.mode,
-				"exclusive",
-				`Implementation task ${task.id} should have exclusive ownership`,
-			);
-		}
-		const analysisTasks = result.tasks.filter((t) => t.type === "analysis");
-		for (const task of analysisTasks) {
-			assert.strictEqual(
-				task.fileOwnership.mode,
-				"shared_read",
-				`Analysis task ${task.id} should have shared_read ownership`,
-			);
-		}
-	});
-});
-
-// --- Test 4: Acceptance criterion mapping -------------------------------
-
-describe("Acceptance criterion mapping", () => {
-	it("every acceptance criterion is assigned to at least one task", async () => {
-		const acs = [
-			{ id: "AC-001", outcome: ["User can register"] },
-			{ id: "AC-002", outcome: ["User receives email"] },
-			{ id: "AC-003", outcome: ["Session is created"] },
-		];
-		const req: CompiledRequirement = {
-			id: "REQ-MAP",
-			title: "User Registration",
-			problemStatement: "Implement user registration flow",
-			goals: [{ id: "g1", description: "Implement registration" }],
-			constraints: [],
-			acceptanceCriteria: acs,
-			riskTags: [],
-		};
-		const result = await compileTasks({
-			requirement: req,
-			project: makeProject(),
-			jobId: "JOB-MAP",
-		});
-		const assigned = new Set<string>();
-		for (const task of result.tasks) {
-			for (const cid of task.acceptanceCriteria) {
-				assigned.add(cid);
-			}
-		}
-		for (const ac of acs) {
-			assert.ok(
-				assigned.has(ac.id),
-				`AC ${ac.id} should be assigned to at least one task`,
-			);
-		}
-	});
-
-	it("every task with acceptance criteria has required verification output", async () => {
-		const result = await compile("Build feature with ACs", makeProject());
-		for (const task of result.tasks) {
-			if (task.acceptanceCriteria.length > 0) {
-				const requiredOutputs = task.expectedOutputs.filter((o) => o.required);
-				assert.ok(
-					requiredOutputs.length > 0,
-					`Task ${task.id} with ${task.acceptanceCriteria.length} ACs should have required verification`,
-				);
-			}
-		}
-	});
-});
-
-// --- Test 5: Command policy -------------------------------------------
-
-describe("Build/migrate/commit restrictions", () => {
-	it("git commit is prohibited by default", async () => {
-		const result = await compile("Add login feature");
-		for (const task of result.tasks) {
-			assert.ok(
-				task.prohibitedCommands.some((c) => c.includes("git commit")),
-				`Task ${task.id} should prohibit git commit`,
-			);
-		}
-	});
-
-	it("bench build and migrate are prohibited by default", async () => {
-		const result = await compile("Build login feature");
-		const allProhibited = result.tasks.flatMap((t) => t.prohibitedCommands);
-		assert.ok(
-			allProhibited.some((c) => c.includes("bench build")),
-			"Should prohibit bench build",
-		);
-		assert.ok(
-			allProhibited.some((c) => c.includes("bench migrate")),
-			"Should prohibit bench migrate",
-		);
-	});
-
-	it("test tasks are permitted to run test commands", async () => {
-		const result = await compile("Build feature with tests", makeProject());
-		const testTasks = result.tasks.filter((t) => t.type === "test");
-		if (testTasks.length > 0) {
-			for (const task of testTasks) {
-				assert.ok(
-					task.permittedCommands.some(
-						(c) =>
-							c.includes("test") || c.includes("pytest") || c.includes("jest"),
-					),
-					`Test task ${task.id} should be permitted to run test commands`,
-				);
-			}
-		}
-	});
-});
-
-// --- Test 6: E2E insertion -----------------------------------------
-
-describe("E2E task insertion", () => {
-	it("E2E task is NOT inserted for non-browser workflows", async () => {
-		const result = await compile("Backend API feature", makeProject());
-		const e2eTasks = result.tasks.filter((t) => t.type === "e2e_test");
-		assert.strictEqual(
-			e2eTasks.length,
-			0,
-			"No E2E task for non-browser projects",
-		);
-	});
-
-	it("E2E task IS inserted for Playwright projects", async () => {
-		const result = await compileTasks({
-			requirement: makeRequirement("Build user dashboard"),
-			project: makeProject({
-				frameworks: [{ name: "Playwright", confidence: 0.9 }],
-				testCapabilities: [],
-			}),
-			jobId: "JOB-E2E",
-		});
-		const e2eTasks = result.tasks.filter((t) => t.type === "e2e_test");
-		assert.ok(
-			e2eTasks.length > 0,
-			"Should have E2E task for Playwright project",
-		);
-		// E2E should depend on tests
-		const e2eDeps = e2eTasks.flatMap((t) => t.dependencies);
-		const hasTestDep = e2eDeps.some((d) => d.includes("test"));
-		assert.ok(hasTestDep, "E2E task should depend on unit test task");
-	});
-
-	it("E2E task is NOT inserted when insertE2E is false", async () => {
-		const result = await compileTasks({
-			requirement: makeRequirement("Build dashboard"),
-			project: makeProject({
-				frameworks: [{ name: "Playwright", confidence: 0.9 }],
-			}),
-			jobId: "JOB-NOE2E",
-			insertE2E: false,
-		});
-		const e2eTasks = result.tasks.filter((t) => t.type === "e2e_test");
-		assert.strictEqual(e2eTasks.length, 0, "No E2E when insertE2E=false");
-	});
-});
-
-// --- Test 7: Advisory provider hints ---------------------------------
-
-describe("Provider preference is advisory", () => {
-	it("implementation tasks have preferred provider hint", async () => {
-		const result = await compile("Build feature");
-		const implTasks = result.tasks.filter((t) => t.type === "implementation");
-		if (implTasks.length > 0) {
-			// Provider hint should be set (advisory)
-			// The Provider Router makes the final decision
-			for (const task of implTasks) {
-				assert.ok(
-					task.requiredCapabilities.length > 0,
-					`Impl task ${task.id} should have required capabilities`,
-				);
-			}
-		}
-	});
-
-	it("E2E tasks require playwright capability", async () => {
-		const result = await compileTasks({
-			requirement: makeRequirement("Build dashboard"),
-			project: makeProject({
-				frameworks: [{ name: "Playwright", confidence: 0.9 }],
-			}),
-			jobId: "JOB-E2E-CAP",
-		});
-		const e2eTasks = result.tasks.filter((t) => t.type === "e2e_test");
-		if (e2eTasks.length > 0) {
-			assert.ok(
-				e2eTasks[0]?.requiredCapabilities.includes("e2e"),
-				"E2E task should require e2e capability",
-			);
-		}
-	});
-
-	it("review tasks require review capability", async () => {
-		const result = await compile("Build feature");
-		const reviewTasks = result.tasks.filter((t) => t.type === "review");
-		if (reviewTasks.length > 0) {
-			assert.ok(
-				reviewTasks[0]?.requiredCapabilities.includes("review"),
-				"Review task should require review capability",
-			);
-		}
-	});
-});
-
-// --- Test 8: Deterministic topology ---------------------------------
-
-describe("Graph ordering is deterministic", () => {
-	it("same input produces same topological order across multiple calls", async () => {
-		const input: TaskCompileInput = {
-			requirement: makeRequirement(
-				"Implement user authentication and profile management system with OAuth2 and JWT tokens",
-			),
-			project: makeProject(),
-			jobId: "JOB-DET",
-		};
-
-		const result1 = await compileTasks(input);
-		const result2 = await compileTasks(input);
-		const result3 = await compileTasks(input);
-
-		assert.deepStrictEqual(
-			result1.topologicalOrder,
-			result2.topologicalOrder,
-			"Topological order should be deterministic (call 1 vs 2)",
-		);
-		assert.deepStrictEqual(
-			result2.topologicalOrder,
-			result3.topologicalOrder,
-			"Topological order should be deterministic (call 2 vs 3)",
-		);
-	});
-
-	it("all tasks appear exactly once in topological order", async () => {
-		const result = await compile("Build feature");
-		const seen = new Set<string>();
-		for (const id of result.topologicalOrder) {
-			assert.ok(!seen.has(id), `Task ${id} appears twice in topological order`);
-			seen.add(id);
-		}
-		assert.strictEqual(
-			seen.size,
-			result.tasks.length,
-			"Every task should appear exactly once",
-		);
-	});
-
-	it("graph is acyclic (all roots precede dependents)", async () => {
-		const result = await compile("Build feature");
-
-		// Verify: for every dependency, the dep appears before the task in order
-		for (const task of result.tasks) {
-			const depIndex = task.dependencies.map((d) =>
-				result.topologicalOrder.indexOf(d),
-			);
-			const taskIndex = result.topologicalOrder.indexOf(task.id);
-			for (const di of depIndex) {
-				assert.ok(
-					di < taskIndex,
-					`Dependency ${task.dependencies[0]} (idx=${di}) should precede ${task.id} (idx=${taskIndex})`,
-				);
-			}
-		}
-	});
-
-	it("roots have no dependencies", async () => {
-		const result = await compile("Build feature");
-		for (const rootId of result.roots) {
-			const task = result.tasks.find((t) => t.id === rootId);
-			assert.ok(task, `Root task ${rootId} should exist`);
-			assert.strictEqual(
-				task?.dependencies.length,
-				0,
-				`Root task ${rootId} should have no dependencies`,
-			);
-		}
-	});
-});
-
-// --- Additional tests: Error cases --------------------------------------
-
-describe("TaskCompilerError", () => {
-	it("TaskCompilerError has correct properties", () => {
-		const error = new TaskCompilerError(
-			TaskCompilerErrorCode.NO_VERIFICATION,
-			"Test error",
-			{ taskIds: ["task-1"] },
-		);
-		assert.strictEqual(error.name, "TaskCompilerError");
-		assert.strictEqual(error.code, TaskCompilerErrorCode.NO_VERIFICATION);
-		assert.strictEqual(error.message, "Test error");
-		assert.deepStrictEqual(error.details, { taskIds: ["task-1"] });
-	});
-});