pi-harness-runtime 1.1.440 → 1.1.441

package/packages/tooling-preference/tests/quality-check.test.ts

@@ -1,272 +0,0 @@
-/**
- * The post-change quality check.
- *
- * The saved preference decides the tool: Biome when the user asked for it,
- * the project's own script otherwise. The check never writes and never runs
- * without a decision of the user.
- */
-
-import { describe, it, expect, afterEach } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-	formatQualityCheckStatus,
-	runQualityCheck,
-	selectQualityCheck,
-} from "../src/quality-check.js";
-import type { ToolingContext } from "../src/detect.js";
-
-const cleanups: string[] = [];
-
-function workspace(pkg: unknown, files: Record<string, string> = {}): string {
-	const root = mkdtempSync(join(tmpdir(), "tooling-check-"));
-	cleanups.push(root);
-	writeFileSync(join(root, "package.json"), JSON.stringify(pkg), "utf8");
-	for (const [name, content] of Object.entries(files)) {
-		writeFileSync(join(root, name), content, "utf8");
-	}
-	return root;
-}
-
-function context(root: string, overrides: Partial<ToolingContext> = {}): ToolingContext {
-	return {
-		root,
-		hasPackageJson: true,
-		isJavaScriptTypeScript: true,
-		isNextJs: false,
-		isReact: false,
-		usesBiome: false,
-		usesEslint: true,
-		usesPrettier: false,
-		packageManager: "npm",
-		frameworks: [],
-		...overrides,
-	};
-}
-
-afterEach(() => {
-	while (cleanups.length > 0) {
-		const root = cleanups.pop();
-		if (root) rmSync(root, { recursive: true, force: true });
-	}
-});
-
-describe("the check selection", () => {
-	it("runs Biome on the changed files when the preference asks for it", () => {
-		const root = workspace({ name: "web" });
-		const plan = selectQualityCheck({
-			context: context(root, { usesBiome: true, packageManager: "bun" }),
-			preference: "prefer_biome",
-			files: ["src/app.ts"],
-		});
-
-		expect(plan.tool).toBe("biome");
-		expect(plan.command).toBe("bunx");
-		expect(plan.args).toEqual(["biome", "check", "src/app.ts"]);
-		expect(plan.files).toEqual(["src/app.ts"]);
-	});
-
-	it("never asks Biome to fix the files", () => {
-		const root = workspace({ name: "web" });
-		const plan = selectQualityCheck({
-			context: context(root, { usesBiome: true }),
-			preference: "prefer_biome",
-			files: ["src/app.ts"],
-		});
-
-		expect(plan.args.join(" ")).not.toContain("--write");
-		expect(plan.args.join(" ")).not.toContain("--fix");
-	});
-
-	it("runs the project script when the preference keeps the project tools", () => {
-		const root = workspace({ name: "web", scripts: { lint: "eslint ." } });
-		const plan = selectQualityCheck({
-			context: context(root),
-			preference: "use_project_tools",
-			files: ["src/app.ts"],
-		});
-
-		expect(plan.tool).toBe("project");
-		expect(plan.command).toBe("npm");
-		expect(plan.args).toEqual(["run", "lint"]);
-	});
-
-	it("falls back to the project script when Biome is not installed yet", () => {
-		const root = workspace({ name: "web", scripts: { lint: "eslint ." } });
-		const plan = selectQualityCheck({
-			context: context(root, { usesBiome: false }),
-			preference: "prefer_biome",
-			files: ["src/app.ts"],
-		});
-
-		expect(plan.tool).toBe("project");
-		expect(plan.reason).toContain("Biome is not installed");
-	});
-
-	it("checks nothing without a decision of the user", () => {
-		const root = workspace({ name: "web", scripts: { lint: "eslint ." } });
-		const plan = selectQualityCheck({
-			context: context(root),
-			preference: undefined,
-			files: ["src/app.ts"],
-		});
-
-		expect(plan.tool).toBe("none");
-		expect(plan.command).toBeNull();
-		expect(plan.reason).toContain("not chosen");
-	});
-
-	it("checks nothing when no file changed", () => {
-		const root = workspace({ name: "web", scripts: { lint: "eslint ." } });
-		const plan = selectQualityCheck({
-			context: context(root),
-			preference: "use_project_tools",
-			files: [],
-		});
-
-		expect(plan.tool).toBe("none");
-		expect(plan.reason).toContain("no JavaScript/TypeScript file changed");
-	});
-
-	it("checks nothing when the project has no script to run", () => {
-		const root = workspace({ name: "web" });
-		const plan = selectQualityCheck({
-			context: context(root),
-			preference: "use_project_tools",
-			files: ["src/app.ts"],
-		});
-
-		expect(plan.tool).toBe("none");
-		expect(plan.reason).toContain("neither a lint nor a typecheck");
-	});
-
-	it("uses the typecheck script when there is no lint script", () => {
-		const root = workspace({ name: "web", scripts: { typecheck: "tsc --noEmit" } });
-		const plan = selectQualityCheck({
-			context: context(root),
-			preference: "use_project_tools",
-			files: ["src/app.ts"],
-		});
-
-		expect(plan.command).toBe("npm");
-		expect(plan.args).toEqual(["run", "typecheck"]);
-	});
-});
-
-describe("the check itself", () => {
-	it("reports a passing check", () => {
-		const root = workspace({ name: "web" });
-		const plan = selectQualityCheck({
-			context: context(root),
-			preference: "use_project_tools",
-			files: ["src/app.ts"],
-		});
-		const pass = {
-			tool: plan.tool,
-			command: "node",
-			args: ["-e", "process.exit(0)"],
-			files: ["src/app.ts"],
-			reason: "test",
-		};
-
-		const result = runQualityCheck(pass, { cwd: root, timeoutMs: 10_000 });
-
-		expect(result.ran).toBe(true);
-		expect(result.passed).toBe(true);
-		expect(result.reason).toContain("passed");
-	});
-
-	it("reports a failing check", () => {
-		const root = workspace({ name: "web" });
-		const fail = {
-			tool: "project" as const,
-			command: "node",
-			args: ["-e", "process.stderr.write('problem'); process.exit(2)"],
-			files: ["src/app.ts"],
-			reason: "test",
-		};
-
-		const result = runQualityCheck(fail, { cwd: root, timeoutMs: 10_000 });
-
-		expect(result.ran).toBe(true);
-		expect(result.passed).toBe(false);
-		expect(result.exitCode).toBe(2);
-		expect(result.output).toContain("problem");
-	});
-
-	it("reports a check that cannot start", () => {
-		const result = runQualityCheck(
-			{
-				tool: "project",
-				command: "definitely-not-a-command",
-				args: [],
-				files: ["src/app.ts"],
-				reason: "test",
-			},
-			{ cwd: process.cwd(), timeoutMs: 10_000 },
-		);
-
-		expect(result.ran).toBe(false);
-		expect(result.reason).toContain("could not start");
-	});
-
-	it("runs nothing when the plan has no command", () => {
-		const result = runQualityCheck(
-			{ tool: "none", command: null, args: [], files: [], reason: "nothing to do" },
-			{ cwd: process.cwd(), timeoutMs: 10_000 },
-		);
-
-		expect(result.ran).toBe(false);
-		expect(result.passed).toBe(false);
-	});
-});
-
-describe("the status line", () => {
-	it("names the tool and the outcome", () => {
-		const line = formatQualityCheckStatus({
-			ran: true,
-			passed: true,
-			tool: "biome",
-			fileCount: 3,
-			exitCode: 0,
-			timedOut: false,
-			output: "",
-			reason: "the check passed",
-		});
-
-		expect(line).toBe("[TOOL] biome: 3 file(s), ok");
-		expect(/[^\x20-\x7e]/.test(line)).toBe(false);
-	});
-
-	it("names the reason when no check ran", () => {
-		const line = formatQualityCheckStatus({
-			ran: false,
-			passed: false,
-			tool: "none",
-			fileCount: 0,
-			exitCode: null,
-			timedOut: false,
-			output: "",
-			reason: "no JavaScript/TypeScript file changed",
-		});
-
-		expect(line).toContain("no check");
-		expect(line).toContain("no JavaScript/TypeScript file changed");
-	});
-
-	it("names a timeout", () => {
-		const line = formatQualityCheckStatus({
-			ran: true,
-			passed: false,
-			tool: "project",
-			fileCount: 2,
-			exitCode: null,
-			timedOut: true,
-			output: "",
-			reason: "the check hit the timeout",
-		});
-
-		expect(line).toContain("timeout");
-	});
-});

