pi-harness-runtime 1.1.440 → 1.1.441

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

@@ -1,743 +0,0 @@
-/**
- * Requirement Compiler - Tests
- *
- * Tests for all 10 acceptance criteria:
- * 1. Explicit requirement remains explicit.
- * 2. Preference is not promoted to mandatory constraint.
- * 3. Contradictory statements create ambiguity.
- * 4. Acceptance criteria become Given/When/Then.
- * 5. Thai terminology remains in the glossary.
- * 6. Financial requirement receives risk tag.
- * 7. Empty requirement is rejected.
- * 8. Source references remain traceable.
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import {
-	compileRequirement,
-	extractStatements,
-	classifyStatements,
-	detectAmbiguities,
-	normalizeAcceptanceCriteria,
-	RequirementCompileError,
-	RequirementCompileErrorCodes,
-	DEFAULT_COMPILER_CONFIG,
-} from "../src/index.js";
-import type { RawRequirement, ExtractedStatement } from "../src/types.js";
-
-// --- Test utilities ------------------------------------------------------
-
-function makeRaw(
-	text: string,
-	overrides?: Partial<RawRequirement>,
-): RawRequirement {
-	return {
-		id: "TEST-001",
-		title: "Test Requirement",
-		text,
-		source: "tui",
-		submittedBy: "test-user",
-		submittedAt: "2026-07-11T00:00:00.000Z",
-		...overrides,
-	};
-}
-
-async function compile(text: string, overrides?: Partial<RawRequirement>) {
-	return compileRequirement(makeRaw(text, overrides));
-}
-
-// --- Test 1: Explicit requirement remains explicit ---------------------
-
-describe("Explicit requirement remains explicit", () => {
-	it("goal statement becomes a goal", async () => {
-		const result = await compile("The system must send an email notification");
-		assert.ok(result.goals.length > 0, "Should have at least one goal");
-		assert.strictEqual(
-			result.goals[0].description.toLowerCase(),
-			"the system must send an email notification",
-		);
-	});
-
-	it("must-statement is classified as explicit behavior", () => {
-		const stmt: ExtractedStatement = {
-			id: "test",
-			kind: "explicit_behavior",
-			originalText: "The system must validate input",
-			normalizedText: "the system must validate input",
-			sourceRef: { source: "test", text: "The system must validate input" },
-		};
-		assert.strictEqual(stmt.kind, "explicit_behavior");
-	});
-});
-
-// --- Test 2: Preference is NOT promoted to mandatory -------------------
-
-describe("Preference is not promoted to mandatory", () => {
-	it("preference becomes non-blocking constraint", async () => {
-		const result = await compile("We prefer to use React for the frontend");
-		const prefConstraints = result.constraints.filter(
-			(c) => c.kind === "preferable",
-		);
-		assert.ok(
-			prefConstraints.length > 0,
-			"Should have at least one preferable constraint",
-		);
-		assert.strictEqual(prefConstraints[0].blocking, false);
-	});
-
-	it("should-statement is classified as preference", async () => {
-		const result = await compile("The button should be blue");
-		assert.ok(
-			result.constraints.some((c) => c.kind === "preferable"),
-			"Should have a preference constraint",
-		);
-	});
-});
-
-// --- Test 3: Contradictory statements create ambiguity -----------------
-
-describe("Contradictory statements create ambiguity", () => {
-	it("opposing must/must not creates contradiction ambiguity", async () => {
-		// Contradictions are blocking → compiler throws UNRESOLVABLE_CONTRADICTION
-		await assert.rejects(
-			() =>
-				compile(
-					"The system must allow anonymous access.\nThe system must not allow anonymous access.",
-				),
-			(error: unknown) => {
-				if (error instanceof RequirementCompileError) {
-					assert.strictEqual(
-						error.code,
-						RequirementCompileErrorCodes.UNRESOLVABLE_CONTRADICTION,
-					);
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-
-	it("detectContradictions returns ambiguity for inverse statements", () => {
-		const goals = [
-			{
-				id: "g1",
-				originalText: "Allow anonymous users",
-				normalizedText: "allow anonymous users",
-				sourceRef: { source: "test", text: "Allow anonymous users" },
-			},
-		] as unknown as ExtractedStatement[];
-		const constraints = [
-			{
-				id: "c1",
-				originalText: "Do not allow anonymous users",
-				normalizedText: "do not allow anonymous users",
-				sourceRef: { source: "test", text: "Do not allow anonymous users" },
-			},
-		] as unknown as ExtractedStatement[];
-
-		const ambiguities = detectAmbiguities(
-			{
-				statements: [...goals, ...constraints],
-				goals,
-				constraints,
-				preferences: [],
-				implementationSuggestions: [],
-				terminologyMentions: [],
-				actorMentions: [],
-				acceptanceCriterionStatements: [],
-				assumptions: [],
-				unknown: [],
-			},
-			DEFAULT_COMPILER_CONFIG,
-		);
-
-		const contradictions = ambiguities.filter(
-			(a) => a.category === "contradiction",
-		);
-		assert.ok(contradictions.length > 0);
-	});
-});
-
-// --- Test 4: Acceptance criteria normalize to Given/When/Then -----------
-
-describe("Acceptance criteria normalize to Given/When/Then", () => {
-	it("Given/When/Then statement parses correctly", () => {
-		const stmts: ExtractedStatement[] = [
-			{
-				id: "test",
-				kind: "acceptance_criterion",
-				originalText:
-					"Given a logged-in user, when they click Save, then the form is saved",
-				normalizedText:
-					"given a logged-in user, when they click save, then the form is saved",
-				sourceRef: {
-					source: "test",
-					text: "Given a logged-in user, when they click Save, then the form is saved",
-				},
-			},
-		];
-
-		const criteria = normalizeAcceptanceCriteria(stmts);
-		assert.strictEqual(criteria.length, 1);
-		assert.strictEqual(criteria[0].given.toLowerCase(), "a logged-in user");
-		assert.ok(criteria[0].when.toLowerCase().includes("click"));
-		assert.ok(criteria[0].outcome.length > 0);
-	});
-
-	it("Natural language statement is inferred to Given/When/Then", () => {
-		const stmts: ExtractedStatement[] = [
-			{
-				id: "test",
-				kind: "explicit_behavior",
-				originalText: "The system must save the form data",
-				normalizedText: "the system must save the form data",
-				sourceRef: {
-					source: "test",
-					text: "The system must save the form data",
-				},
-			},
-		];
-
-		const criteria = normalizeAcceptanceCriteria(stmts);
-		assert.strictEqual(criteria.length, 1);
-		assert.ok(criteria[0].given.length > 0);
-		assert.ok(criteria[0].when.length > 0);
-		assert.ok(criteria[0].outcome.length > 0);
-	});
-
-	it("automatable flag is set based on content", () => {
-		const stmts: ExtractedStatement[] = [
-			{
-				id: "test1",
-				kind: "acceptance_criterion",
-				originalText: "Then the API returns HTTP 200",
-				normalizedText: "then the api returns http 200",
-				sourceRef: { source: "test", text: "Then the API returns HTTP 200" },
-			},
-			{
-				id: "test2",
-				kind: "acceptance_criterion",
-				originalText: "Then the UI looks good",
-				normalizedText: "then the ui looks good",
-				sourceRef: { source: "test", text: "Then the UI looks good" },
-			},
-		];
-
-		const criteria = normalizeAcceptanceCriteria(stmts);
-		const apiCriterion = criteria.find((c) =>
-			c.originalText?.includes("HTTP 200"),
-		);
-		const uiCriterion = criteria.find((c) =>
-			c.originalText?.includes("looks good"),
-		);
-		assert.strictEqual(apiCriterion?.automatable, true);
-		assert.strictEqual(uiCriterion?.automatable, false);
-	});
-});
-
-// --- Test 5: Thai terminology preserved in glossary --------------------
-
-describe("Thai terminology remains in glossary", () => {
-	it("Thai term is preserved in terminology", async () => {
-		const result = await compile(
-			"ระบบต้องสร้างใบแจ้งหนี้\nThe invoice must include the tax amount",
-		);
-		assert.ok(
-			result.terminology.length > 0,
-			"Should have at least one terminology entry",
-		);
-		const thaiEntry = result.terminology.find((t) => t.language === "th");
-		assert.ok(thaiEntry, "Should have a Thai-language terminology entry");
-	});
-
-	it("Thai detection works correctly", () => {
-		const stmts: ExtractedStatement[] = [
-			{
-				id: "test",
-				kind: "terminology",
-				originalText: "ใบกำกับภาษี",
-				normalizedText: "ใบกำกับภาษี",
-				sourceRef: { source: "test", text: "ใบกำกับภาษี" },
-			},
-		];
-		const [stmt] = stmts;
-		const hasThai = /[ก-๙]/.test(stmt.originalText);
-		assert.strictEqual(hasThai, true);
-	});
-});
-
-// --- Test 6: Financial requirement receives risk tag ------------------
-
-describe("Financial requirement receives risk tag", () => {
-	it("payment keyword triggers financial risk", async () => {
-		const result = await compile(
-			"The system must process payment via credit card",
-		);
-		const financialRisks = result.riskTags.filter(
-			(r) => r.risk === "financial",
-		);
-		assert.ok(financialRisks.length > 0, "Should have financial risk tag");
-		assert.ok(result.riskTags.some((r) => r.description.includes("payment")));
-	});
-
-	it("tax-related keyword triggers financial risk", async () => {
-		const result = await compile(
-			"Calculate the ภาษีมูลค่าเพิ่ม for each transaction",
-		);
-		assert.ok(
-			result.riskTags.some((r) => r.risk === "financial"),
-			"Should detect financial risk from Thai tax term",
-		);
-	});
-
-	it("authentication keyword triggers auth risk", async () => {
-		const result = await compile("Users must login with OAuth credentials");
-		assert.ok(
-			result.riskTags.some((r) => r.risk === "authentication"),
-			"Should have authentication risk tag",
-		);
-	});
-});
-
-// --- Test 7: Empty requirement is rejected ---------------------------
-
-describe("Empty requirement is rejected", () => {
-	it("rejects empty text requirement", async () => {
-		await assert.rejects(
-			() => compile("   ", { text: "" }),
-			(error: unknown) => {
-				if (error instanceof RequirementCompileError) {
-					assert.strictEqual(
-						error.code,
-						RequirementCompileErrorCodes.EMPTY_REQUIREMENT,
-					);
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-
-	it("rejects requirement with no goals or constraints", async () => {
-		// Just whitespace or nothing useful
-		await assert.rejects(
-			() => compile("maybe perhaps possibly"),
-			(error: unknown) => {
-				if (error instanceof RequirementCompileError) {
-					assert.strictEqual(
-						error.code,
-						RequirementCompileErrorCodes.EMPTY_REQUIREMENT,
-					);
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-
-	it("accepts requirement with at least a title but no text", async () => {
-		const result = await compile("Process user data", {
-			text: "",
-			title: "Process user data",
-		});
-		assert.strictEqual(result.goals.length, 1);
-	});
-});
-
-// --- Test 8: Source references remain traceable -------------------------
-
-describe("Source references remain traceable", () => {
-	it("every goal has a source reference", async () => {
-		const result = await compile("Add a login form to the page");
-		for (const goal of result.goals) {
-			assert.ok(
-				goal.sourceRefs.length > 0,
-				`Goal "${goal.description}" should have source refs`,
-			);
-			assert.strictEqual(
-				goal.sourceRefs[0].source,
-				"tui",
-				"Source should be 'tui'",
-			);
-		}
-	});
-
-	it("every constraint has a source reference", async () => {
-		const result = await compile("Do not allow SQL injection");
-		for (const constraint of result.constraints) {
-			assert.ok(
-				constraint.sourceRefs.length > 0,
-				"Constraint should have source refs",
-			);
-		}
-	});
-
-	it("every ambiguity has evidence source references", async () => {
-		// Use a text that creates vagueness ambiguity (not contradiction) so
-		// the compiler returns normally instead of throwing
-		const result = await compile(
-			"The page should be maybe good.\nUsers can access the maybe system.",
-		);
-		for (const ambiguity of result.ambiguities) {
-			assert.ok(
-				ambiguity.evidence.length > 0,
-				`Ambiguity "${ambiguity.question}" should have evidence`,
-			);
-		}
-	});
-
-	it("acceptance criteria preserve original text", async () => {
-		const stmts: ExtractedStatement[] = [
-			{
-				id: "test",
-				kind: "acceptance_criterion",
-				originalText:
-					"Given admin, when they delete user, then confirmation appears",
-				normalizedText:
-					"given admin, when they delete user, then confirmation appears",
-				sourceRef: { source: "test", text: "Given admin..." },
-			},
-		];
-
-		const criteria = normalizeAcceptanceCriteria(stmts);
-		assert.strictEqual(
-			criteria[0].originalText,
-			"Given admin, when they delete user, then confirmation appears",
-		);
-	});
-});
-
-// --- Extractor tests -----------------------------------------------------
-
-describe("Statement extraction", () => {
-	it("extracts numbered list items", () => {
-		const raw = makeRaw("1. Add user\n2. Delete user\n3. Edit user");
-		const result = extractStatements(raw);
-		assert.ok(result.statements.length >= 3);
-	});
-
-	it("extracts bullet points", () => {
-		const raw = makeRaw("- First item\n- Second item\n- Third item");
-		const result = extractStatements(raw);
-		assert.ok(result.statements.length >= 3);
-	});
-
-	it("includes title as first statement", () => {
-		const raw = makeRaw("The system must work", {
-			title: "My Custom Title",
-		});
-		const result = extractStatements(raw);
-		assert.strictEqual(result.statements[0]?.id, "stmt-title");
-		assert.strictEqual(result.statements[0]?.originalText, "My Custom Title");
-	});
-});
-
-// --- Classifier tests ---------------------------------------------------
-
-describe("Statement classification", () => {
-	it("classifies must statements as explicit_behavior", () => {
-		const stmt: ExtractedStatement = {
-			id: "test",
-			kind: "unknown",
-			originalText: "The system must validate input",
-			normalizedText: "the system must validate input",
-			sourceRef: { source: "test", text: "The system must validate input" },
-		};
-
-		const result = classifyStatements([stmt], DEFAULT_COMPILER_CONFIG);
-		assert.strictEqual(result.goals.length, 1);
-	});
-
-	it("classifies do not statements as constraints", () => {
-		const stmt: ExtractedStatement = {
-			id: "test",
-			kind: "unknown",
-			originalText: "Do not expose API keys",
-			normalizedText: "do not expose api keys",
-			sourceRef: { source: "test", text: "Do not expose API keys" },
-		};
-
-		const result = classifyStatements([stmt], DEFAULT_COMPILER_CONFIG);
-		assert.strictEqual(result.constraints.length, 1);
-	});
-
-	it("classifies assumption statements", () => {
-		const stmt: ExtractedStatement = {
-			id: "test",
-			kind: "unknown",
-			originalText: "Assume the user is authenticated",
-			normalizedText: "assume the user is authenticated",
-			sourceRef: { source: "test", text: "Assume the user is authenticated" },
-		};
-
-		const result = classifyStatements([stmt], DEFAULT_COMPILER_CONFIG);
-		assert.strictEqual(result.assumptions.length, 1);
-	});
-
-	it("classifies Given/When/Then as acceptance criteria", () => {
-		const stmt: ExtractedStatement = {
-			id: "test",
-			kind: "unknown",
-			originalText: "Given a user, when they submit, then it saves",
-			normalizedText: "given a user, when they submit, then it saves",
-			sourceRef: {
-				source: "test",
-				text: "Given a user, when they submit, then it saves",
-			},
-		};
-
-		const result = classifyStatements([stmt], DEFAULT_COMPILER_CONFIG);
-		assert.strictEqual(result.acceptanceCriterionStatements.length, 1);
-	});
-});
-
-// --- Risk detection tests ------------------------------------------------
-
-describe("Risk detection", () => {
-	it("detects destructive operation risk", async () => {
-		const result = await compile("The system must delete all user data");
-		assert.ok(result.riskTags.some((r) => r.risk === "destructive_operation"));
-	});
-
-	it("detects privacy risk", async () => {
-		const result = await compile(
-			"Collect personal data from users for analysis",
-		);
-		assert.ok(result.riskTags.some((r) => r.risk === "privacy"));
-	});
-
-	it("detects regulatory risk", async () => {
-		const result = await compile(
-			"Ensure compliance with Thai PDPA regulations",
-		);
-		assert.ok(result.riskTags.some((r) => r.risk === "regulatory"));
-	});
-
-	it("deduplicates risk tags for same statement", async () => {
-		const result = await compile(
-			"Payment data must be encrypted and stored securely",
-		);
-		const paymentRisks = result.riskTags.filter(
-			(r) => r.affectedId === result.riskTags[0]?.affectedId,
-		);
-		// Should not have duplicate entries for same statement
-		const uniqueRisks = new Set(paymentRisks.map((r) => r.risk));
-		assert.ok(uniqueRisks.size <= 2); // financial + privacy
-	});
-});
-
-// --- Ambiguity detection tests -------------------------------------------
-
-describe("Ambiguity detection", () => {
-	it("detects vague terms", () => {
-		const stmts: ExtractedStatement[] = [
-			{
-				id: "test",
-				kind: "unknown",
-				originalText: "The system must be fast and reliable",
-				normalizedText: "the system must be fast and reliable",
-				sourceRef: {
-					source: "test",
-					text: "The system must be fast and reliable",
-				},
-			},
-		];
-
-		const ambiguities = detectAmbiguities(
-			{
-				statements: stmts,
-				goals: stmts,
-				constraints: [],
-				preferences: [],
-				implementationSuggestions: [],
-				terminologyMentions: [],
-				actorMentions: [],
-				acceptanceCriterionStatements: [],
-				assumptions: [],
-				unknown: [],
-			},
-			DEFAULT_COMPILER_CONFIG,
-		);
-
-		assert.ok(
-			ambiguities.some((a) => a.category === "vague_term"),
-			"Should detect vague term",
-		);
-	});
-
-	it("detects missing actor", () => {
-		const stmts: ExtractedStatement[] = [
-			{
-				id: "test",
-				kind: "goal",
-				originalText: "Who should approve the request?",
-				normalizedText: "who should approve the request?",
-				sourceRef: {
-					source: "test",
-					text: "Who should approve the request?",
-				},
-			},
-		];
-
-		const ambiguities = detectAmbiguities(
-			{
-				statements: stmts,
-				goals: stmts,
-				constraints: [],
-				preferences: [],
-				implementationSuggestions: [],
-				terminologyMentions: [],
-				actorMentions: [],
-				acceptanceCriterionStatements: [],
-				assumptions: [],
-				unknown: [],
-			},
-			DEFAULT_COMPILER_CONFIG,
-		);
-
-		assert.ok(
-			ambiguities.some(
-				(a) => a.category === "missing_actor" && a.blocking === true,
-			),
-			"Should detect missing actor",
-		);
-	});
-
-	it("deduplicates ambiguities by question text", () => {
-		const stmts: ExtractedStatement[] = [
-			{
-				id: "test1",
-				kind: "unknown",
-				originalText: "The system should be secure",
-				normalizedText: "the system should be secure",
-				sourceRef: { source: "test", text: "The system should be secure" },
-			},
-			{
-				id: "test2",
-				kind: "unknown",
-				originalText: "The system should be secure",
-				normalizedText: "the system should be secure",
-				sourceRef: { source: "test", text: "The system should be secure" },
-			},
-		];
-
-		const ambiguities = detectAmbiguities(
-			{
-				statements: stmts,
-				goals: [],
-				constraints: [],
-				preferences: [],
-				implementationSuggestions: [],
-				terminologyMentions: [],
-				actorMentions: [],
-				acceptanceCriterionStatements: [],
-				assumptions: [],
-				unknown: stmts,
-			},
-			DEFAULT_COMPILER_CONFIG,
-		);
-
-		// Should de-duplicate
-		const secureAmbiguities = ambiguities.filter((a) =>
-			a.question.includes("secure"),
-		);
-		assert.ok(secureAmbiguities.length <= 1, "Should deduplicate");
-	});
-});
-
-// --- Workflow tests ------------------------------------------------------
-
-describe("Workflow extraction", () => {
-	it("groups multiple goals into a workflow", async () => {
-		const result = await compile(
-			"1. Create user account\n2. Send verification email\n3. Display user dashboard",
-		);
-		assert.ok(result.workflows.length > 0, "Should have at least one workflow");
-		assert.ok(
-			result.workflows[0].steps.length >= 2,
-			"Workflow should have multiple steps",
-		);
-	});
-});
-
-// --- Actor extraction tests ---------------------------------------------
-
-describe("Actor extraction", () => {
-	it("extracts actors from statements", async () => {
-		const result = await compile(
-			"The admin can delete any user account.\nThe user can edit their own profile.",
-		);
-		assert.ok(result.actors.length > 0, "Should detect at least one actor");
-		const actorNames = result.actors.map((a) => a.name.toLowerCase());
-		assert.ok(
-			actorNames.some((n) => n.includes("admin") || n.includes("user")),
-			"Should detect admin or user actor",
-		);
-	});
-});
-
-// --- Error handling tests ----------------------------------------------
-
-describe("Error handling", () => {
-	it("RequirementCompileError has correct properties", () => {
-		const error = new RequirementCompileError(
-			RequirementCompileErrorCodes.EMPTY_REQUIREMENT,
-			"Test error message",
-			{ extra: "info" },
-		);
-		assert.strictEqual(error.code, "EMPTY_REQUIREMENT");
-		assert.strictEqual(error.message, "Test error message");
-		assert.strictEqual(error.details?.extra, "info");
-		assert.strictEqual(error.name, "RequirementCompileError");
-	});
-
-	it("unresolvable contradiction throws error", async () => {
-		await assert.rejects(
-			() =>
-				compile(
-					"The system must allow public access.\nThe system must not allow public access.",
-				),
-			(error: unknown) => {
-				if (error instanceof RequirementCompileError) {
-					assert.strictEqual(
-						error.code,
-						RequirementCompileErrorCodes.UNRESOLVABLE_CONTRADICTION,
-					);
-					return true;
-				}
-				return false;
-			},
-		);
-	});
-});
-
-// --- Multilingual tests -------------------------------------------------
-
-describe("Multilingual handling", () => {
-	it("preserves Thai business terms", async () => {
-		const result = await compile(
-			"ระบบต้องสร้างใบเสร็จรับเงิน\nThe receipt must include ยอดเงินรวม",
-		);
-		assert.ok(
-			result.terminology.length > 0,
-			"Should preserve Thai terms in glossary",
-		);
-	});
-
-	it("status is 'ready' for non-blocking ambiguities", async () => {
-		const result = await compile(
-			"The system should be fast.\nThe system should be secure.",
-		);
-		// Vague terms create non-blocking ambiguities
-		assert.ok(
-			result.status === "ready" || result.status === "needs_human",
-			"Status should be ready or needs_human",
-		);
-	});
-
-	it("status is 'needs_human' for blocking ambiguities", async () => {
-		const result = await compile("Who should access the admin panel?");
-		assert.strictEqual(result.status, "needs_human");
-	});
-});