oh-my-opencode 5.1.42 → 5.1.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "5.1.42",
+  "version": "5.1.43",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -238,18 +238,18 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "5.1.42",
-    "oh-my-opencode-darwin-x64": "5.1.42",
-    "oh-my-opencode-darwin-x64-baseline": "5.1.42",
-    "oh-my-opencode-linux-arm64": "5.1.42",
-    "oh-my-opencode-linux-arm64-musl": "5.1.42",
-    "oh-my-opencode-linux-x64": "5.1.42",
-    "oh-my-opencode-linux-x64-baseline": "5.1.42",
-    "oh-my-opencode-linux-x64-musl": "5.1.42",
-    "oh-my-opencode-linux-x64-musl-baseline": "5.1.42",
-    "oh-my-opencode-windows-arm64": "5.1.42",
-    "oh-my-opencode-windows-x64": "5.1.42",
-    "oh-my-opencode-windows-x64-baseline": "5.1.42"
+    "oh-my-opencode-darwin-arm64": "5.1.43",
+    "oh-my-opencode-darwin-x64": "5.1.43",
+    "oh-my-opencode-darwin-x64-baseline": "5.1.43",
+    "oh-my-opencode-linux-arm64": "5.1.43",
+    "oh-my-opencode-linux-arm64-musl": "5.1.43",
+    "oh-my-opencode-linux-x64": "5.1.43",
+    "oh-my-opencode-linux-x64-baseline": "5.1.43",
+    "oh-my-opencode-linux-x64-musl": "5.1.43",
+    "oh-my-opencode-linux-x64-musl-baseline": "5.1.43",
+    "oh-my-opencode-windows-arm64": "5.1.43",
+    "oh-my-opencode-windows-x64": "5.1.43",
+    "oh-my-opencode-windows-x64-baseline": "5.1.43"
   },
   "overrides": {
     "hono": "^4.13.8",

package/packages/lsp-core/src/lsp/bun-command-output.ts

@@ -0,0 +1,82 @@
+import { resolve } from "node:path";
+import type { Diagnostic } from "./types.js";
+
+export interface FileDiagnostic {
+	readonly file: string;
+	readonly diagnostic: Diagnostic;
+}
+
+const TSC_LINE = /^(.+?)\((\d+),(\d+)\): (error|warning|message) (TS\d+): (.*)$/;
+const TSC_SEVERITY: Record<string, number> = { error: 1, warning: 2, message: 3 };
+
+export function parseBunCheckOutput(stdout: string, cwd: string): FileDiagnostic[] {
+	const results: Array<{ file: string; diagnostic: Diagnostic }> = [];
+	for (const line of stdout.split(/\r?\n/)) {
+		const match = TSC_LINE.exec(line);
+		if (match) {
+			const [, path, lineNumber, column, severity, code, message] = match;
+			const start = { line: Number(lineNumber) - 1, character: Number(column) - 1 };
+			results.push({
+				file: resolve(cwd, path ?? ""),
+				diagnostic: {
+					range: { start, end: start },
+					severity: TSC_SEVERITY[severity ?? "error"] ?? 1,
+					code: code ?? "",
+					source: "bun check",
+					message: message ?? "",
+				},
+			});
+			continue;
+		}
+		const previous = results[results.length - 1];
+		if (previous !== undefined && /^\s+\S/.test(line)) {
+			previous.diagnostic.message = `${previous.diagnostic.message}\n${line.trim()}`;
+		}
+	}
+	return results;
+}
+
+interface EslintJsonMessage {
+	readonly ruleId?: string | null;
+	readonly severity?: number;
+	readonly message?: string;
+	readonly line?: number;
+	readonly column?: number;
+	readonly endLine?: number;
+	readonly endColumn?: number;
+}
+
+export function parseBunLintJson(stdout: string): FileDiagnostic[] | undefined {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(stdout);
+	} catch {
+		return undefined;
+	}
+	if (!Array.isArray(parsed)) return undefined;
+	const results: FileDiagnostic[] = [];
+	for (const entry of parsed) {
+		if (entry === null || typeof entry !== "object") continue;
+		const filePath = (entry as { filePath?: unknown }).filePath;
+		const messages = (entry as { messages?: unknown }).messages;
+		if (typeof filePath !== "string" || !Array.isArray(messages)) continue;
+		for (const raw of messages as EslintJsonMessage[]) {
+			const start = { line: Math.max(0, (raw.line ?? 1) - 1), character: Math.max(0, (raw.column ?? 1) - 1) };
+			const end = {
+				line: raw.endLine === undefined ? start.line : Math.max(0, raw.endLine - 1),
+				character: raw.endColumn === undefined ? start.character : Math.max(0, raw.endColumn - 1),
+			};
+			results.push({
+				file: filePath,
+				diagnostic: {
+					range: { start, end },
+					severity: raw.severity === 2 ? 1 : 2,
+					...(raw.ruleId ? { code: raw.ruleId } : {}),
+					source: "bun lint",
+					message: raw.message ?? "",
+				},
+			});
+		}
+	}
+	return results;
+}