package/packages/tooling-preference/tests/registry.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { ToolingRequestRegistry } from "../src/registry.ts";
-
-const request = {
-	requestId: "biome-abc123",
-	workspaceRoot: "/work/web",
-	userKey: "user-1",
-	frameworks: ["next"],
-};
-
-describe("ToolingRequestRegistry", () => {
-	it("registers a proposal once", () => {
-		const registry = new ToolingRequestRegistry();
-		expect(registry.register(request)).toBe(true);
-		expect(registry.register(request)).toBe(false);
-		expect(registry.has(request.requestId)).toBe(true);
-	});
-
-	it("lets the first answer win", () => {
-		const registry = new ToolingRequestRegistry();
-		registry.register(request);
-
-		const first = registry.claim(request.requestId, "yes", "telegram");
-		expect(first?.resolution.preference).toBe("prefer_biome");
-		expect(first?.request.workspaceRoot).toBe("/work/web");
-
-		// The second click finds nothing - the first answer stays.
-		expect(registry.claim(request.requestId, "no", "line")).toBeNull();
-		expect(registry.resolutionOf(request.requestId)?.preference).toBe("prefer_biome");
-	});
-
-	it("maps a no to the current tools", () => {
-		const registry = new ToolingRequestRegistry();
-		registry.register(request);
-		const claimed = registry.claim(request.requestId, "no", "line");
-		expect(claimed?.resolution.preference).toBe("use_project_tools");
-		expect(claimed?.resolution.channel).toBe("line");
-	});
-
-	it("refuses a claim for an unknown request", () => {
-		const registry = new ToolingRequestRegistry();
-		expect(registry.claim("biome-unknown", "yes")).toBeNull();
-	});
-
-	it("does not register a request that was already answered", () => {
-		const registry = new ToolingRequestRegistry();
-		registry.register(request);
-		registry.claim(request.requestId, "no");
-		expect(registry.register(request)).toBe(false);
-	});
-});

