pi-harness-runtime 1.1.440 → 1.1.441

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

@@ -1,186 +0,0 @@
-/**
- * The review scope.
- *
- * The scope is the diff of the task, never the whole repository. A workspace
- * without Git has no honest scope, so nothing is reviewed.
- */
-
-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 {
-	chunkScope,
-	collectScope,
-	countModules,
-	currentRevision,
-	isGitRepository,
-	isReviewablePath,
-	moduleKey,
-	parseNumstat,
-	shouldChunkScope,
-} from "../src/scope.js";
-import { withPlainTempDir, withTempDir } from "./helpers.js";
-
-function git(root: string, ...args: string[]): void {
-	// The ambient Git configuration must not decide whether the fixture works:
-	// a global identity, a signing key or a hook would break the commit.
-	try {
-		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: "pipe" },
-		);
-	} catch (error) {
-		const detail = error as { stderr?: Buffer; status?: number; signal?: string; message?: string };
-		const stderr = detail.stderr?.toString() ?? "";
-		throw new Error(
-			`git ${args.join(" ")} failed in ${root}: status=${detail.status} signal=${detail.signal} message=${detail.message} stderr=${stderr}`,
-		);
-	}
-}
-
-/** A fresh Git repository with one commit. */
-function withRepository(body: (root: string) => void): void {
-	withTempDir("scope", (root) => {
-		git(root, "init", "-q");
-		body(root);
-	});
-}
-
-describe("isReviewablePath", () => {
-	it("keeps the source files", () => {
-		expect(isReviewablePath("packages/notification/src/index.ts")).toBe(true);
-		expect(isReviewablePath("index.ts")).toBe(true);
-	});
-
-	it("drops the build output", () => {
-		expect(isReviewablePath("dist/index.js")).toBe(false);
-		expect(isReviewablePath("node_modules/x/index.js")).toBe(false);
-		expect(isReviewablePath("coverage/lcov.info")).toBe(false);
-	});
-
-	it("drops the build output of a nested module", () => {
-		expect(isReviewablePath("packages/foo/dist/index.js")).toBe(false);
-		expect(isReviewablePath("apps/x/coverage/lcov.info")).toBe(false);
-		expect(isReviewablePath("services/x/vendor/lib.js")).toBe(false);
-		expect(isReviewablePath("packages/foo/node_modules/x/index.js")).toBe(false);
-	});
-});
-
-describe("moduleKey", () => {
-	it("names the module of a file", () => {
-		expect(moduleKey("packages/notification/src/index.ts")).toBe("packages/notification");
-		expect(moduleKey("harness/wiki-integration.ts")).toBe("harness");
-		expect(moduleKey("index.ts")).toBe("root");
-	});
-});
-
-describe("collectScope", () => {
-	it("reads the diff since the start revision", () => {
-		withRepository((root) => {
-			mkdirSync(join(root, "packages", "notification"), { recursive: true });
-			writeFileSync(join(root, "packages", "notification", "index.ts"), "export const a = 1;\n");
-			git(root, "add", "-A");
-			git(root, "commit", "-qm", "base");
-			const start = currentRevision(root);
-			expect(start).toBeTruthy();
-
-			writeFileSync(join(root, "packages", "notification", "index.ts"), "export const a = 2;\n");
-			writeFileSync(join(root, "packages", "notification", "new.ts"), "export const b = 1;\n");
-
-			const scope = collectScope(root, start);
-			expect(scope.detected).toBe(true);
-			expect(scope.files).toContain("packages/notification/index.ts");
-			expect(scope.files).toContain("packages/notification/new.ts");
-			expect(scope.metrics.files).toBe(2);
-			expect(scope.metrics.modules).toBe(1);
-		});
-	});
-
-	it("ignores the build output", () => {
-		withRepository((root) => {
-			mkdirSync(join(root, "dist"), { recursive: true });
-			writeFileSync(join(root, "dist", "index.js"), "built\n");
-			git(root, "add", "-A");
-			git(root, "commit", "-qm", "base");
-			const start = currentRevision(root);
-			writeFileSync(join(root, "dist", "index.js"), "built again\n");
-
-			const scope = collectScope(root, start);
-			expect(scope.files).not.toContain("dist/index.js");
-		});
-	});
-
-	it("reports no scope without Git", () => {
-		withPlainTempDir("plain", (plain) => {
-			expect(isGitRepository(plain)).toBe(false);
-			const scope = collectScope(plain, null);
-			expect(scope.detected).toBe(false);
-			expect(scope.files).toEqual([]);
-		});
-	});
-
-	it("reports no scope when the start revision is gone", () => {
-		withRepository((root) => {
-			// A missing baseline would silently reduce the scope to the last
-			// commit, so the scope is empty instead of incomplete.
-			const scope = collectScope(root, "0000000000000000000000000000000000000000");
-			expect(scope.detected).toBe(false);
-			expect(scope.files).toEqual([]);
-			expect(scope.reason).toMatch(/does not exist/);
-		});
-	});
-});
-
-describe("parseNumstat", () => {
-	it("adds the changed lines", () => {
-		expect(parseNumstat("3\t1\tindex.ts\n0\t0\tother.ts\n")).toBe(4);
-	});
-});
-
-describe("chunkScope", () => {
-	it("splits the scope by module", () => {
-		const chunks = chunkScope([
-			"packages/notification/src/a.ts",
-			"packages/notification/src/b.ts",
-			"packages/jev-judge/src/c.ts",
-		]);
-		expect(chunks).toHaveLength(2);
-		expect(chunks[0]?.id).toBe("chunk-1");
-		expect(chunks.map((chunk) => chunk.files.length)).toEqual([2, 1]);
-	});
-
-	it("splits a big module into several chunks", () => {
-		const files = Array.from({ length: 7 }, (_, index) => `packages/x/src/file-${index}.ts`);
-		const chunks = chunkScope(files, { maxFilesPerChunk: 3 });
-		expect(chunks).toHaveLength(3);
-		expect(chunks[2]?.files).toHaveLength(1);
-	});
-
-	it("returns nothing for an empty scope", () => {
-		expect(chunkScope([])).toEqual([]);
-	});
-});
-
-describe("countModules and shouldChunkScope", () => {
-	it("counts the modules", () => {
-		expect(countModules(["packages/a/x.ts", "packages/b/y.ts", "packages/a/z.ts"])).toBe(2);
-	});
-
-	it("measures the scope instead of assuming it", () => {
-		expect(shouldChunkScope({ files: 3, modules: 1, changedLines: 100 })).toBe(false);
-		expect(shouldChunkScope({ files: 20, modules: 1, changedLines: 100 })).toBe(true);
-		expect(shouldChunkScope({ files: 3, modules: 5, changedLines: 100 })).toBe(true);
-	});
-});

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

