pi-harness-runtime 1.1.440 → 1.1.441

package/packages/token-optimizer/test/optimizer.test.ts

@@ -1,141 +0,0 @@
-/**
- * Token Optimizer Tests (RFC-0011)
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	estimateTokens,
-	estimateMessageTokens,
-	buildBudget,
-	splitByPriority,
-	optimizeBudget,
-	calculateCost,
-	trimToTokens,
-	DEFAULT_PRICING,
-} from "../src/index.js";
-import type { PromptMessage } from "../src/index.js";
-
-const makeMsg = (overrides?: Partial<PromptMessage>): PromptMessage => ({
-	role: "user",
-	content: "Hello world",
-	priority: 5,
-	...overrides,
-});
-
-describe("DEFAULT_PRICING", () => {
-	it("has gpt-4o pricing", () => {
-		expect(DEFAULT_PRICING["gpt-4o"].inputPer1M).toBe(2.5);
-		expect(DEFAULT_PRICING["gpt-4o"].outputPer1M).toBe(10.0);
-	});
-	it("has claude pricing", () => {
-		expect(DEFAULT_PRICING["claude-haiku"].inputPer1M).toBe(0.25);
-	});
-});
-
-describe("estimateTokens", () => {
-	it("estimates 1 token per 4 chars", () => {
-		expect(estimateTokens("01234")).toBe(2);
-	});
-	it("empty string returns 0", () => expect(estimateTokens("")).toBe(0));
-});
-
-describe("estimateMessageTokens", () => {
-	it("sums messages plus overhead", () => {
-		const msgs = [makeMsg({ content: "hello" }), makeMsg({ content: "world" })];
-		expect(estimateMessageTokens(msgs)).toBeGreaterThan(
-			estimateTokens("hello") + estimateTokens("world"),
-		);
-	});
-	it("empty returns 0", () => expect(estimateMessageTokens([])).toBe(0));
-});
-
-describe("buildBudget", () => {
-	it("calculates available tokens", () => {
-		const b = buildBudget(1000, 100, 50);
-		expect(b.maxTokens).toBe(1000);
-		expect(b.systemTokens).toBe(100);
-		expect(b.reservedTokens).toBe(50);
-		expect(b.availableTokens).toBe(850);
-	});
-
-	it("available never negative", () => {
-		const b = buildBudget(100, 200, 0);
-		expect(b.availableTokens).toBe(0);
-	});
-});
-
-describe("splitByPriority", () => {
-	it("splits into three groups", () => {
-		const msgs = Array.from({ length: 9 }, (_, i) =>
-			makeMsg({ content: `msg${i}`, priority: i + 1 }),
-		);
-		const { high, medium, low } = splitByPriority(msgs);
-		expect(high.length).toBeGreaterThan(0);
-		expect(medium.length).toBeGreaterThan(0);
-		expect(low.length).toBeGreaterThan(0);
-		expect(high[0].priority).toBeLessThanOrEqual(medium[0].priority);
-	});
-
-	it("handles single item", () => {
-		const { high } = splitByPriority([makeMsg({ priority: 1 })]);
-		expect(high.length).toBe(1);
-	});
-});
-
-describe("optimizeBudget", () => {
-	it("keeps high priority", () => {
-		const msgs = [
-			makeMsg({ content: "high", priority: 1 }),
-			makeMsg({ content: "low", priority: 9 }),
-		];
-		const budget = buildBudget(1000, 0, 0);
-		const result = optimizeBudget(msgs, budget);
-		expect(result.kept.some((m) => m.content === "high")).toBe(true);
-	});
-
-	it("removes when over budget", () => {
-		const longMsg = makeMsg({ content: "x".repeat(1000), priority: 5 });
-		const budget = buildBudget(100, 0, 0);
-		const result = optimizeBudget([longMsg], budget);
-		expect(result.kept.length).toBeLessThan(1);
-	});
-
-	it("zero available keeps nothing", () => {
-		const result = optimizeBudget([makeMsg()], buildBudget(100, 100, 0));
-		expect(result.kept).toEqual([]);
-		expect(result.compressionRatio).toBe(1);
-	});
-});
-
-describe("calculateCost", () => {
-	it("calculates total cost", () => {
-		const msgs = [makeMsg({ content: "hello world" })];
-		const cost = calculateCost(msgs, 50, "gpt-4o-mini");
-		expect(cost.inputTokens).toBeGreaterThan(0);
-		expect(cost.outputTokens).toBe(50);
-		expect(cost.totalCost).toBeGreaterThan(0);
-		expect(cost.currency).toBe("USD");
-	});
-
-	it("uses default pricing", () => {
-		const cost = calculateCost([], 0, "unknown-model");
-		expect(cost.totalCost).toBe(0);
-	});
-});
-
-describe("trimToTokens", () => {
-	it("trims to max tokens", () => {
-		const text = "one two three four five";
-		const trimmed = trimToTokens(text, 3);
-		expect(trimmed.split(" ").length).toBeLessThanOrEqual(3);
-	});
-
-	it("returns empty for zero", () => {
-		expect(trimToTokens("hello", 0)).toBe("");
-	});
-
-	it("handles text shorter than limit", () => {
-		const result = trimToTokens("hi", 10);
-		expect(result).toBe("hi");
-	});
-});

package/packages/tooling-preference/tests/changed-files.test.ts

@@ -1,124 +0,0 @@
-/**
- * The changed JavaScript/TypeScript files of a workspace.
- *
- * The detection reads the worktree of the session: a file that changed is
- * a file the check may read. A workspace without git yields nothing - the
- * harness never guesses which files belong to the session.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { execFileSync } from "node:child_process";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-	detectChangedJsTsFiles,
-	isIgnoredPath,
-	isJsTsFile,
-	parseGitStatus,
-} from "../src/changed-files.js";
-
-let root = "";
-
-function git(...args: string[]): void {
-	execFileSync("git", args, { cwd: root, stdio: "ignore" });
-}
-
-beforeEach(() => {
-	root = mkdtempSync(join(tmpdir(), "tooling-changed-"));
-	git("init", "-q");
-	git("config", "user.email", "test@example.com");
-	git("config", "user.name", "Test");
-});
-
-afterEach(() => {
-	rmSync(root, { recursive: true, force: true });
-});
-
-describe("the changed file detection", () => {
-	it("finds the JavaScript and TypeScript files of the worktree", () => {
-		mkdirSync(join(root, "src"), { recursive: true });
-		writeFileSync(join(root, "src", "app.ts"), "export const a = 1;\n");
-		writeFileSync(join(root, "src", "app.tsx"), "export const B = 1;\n");
-		writeFileSync(join(root, "src", "notes.md"), "# notes\n");
-		writeFileSync(join(root, "src", "styles.css"), "body {}\n");
-
-		const result = detectChangedJsTsFiles(root);
-
-		expect(result.detected).toBe(true);
-		expect(result.files).toEqual(["src/app.ts", "src/app.tsx"]);
-	});
-
-	it("finds the files that were changed after the commit", () => {
-		writeFileSync(join(root, "a.ts"), "export const a = 1;\n");
-		git("add", ".");
-		git("commit", "-q", "-m", "first");
-		writeFileSync(join(root, "a.ts"), "export const a = 2;\n");
-
-		const result = detectChangedJsTsFiles(root);
-
-		expect(result.files).toEqual(["a.ts"]);
-	});
-
-	it("finds a file that was renamed", () => {
-		writeFileSync(join(root, "old.ts"), "export const a = 1;\n");
-		git("add", ".");
-		git("commit", "-q", "-m", "first");
-		git("mv", "old.ts", "new.ts");
-
-		const result = detectChangedJsTsFiles(root);
-
-		expect(result.files).toEqual(["new.ts"]);
-	});
-
-	it("ignores the files of a build directory", () => {
-		mkdirSync(join(root, "dist"), { recursive: true });
-		writeFileSync(join(root, "dist", "bundle.js"), "// built\n");
-
-		const result = detectChangedJsTsFiles(root);
-
-		expect(result.files).toEqual([]);
-	});
-
-	it("yields nothing in a workspace that is not a repository", () => {
-		const plain = mkdtempSync(join(tmpdir(), "tooling-plain-"));
-		try {
-			writeFileSync(join(plain, "app.ts"), "export const a = 1;\n");
-
-			const result = detectChangedJsTsFiles(plain);
-
-			expect(result.detected).toBe(false);
-			expect(result.files).toEqual([]);
-		} finally {
-			rmSync(plain, { recursive: true, force: true });
-		}
-	});
-});
-
-describe("the git status parser", () => {
-	it("reads the path of every record", () => {
-		const output = " M src/app.ts\0?? src/new.ts\0";
-		expect(parseGitStatus(output)).toEqual(["src/app.ts", "src/new.ts"]);
-	});
-
-	it("skips the original path of a rename", () => {
-		const output = "R  src/new.ts\0src/old.ts\0";
-		expect(parseGitStatus(output)).toEqual(["src/new.ts"]);
-	});
-});
-
-describe("the file filters", () => {
-	it("knows the JavaScript and TypeScript extensions", () => {
-		expect(isJsTsFile("src/app.ts")).toBe(true);
-		expect(isJsTsFile("src/app.tsx")).toBe(true);
-		expect(isJsTsFile("src/app.mjs")).toBe(true);
-		expect(isJsTsFile("src/app.json")).toBe(false);
-		expect(isJsTsFile("README.md")).toBe(false);
-	});
-
-	it("knows the directories that hold no source", () => {
-		expect(isIgnoredPath("node_modules/pkg/index.js")).toBe(true);
-		expect(isIgnoredPath("dist/bundle.js")).toBe(true);
-		expect(isIgnoredPath("src/app.ts")).toBe(false);
-	});
-});

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

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

@@ -1,107 +0,0 @@
-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");
-	});
-});