package/packages/lsp-core/src/lsp/bun-project-checks.test.ts

@@ -0,0 +1,170 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { parseBunCheckOutput, parseBunLintJson } from "./bun-command-output.js";
+import {
+	__resetBunCommandProbeCacheForTests,
+	bunHasCommand,
+	findBunProjectRoot,
+	projectShadowsBunCommand,
+	resolveBunProjectCommand,
+} from "./bun-project-checks.js";
+import { createFakeBun, createProject, removeFakeBunFixtures } from "./fake-bun-test-support.js";
+
+afterEach(() => {
+	__resetBunCommandProbeCacheForTests();
+	removeFakeBunFixtures();
+});
+
+describe("findBunProjectRoot", () => {
+	it("#given a bun.lock, a bunfig.toml or a bun packageManager #when looked up from a nested directory #then that project root is found", () => {
+		for (const marker of [{ "bun.lock": "" }, { "bunfig.toml": "" }, { "package.json": '{"packageManager":"bun@1.4.3"}' }]) {
+			const root = createProject({ ...marker, "src/deep/a.ts": "" });
+			expect(findBunProjectRoot(join(root, "src", "deep"))).toBe(root);
+		}
+	});
+
+	it("#given an npm project inside a repository #when looked up #then the walk stops at the repository boundary", () => {
+		const root = createProject({ "package.json": '{"packageManager":"npm@11.0.0"}', "package-lock.json": "{}", "src/a.ts": "" });
+		expect(findBunProjectRoot(join(root, "src"))).toBeUndefined();
+	});
+
+	it("#given a bunfig.toml in the home directory and no repository #when looked up below home #then it is not a Bun project", () => {
+		const home = createProject({ "bunfig.toml": "", "work/src/a.ts": "" }, { git: false });
+		expect(findBunProjectRoot(join(home, "work", "src"), home)).toBeUndefined();
+	});
+});
+
+describe("projectShadowsBunCommand", () => {
+	it("#given a package.json script named like the command #when checked #then the built-in command is shadowed", () => {
+		const root = createProject({ "bun.lock": "", "package.json": '{"scripts":{"check":"tsc","lint":"eslint ."}}' });
+		expect(projectShadowsBunCommand("check", root)).toBe(true);
+		expect(projectShadowsBunCommand("lint", root)).toBe(true);
+		expect(projectShadowsBunCommand("format", root)).toBe(false);
+	});
+
+	it("#given a lint.ts file #when checked #then lint is shadowed but check is not", () => {
+		const root = createProject({ "bun.lock": "", "lint.ts": "", "check.ts": "" });
+		expect(projectShadowsBunCommand("lint", root)).toBe(true);
+		expect(projectShadowsBunCommand("check", root)).toBe(false);
+	});
+
+	it("#given a plain lint/ or format/ folder #when checked #then it does not shadow, but one with an index file does", () => {
+		const plain = createProject({ "bun.lock": "", "lint/rules.md": "", "format/notes.txt": "" });
+		expect(projectShadowsBunCommand("lint", plain)).toBe(false);
+		expect(projectShadowsBunCommand("format", plain)).toBe(false);
+		const runnable = createProject({ "bun.lock": "", "lint/index.ts": "" });
+		expect(projectShadowsBunCommand("lint", runnable)).toBe(true);
+	});
+});
+
+describe("bunHasCommand", () => {
+	it("#given a bun without lint #when probed #then only the commands whose --help exits 0 are available", async () => {
+		const bun = createFakeBun({ commands: ["check"] });
+		expect(await bunHasCommand(bun.path, "check")).toBe(true);
+		expect(await bunHasCommand(bun.path, "lint")).toBe(false);
+		expect(await bunHasCommand(bun.path, "format")).toBe(false);
+	});
+
+	it("#given concurrent and repeated probes #when probed #then each command runs --help once, in an empty directory", async () => {
+		const bun = createFakeBun({ commands: ["check", "lint"] });
+		await Promise.all([bunHasCommand(bun.path, "lint"), bunHasCommand(bun.path, "lint")]);
+		await bunHasCommand(bun.path, "lint");
+		const calls = bun.calls();
+		expect(calls.map((call) => call.args)).toEqual([["lint", "--help"]]);
+		expect(calls[0]?.cwdEntries).toEqual([]);
+	});
+
+	it("#given a bun whose format answers --help #when its format --write leaves the file unchanged #then format counts as unavailable", async () => {
+		const silent = createFakeBun({ commands: ["check", "format"], formatWrites: false });
+		const writing = createFakeBun({ commands: ["check", "format"], formatWrites: true });
+		expect(await bunHasCommand(silent.path, "format")).toBe(false);
+		expect(await bunHasCommand(writing.path, "format")).toBe(true);
+		expect(writing.calls().map((call) => call.args)).toEqual([
+			["format", "--help"],
+			["format", "--write", "probe.ts"],
+		]);
+	});
+
+	it("#given a probe that times out #when probed again #then the timeout is not cached as absent and the retry answers", async () => {
+		const release = join(createProject({}), "release");
+		const bun = createFakeBun({ commands: ["check", "lint"], hangHelpUntil: release });
+		expect(await bunHasCommand(bun.path, "lint", 500)).toBe(false);
+		writeFileSync(release, "");
+		expect(await bunHasCommand(bun.path, "lint")).toBe(true);
+	}, 30_000);
+
+	it("#given a bun wrapper that starts bun as a child #when the probe times out #then the probe settles near its deadline", async () => {
+		const release = join(createProject({}), "release");
+		const bun = createFakeBun({ commands: ["check", "lint"], hangHelpUntil: release, wrapperForks: true });
+		const started = performance.now();
+		expect(await bunHasCommand(bun.path, "lint", 500)).toBe(false);
+		expect(performance.now() - started).toBeLessThan(5_000);
+		writeFileSync(release, "");
+	}, 30_000);
+
+	it("#given the bun binary is replaced in place #when probed again #then the new binary is probed", async () => {
+		const bun = createFakeBun({ commands: ["check"] });
+		expect(await bunHasCommand(bun.path, "lint")).toBe(false);
+		bun.upgrade({ commands: ["check", "lint"] });
+		expect(await bunHasCommand(bun.path, "lint")).toBe(true);
+	});
+});
+
+describe("resolveBunProjectCommand", () => {
+	it("#given a non-Bun project #when resolved #then bun is never looked up", async () => {
+		const root = createProject({ "package.json": "{}", "src/a.ts": "" });
+		let lookups = 0;
+		expect(await resolveBunProjectCommand("check", root, { resolveBun: () => (lookups++, "/unused/bun") })).toBeUndefined();
+		expect(lookups).toBe(0);
+	});
+
+	it("#given a Bun project and a bun with check #when resolved #then that bun is returned", async () => {
+		const root = createProject({ "bun.lock": "" });
+		const bun = createFakeBun({ commands: ["check"] });
+		expect(await resolveBunProjectCommand("check", root, { resolveBun: () => bun.path })).toBe(bun.path);
+		expect(await resolveBunProjectCommand("lint", root, { resolveBun: () => bun.path })).toBeUndefined();
+	});
+});
+
+describe("bun command output", () => {
+	it("#given tsc-style bun check output #when parsed #then diagnostics carry file, 0-based position, code and continuation lines", () => {
+		const cwd = createProject({});
+		const parsed = parseBunCheckOutput(
+			"src/x.ts(3,7): error TS2322: Type 'string' is not assignable to type 'number'.\n  The expected type comes from here.\n",
+			cwd,
+		);
+		expect(parsed).toEqual([
+			{
+				file: join(cwd, "src", "x.ts"),
+				diagnostic: {
+					range: { start: { line: 2, character: 6 }, end: { line: 2, character: 6 } },
+					severity: 1,
+					code: "TS2322",
+					source: "bun check",
+					message: "Type 'string' is not assignable to type 'number'.\nThe expected type comes from here.",
+				},
+			},
+		]);
+	});
+
+	it("#given ESLint JSON from bun lint #when parsed #then errors and warnings map to LSP severities", () => {
+		const parsed = parseBunLintJson(
+			JSON.stringify([
+				{
+					filePath: "/p/a.ts",
+					messages: [
+						{ ruleId: "prefer-const", severity: 2, message: "Use const", line: 3, column: 7, endLine: 3, endColumn: 12 },
+						{ ruleId: null, severity: 1, message: "Unused directive", line: 1, column: 1 },
+					],
+				},
+			]),
+		);
+		expect(parsed?.map(({ file, diagnostic }) => [file, diagnostic.severity, diagnostic.code, diagnostic.range.start])).toEqual([
+			["/p/a.ts", 1, "prefer-const", { line: 2, character: 6 }],
+			["/p/a.ts", 2, undefined, { line: 0, character: 0 }],
+		]);
+		expect(parseBunLintJson("not json")).toBeUndefined();
+	});
+});