@@ -1,183 +0,0 @@
-/**
- * Review signals.
- *
- * A signal is only raised for a comprehensive review. An ordinary task-level
- * check (a type error of the file that is edited right now) stays actionable
- * and must not be deferred.
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	detectReviewInvocation,
-	dispatchAgentName,
-	explicitReviewRequest,
-	extractFiles,
-	isComprehensiveReviewTool,
-	isReviewCommand,
-	mergeSignals,
-	summarizeSignals,
-} from "../src/signals.js";
-import type { ReviewSignal } from "../src/types.js";
-
-describe("isComprehensiveReviewTool", () => {
-	it("knows the review tools", () => {
-		expect(isComprehensiveReviewTool("code-reviewer")).toBe(true);
-		expect(isComprehensiveReviewTool("code_reviewer")).toBe(true);
-		expect(isComprehensiveReviewTool("differential-review")).toBe(true);
-		expect(isComprehensiveReviewTool("semgrep")).toBe(true);
-		expect(isComprehensiveReviewTool("codeql")).toBe(true);
-	});
-
-	it("matches a namespaced tool by its bare name", () => {
-		expect(isComprehensiveReviewTool("mcp__pi__code-review")).toBe(true);
-	});
-
-	it("does not match a tool that only mentions a review", () => {
-		expect(isComprehensiveReviewTool("read_audit_log")).toBe(false);
-		expect(isComprehensiveReviewTool("review_status")).toBe(false);
-		expect(isComprehensiveReviewTool("semgrep_scan")).toBe(false);
-	});
-
-	it("leaves the task-level checks alone", () => {
-		expect(isComprehensiveReviewTool("lens_diagnostics")).toBe(false);
-		expect(isComprehensiveReviewTool("bash")).toBe(false);
-		expect(isComprehensiveReviewTool("edit")).toBe(false);
-		expect(isComprehensiveReviewTool("todo")).toBe(false);
-		expect(isComprehensiveReviewTool("read")).toBe(false);
-	});
-
-	it("accepts extra patterns from the deployment", () => {
-		expect(isComprehensiveReviewTool("house_review", ["house_review"])).toBe(true);
-	});
-});
-
-describe("isReviewCommand", () => {
-	it("knows a review runner", () => {
-		expect(isReviewCommand("bun run code-review")).toBe(true);
-		expect(isReviewCommand("semgrep scan --config auto")).toBe(true);
-		expect(isReviewCommand("npx differential-review")).toBe(true);
-		expect(isReviewCommand("bun test && code-review")).toBe(true);
-	});
-
-	it("ignores an ordinary command", () => {
-		expect(isReviewCommand("bun test")).toBe(false);
-		expect(isReviewCommand("npx biome check index.ts")).toBe(false);
-	});
-
-	it("ignores a runner that is only mentioned", () => {
-		expect(isReviewCommand("echo code-review")).toBe(false);
-		expect(isReviewCommand("grep security-review README.md")).toBe(false);
-		expect(isReviewCommand("# semgrep scan")).toBe(false);
-		expect(isReviewCommand("cat notes.md | grep semgrep")).toBe(false);
-	});
-});
-
-describe("dispatchAgentName", () => {
-	it("reads the agent of a dispatch tool", () => {
-		expect(dispatchAgentName("subagent", { agent: "code-reviewer" })).toBe("code-reviewer");
-		expect(dispatchAgentName("subagent", { agent: "researcher" })).toBe("researcher");
-		expect(dispatchAgentName("bash", { command: "ls" })).toBe("");
-	});
-});
-
-describe("detectReviewInvocation", () => {
-	it("recognizes a review tool", () => {
-		const invocation = detectReviewInvocation("code-reviewer", { files: ["index.ts"] });
-		expect(invocation?.source).toBe("code-reviewer");
-		expect(invocation?.files).toEqual(["index.ts"]);
-	});
-
-	it("recognizes a reviewer that was dispatched as an agent", () => {
-		const invocation = detectReviewInvocation("subagent", { agent: "code-reviewer" });
-		expect(invocation?.source).toBe("code-reviewer");
-	});
-
-	it("recognizes a review runner in the shell", () => {
-		const invocation = detectReviewInvocation("bash", {
-			command: "bun run code-review --scope packages/notification",
-		});
-		expect(invocation?.source).toBe("bash");
-		expect(invocation?.reason).toContain("code-review");
-	});
-
-	it("does not raise a signal for a task-level check", () => {
-		expect(detectReviewInvocation("lens_diagnostics", { paths: ["index.ts"] })).toBeNull();
-		expect(detectReviewInvocation("bash", { command: "npx tsc --noEmit" })).toBeNull();
-		expect(detectReviewInvocation("edit", { path: "index.ts" })).toBeNull();
-	});
-});
-
-describe("extractFiles", () => {
-	it("reads the files of a tool input", () => {
-		expect(extractFiles("code-reviewer", { files: ["a.ts", "b.ts"] })).toEqual(["a.ts", "b.ts"]);
-	});
-
-	it("reads the files of a shell command", () => {
-		const files = extractFiles("bash", { command: "eslint packages/notification/index.ts" });
-		expect(files).toContain("packages/notification/index.ts");
-	});
-});
-
-describe("explicitReviewRequest", () => {
-	it("sees an explicit request of the user", () => {
-		expect(explicitReviewRequest("please review the whole diff now")).toBe(true);
-		expect(explicitReviewRequest("run an audit of the repository")).toBe(true);
-		expect(explicitReviewRequest("review the task diff")).toBe(true);
-	});
-
-	it("sees no request in an ordinary message", () => {
-		expect(explicitReviewRequest("fix the failing test")).toBe(false);
-		expect(explicitReviewRequest("")).toBe(false);
-		expect(explicitReviewRequest("the review notes mention a stale cache")).toBe(false);
-	});
-
-	it("respects a negation", () => {
-		expect(explicitReviewRequest("do not review yet, continue the implementation")).toBe(false);
-		expect(explicitReviewRequest("no review for now")).toBe(false);
-		expect(explicitReviewRequest("skip the audit")).toBe(false);
-	});
-
-	it("reads every sentence on its own", () => {
-		expect(explicitReviewRequest("Do not review yet. Please review the diff afterwards.")).toBe(
-			true,
-		);
-	});
-});
-
-describe("mergeSignals", () => {
-	const signal: ReviewSignal = {
-		source: "code-reviewer",
-		files: ["index.ts"],
-		reason: "a comprehensive review was requested",
-		at: "2026-10-25T00:00:00.000Z",
-	};
-
-	it("records a signal once", () => {
-		const once = mergeSignals([], signal);
-		const twice = mergeSignals(once, signal);
-		expect(twice).toHaveLength(1);
-	});
-
-	it("keeps a different signal", () => {
-		const merged = mergeSignals(mergeSignals([], signal), {
-			...signal,
-			source: "semgrep",
-		});
-		expect(merged).toHaveLength(2);
-	});
-
-	it("summarizes the signals into one scope", () => {
-		const merged = mergeSignals(mergeSignals([], signal), {
-			source: "semgrep",
-			files: ["other.ts"],
-			reason: "a second source",
-			at: "2026-10-25T00:01:00.000Z",
-		});
-		const summary = summarizeSignals(merged);
-		expect(summary.sources).toEqual(["code-reviewer", "semgrep"]);
-		expect(summary.files).toEqual(["index.ts", "other.ts"]);
-		expect(summary.reason).toContain("a second source");
-	});
-});
-
-// touched

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

@@ -1,201 +0,0 @@
-/**
- * The persisted state.
- *
- * The phase, the start revision, the scope, the finished chunks and the open
- * findings survive a restart, so the workflow can be resumed after a
- * compaction or a reset.
- */
-
-import { describe, it, expect } from "bun:test";
-import { readdirSync, writeFileSync } from "node:fs";
-import {
-	TwoPhaseStateStore,
-	allChunksDone,
-	createState,
-	hasQueuedReview,
-	markChunkDone,
-	markComplete,
-	moveToPhase,
-	normalizeState,
-	recordFinding,
-	recordSignal,
-	safeFileName,
-	startReview,
-	transitionToReviewFixes,
-	transitionToReviewPending,
-} from "../src/state.js";
-import type { ReviewChunk, ReviewSignal } from "../src/types.js";
-import { withTempDir } from "./helpers.js";
-
-/** A review chunk of the given id. */
-function chunk(id: string): ReviewChunk {
-	return { id, label: `${id} (1 file)`, files: [`${id}.ts`], status: "pending" };
-}
-
-const signal: ReviewSignal = {
-	source: "code-reviewer",
-	files: ["index.ts"],
-	reason: "a comprehensive review was requested with code-reviewer",
-	at: "2026-10-25T00:00:00.000Z",
-};
-
-describe("createState", () => {
-	it("starts in the implementation phase", () => {
-		const state = createState("task-1", "abc123");
-		expect(state.phase).toBe("implementation");
-		expect(state.startRevision).toBe("abc123");
-		expect(state.signals).toEqual([]);
-	});
-});
-
-describe("signals", () => {
-	it("records a signal once", () => {
-		const once = recordSignal(createState("t"), signal);
-		const twice = recordSignal(once, signal);
-		expect(twice.signals).toHaveLength(1);
-		expect(hasQueuedReview(twice)).toBe(true);
-	});
-
-	it("keeps the phase while a signal is recorded", () => {
-		const state = recordSignal(createState("t"), signal);
-		expect(state.phase).toBe("implementation");
-	});
-});
-
-describe("phases", () => {
-	it("moves forward only", () => {
-		const state = createState("t");
-		expect(moveToPhase(state, "review_pending").phase).toBe("review_pending");
-		expect(moveToPhase(state, "implementation").phase).toBe("implementation");
-		const review = moveToPhase(state, "review");
-		expect(moveToPhase(review, "implementation").phase).toBe("review");
-	});
-
-	it("does not move back from the review into the implementation", () => {
-		const review = startReview(createState("t"), []);
-		expect(moveToPhase(review, "implementation").phase).toBe("review");
-	});
-
-	it("enters the review with the scope and the chunks", () => {
-		const pending = transitionToReviewPending(createState("t"), ["a.ts", "b.ts"]);
-		expect(pending.phase).toBe("review_pending");
-		expect(pending.scopeFiles).toEqual(["a.ts", "b.ts"]);
-
-		const review = startReview(pending, [
-			{ id: "chunk-1", label: "packages/x (1 file)", files: ["a.ts"], status: "pending" },
-		]);
-		expect(review.phase).toBe("review");
-		expect(review.chunks).toHaveLength(1);
-	});
-
-	it("marks the chunks as done", () => {
-		const review = startReview(createState("t"), [
-			{ id: "chunk-1", label: "a", files: ["a.ts"], status: "pending" },
-			{ id: "chunk-2", label: "b", files: ["b.ts"], status: "pending" },
-		]);
-		const one = markChunkDone(review, "chunk-1");
-		expect(allChunksDone(one)).toBe(false);
-		const both = markChunkDone(one, "chunk-2");
-		expect(allChunksDone(both)).toBe(true);
-	});
-
-	it("enters the fixes only when the review is finished", () => {
-		const review = startReview(createState("t"), [chunk("chunk-1")]);
-		expect(transitionToReviewFixes(review).phase).toBe("review");
-
-		const withFinding = recordFinding(review, {
-			id: "finding-1",
-			severity: "medium",
-			summary: "the callback is not idempotent",
-			at: "2026-10-25T00:00:00.000Z",
-		});
-		// The review has not run over every chunk yet.
-		expect(transitionToReviewFixes(withFinding).phase).toBe("review");
-
-		const reviewed = markChunkDone(withFinding, "chunk-1");
-		expect(transitionToReviewFixes(reviewed).phase).toBe("review_fixes");
-		expect(withFinding.findings).toHaveLength(1);
-	});
-
-	it("marks the task complete only when the review ran", () => {
-		// The implementation alone never completes the task.
-		expect(markComplete(createState("t")).phase).toBe("implementation");
-
-		const review = startReview(createState("t"), [chunk("chunk-1")]);
-		expect(markComplete(review).phase).toBe("review");
-
-		const reviewed = markChunkDone(review, "chunk-1");
-		expect(markComplete(reviewed).phase).toBe("complete");
-	});
-
-	it("never moves the phase backwards", () => {
-		const review = startReview(createState("t"), [chunk("chunk-1")]);
-		const done = markComplete(markChunkDone(review, "chunk-1"));
-		expect(done.phase).toBe("complete");
-		// A late transition cannot undo the completion.
-		expect(transitionToReviewFixes(done).phase).toBe("complete");
-		expect(moveToPhase(done, "review").phase).toBe("complete");
-	});
-});
-
-describe("TwoPhaseStateStore", () => {
-	it("writes and reads the state of a task", () => {
-		withTempDir("state", (dir) => {
-			const store = new TwoPhaseStateStore(dir);
-			const state = recordSignal(createState("task-1", "rev1"), signal);
-			store.write(state);
-
-			const read = store.read("task-1");
-			expect(read?.phase).toBe("implementation");
-			expect(read?.signals).toHaveLength(1);
-			expect(read?.startRevision).toBe("rev1");
-		});
-	});
-
-	it("returns nothing for an unknown task", () => {
-		withTempDir("state", (dir) => {
-			const store = new TwoPhaseStateStore(dir);
-			expect(store.read("unknown")).toBeNull();
-		});
-	});
-
-	it("reports a corrupt state instead of losing it", () => {
-		withTempDir("state", (dir) => {
-			const store = new TwoPhaseStateStore(dir);
-			store.write(createState("task-1", "rev1"));
-			writeFileSync(store.path("task-1"), "{not json", "utf8");
-
-			// A corrupt state must not look like a fresh task: that would lose
-			// the revision the task started at and the progress of the review.
-			expect(() => store.read("task-1")).toThrow(/not valid JSON/);
-		});
-	});
-
-	it("leaves no temporary file behind", () => {
-		withTempDir("state", (dir) => {
-			const store = new TwoPhaseStateStore(dir);
-			store.write(createState("task-1"));
-			store.write(createState("task-1"));
-			expect(readdirSync(dir).filter((entry) => entry.endsWith(".tmp"))).toEqual([]);
-		});
-	});
-
-	it("keeps the tasks apart", () => {
-		withTempDir("state", (dir) => {
-			const store = new TwoPhaseStateStore(dir);
-			store.write(recordSignal(createState("task-a"), signal));
-			store.write(createState("task-b"));
-			expect(store.read("task-a")?.signals).toHaveLength(1);
-			expect(store.read("task-b")?.signals).toHaveLength(0);
-		});
-	});
-
-	it("repairs a broken state", () => {
-		expect(normalizeState({ phase: "nonsense" }, "task-1").phase).toBe("implementation");
-		expect(normalizeState(null, "task-1").taskId).toBe("task-1");
-	});
-
-	it("uses a safe file name", () => {
-		expect(safeFileName("session/with spaces")).toBe("session_with_spaces");
-	});
-});