pi-harness-runtime 1.1.403 → 1.1.405

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

@@ -0,0 +1,188 @@
+import { describe, expect, it } from "bun:test";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	detectToolingContext,
+	evaluateBiomeProposalEligibility,
+} from "../src/detect.ts";
+
+function workspace(files: Record<string, string>): string {
+	const root = mkdtempSync(join(tmpdir(), "tooling-preference-"));
+	for (const [name, content] of Object.entries(files)) {
+		const path = join(root, name);
+		mkdirSync(join(path, ".."), { recursive: true });
+		writeFileSync(path, content, "utf8");
+	}
+	return root;
+}
+
+function cleanup(root: string): void {
+	rmSync(root, { recursive: true, force: true });
+}
+
+describe("detectToolingContext", () => {
+	it("detects a Next.js + React + TypeScript workspace with ESLint and Prettier", () => {
+		const root = workspace({
+			"package.json": JSON.stringify({
+				name: "web",
+				dependencies: { next: "15.0.0", react: "19.0.0" },
+				devDependencies: { eslint: "^9.0.0", prettier: "^3.0.0", typescript: "^5.7.0" },
+			}),
+			"tsconfig.json": "{}",
+			".eslintrc.json": "{}",
+			".prettierrc": "{}",
+			"src/app/page.tsx": "export const x = 1;",
+		});
+		try {
+			const context = detectToolingContext(root);
+			expect(context.hasPackageJson).toBe(true);
+			expect(context.isJavaScriptTypeScript).toBe(true);
+			expect(context.isNextJs).toBe(true);
+			expect(context.isReact).toBe(true);
+			expect(context.usesBiome).toBe(false);
+			expect(context.usesEslint).toBe(true);
+			expect(context.usesPrettier).toBe(true);
+			expect(context.frameworks).toContain("next");
+		} finally {
+			cleanup(root);
+		}
+	});
+
+	it("reports a workspace that already uses Biome", () => {
+		const root = workspace({
+			"package.json": JSON.stringify({ name: "web", devDependencies: { eslint: "^9.0.0" } }),
+			"biome.json": "{}",
+			"tsconfig.json": "{}",
+		});
+		try {
+			const context = detectToolingContext(root);
+			expect(context.usesBiome).toBe(true);
+		} finally {
+			cleanup(root);
+		}
+	});
+
+	it("detects Biome through the dependency alone", () => {
+		const root = workspace({
+			"package.json": JSON.stringify({
+				name: "web",
+				devDependencies: { "@biomejs/biome": "^2.4.7" },
+			}),
+			"tsconfig.json": "{}",
+		});
+		try {
+			expect(detectToolingContext(root).usesBiome).toBe(true);
+		} finally {
+			cleanup(root);
+		}
+	});
+
+	it("detects the package manager through the lockfile", () => {
+		const root = workspace({
+			"package.json": JSON.stringify({ name: "web" }),
+			"pnpm-lock.yaml": "",
+		});
+		try {
+			expect(detectToolingContext(root).packageManager).toBe("pnpm");
+		} finally {
+			cleanup(root);
+		}
+	});
+
+	it("prefers the declared package manager", () => {
+		const root = workspace({
+			"package.json": JSON.stringify({ name: "web", packageManager: "bun@1.3.0" }),
+			"package-lock.json": "{}",
+		});
+		try {
+			expect(detectToolingContext(root).packageManager).toBe("bun");
+		} finally {
+			cleanup(root);
+		}
+	});
+
+	it("finds a source file without a tsconfig", () => {
+		const root = workspace({
+			"package.json": JSON.stringify({ name: "web" }),
+			"src/index.ts": "export const x = 1;",
+		});
+		try {
+			expect(detectToolingContext(root).isJavaScriptTypeScript).toBe(true);
+		} finally {
+			cleanup(root);
+		}
+	});
+
+	it("does not walk into a dependency directory for sources", () => {
+		const root = workspace({
+			"package.json": JSON.stringify({ name: "web" }),
+			"node_modules/some-package/index.js": "module.exports = 1;",
+		});
+		try {
+			expect(detectToolingContext(root).isJavaScriptTypeScript).toBe(false);
+		} finally {
+			cleanup(root);
+		}
+	});
+});
+
+describe("evaluateBiomeProposalEligibility", () => {
+	it("offers the proposal for a JS/TS workspace with ESLint or Prettier", () => {
+		const root = workspace({
+			"package.json": JSON.stringify({ name: "web", devDependencies: { eslint: "^9.0.0" } }),
+			"tsconfig.json": "{}",
+		});
+		try {
+			const decision = evaluateBiomeProposalEligibility(detectToolingContext(root));
+			expect(decision.eligible).toBe(true);
+		} finally {
+			cleanup(root);
+		}
+	});
+
+	it("never asks a workspace that already uses Biome", () => {
+		const root = workspace({
+			"package.json": JSON.stringify({
+				name: "web",
+				devDependencies: { eslint: "^9.0.0", "@biomejs/biome": "^2.4.7" },
+			}),
+			"tsconfig.json": "{}",
+		});
+		try {
+			const decision = evaluateBiomeProposalEligibility(detectToolingContext(root));
+			expect(decision.eligible).toBe(false);
+			expect(decision.reason).toContain("Biome");
+		} finally {
+			cleanup(root);
+		}
+	});
+
+	it("never asks a workspace without ESLint and Prettier", () => {
+		const root = workspace({
+			"package.json": JSON.stringify({ name: "web" }),
+			"tsconfig.json": "{}",
+		});
+		try {
+			const decision = evaluateBiomeProposalEligibility(detectToolingContext(root));
+			expect(decision.eligible).toBe(false);
+			expect(decision.reason).toContain("neither ESLint nor Prettier");
+		} finally {
+			cleanup(root);
+		}
+	});
+
+	it("never asks a workspace that is not JavaScript/TypeScript", () => {
+		const root = workspace({
+			"package.json": JSON.stringify({ name: "docs" }),
+			"README.md": "# docs",
+		});
+		try {
+			const decision = evaluateBiomeProposalEligibility(detectToolingContext(root));
+			expect(decision.eligible).toBe(false);
+			expect(decision.reason).toContain("not a JavaScript/TypeScript project");
+		} finally {
+			cleanup(root);
+		}
+	});
+});

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

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "bun:test";
+import {
+	buildToolingButtons,
+	buildToolingImplementationPrompt,
+	buildToolingProposalMessage,
+	buildToolingRequestId,
+	parseToolingTarget,
+	TOOLING_ACTION,
+} from "../src/proposal.ts";
+import type { ToolingContext } from "../src/detect.ts";
+
+const context: ToolingContext = {
+	root: "/work/web",
+	hasPackageJson: true,
+	isJavaScriptTypeScript: true,
+	isNextJs: true,
+	isReact: true,
+	usesBiome: false,
+	usesEslint: true,
+	usesPrettier: true,
+	packageManager: "pnpm",
+	frameworks: ["next"],
+};
+
+describe("buildToolingRequestId", () => {
+	it("is stable for the same user and workspace", () => {
+		const first = buildToolingRequestId("user-1", "/work/web");
+		const second = buildToolingRequestId("user-1", "/work/web");
+		expect(first).toBe(second);
+	});
+
+	it("differs per user and per workspace", () => {
+		expect(buildToolingRequestId("user-1", "/work/web")).not.toBe(
+			buildToolingRequestId("user-2", "/work/web"),
+		);
+		expect(buildToolingRequestId("user-1", "/work/web")).not.toBe(
+			buildToolingRequestId("user-1", "/work/other"),
+		);
+	});
+
+	it("holds no underscore, so the callback parser keeps it intact", () => {
+		const requestId = buildToolingRequestId("user-1", "/work/web");
+		expect(requestId).not.toContain("_");
+		expect(requestId.startsWith("biome-")).toBe(true);
+	});
+});
+
+describe("buildToolingButtons", () => {
+	it("sends one action with a choice per button", () => {
+		const requestId = buildToolingRequestId("user-1", "/work/web");
+		const buttons = buildToolingButtons(requestId);
+		expect(buttons).toHaveLength(2);
+		for (const button of buttons) {
+			expect(button.action).toBe(TOOLING_ACTION);
+			expect(button.targetId).toContain(requestId);
+		}
+		expect(buttons[0].targetId.startsWith("yes-")).toBe(true);
+		expect(buttons[1].targetId.startsWith("no-")).toBe(true);
+	});
+
+	it("keeps the action a single token", () => {
+		expect(TOOLING_ACTION).not.toContain("_");
+	});
+});
+
+describe("parseToolingTarget", () => {
+	it("reads the choice and the request ID back", () => {
+		const requestId = buildToolingRequestId("user-1", "/work/web");
+		const [yes, no] = buildToolingButtons(requestId);
+		expect(parseToolingTarget(yes.targetId)).toEqual({ choice: "yes", requestId });
+		expect(parseToolingTarget(no.targetId)).toEqual({ choice: "no", requestId });
+	});
+
+	it("refuses a target that is not part of the proposal", () => {
+		expect(parseToolingTarget("q-123")).toBeNull();
+		expect(parseToolingTarget("maybe-biome-abc")).toBeNull();
+		expect(parseToolingTarget("")).toBeNull();
+		expect(parseToolingTarget(undefined)).toBeNull();
+	});
+
+	it("survives the callback data round trip", () => {
+		const requestId = buildToolingRequestId("user-1", "/work/web");
+		const [yes] = buildToolingButtons(requestId);
+		const data = `${yes.action}_${yes.targetId}`;
+		const [action, targetId] = data.split("_");
+		expect(action).toBe(TOOLING_ACTION);
+		expect(parseToolingTarget(targetId)?.requestId).toBe(requestId);
+	});
+});
+
+describe("the wording", () => {
+	it("names the detected tools and the frameworks", () => {
+		const message = buildToolingProposalMessage(context);
+		expect(message).toContain("Next.js");
+		expect(message).toContain("ESLint");
+		expect(message).toContain("Prettier");
+		expect(message).toContain("Biome");
+	});
+
+	it("asks the agent to implement Biome after a yes", () => {
+		const prompt = buildToolingImplementationPrompt(context, "/work/web");
+		expect(prompt).toContain("/work/web");
+		expect(prompt).toContain("@biomejs/biome");
+		expect(prompt).toContain("pnpm add --save-dev");
+		expect(prompt).toContain("Next.js");
+	});
+});

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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,99 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/trajectory",
-  "version": "1.1.403",
+  "version": "1.1.405",
   "description": "Trajectory capture for the write-review loop — persists cycle records for learning",
   "type": "module",
   "main": "./dist/src/index.js",