package/packages/tooling-preference/tests/store.test.ts

@@ -1,99 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-	shouldAskAgain,
-	ToolingPreferenceStore,
-	toolingPreferenceKey,
-} from "../src/store.ts";
-
-function storePath(): string {
-	return join(mkdtempSync(join(tmpdir(), "tooling-store-")), "tooling-preference.json");
-}
-
-describe("ToolingPreferenceStore", () => {
-	it("has no record for an unknown user and workspace", () => {
-		const path = storePath();
-		const store = new ToolingPreferenceStore(path);
-		expect(store.read("user-1", "/work/web")).toBeUndefined();
-	});
-
-	it("keeps the record of a user in a workspace apart", () => {
-		const path = storePath();
-		const store = new ToolingPreferenceStore(path);
-		store.recordDecision("user-1", "/work/web", "prefer_biome", "biome-1");
-		store.recordDecision("user-2", "/work/web", "use_project_tools", "biome-2");
-		store.recordDecision("user-1", "/work/other", "use_project_tools", "biome-3");
-
-		expect(store.read("user-1", "/work/web")?.decision).toBe("prefer_biome");
-		expect(store.read("user-2", "/work/web")?.decision).toBe("use_project_tools");
-		expect(store.read("user-1", "/work/other")?.decision).toBe("use_project_tools");
-	});
-
-	it("remembers that the proposal was sent", () => {
-		const path = storePath();
-		const store = new ToolingPreferenceStore(path);
-		store.markAsked("user-1", "/work/web", "biome-1");
-		const record = store.read("user-1", "/work/web");
-		expect(record?.askedAt).toBeTruthy();
-		expect(record?.requestId).toBe("biome-1");
-		expect(record?.decision).toBeUndefined();
-	});
-
-	it("keeps a decision across a new store instance", () => {
-		const path = storePath();
-		new ToolingPreferenceStore(path).recordDecision(
-			"user-1",
-			"/work/web",
-			"prefer_biome",
-			"biome-1",
-			"telegram",
-		);
-		const record = new ToolingPreferenceStore(path).read("user-1", "/work/web");
-		expect(record?.decision).toBe("prefer_biome");
-		expect(record?.channel).toBe("telegram");
-	});
-
-	it("survives a broken store file", () => {
-		const path = storePath();
-		const store = new ToolingPreferenceStore(path);
-		store.markAsked("user-1", "/work/web", "biome-1");
-		// A store that cannot be read must not stop the harness.
-		Bun.write(path, "not json");
-		expect(store.read("user-1", "/work/web")).toBeUndefined();
-	});
-
-	it("keys a record by the user and the workspace", () => {
-		expect(toolingPreferenceKey("user-1", "/work/web")).not.toBe(
-			toolingPreferenceKey("user-2", "/work/web"),
-		);
-		expect(toolingPreferenceKey("user-1", "/work/web")).toBe(
-			toolingPreferenceKey("user-1", "/work/web"),
-		);
-	});
-});
-
-describe("shouldAskAgain", () => {
-	const day = 24 * 60 * 60 * 1000;
-	const now = new Date("2026-10-24T12:00:00.000Z");
-
-	it("asks a workspace that was never asked", () => {
-		expect(shouldAskAgain(undefined, 30 * day, now)).toBe(true);
-	});
-
-	it("never asks a workspace with a decision", () => {
-		const record = { decision: "prefer_biome" as const, askedAt: "2026-01-01T00:00:00.000Z" };
-		expect(shouldAskAgain(record, 30 * day, now)).toBe(false);
-	});
-
-	it("does not ask again inside the cooldown", () => {
-		const record = { askedAt: new Date(now.getTime() - day).toISOString() };
-		expect(shouldAskAgain(record, 30 * day, now)).toBe(false);
-	});
-
-	it("asks again after the cooldown", () => {
-		const record = { askedAt: new Date(now.getTime() - 31 * day).toISOString() };
-		expect(shouldAskAgain(record, 30 * day, now)).toBe(true);
-	});
-});

