pi-harness-runtime 1.1.439 → 1.1.441

package/packages/two-phase-review/test/helpers.ts

@@ -1,72 +0,0 @@
-/**
- * Test helpers.
- *
- * The fixtures live inside the package, never in the shared `/tmp`: a full
- * `bun test packages/` run is long enough that a temporary directory there
- * can disappear while the test is still running.
- */
-
-import { mkdtempSync, rmSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const PACKAGE_ROOT = fileURLToPath(new URL("..", import.meta.url));
-
-/** A fresh temporary directory inside the package. */
-export function makeTempDir(prefix: string): string {
-	return mkdtempSync(join(PACKAGE_ROOT, `.test-${prefix}-`));
-}
-
-/**
- * A fresh temporary directory that belongs to no Git repository.
- *
- * The home directory is used because it is neither the shared `/tmp` nor part
- * of the repository under test.
- */
-export function makePlainTempDir(prefix: string): string {
-	return mkdtempSync(join(homedir(), `.test-${prefix}-`));
-}
-
-/**
- * Run the body with a fresh temporary directory and remove it afterwards.
- *
- * The directory lives only inside the body, never in a variable that a hook
- * could clean up at the wrong moment.
- */
-export function withTempDir<T>(prefix: string, body: (dir: string) => T): T {
-	const dir = makeTempDir(prefix);
-	try {
-		return body(dir);
-	} finally {
-		rmSync(dir, { recursive: true, force: true });
-	}
-}
-
-/** Run the body with a fresh directory outside every Git repository. */
-export function withPlainTempDir<T>(prefix: string, body: (dir: string) => T): T {
-	const dir = makePlainTempDir(prefix);
-	try {
-		return body(dir);
-	} finally {
-		rmSync(dir, { recursive: true, force: true });
-	}
-}
-
-/**
- * Run an asynchronous body with a fresh temporary directory.
- *
- * The directory only disappears after the body finished: a synchronous
- * helper would remove it while the body is still running.
- */
-export async function withTempDirAsync<T>(
-	prefix: string,
-	body: (dir: string) => Promise<T>,
-): Promise<T> {
-	const dir = makeTempDir(prefix);
-	try {
-		return await body(dir);
-	} finally {
-		rmSync(dir, { recursive: true, force: true });
-	}
-}

package/packages/two-phase-review/test/rules.test.ts

@@ -1,150 +0,0 @@
-/**
- * The workflow rules.
- *
- * The injected instruction names the phase, the open work and the next step.
- * It must never suggest to start the review while the implementation runs.
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	TWO_PHASE_CONTRACT,
-	buildChunkTodoSubject,
-	buildPhaseInstruction,
-	buildPhaseView,
-	buildReviewTodoDescription,
-	buildReviewTodoSubject,
-	isChunkTodo,
-	syncChunkStatus,
-} from "../src/rules.js";
-import { createState, recordSignal, startReview, transitionToReviewPending } from "../src/state.js";
-import { REVIEW_PREFIX } from "../src/classify.js";
-import type { ReviewChunk, ReviewSignal } from "../src/types.js";
-
-const signal: ReviewSignal = {
-	source: "code-reviewer",
-	files: ["packages/notification/index.ts"],
-	reason: "a comprehensive review was requested with code-reviewer",
-	at: "2026-10-25T00:00:00.000Z",
-};
-
-describe("TWO_PHASE_CONTRACT", () => {
-	it("names the two phases", () => {
-		expect(TWO_PHASE_CONTRACT).toContain("Phase 1");
-		expect(TWO_PHASE_CONTRACT).toContain("Phase 2");
-	});
-
-	it("keeps the correctness checks in the implementation", () => {
-		expect(TWO_PHASE_CONTRACT).toContain("type errors");
-	});
-
-	it("names the todo prefixes", () => {
-		expect(TWO_PHASE_CONTRACT).toContain("[IMPLEMENT]");
-		expect(TWO_PHASE_CONTRACT).toContain(REVIEW_PREFIX);
-		expect(TWO_PHASE_CONTRACT).toContain("[REVIEW-FIX]");
-	});
-});
-
-describe("buildPhaseInstruction", () => {
-	it("asks for the implementation while it runs", () => {
-		const state = createState("t");
-		const view = buildPhaseView(state, [
-			{ id: 1, subject: "Add the storage", status: "pending" },
-		]);
-		const instruction = buildPhaseInstruction(state, view);
-		expect(instruction).toContain("Phase 1");
-		expect(instruction).toContain("1 implementation todo(s) open");
-		expect(instruction).toContain("Do not start a comprehensive review");
-	});
-
-	it("does not start the review while a signal is queued", () => {
-		const state = recordSignal(createState("t"), signal);
-		const view = buildPhaseView(state, [
-			{ id: 1, subject: "Add the storage", status: "pending" },
-		]);
-		const instruction = buildPhaseInstruction(state, view);
-		expect(instruction).toContain("must not start yet");
-		expect(instruction).toContain("code-reviewer");
-	});
-
-	it("asks for the review when the implementation is done", () => {
-		const pending = transitionToReviewPending(createState("t"), ["a.ts", "b.ts"]);
-		const state = startReview(pending, [
-			{ id: "chunk-1", label: "packages/x (2 files)", files: ["a.ts", "b.ts"], status: "pending" },
-		]);
-		const view = buildPhaseView(state, []);
-		const instruction = buildPhaseInstruction(state, view);
-		expect(instruction).toContain("Phase 2");
-		expect(instruction).toContain("chunk-1");
-		expect(instruction).toContain("never the whole repository");
-	});
-
-	it("asks for the fixes when the review found something", () => {
-		const state = { ...createState("t"), phase: "review_fixes" as const };
-		const view = buildPhaseView(state, [
-			{ id: 1, subject: "[REVIEW-FIX] Fix the race", status: "pending" },
-		]);
-		const instruction = buildPhaseInstruction(state, view);
-		expect(instruction).toContain("review-fix todo(s) open");
-	});
-});
-
-describe("the queued review todo", () => {
-	it("is one item with the source and the scope", () => {
-		const state = transitionToReviewPending(recordSignal(createState("t"), signal), [
-			"packages/notification/index.ts",
-		]);
-		const subject = buildReviewTodoSubject(state);
-		const description = buildReviewTodoDescription(state);
-		expect(subject.startsWith(REVIEW_PREFIX)).toBe(true);
-		expect(subject).toContain("code-reviewer");
-		expect(description).toContain("Source: code-reviewer");
-		expect(description).toContain("packages/notification/index.ts");
-	});
-});
-
-describe("the review chunks", () => {
-	const chunk: ReviewChunk = {
-		id: "chunk-1",
-		label: "packages/notification (2 files)",
-		files: ["packages/notification/index.ts"],
-		status: "pending",
-	};
-
-	it("names the chunk in the subject of its todo", () => {
-		const subject = buildChunkTodoSubject(chunk);
-		expect(subject.startsWith(REVIEW_PREFIX)).toBe(true);
-		expect(subject).toContain("chunk-1");
-		expect(subject).toContain("packages/notification");
-	});
-
-	it("belongs to the todo that names it", () => {
-		expect(isChunkTodo({ subject: subject(chunk), status: "pending" }, chunk)).toBe(true);
-		// "chunk-1" must not match "chunk-10".
-		expect(isChunkTodo({ subject: "[REVIEW] chunk-10: other", status: "pending" }, chunk)).toBe(
-			false,
-		);
-		// An implementation todo never belongs to a chunk.
-		expect(
-			isChunkTodo({ subject: "[IMPLEMENT] chunk-1: other", status: "pending" }, chunk),
-		).toBe(false);
-	});
-
-	it("is done when its todo is completed", () => {
-		const state = startReview(createState("t"), [chunk]);
-		const synced = syncChunkStatus(state, [
-			{ subject: buildChunkTodoSubject(chunk), status: "completed" },
-		]);
-		expect(synced.chunks[0].status).toBe("done");
-	});
-
-	it("keeps the progress when the todo list is empty", () => {
-		const state = startReview(createState("t"), [{ ...chunk, status: "done" }]);
-		const synced = syncChunkStatus(state, []);
-		expect(synced.chunks[0].status).toBe("done");
-	});
-});
-
-/** The subject of the todo of a chunk. */
-function subject(chunk: ReviewChunk): string {
-	return buildChunkTodoSubject(chunk);
-}

package/packages/two-phase-review/test/runtime.test.ts

@@ -1,362 +0,0 @@
-/**
- * The runtime of the two-phase workflow.
- *
- * The runtime is tested with a fake extension API: the handlers are called
- * the way the session calls them, so the behavior (blocking, persistence,
- * the phase transition, the steer and the prompt) is verified and not only
- * the presence of a few source lines.
- */
-
-import { describe, it, expect } from "bun:test";
-import { execFileSync } from "node:child_process";
-import { mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { initTwoPhaseReview } from "../src/runtime.js";
-import type {
-	TodoReadResult,
-	TwoPhaseExtensionApi,
-	TwoPhaseRuntime,
-} from "../src/runtime.js";
-import { TwoPhaseStateStore } from "../src/state.js";
-import { withTempDirAsync } from "./helpers.js";
-
-type Handler = (...args: any[]) => unknown;
-
-/** A fake extension API that records what the runtime does. */
-class FakePi implements TwoPhaseExtensionApi {
-	handlers = new Map<string, Handler[]>();
-	entries: { type: string; data: unknown }[] = [];
-	messages: { content: string; options?: { deliverAs?: string } }[] = [];
-	status: { key: string; value: string }[] = [];
-
-	on(event: string, handler: Handler): void {
-		const list = this.handlers.get(event) ?? [];
-		list.push(handler);
-		this.handlers.set(event, list);
-	}
-
-	appendEntry(type: string, data: unknown): void {
-		this.entries.push({ type, data });
-	}
-
-	async sendUserMessage(
-		content: string,
-		options?: { deliverAs?: "steer" | "followUp" },
-	): Promise<void> {
-		this.messages.push({ content, options });
-	}
-
-	/** Call every handler of the event. */
-	async emit(event: string, ...args: unknown[]): Promise<unknown[]> {
-		const list = this.handlers.get(event) ?? [];
-		const results: unknown[] = [];
-		for (const handler of list) results.push(await handler(...args));
-		return results;
-	}
-}
-
-/** A fake session context. */
-function context(sessionId = "session-1") {
-	return {
-		sessionManager: { getSessionId: () => sessionId },
-		ui: {
-			setStatus: (key: string, value: string) => {
-				// The status line is a convenience; it is recorded, not asserted.
-			},
-		},
-	};
-}
-
-/** A Git repository with one committed file. */
-function makeRepo(root: string): void {
-	const git = (...args: string[]): void => {
-		execFileSync(
-			"git",
-			[
-				"-c",
-				"user.email=test@example.com",
-				"-c",
-				"user.name=Test",
-				"-c",
-				"commit.gpgsign=false",
-				"-c",
-				"core.hooksPath=/dev/null",
-				...args,
-			],
-			{ cwd: root, stdio: "ignore" },
-		);
-	};
-	git("init", "-q");
-	mkdirSync(join(root, "packages", "app"), { recursive: true });
-	writeFileSync(join(root, "packages", "app", "index.ts"), "export const a = 1;\n");
-	git("add", "-A");
-	git("commit", "-qm", "base");
-}
-
-/** The todo list the runtime reads. */
-function reader(items: TodoReadResult["todos"], available = true): (ctx: unknown) => Promise<TodoReadResult> {
-	return async () => ({
-		available,
-		todos: available ? items : [],
-		reason: available ? undefined : "the todo provider is not available",
-	});
-}
-
-describe("the two-phase runtime", () => {
-	it("blocks a comprehensive review while the implementation runs", async () => {
-		await withTempDirAsync("runtime", async (dir) => {
-			const pi = new FakePi();
-			const runtime = await initTwoPhaseReview({
-				pi,
-				readTodos: reader([
-					{ id: 1, subject: "[IMPLEMENT] Add the storage", status: "pending" },
-				]),
-				workspaceRoot: () => dir,
-				store: new TwoPhaseStateStore(dir),
-			});
-			await pi.emit("session_start", {}, context());
-
-			const result = (await pi.emit(
-				"tool_call",
-				{ toolName: "code-reviewer", input: { files: ["index.ts"] } },
-				context(),
-			))[0] as { block?: boolean; reason?: string };
-
-			expect(result.block).toBe(true);
-			expect(result.reason).toMatch(/Phase 1 \(implementation\) is still running/);
-			// The signal is queued, not lost.
-			expect(runtime.getState().signals.length).toBe(1);
-			expect(runtime.getState().phase).toBe("implementation");
-			// The queued review is part of the session.
-			expect(pi.entries.length).toBe(1);
-			expect(pi.entries[0].type).toBe("harness-two-phase-review");
-		});
-	});
-
-	it("does not block a task level check", async () => {
-		await withTempDirAsync("runtime", async (dir) => {
-			const pi = new FakePi();
-			await initTwoPhaseReview({
-				pi,
-				readTodos: reader([{ id: 1, subject: "[IMPLEMENT] Work", status: "pending" }]),
-				workspaceRoot: () => dir,
-				store: new TwoPhaseStateStore(dir),
-			});
-			await pi.emit("session_start", {}, context());
-
-			const result = (await pi.emit(
-				"tool_call",
-				{ toolName: "lens_diagnostics", input: { paths: ["index.ts"] } },
-				context(),
-			))[0] as { block?: boolean };
-
-			expect(result).toEqual({});
-		});
-	});
-
-	it("lets an explicit request of the human run the review", async () => {
-		await withTempDirAsync("runtime", async (dir) => {
-			const pi = new FakePi();
-			await initTwoPhaseReview({
-				pi,
-				readTodos: reader([{ id: 1, subject: "[IMPLEMENT] Work", status: "pending" }]),
-				workspaceRoot: () => dir,
-				store: new TwoPhaseStateStore(dir),
-			});
-			await pi.emit("session_start", {}, context());
-			await pi.emit("message_end", {
-				message: { role: "user", content: "please review the diff now" },
-			});
-
-			const result = (await pi.emit(
-				"tool_call",
-				{ toolName: "code-reviewer", input: { files: ["index.ts"] } },
-				context(),
-			))[0] as { block?: boolean };
-
-			expect(result).toEqual({});
-		});
-	});
-
-	it("ignores a request that the harness sent itself", async () => {
-		await withTempDirAsync("runtime", async (dir) => {
-			const pi = new FakePi();
-			await initTwoPhaseReview({
-				pi,
-				readTodos: reader([{ id: 1, subject: "[IMPLEMENT] Work", status: "pending" }]),
-				workspaceRoot: () => dir,
-				store: new TwoPhaseStateStore(dir),
-			});
-			await pi.emit("session_start", {}, context());
-			await pi.emit("message_end", {
-				message: { role: "user", content: "[harness:two-phase] please review the diff" },
-			});
-
-			const result = (await pi.emit(
-				"tool_call",
-				{ toolName: "code-reviewer", input: { files: ["index.ts"] } },
-				context(),
-			))[0] as { block?: boolean };
-
-			expect(result.block).toBe(true);
-		});
-	});
-
-	it("blocks the review when the todo list cannot be read", async () => {
-		await withTempDirAsync("runtime", async (dir) => {
-			const pi = new FakePi();
-			const runtime = await initTwoPhaseReview({
-				pi,
-				readTodos: reader([], false),
-				workspaceRoot: () => dir,
-				store: new TwoPhaseStateStore(dir),
-			});
-			await pi.emit("session_start", {}, context());
-
-			const result = (await pi.emit(
-				"tool_call",
-				{ toolName: "code-reviewer", input: { files: ["index.ts"] } },
-				context(),
-			))[0] as { block?: boolean; reason?: string };
-
-			expect(result.block).toBe(true);
-			expect(result.reason).toMatch(/todo list of the session is not readable/);
-			// The phase did not move either.
-			expect(runtime.getState().phase).toBe("implementation");
-		});
-	});
-
-	it("starts the review when the implementation is done", async () => {
-		await withTempDirAsync("runtime", async (dir) => {
-			makeRepo(dir);
-			writeFileSync(join(dir, "packages", "app", "index.ts"), "export const a = 2;\n");
-
-			const pi = new FakePi();
-			const runtime = await initTwoPhaseReview({
-				pi,
-				readTodos: reader([
-					{ id: 1, subject: "[IMPLEMENT] Work", status: "completed" },
-					{ id: 2, subject: "[REVIEW] Review the task diff", status: "pending" },
-				]),
-				workspaceRoot: () => dir,
-				store: new TwoPhaseStateStore(dir),
-			});
-			await pi.emit("session_start", {}, context());
-			await pi.emit("turn_end", {}, context());
-
-			expect(runtime.getState().phase).toBe("review");
-			expect(runtime.getState().scopeFiles.length).toBeGreaterThan(0);
-			// The review is started with a steer, not with a tool call.
-			expect(pi.messages.length).toBe(1);
-			expect(pi.messages[0].options?.deliverAs).toBe("steer");
-			expect(pi.messages[0].content).toMatch(/Phase 2 \(review\) starts now/);
-		});
-	});
-
-	it("does not start the review while the implementation is open", async () => {
-		await withTempDirAsync("runtime", async (dir) => {
-			const pi = new FakePi();
-			const runtime = await initTwoPhaseReview({
-				pi,
-				readTodos: reader([
-					{ id: 1, subject: "[IMPLEMENT] Work", status: "pending" },
-					{ id: 2, subject: "[REVIEW] Review the task diff", status: "pending" },
-				]),
-				workspaceRoot: () => dir,
-				store: new TwoPhaseStateStore(dir),
-			});
-			await pi.emit("session_start", {}, context());
-			await pi.emit("turn_end", {}, context());
-
-			expect(runtime.getState().phase).toBe("implementation");
-			expect(pi.messages.length).toBe(0);
-		});
-	});
-
-	it("puts the rules and the phase into the system prompt", async () => {
-		await withTempDirAsync("runtime", async (dir) => {
-			const pi = new FakePi();
-			await initTwoPhaseReview({
-				pi,
-				readTodos: reader([{ id: 1, subject: "[IMPLEMENT] Work", status: "pending" }]),
-				workspaceRoot: () => dir,
-				store: new TwoPhaseStateStore(dir),
-			});
-			await pi.emit("session_start", {}, context());
-
-			const result = (await pi.emit(
-				"before_agent_start",
-				{ systemPrompt: "BASE PROMPT" },
-				context(),
-			))[0] as { systemPrompt?: string } | undefined;
-
-			expect(result?.systemPrompt).toMatch(/^BASE PROMPT/);
-			expect(result?.systemPrompt).toMatch(/Two-phase implementation and review/);
-			expect(result?.systemPrompt).toMatch(/Phase 1 \(implementation\)/);
-		});
-	});
-
-	it("keeps the state when it cannot be written", async () => {
-		await withTempDirAsync("runtime", async (dir) => {
-			const pi = new FakePi();
-			const store = new TwoPhaseStateStore(dir);
-			const runtime = await initTwoPhaseReview({
-				pi,
-				readTodos: reader([{ id: 1, subject: "[IMPLEMENT] Work", status: "pending" }]),
-				workspaceRoot: () => dir,
-				store: {
-					path: store.path.bind(store),
-					read: store.read.bind(store),
-					clear: store.clear.bind(store),
-					write: () => {
-						throw new Error("the disk is full");
-					},
-				} as unknown as TwoPhaseStateStore,
-			});
-			await pi.emit("session_start", {}, context());
-
-			const result = (await pi.emit(
-				"tool_call",
-				{ toolName: "code-reviewer", input: { files: ["index.ts"] } },
-				context(),
-			))[0] as { block?: boolean };
-
-			// The review is still deferred, but nothing was queued.
-			expect(result.block).toBe(true);
-			expect(runtime.getState().signals.length).toBe(0);
-			expect(pi.entries.length).toBe(0);
-		});
-	});
-
-	it("keeps the state of the session across a restart", async () => {
-		await withTempDirAsync("runtime", async (dir) => {
-			const store = new TwoPhaseStateStore(dir);
-			const first = new FakePi();
-			const runtime: TwoPhaseRuntime = await initTwoPhaseReview({
-				pi: first,
-				readTodos: reader([{ id: 1, subject: "[IMPLEMENT] Work", status: "pending" }]),
-				workspaceRoot: () => dir,
-				store,
-			});
-			await first.emit("session_start", {}, context("session-7"));
-			await first.emit(
-				"tool_call",
-				{ toolName: "code-reviewer", input: { files: ["index.ts"] } },
-				context("session-7"),
-			);
-			expect(runtime.getState().signals.length).toBe(1);
-
-			const second = new FakePi();
-			const restarted = await initTwoPhaseReview({
-				pi: second,
-				readTodos: reader([{ id: 1, subject: "[IMPLEMENT] Work", status: "pending" }]),
-				workspaceRoot: () => dir,
-				store,
-			});
-			await second.emit("session_start", {}, context("session-7"));
-
-			expect(restarted.getState().signals.length).toBe(1);
-			expect(restarted.getState().startRevision).toBe(runtime.getState().startRevision);
-		});
-	});
-});