package/packages/tui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/tui",
-  "version": "1.1.403",
+  "version": "1.1.405",
   "description": "pi-harness-runtime — tui",
   "type": "module",
   "main": "./dist/index.js",

package/packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/types",
-  "version": "1.1.403",
+  "version": "1.1.405",
   "description": "Shared TypeScript types for pi-harness-runtime packages",
   "type": "module",
   "main": "./dist/index.js",

package/packages/voice-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/voice-api",
-  "version": "1.1.403",
+  "version": "1.1.405",
   "type": "module",
   "description": "Voice-to-text API using Whisper for Telegram and LINE integration",
   "main": "./dist/index.js",

package/packages/webmcp-tester/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/webmcp-tester",
-  "version": "1.1.403",
+  "version": "1.1.405",
   "description": "WebMCP-powered E2E testing for pi-harness - natural language test scenarios",
   "type": "module",
   "main": "./dist/index.js",

package/packages/wiki/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/wiki",
-  "version": "1.1.403",
+  "version": "1.1.405",
   "description": "LLM Wiki integration for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/workflow-events/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/workflow-events",
-  "version": "1.1.403",
+  "version": "1.1.405",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/workspace-scanner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/workspace-scanner",
-  "version": "1.1.403",
+  "version": "1.1.405",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/worktree/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/worktree",
-  "version": "1.1.403",
+  "version": "1.1.405",
   "description": "pi-harness-runtime — worktree",
   "type": "module",
   "main": "./dist/index.js",

package/packages/write-review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/write-review",
-  "version": "1.1.403",
+  "version": "1.1.405",
   "description": "Two-agent write-review loop with blackboard coordination",
   "type": "module",
   "main": "src/index.ts",