package/packages/trajectory/test/store.test.ts

@@ -1,250 +0,0 @@
-import { describe, it, beforeEach } from "node:test";
-import assert from "node:assert";
-import { rmSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { TrajectoryStore, resetTrajectoryStore } from "../src/store.js";
-
-const TEST_DIR = join(homedir(), ".pi-harness-test-trajectories");
-
-function freshStore(): TrajectoryStore {
-	rmSync(TEST_DIR, { force: true, recursive: true });
-	mkdirSync(TEST_DIR, { recursive: true });
-	return new TrajectoryStore(TEST_DIR);
-}
-
-describe("TrajectoryStore", () => {
-	beforeEach(() => {
-		rmSync(TEST_DIR, { force: true, recursive: true });
-		mkdirSync(TEST_DIR, { recursive: true });
-		resetTrajectoryStore();
-	});
-
-	it("start() returns a UUID", () => {
-		const store = freshStore();
-		const id = store.start("test task");
-		assert.match(id, /^[0-9a-f-]{36}$/);
-	});
-
-	it("append() writes NDJSON to the correct daily file", () => {
-		const store = freshStore();
-		const id = "test-id-123";
-		const now = new Date();
-
-		store.append({
-			id,
-			taskRequest: "fix the login bug",
-			createdAt: now.toISOString(),
-			durationMs: 5000,
-			iterations: 2,
-			verdict: "approved",
-			reason: "reviewer approved",
-			plan: "# Plan\n1. Fix it",
-			code: "// fixed",
-			files: ["auth.ts"],
-			comments: [{ file: "auth.ts", comment: "looks good", severity: "minor" }],
-			summary: "looks good",
-			classified: false,
-		});
-
-		// Should have created a daily file
-		const files = readdirSync(TEST_DIR);
-		assert.ok(files.length > 0, "should create at least one directory");
-
-		// Navigate to the daily file
-		const monthDir = files[0];
-		const monthFiles = readdirSync(join(TEST_DIR, monthDir));
-		assert.ok(monthFiles.length > 0, "should create daily ndjson file");
-
-		const content = readFileSync(join(TEST_DIR, monthDir, monthFiles[0]), "utf8");
-		const record = JSON.parse(content.split("\n").find((l) => l.trim())!);
-		assert.strictEqual(record.id, id);
-		assert.strictEqual(record.verdict, "approved");
-		assert.strictEqual(record.iterations, 2);
-	});
-
-	it("list() returns records newest-first", () => {
-		const store = freshStore();
-
-		const id1 = store.start("task 1");
-		store.append({
-			id: id1,
-			taskRequest: "task 1",
-			createdAt: "2025-07-01T10:00:00.000Z",
-			durationMs: 1000,
-			iterations: 1,
-			verdict: "approved",
-			reason: "ok",
-			plan: "p1",
-			code: "c1",
-			files: [],
-			comments: [],
-			summary: "s1",
-			classified: false,
-		});
-
-		const id2 = store.start("task 2");
-		store.append({
-			id: id2,
-			taskRequest: "task 2",
-			createdAt: "2025-07-02T10:00:00.000Z",
-			durationMs: 2000,
-			iterations: 2,
-			verdict: "changes_requested",
-			reason: "converged: only minor comments",
-			plan: "p2",
-			code: "c2",
-			files: [],
-			comments: [],
-			summary: "s2",
-			classified: false,
-		});
-
-		const all = store.list();
-		assert.strictEqual(all.length, 2);
-		assert.strictEqual(all[0].id, id2, "newest first");
-		assert.strictEqual(all[1].id, id1);
-	});
-
-	it("stats() aggregates correctly", () => {
-		const store = freshStore();
-
-		store.append({
-			id: "s1",
-			taskRequest: "t1",
-			createdAt: "2025-07-01T10:00:00.000Z",
-			durationMs: 1000,
-			iterations: 1,
-			verdict: "approved",
-			reason: "reviewer approved",
-			plan: "p",
-			code: "c",
-			files: ["a.ts"],
-			comments: [],
-			summary: "s",
-			classified: false,
-		});
-
-		store.append({
-			id: "s2",
-			taskRequest: "t2",
-			createdAt: "2025-07-01T11:00:00.000Z",
-			durationMs: 3000,
-			iterations: 3,
-			verdict: "changes_requested",
-			reason: "max iterations (3) reached with changes still requested",
-			plan: "p",
-			code: "c",
-			files: ["a.ts", "b.ts"],
-			comments: [],
-			summary: "s",
-			classified: false,
-		});
-
-		const stats = store.stats();
-		assert.strictEqual(stats.total, 2);
-		assert.strictEqual(stats.byVerdict.approved, 1);
-		assert.strictEqual(stats.byVerdict.changes_requested, 1);
-		assert.strictEqual(stats.avgIterations, 2);
-		assert.strictEqual(stats.avgDurationMs, 2000);
-		assert.strictEqual(stats.byFile["a.ts"], 2);
-		assert.strictEqual(stats.byFile["b.ts"], 1);
-		assert.strictEqual(stats.byLabel["max-iterations"], 1);
-		assert.strictEqual(stats.byLabel["converged"], 1);
-	});
-
-	it("classify() returns correct label for converged", () => {
-		const store = freshStore();
-		const cls = store.classify({
-			id: "x",
-			taskRequest: "x",
-			createdAt: new Date().toISOString(),
-			durationMs: 1000,
-			iterations: 1,
-			verdict: "approved",
-			reason: "reviewer approved",
-			plan: "",
-			code: "",
-			files: [],
-			comments: [],
-			summary: "",
-			classified: false,
-		});
-		assert.strictEqual(cls.label, "converged");
-		assert.strictEqual(cls.trajectoryId, "x");
-	});
-
-	it("classify() returns stuck for same-file reason", () => {
-		const store = freshStore();
-		const cls = store.classify({
-			id: "y",
-			taskRequest: "y",
-			createdAt: new Date().toISOString(),
-			durationMs: 1000,
-			iterations: 2,
-			verdict: "changes_requested",
-			reason: "stuck: same file (auth.ts) flagged for 3 comment(s)",
-			plan: "",
-			code: "",
-			files: ["auth.ts"],
-			comments: [],
-			summary: "",
-			classified: false,
-		});
-		assert.strictEqual(cls.label, "stuck");
-		assert.strictEqual(cls.pattern, "same-file-repeated");
-		assert.ok(cls.confidence < 1.0);
-	});
-
-	it("byVerdict() filters correctly", () => {
-		const store = freshStore();
-		store.append({
-			id: "v1",
-			taskRequest: "v1",
-			createdAt: "2025-07-01T10:00:00.000Z",
-			durationMs: 1000,
-			iterations: 1,
-			verdict: "approved",
-			reason: "ok",
-			plan: "",
-			code: "",
-			files: [],
-			comments: [],
-			summary: "",
-			classified: false,
-		});
-		store.append({
-			id: "v2",
-			taskRequest: "v2",
-			createdAt: "2025-07-02T10:00:00.000Z",
-			durationMs: 1000,
-			iterations: 1,
-			verdict: "blocked",
-			reason: "blocked",
-			plan: "",
-			code: "",
-			files: [],
-			comments: [],
-			summary: "",
-			classified: false,
-		});
-
-		const approved = store.byVerdict("approved");
-		assert.strictEqual(approved.length, 1);
-		assert.strictEqual(approved[0].id, "v1");
-
-		const blocked = store.byVerdict("blocked");
-		assert.strictEqual(blocked.length, 1);
-		assert.strictEqual(blocked[0].id, "v2");
-	});
-
-	it("stats() handles empty store gracefully", () => {
-		rmSync(TEST_DIR, { force: true, recursive: true });
-		mkdirSync(TEST_DIR, { recursive: true });
-		// Remove the month dir so the store sees an empty directory
-		const store = freshStore();
-		const stats = store.stats();
-		assert.strictEqual(stats.total, 0);
-		assert.strictEqual(stats.avgIterations, 0);
-	});
-});