package/packages/lsp-core/src/lsp/bun-project-checks.ts

@@ -0,0 +1,223 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { createSpawnCommand, killProcessTree } from "./process.js";
+import { resolveServerBinary } from "./server-installation.js";
+
+export type BunProjectCommand = "check" | "lint" | "format";
+
+export interface BunProjectChecksOptions {
+	readonly resolveBun?: (cwd: string) => string | null;
+	readonly homeDir?: string;
+}
+
+export interface BunCommandRun {
+	readonly exitCode: number | null;
+	readonly stdout: string;
+	readonly stderr: string;
+}
+
+const BUN_LOCKFILES = ["bun.lock", "bun.lockb", "bunfig.toml"];
+const RUNNABLE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".cts", ".cjs", ".js", ".mjs", ".mts"];
+const BIN_SUFFIXES = process.platform === "win32" ? [".exe", ".bunx", ".cmd", ""] : [""];
+const PROBE_TIMEOUT_MS = 10_000;
+const UNFORMATTED_PROBE = "const a=1\n";
+
+const probeCache = new Map<string, Promise<boolean>>();
+
+export function __resetBunCommandProbeCacheForTests(): void {
+	probeCache.clear();
+}
+
+// The walk stops at the repository boundary, and never reads the home directory or anything above
+// it, so a stray file there does not turn every directory outside a repository into a Bun project.
+export function findBunProjectRoot(start: string, home: string = homedir()): string | undefined {
+	const stopAt = resolve(home);
+	let dir = resolve(start);
+	for (;;) {
+		if (dir === stopAt) return undefined;
+		if (BUN_LOCKFILES.some((name) => existsSync(join(dir, name)))) return dir;
+		if (packageManagerIsBun(join(dir, "package.json"))) return dir;
+		if (existsSync(join(dir, ".git"))) return undefined;
+		const parent = dirname(dir);
+		if (parent === dir) return undefined;
+		dir = parent;
+	}
+}
+
+function packageManagerIsBun(packageJsonPath: string): boolean {
+	const manifest = readJsonObject(packageJsonPath);
+	const packageManager = manifest?.["packageManager"];
+	return typeof packageManager === "string" && packageManager.startsWith("bun@");
+}
+
+function readJsonObject(path: string): Record<string, unknown> | undefined {
+	if (!existsSync(path)) return undefined;
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+		return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
+			? (parsed as Record<string, unknown>)
+			: undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function isFile(path: string): boolean {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+
+function isDirectory(path: string): boolean {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+// Bun still runs a project's own script (nearest package.json) named check/lint/format, and for
+// lint/format also what `bun <name>` would run as a file: `name` or `name.<ext>`, a `name/` directory
+// with a package.json or an index file, or an executable a package installed in node_modules/.bin.
+export function projectShadowsBunCommand(command: BunProjectCommand, cwd: string): boolean {
+	const packageJsonDir = nearestPackageJsonDir(cwd);
+	if (packageJsonDir !== undefined) {
+		const scripts = readJsonObject(join(packageJsonDir, "package.json"))?.["scripts"];
+		if (scripts !== null && typeof scripts === "object" && typeof (scripts as Record<string, unknown>)[command] === "string") {
+			return true;
+		}
+	}
+	if (command === "check") return false;
+	const base = join(cwd, command);
+	if (isFile(base) || RUNNABLE_EXTENSIONS.some((extension) => isFile(`${base}${extension}`))) return true;
+	if (isDirectory(base) && (isFile(join(base, "package.json")) || RUNNABLE_EXTENSIONS.some((extension) => isFile(join(base, `index${extension}`))))) {
+		return true;
+	}
+	let dir = resolve(cwd);
+	for (;;) {
+		if (BIN_SUFFIXES.some((suffix) => existsSync(join(dir, "node_modules", ".bin", `${command}${suffix}`)))) return true;
+		const parent = dirname(dir);
+		if (parent === dir) return false;
+		dir = parent;
+	}
+}
+
+function nearestPackageJsonDir(start: string): string | undefined {
+	let dir = resolve(start);
+	for (;;) {
+		if (existsSync(join(dir, "package.json"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return undefined;
+		dir = parent;
+	}
+}
+
+function binaryIdentity(bunPath: string): string {
+	try {
+		const stats = statSync(bunPath);
+		return `${stats.mtimeMs}:${stats.size}`;
+	} catch {
+		return "missing";
+	}
+}
+
+// Feature detection by exit code, in an empty directory: next to a same-named project script an
+// older Bun runs that script for `--help` and exits 0. Asynchronous, so a probe never blocks the
+// event loop; cached per binary and command, and re-probed when the binary file changes. Only a
+// definite answer is kept: a probe that timed out or could not spawn is retried on the next call.
+export function bunHasCommand(
+	bunPath: string,
+	command: BunProjectCommand,
+	timeoutMs: number = PROBE_TIMEOUT_MS,
+): Promise<boolean> {
+	const key = `${bunPath}\0${binaryIdentity(bunPath)}\0${command}`;
+	const cached = probeCache.get(key);
+	if (cached !== undefined) return cached;
+	const probe = probeOnce(bunPath, command, timeoutMs).then((answer) => {
+		if (answer === undefined) probeCache.delete(key);
+		return answer === true;
+	});
+	probeCache.set(key, probe);
+	return probe;
+}
+
+// `format` must also prove it rewrites a file in place: a bun whose `format --write` printed to stdout
+// instead, or ignored the flag, would leave every file unchanged and silently stop formatting.
+async function probeOnce(bunPath: string, command: BunProjectCommand, timeoutMs: number): Promise<boolean | undefined> {
+	const emptyDir = mkdtempSync(join(tmpdir(), "omo-bun-probe-"));
+	const timeout = AbortSignal.timeout(timeoutMs);
+	try {
+		const help = await runBunCommand(bunPath, [command, "--help"], emptyDir, timeout);
+		if (help.exitCode === null) return undefined;
+		if (help.exitCode !== 0) return false;
+		if (command !== "format") return true;
+		const probeFile = join(emptyDir, "probe.ts");
+		writeFileSync(probeFile, UNFORMATTED_PROBE);
+		const write = await runBunCommand(bunPath, ["format", "--write", "probe.ts"], emptyDir, timeout);
+		if (write.exitCode === null) return undefined;
+		return write.exitCode === 0 && readFileSync(probeFile, "utf8") !== UNFORMATTED_PROBE;
+	} catch {
+		return undefined;
+	} finally {
+		rmSync(emptyDir, { recursive: true, force: true });
+	}
+}
+
+export async function resolveBunProjectCommand(
+	command: BunProjectCommand,
+	cwd: string,
+	options: BunProjectChecksOptions = {},
+): Promise<string | undefined> {
+	if (findBunProjectRoot(cwd, options.homeDir) === undefined) return undefined;
+	if (projectShadowsBunCommand(command, cwd)) return undefined;
+	const bunPath = (options.resolveBun ?? defaultResolveBun)(cwd);
+	if (!bunPath) return undefined;
+	return (await bunHasCommand(bunPath, command)) ? bunPath : undefined;
+}
+
+function defaultResolveBun(cwd: string): string | null {
+	return resolveServerBinary(["bun"], cwd);
+}
+
+export function runBunCommand(bunPath: string, args: readonly string[], cwd: string, signal?: AbortSignal): Promise<BunCommandRun> {
+	signal?.throwIfAborted();
+	const prepared = createSpawnCommand([bunPath, ...args]);
+	return new Promise((resolvePromise, reject) => {
+		const child = spawn(prepared.command, prepared.args, {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+			shell: prepared.shell,
+			windowsHide: true,
+			detached: process.platform !== "win32",
+		});
+		const stdout: Buffer[] = [];
+		const stderr: Buffer[] = [];
+		// A wrapper (a .cmd shim through cmd.exe on Windows, a non-exec sh script elsewhere) leaves bun holding
+		// the pipes when only the direct child dies, so an aborted probe would outlive its timeout. Kill the
+		// whole tree: taskkill /T on Windows, the process group (hence `detached`) elsewhere.
+		const onAbort = () => killProcessTree(child, "SIGKILL");
+		signal?.addEventListener("abort", onAbort, { once: true });
+		child.stdout?.on("data", (chunk: Buffer) => stdout.push(chunk));
+		child.stderr?.on("data", (chunk: Buffer) => stderr.push(chunk));
+		child.once("error", (error) => {
+			signal?.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+		child.once("close", (exitCode) => {
+			signal?.removeEventListener("abort", onAbort);
+			if (signal?.aborted) {
+				reject(signal.reason);
+				return;
+			}
+			resolvePromise({
+				exitCode,
+				stdout: Buffer.concat(stdout).toString("utf8"),
+				stderr: Buffer.concat(stderr).toString("utf8"),
+			});
+		});
+	});
+}

package/packages/lsp-core/src/lsp/fake-bun-test-support.ts

@@ -0,0 +1,102 @@
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const createdDirs: string[] = [];
+
+function createTempDir(prefix: string): string {
+	const dir = mkdtempSync(join(tmpdir(), prefix));
+	createdDirs.push(dir);
+	return dir;
+}
+
+export function removeFakeBunFixtures(): void {
+	for (const dir of createdDirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+}
+
+export interface FakeBunBehavior {
+	readonly commands: readonly ("check" | "lint" | "format")[];
+	readonly checkStdout?: string;
+	readonly checkExitCode?: number;
+	readonly lintStdout?: string;
+	readonly lintExitCode?: number;
+	readonly formatWrites?: boolean;
+	readonly hangHelpUntil?: string;
+	readonly wrapperForks?: boolean;
+}
+
+export interface FakeBunCall {
+	readonly args: readonly string[];
+	readonly cwd: string;
+	readonly cwdEntries: readonly string[];
+}
+
+export interface FakeBun {
+	readonly path: string;
+	calls(): FakeBunCall[];
+	upgrade(behavior: FakeBunBehavior): void;
+}
+
+export function createFakeBun(behavior: FakeBunBehavior): FakeBun {
+	const dir = createTempDir("omo-fake-bun-");
+	const logPath = join(dir, "calls.jsonl");
+	const binDir = join(dir, "bin");
+	mkdirSync(binDir);
+	const path = process.platform === "win32" ? join(binDir, "bun.cmd") : join(binDir, "bun");
+	let version = 0;
+	const install = (next: FakeBunBehavior) => {
+		version += 1;
+		const scriptPath = join(dir, `fake-bun-${version}.mjs`);
+		writeFakeBunScript(scriptPath, logPath, next);
+		if (process.platform === "win32") {
+			writeFileSync(path, `@"${process.execPath}" "${scriptPath}" %*\r\n`);
+		} else {
+			const launch = `"${process.execPath}" "${scriptPath}" "$@"`;
+			writeFileSync(path, next.wrapperForks ? `#!/bin/sh\n${launch}\n` : `#!/bin/sh\nexec ${launch}\n`);
+			chmodSync(path, 0o755);
+		}
+	};
+	install(behavior);
+	return {
+		path,
+		upgrade: install,
+		calls: () =>
+			existsSync(logPath)
+				? readFileSync(logPath, "utf8")
+						.split("\n")
+						.filter((line) => line.length > 0)
+						.map((line): FakeBunCall => JSON.parse(line))
+				: [],
+	};
+}
+
+function writeFakeBunScript(scriptPath: string, logPath: string, behavior: FakeBunBehavior): void {
+	writeFileSync(
+		scriptPath,
+		[
+			'import { appendFileSync, existsSync, readdirSync, writeFileSync } from "node:fs";',
+			`const behavior = ${JSON.stringify(behavior)};`,
+			'if (behavior.hangHelpUntil && process.argv.includes("--help") && !existsSync(behavior.hangHelpUntil)) await new Promise((r) => setTimeout(r, 60_000));',
+			"const args = process.argv.slice(2);",
+			`appendFileSync(${JSON.stringify(logPath)}, JSON.stringify({ args, cwd: process.cwd(), cwdEntries: readdirSync(process.cwd()) }) + "\\n");`,
+			"const [command] = args;",
+			"if (!behavior.commands.includes(command)) process.exit(1);",
+			'if (args.includes("--help")) process.exit(0);',
+			'if (command === "check") { process.stdout.write(behavior.checkStdout ?? ""); process.exit(behavior.checkExitCode ?? 0); }',
+			'if (command === "lint") { process.stdout.write(behavior.lintStdout ?? "[]"); process.exit(behavior.lintExitCode ?? 0); }',
+			'if (command === "format" && behavior.formatWrites && args.includes("--write")) writeFileSync(args[args.length - 1], "const a = 1;\\n");',
+			"process.exit(0);",
+		].join("\n"),
+	);
+}
+
+export function createProject(files: Record<string, string>, options: { readonly git?: boolean } = {}): string {
+	const root = createTempDir("omo-bun-project-");
+	if (options.git !== false) mkdirSync(join(root, ".git"));
+	for (const [relativePath, content] of Object.entries(files)) {
+		const target = join(root, relativePath);
+		mkdirSync(join(target, ".."), { recursive: true });
+		writeFileSync(target, content);
+	}
+	return root;
+}

package/packages/lsp-core/src/lsp/process.ts

@@ -102,7 +102,7 @@ function wrap(proc: ChildProcess): SpawnedProcess {
 	};
 }
 
-function killProcessTree(proc: ChildProcess, signal: NodeJS.Signals): void {
+export function killProcessTree(proc: ChildProcess, signal: NodeJS.Signals): void {
 	if (process.platform === "win32" && proc.pid) {
 		const result = spawnSync("taskkill", ["/pid", String(proc.pid), "/f", "/t"], {
 			stdio: "ignore",

package/packages/lsp-core/src/tool-surface.test.ts

@@ -14,7 +14,8 @@ const expectedToolSurface = [
 	{
 		name: "diagnostics",
 		title: "LSP Diagnostics",
-		description: "Get errors, warnings, and hints for a source file or directory.",
+		description:
+			"Get errors, warnings, and hints for a source file or directory. In a Bun project, a TypeScript directory is typechecked with `bun check`, plus `bun lint` when the installed Bun has it.",
 		inputSchema: {
 			type: "object",
 			properties: {