pi-harness-runtime 0.10.43 → 1.1.1

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

@@ -0,0 +1,746 @@
+/**
+ * Context Compiler - Tests
+ *
+ * Tests cover acceptance criteria from RFC-0042:
+ * 1. Required project rules are always included.
+ * 2. .env content is denied.
+ * 3. Broken optional OKF link does not fail compilation.
+ * 4. Broken required source does fail compilation.
+ * 5. Duplicate source slices are merged.
+ * 6. Context remains under requested token budget.
+ * 7. Changed file hash invalidates cache.
+ * 8. Identical repository state produces identical compiled context.
+ * 9. Omitted items include explicit reasons.
+ */
+
+import assert from "node:assert";
+import { describe, it } from "node:test";
+
+import { estimateTokens } from "../src/budget.js";
+import {
+	extractItemHashes,
+	generateCacheKey,
+	shouldInvalidate,
+} from "../src/cache.js";
+import { compileContext } from "../src/compiler.js";
+import { deduplicateCandidates, mergeFileSlices } from "../src/deduplicate.js";
+import { applyPolicyFilter, mergePolicy } from "../src/filter.js";
+import { mergeWeights, rankCandidates } from "../src/score.js";
+import { ContextCompileError } from "../src/types.js";
+import type {
+	ContextCandidate,
+	ContextCompileRequest,
+	ContextPolicy,
+} from "../src/types.js";
+
+// --- Test fixtures -------------------------------------------------------
+
+function makeCandidate(
+	overrides?: Partial<ContextCandidate>,
+): ContextCandidate {
+	return {
+		id: "ctx-001",
+		kind: "source_file",
+		content: "function hello() { return 'world'; }",
+		source: "src/hello.ts",
+		priority: 1,
+		required: false,
+		trust: "unverified",
+		...overrides,
+	};
+}
+
+function makeRequest(
+	overrides?: Partial<ContextCompileRequest>,
+): ContextCompileRequest {
+	return {
+		jobId: "job-001",
+		taskId: "task-001",
+		taskObjective: "Add login feature",
+		maximumTokens: 50_000,
+		worktreePath: "/tmp/test-worktree",
+		candidates: [],
+		...overrides,
+	};
+}
+
+// --- AC-1: Required project rules always included ------------------------
+
+describe("AC-1: Required project rules always included", () => {
+	it("includes required project_rule even when budget is tiny", async () => {
+		const required = makeCandidate({
+			id: "rule-auth",
+			kind: "project_rule",
+			source: "src/auth/permissions.ts",
+			content: "Auth permission rules",
+			required: true,
+			priority: 3,
+		});
+
+		const result = await compileContext(
+			makeRequest({
+				taskId: "task-ac1",
+				maximumTokens: 1, // Tiny budget
+				candidates: [required],
+			}),
+		);
+
+		assert.ok(result.items.some((i) => i.id === "rule-auth"));
+	});
+
+	it("excludes non-required items when budget is exceeded", async () => {
+		const optional = makeCandidate({
+			id: "opt-001",
+			kind: "source_file",
+			source: "src/other.ts",
+			content: "x".repeat(10_000),
+			required: false,
+			priority: 1,
+		});
+
+		const result = await compileContext(
+			makeRequest({
+				taskId: "task-ac1b",
+				maximumTokens: 100, // Tiny budget
+				candidates: [optional],
+			}),
+		);
+
+		assert.ok(result.items.length === 0);
+		assert.ok(result.omitted.some((o) => o.reason === "budget"));
+	});
+});
+
+// --- AC-2: .env content denied ------------------------------------------
+
+describe("AC-2: .env content denied by policy", () => {
+	it("denies .env file content", () => {
+		const candidates = [
+			makeCandidate({
+				id: "env-001",
+				kind: "source_file",
+				source: ".env",
+				content: "SECRET=abc123",
+				required: false,
+			}),
+		];
+
+		const { denied } = applyPolicyFilter(candidates, mergePolicy(undefined));
+		assert.ok(denied.some((d) => d.candidate.id === "env-001"));
+		assert.ok(denied.some((d) => d.reason.includes(".env")));
+	});
+
+	it("denies .env.local file content", () => {
+		const candidates = [
+			makeCandidate({
+				id: "env-local",
+				kind: "source_file",
+				source: ".env.local",
+				content: "DATABASE_URL=postgres://...",
+				required: false,
+			}),
+		];
+
+		const { denied } = applyPolicyFilter(candidates, mergePolicy(undefined));
+		assert.ok(denied.some((d) => d.candidate.id === "env-local"));
+	});
+
+	it("allows non-secret files", () => {
+		const candidates = [
+			makeCandidate({
+				id: "src-main",
+				kind: "source_file",
+				source: "src/main.ts",
+				content: "console.log('hello')",
+				required: false,
+			}),
+		];
+
+		const { passed } = applyPolicyFilter(candidates, mergePolicy(undefined));
+		assert.ok(passed.some((c) => c.id === "src-main"));
+	});
+});
+
+// --- AC-3: Broken optional OKF link does not fail compilation -------------
+
+describe("AC-3: Broken optional OKF link does not fail compilation", () => {
+	it("does not throw when optional OKF has no content", async () => {
+		const broken = makeCandidate({
+			id: "okf-001",
+			kind: "okf_concept",
+			source: "okfs/missing.okf",
+			content: "", // empty = broken
+			required: false,
+			priority: 1,
+		});
+
+		const result = await compileContext(
+			makeRequest({
+				taskId: "task-ac3",
+				maximumTokens: 50_000,
+				candidates: [broken],
+			}),
+		);
+
+		// Should succeed without throwing
+		assert.ok(result.taskId === "task-ac3");
+		// Broken optional should be omitted (no content means 0 tokens, but still empty)
+		assert.ok(result.items.every((i) => i.id !== "okf-001"));
+	});
+});
+
+// --- AC-4: Broken required source fails compilation ----------------------
+
+describe("AC-4: Broken required source fails compilation", () => {
+	it("throws MISSING_REQUIRED_SOURCE when required source has no content", async () => {
+		const broken = makeCandidate({
+			id: "req-001",
+			kind: "okf_concept",
+			source: "okfs/required.okf",
+			content: "", // empty = broken
+			required: true,
+			priority: 3,
+		});
+
+		await assert.rejects(
+			() =>
+				compileContext(
+					makeRequest({
+						taskId: "task-ac4",
+						maximumTokens: 50_000,
+						candidates: [broken],
+					}),
+				),
+			(err: unknown) => {
+				if (err instanceof ContextCompileError) {
+					const details = err.details as
+						| { missingSources?: string[] }
+						| undefined;
+					return (
+						err.code === "MISSING_REQUIRED_SOURCE" &&
+						details?.missingSources?.includes("okfs/required.okf")
+					);
+				}
+				return false;
+			},
+		);
+	});
+});
+
+// --- AC-5: Duplicate source slices merged -------------------------------
+
+describe("AC-5: Duplicate source slices merged", () => {
+	it("merges slices from the same file", () => {
+		const slice1 = makeCandidate({
+			id: "slice-1",
+			kind: "source_file",
+			source: "src/main.ts",
+			content: "function a() {}",
+			filePath: "src/main.ts",
+			startLine: 1,
+			endLine: 5,
+			priority: 1,
+		});
+
+		const slice2 = makeCandidate({
+			id: "slice-2",
+			kind: "source_file",
+			source: "src/main.ts",
+			content: "function b() {}",
+			filePath: "src/main.ts",
+			startLine: 10,
+			endLine: 15,
+			priority: 2,
+		});
+
+		const result = mergeFileSlices([slice1, slice2]);
+		assert.ok(result.length === 1);
+		const merged = result[0];
+		if (!merged) return;
+		assert.ok(merged.filePath === "src/main.ts");
+		assert.ok(merged.startLine === 1);
+		assert.ok(merged.endLine === 15);
+	});
+
+	it("keeps separate files separate", () => {
+		const file1 = makeCandidate({
+			id: "file-1",
+			kind: "source_file",
+			source: "src/a.ts",
+			content: "// a",
+			filePath: "src/a.ts",
+		});
+
+		const file2 = makeCandidate({
+			id: "file-2",
+			kind: "source_file",
+			source: "src/b.ts",
+			content: "// b",
+			filePath: "src/b.ts",
+		});
+
+		const result = mergeFileSlices([file1, file2]);
+		assert.ok(result.length === 2);
+	});
+
+	it("deduplicates exact duplicate content", () => {
+		const dup1 = makeCandidate({
+			id: "dup-1",
+			content: "same content",
+			source: "src/same.ts",
+		});
+		const dup2 = makeCandidate({
+			id: "dup-2",
+			content: "same content",
+			source: "src/same.ts",
+		});
+
+		const { unique, duplicates } = deduplicateCandidates([dup1, dup2]);
+		assert.ok(unique.length === 1);
+		assert.ok(duplicates.includes("dup-2"));
+		assert.ok(!duplicates.includes("dup-1")); // first occurrence kept
+	});
+
+	it("required items are never deduplicated", () => {
+		const req1 = makeCandidate({
+			id: "req-1",
+			content: "same",
+			required: true,
+		});
+		const req2 = makeCandidate({
+			id: "req-2",
+			content: "same",
+			required: true,
+		});
+
+		const { unique, duplicates } = deduplicateCandidates([req1, req2]);
+		assert.ok(unique.length === 2);
+		assert.ok(duplicates.length === 0);
+	});
+});
+
+// --- AC-6: Context under token budget -----------------------------------
+
+describe("AC-6: Context remains under requested token budget", () => {
+	it("fits within budget when content is small enough", async () => {
+		const small = makeCandidate({
+			id: "small-001",
+			kind: "source_file",
+			content: "const x = 1;",
+			required: true,
+		});
+
+		const result = await compileContext(
+			makeRequest({
+				taskId: "task-ac6",
+				maximumTokens: 1_000_000, // generous
+				candidates: [small],
+			}),
+		);
+
+		assert.ok(result.estimatedTokens <= 1_000_000);
+		assert.ok(result.items.some((i) => i.id === "small-001"));
+	});
+
+	it("omits items that exceed remaining budget", async () => {
+		const tiny = makeCandidate({
+			id: "tiny",
+			kind: "source_file",
+			content: "a",
+			required: true,
+		});
+
+		const large = makeCandidate({
+			id: "large",
+			kind: "source_file",
+			content: "x".repeat(10_000),
+			required: false,
+			priority: 1,
+		});
+
+		const result = await compileContext(
+			makeRequest({
+				taskId: "task-ac6b",
+				maximumTokens: 5, // very small
+				candidates: [tiny, large],
+			}),
+		);
+
+		assert.ok(
+			result.omitted.some((o) => o.id === "large" && o.reason === "budget"),
+		);
+	});
+
+	it("token estimation uses 4-char-per-token", () => {
+		const content = "1234"; // 4 chars = 1 token
+		assert.ok(estimateTokens(content) === 1);
+
+		const long = "a".repeat(100);
+		assert.ok(estimateTokens(long) === 25);
+	});
+});
+
+// --- AC-7: Changed file hash invalidates cache ---------------------------
+
+describe("AC-7: Changed file hash invalidates cache", () => {
+	it("source_hash_changed invalidates when hash differs", () => {
+		const prevItems = [
+			{
+				id: "ctx-001",
+				kind: "source_file" as const,
+				content: "original content",
+				source: "src/a.ts",
+				priority: 1 as const,
+				required: false,
+				trust: "unverified" as const,
+				estimatedTokens: 1,
+				contentHash: "abc123",
+			},
+		];
+
+		const currentHashes = new Map([["src/a.ts", "xyz789"]]);
+
+		const result = shouldInvalidate(
+			{
+				taskId: "task-001",
+				items: prevItems,
+				omitted: [],
+				estimatedTokens: 1,
+				sourceGraph: [],
+				generatedAt: "",
+				mapping: {},
+			},
+			{
+				reason: "source_hash_changed",
+				details: { sourcePath: "src/a.ts" },
+				taskId: "task-001",
+			},
+			currentHashes,
+		);
+
+		assert.ok(result === true);
+	});
+
+	it("source_hash_changed does not invalidate when hash unchanged", () => {
+		const prevItems = [
+			{
+				id: "ctx-001",
+				kind: "source_file" as const,
+				content: "original content",
+				source: "src/a.ts",
+				priority: 1 as const,
+				required: false,
+				trust: "unverified" as const,
+				estimatedTokens: 1,
+				contentHash: "abc123",
+			},
+		];
+
+		const currentHashes = new Map([["src/a.ts", "abc123"]]);
+
+		const result = shouldInvalidate(
+			{
+				taskId: "task-001",
+				items: prevItems,
+				omitted: [],
+				estimatedTokens: 1,
+				sourceGraph: [],
+				generatedAt: "",
+				mapping: {},
+			},
+			{
+				reason: "source_hash_changed",
+				details: { sourcePath: "src/a.ts" },
+				taskId: "task-001",
+			},
+			currentHashes,
+		);
+
+		assert.ok(result === false);
+	});
+
+	it("task_objective_changed always invalidates", () => {
+		const result = shouldInvalidate(
+			{
+				taskId: "task-001",
+				items: [],
+				omitted: [],
+				estimatedTokens: 0,
+				sourceGraph: [],
+				generatedAt: "",
+				mapping: {},
+			},
+			{ reason: "task_objective_changed", taskId: "task-001" },
+			new Map(),
+		);
+
+		assert.ok(result === true);
+	});
+});
+
+// --- AC-8: Identical repo state → identical compiled context -------------
+
+describe("AC-8: Identical repository state produces identical compiled context", () => {
+	it("same candidates produce same cache key", () => {
+		const items = [
+			{
+				id: "ctx-001",
+				kind: "source_file" as const,
+				content: "const x = 1;",
+				source: "src/main.ts",
+				priority: 1 as const,
+				required: false,
+				trust: "unverified" as const,
+				estimatedTokens: 1,
+				contentHash: "hash123",
+			},
+		];
+
+		const key1 = generateCacheKey("task-001", items, "Add login");
+		const key2 = generateCacheKey("task-001", items, "Add login");
+
+		assert.ok(key1 === key2);
+	});
+
+	it("different objectives produce different cache keys", () => {
+		const items = [
+			{
+				id: "ctx-001",
+				kind: "source_file" as const,
+				content: "const x = 1;",
+				source: "src/main.ts",
+				priority: 1 as const,
+				required: false,
+				trust: "unverified" as const,
+				estimatedTokens: 1,
+				contentHash: "hash123",
+			},
+		];
+
+		const key1 = generateCacheKey("task-001", items, "Add login");
+		const key2 = generateCacheKey("task-001", items, "Fix logout bug");
+
+		assert.ok(key1 !== key2);
+	});
+
+	it("compileContext is deterministic", async () => {
+		const c1 = makeCandidate({
+			id: "c1",
+			kind: "source_file",
+			content: "const x = 1;",
+			source: "src/a.ts",
+		});
+		const c2 = makeCandidate({
+			id: "c2",
+			kind: "okf_concept",
+			content: "Authentication concepts",
+			source: "okfs/auth.okf",
+		});
+
+		const req = makeRequest({ taskId: "task-det", candidates: [c1, c2] });
+
+		const [result1, result2] = await Promise.all([
+			compileContext(req),
+			compileContext(req),
+		]);
+
+		assert.ok(result1.cacheKey === result2.cacheKey);
+		assert.ok(result1.estimatedTokens === result2.estimatedTokens);
+		assert.ok(result1.items.length === result2.items.length);
+	});
+});
+
+// --- AC-9: Omitted items include explicit reasons ----------------------
+
+describe("AC-9: Omitted items include explicit reasons", () => {
+	it("policy denied items have reason=policy_denied", async () => {
+		const env = makeCandidate({
+			id: "env",
+			source: ".env",
+			content: "SECRET=123",
+			required: false,
+		});
+		const normal = makeCandidate({
+			id: "src",
+			source: "src/a.ts",
+			content: "const x = 1;",
+			required: false,
+		});
+
+		const result = await compileContext(
+			makeRequest({ taskId: "task-ac9", candidates: [env, normal] }),
+		);
+
+		const envOmission = result.omitted.find((o) => o.id === "env");
+		assert.ok(envOmission);
+		assert.ok(envOmission.reason === "policy_denied");
+		assert.ok(envOmission.deniedBy !== undefined);
+	});
+
+	it("duplicate items have reason=duplicate", () => {
+		const d1 = makeCandidate({
+			id: "d1",
+			content: "same",
+			source: "src/s.ts",
+		});
+		const d2 = makeCandidate({
+			id: "d2",
+			content: "same",
+			source: "src/s.ts",
+		});
+
+		const { unique, duplicates } = deduplicateCandidates([d1, d2]);
+		assert.ok(unique.length === 1);
+		assert.ok(duplicates.length === 1);
+	});
+
+	it("budget-omitted items have reason=budget", async () => {
+		const large = makeCandidate({
+			id: "large",
+			content: "x".repeat(50_000),
+			source: "src/large.ts",
+			required: false,
+			priority: 1,
+		});
+
+		const result = await compileContext(
+			makeRequest({
+				taskId: "task-ac9b",
+				maximumTokens: 100,
+				candidates: [large],
+			}),
+		);
+
+		const omit = result.omitted.find((o) => o.id === "large");
+		assert.ok(omit);
+		assert.ok(omit.reason === "budget");
+		assert.ok(omit.estimatedTokens !== undefined);
+		assert.ok(omit.estimatedTokens > 0);
+	});
+});
+
+// --- Additional coverage -------------------------------------------------
+
+describe("mergePolicy", () => {
+	it("merges user policy with defaults", () => {
+		const userPolicy: ContextPolicy = {
+			deny: ["secrets/**"],
+			allowLargeFiles: false,
+			maxFileBytes: 1_000_000,
+		};
+
+		const merged = mergePolicy(userPolicy);
+		assert.ok(merged.deny.includes("secrets/**"));
+		assert.ok(merged.maxFileBytes === 1_000_000);
+	});
+
+	it("returns defaults when no user policy", () => {
+		const merged = mergePolicy(undefined);
+		assert.ok(merged.deny.length > 0);
+		assert.ok(merged.maxFileBytes > 0);
+	});
+});
+
+describe("mergeWeights", () => {
+	it("applies partial user weights", () => {
+		const w = mergeWeights({ priority: 10 });
+		assert.ok(w.priority === 10);
+		assert.ok(w.directFileReference > 0); // default
+	});
+
+	it("returns defaults when no user weights", () => {
+		const w = mergeWeights(undefined);
+		assert.ok(w.priority > 0);
+		assert.ok(w.directFileReference > 0);
+	});
+});
+
+describe("rankCandidates", () => {
+	it("required items always rank first", () => {
+		const opt = makeCandidate({
+			id: "opt",
+			required: false,
+			priority: 3,
+		});
+		const req = makeCandidate({
+			id: "req",
+			required: true,
+			priority: 1,
+		});
+
+		const ranked = rankCandidates([opt, req], mergeWeights(), {
+			directFileReferences: new Set(),
+			taskDependencies: [],
+		});
+
+		assert.ok(ranked[0]?.candidate.id === "req");
+		assert.ok(
+			ranked[0]?.score != null &&
+				ranked[1]?.score != null &&
+				ranked[0]?.score > ranked[1]?.score,
+		);
+	});
+
+	it("higher priority scores higher", () => {
+		const lo = makeCandidate({ id: "lo", priority: 1 });
+		const hi = makeCandidate({ id: "hi", priority: 3 });
+
+		const ranked = rankCandidates([lo, hi], mergeWeights(), {
+			directFileReferences: new Set(),
+			taskDependencies: [],
+		});
+
+		assert.ok(ranked[0]?.candidate.id === "hi");
+	});
+});
+
+describe("extractItemHashes", () => {
+	it("extracts hashes from items", () => {
+		const items = [
+			{
+				id: "ctx-1",
+				kind: "source_file" as const,
+				content: "a",
+				source: "src/a.ts",
+				priority: 1 as const,
+				required: false,
+				trust: "unverified" as const,
+				estimatedTokens: 1,
+				contentHash: "hash-a",
+			},
+			{
+				id: "ctx-2",
+				kind: "okf_concept" as const,
+				content: "b",
+				source: "okfs/b.okf",
+				priority: 1 as const,
+				required: false,
+				trust: "unverified" as const,
+				estimatedTokens: 1,
+				contentHash: undefined,
+			},
+		];
+
+		const hashes = extractItemHashes(items);
+		assert.ok(hashes.get("src/a.ts") === "hash-a");
+		assert.ok(hashes.get("okfs/b.okf") === undefined);
+	});
+});
+
+describe("ContextCompileError", () => {
+	it("has code, message, and details", () => {
+		const err = new ContextCompileError(
+			"MISSING_REQUIRED_SOURCE",
+			"Source not found",
+			{ missingSources: ["src/a.ts"] },
+		);
+
+		assert.ok(err.code === "MISSING_REQUIRED_SOURCE");
+		assert.ok(err.message === "Source not found");
+		assert.ok(
+			(err.details as { missingSources?: string[] })?.missingSources?.[0] ===
+				"src/a.ts",
+		);
+		assert.ok(err instanceof Error);
+	});
+});