oh-my-opencode 5.1.42 → 5.1.44

package/packages/lsp-core/src/tools/bun-directory-diagnostics.test.ts

@@ -0,0 +1,113 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { join } from "node:path";
+
+import { __resetBunCommandProbeCacheForTests } from "../lsp/bun-project-checks.js";
+import { createFakeBun, createProject, type FakeBun, removeFakeBunFixtures } from "../lsp/fake-bun-test-support.js";
+import { createStandaloneMcpRequestContext, runWithRequestContext } from "../request-context.js";
+import { runBunDirectoryDiagnostics } from "./bun-directory-diagnostics.js";
+import { executeLspDiagnostics } from "./diagnostics.js";
+import type { LspDiagnosticsDetails } from "./types.js";
+
+afterEach(() => {
+	__resetBunCommandProbeCacheForTests();
+	removeFakeBunFixtures();
+});
+
+const CHECK_ERROR = "src/x.ts(1,7): error TS2322: Type 'string' is not assignable to type 'number'.\n";
+const LINT_REPORT = (root: string) =>
+	JSON.stringify([{ filePath: join(root, "src", "x.ts"), messages: [{ ruleId: "prefer-const", severity: 2, message: "Use const", line: 1, column: 1 }] }]);
+
+function diagnose(root: string, bun: FakeBun) {
+	return runWithRequestContext(createStandaloneMcpRequestContext({ cwd: root }), () =>
+		executeLspDiagnostics({ filePath: root, severity: "all" }, undefined, { resolveBun: () => bun.path }),
+	);
+}
+
+function commandsRun(bun: FakeBun): string[] {
+	return bun.calls().map((call) => call.args.join(" "));
+}
+
+describe("lsp_diagnostics on a directory of a Bun project", () => {
+	it("#given a Bun project and a bun with check #when diagnosed #then bun check is the typecheck", async () => {
+		const root = createProject({ "bun.lock": "", "src/x.ts": 'const n: number = "s";\n' });
+		const bun = createFakeBun({ commands: ["check"], checkStdout: CHECK_ERROR, checkExitCode: 1 });
+
+		const result = await diagnose(root, bun);
+		const details = result.details as LspDiagnosticsDetails;
+
+		expect(result.content[0]?.text).toContain("Typecheck: bun check");
+		expect(result.content[0]?.text).toContain(`${join(root, "src", "x.ts")}: error[bun check] (TS2322) at 1:6:`);
+		expect(details.totalDiagnostics).toBe(1);
+		expect(details.projectCommands).toEqual(["bun check"]);
+		expect(commandsRun(bun)).toEqual(["check --help", "check --no-pretty .", "lint --help"]);
+	});
+
+	it("#given a bun without lint #when diagnosed #then lint is neither run nor reported", async () => {
+		const root = createProject({ "bun.lock": "", "src/x.ts": "" });
+		const bun = createFakeBun({ commands: ["check"] });
+
+		const result = await diagnose(root, bun);
+
+		expect(result.content[0]?.text).not.toContain("Lint:");
+		expect(commandsRun(bun)).not.toContain("lint -f json .");
+	});
+
+	it("#given a bun with lint #when diagnosed #then bun lint diagnostics join the typecheck", async () => {
+		const root = createProject({ "bun.lock": "", "src/x.ts": "let a = 1\n" });
+		const bun = createFakeBun({ commands: ["check", "lint"], lintStdout: LINT_REPORT(root), lintExitCode: 1 });
+
+		const result = await diagnose(root, bun);
+		const details = result.details as LspDiagnosticsDetails;
+
+		expect(result.content[0]?.text).toContain("Lint: bun lint");
+		expect(result.content[0]?.text).toContain("error[bun lint] (prefer-const) at 1:0: Use const");
+		expect(details.projectCommands).toEqual(["bun check", "bun lint"]);
+		expect(commandsRun(bun)).toContain("lint -f json .");
+	});
+
+	it("#given a bun lint that cannot lint #when diagnosed #then the typecheck stands and the lint failure is named", async () => {
+		const root = createProject({ "bun.lock": "", "src/x.ts": "" });
+		const bun = createFakeBun({ commands: ["check", "lint"], lintStdout: "", lintExitCode: 2 });
+
+		const result = await diagnose(root, bun);
+
+		expect(result.content[0]?.text).toContain("Typecheck: bun check");
+		expect(result.content[0]?.text).toContain("Lint: bun lint could not lint (exit 2)");
+	});
+});
+
+describe("fallback to the language server path", () => {
+	it("#given a non-Bun project #when the Bun path is consulted #then it declines without running bun", async () => {
+		const root = createProject({ "package.json": "{}", "src/x.ts": "" });
+		const bun = createFakeBun({ commands: ["check", "lint"] });
+
+		expect(await runBunDirectoryDiagnostics(root, ".ts", "all", undefined, { resolveBun: () => bun.path })).toBeUndefined();
+		expect(bun.calls()).toEqual([]);
+	});
+
+	it("#given a project script named check #when the Bun path is consulted #then it declines without running bun check", async () => {
+		const root = createProject({ "bun.lock": "", "package.json": '{"scripts":{"check":"tsc --noEmit"}}', "src/x.ts": "" });
+		const bun = createFakeBun({ commands: ["check"] });
+
+		expect(await runBunDirectoryDiagnostics(root, ".ts", "all", undefined, { resolveBun: () => bun.path })).toBeUndefined();
+		expect(bun.calls()).toEqual([]);
+	});
+
+	it("#given a bun without check, or a bun check that fails to run #when consulted #then it declines", async () => {
+		const root = createProject({ "bun.lock": "", "src/x.ts": "" });
+		const old = createFakeBun({ commands: [] });
+		const broken = createFakeBun({ commands: ["check"], checkStdout: "error: tsconfig.json not found\n", checkExitCode: 1 });
+
+		expect(await runBunDirectoryDiagnostics(root, ".ts", "all", undefined, { resolveBun: () => old.path })).toBeUndefined();
+		expect(await runBunDirectoryDiagnostics(root, ".ts", "all", undefined, { resolveBun: () => broken.path })).toBeUndefined();
+	});
+
+	it("#given a JavaScript directory #when consulted #then the Bun typecheck path is not used", async () => {
+		const root = createProject({ "bun.lock": "", "src/x.js": "" });
+		const bun = createFakeBun({ commands: ["check"] });
+
+		expect(await runBunDirectoryDiagnostics(root, ".js", "all", undefined, { resolveBun: () => bun.path })).toBeUndefined();
+		expect(bun.calls()).toEqual([]);
+	});
+});
+

package/packages/lsp-core/src/tools/bun-directory-diagnostics.ts

@@ -0,0 +1,75 @@
+import { parseBunCheckOutput, parseBunLintJson, type FileDiagnostic } from "../lsp/bun-command-output.js";
+import { type BunProjectChecksOptions, resolveBunProjectCommand, runBunCommand } from "../lsp/bun-project-checks.js";
+import { DEFAULT_MAX_DIAGNOSTICS } from "../lsp/constants.js";
+import { filterDiagnosticsBySeverity, formatDiagnostic } from "../lsp/formatters.js";
+import type { SeverityFilter } from "../lsp/types.js";
+
+const TYPESCRIPT_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".cts"]);
+
+export interface BunDirectoryDiagnostics {
+	readonly output: string;
+	readonly diagnostics: readonly FileDiagnostic[];
+	readonly projectCommands: readonly string[];
+}
+
+export async function runBunDirectoryDiagnostics(
+	absDir: string,
+	extension: string,
+	severity: SeverityFilter | undefined,
+	signal: AbortSignal | undefined,
+	options: BunProjectChecksOptions = {},
+): Promise<BunDirectoryDiagnostics | undefined> {
+	if (!TYPESCRIPT_EXTENSIONS.has(extension)) return undefined;
+	const checkBun = await resolveBunProjectCommand("check", absDir, options);
+	if (checkBun === undefined) return undefined;
+
+	let typecheck: FileDiagnostic[];
+	try {
+		const run = await runBunCommand(checkBun, ["check", "--no-pretty", "."], absDir, signal);
+		typecheck = parseBunCheckOutput(run.stdout, absDir);
+		const failedWithoutDiagnostics = run.exitCode === 1 && typecheck.length === 0;
+		if ((run.exitCode !== 0 && run.exitCode !== 1) || failedWithoutDiagnostics) return undefined;
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		return undefined;
+	}
+
+	const header = [`Directory: ${absDir}`, "Typecheck: bun check (files in this directory and everything they import)"];
+	const projectCommands = ["bun check"];
+	const collected = [...typecheck];
+	const lintBun = await resolveBunProjectCommand("lint", absDir, options);
+	if (lintBun !== undefined) {
+		const lint = await runBunLint(lintBun, absDir, signal);
+		header.push(lint.status);
+		projectCommands.push("bun lint");
+		collected.push(...lint.diagnostics);
+	}
+
+	const diagnostics = collected.filter(({ diagnostic }) => filterDiagnosticsBySeverity([diagnostic], severity).length > 0);
+	const lines = [...header, `Total diagnostics: ${diagnostics.length}`];
+	const shown = diagnostics.slice(0, DEFAULT_MAX_DIAGNOSTICS);
+	if (shown.length > 0) {
+		lines.push("", ...shown.map(({ file, diagnostic }) => `${file}: ${formatDiagnostic(diagnostic)}`));
+		if (diagnostics.length > shown.length) {
+			lines.push("", `... (${diagnostics.length - shown.length} more diagnostics not shown)`);
+		}
+	}
+	return { output: lines.join("\n"), diagnostics, projectCommands };
+}
+
+async function runBunLint(
+	bunPath: string,
+	absDir: string,
+	signal: AbortSignal | undefined,
+): Promise<{ status: string; diagnostics: FileDiagnostic[] }> {
+	try {
+		const run = await runBunCommand(bunPath, ["lint", "-f", "json", "."], absDir, signal);
+		const diagnostics = run.exitCode === 0 || run.exitCode === 1 ? parseBunLintJson(run.stdout) : undefined;
+		if (diagnostics !== undefined) return { status: "Lint: bun lint", diagnostics };
+		const reason = run.stderr.trim().split(/\r?\n/)[0] ?? "";
+		return { status: `Lint: bun lint could not lint (exit ${run.exitCode ?? "signal"})${reason ? `: ${reason}` : ""}`, diagnostics: [] };
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		return { status: `Lint: bun lint could not run: ${error instanceof Error ? error.message : String(error)}`, diagnostics: [] };
+	}
+}

package/packages/lsp-core/src/tools/definitions.ts

@@ -21,7 +21,8 @@ export const LSP_MCP_TOOLS: LspMcpTool[] = [
 		name: "diagnostics",
 		aliases: ["lsp_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: objectSchema(
 			{
 				filePath: { type: "string", description: "File or directory path to check." },

package/packages/lsp-core/src/tools/diagnostics.ts

@@ -1,10 +1,12 @@
 import { isDirectoryPath, resolveReadablePathInsideContext, withLspClient } from "../lsp/client-wrapper.js";
 import { DEFAULT_MAX_DIAGNOSTICS } from "../lsp/constants.js";
+import type { BunProjectChecksOptions } from "../lsp/bun-project-checks.js";
 import { aggregateDiagnosticsForDirectory } from "../lsp/directory-diagnostics.js";
 import { filterDiagnosticsBySeverity, formatDiagnostic } from "../lsp/formatters.js";
 import { inferExtensionFromDirectory } from "../lsp/infer-extension.js";
 import type { Diagnostic } from "../lsp/types.js";
 import { missingDependencyResult } from "../missing-dependency-result.js";
+import { runBunDirectoryDiagnostics } from "./bun-directory-diagnostics.js";
 import { clientOptions, requireString, severityFilter } from "./parameters.js";
 import { text } from "./result.js";
 import type { LspDiagnosticsDetails, ToolExecutionResult } from "./types.js";
@@ -18,6 +20,7 @@ function asDiagnosticArray(result: { items?: Diagnostic[] } | Diagnostic[] | nul
 export async function executeLspDiagnostics(
 	params: Record<string, unknown>,
 	signal?: AbortSignal,
+	bunOptions: BunProjectChecksOptions = {},
 ): Promise<ToolExecutionResult> {
 	const filePath = requireString(params, "filePath");
 	const severity = severityFilter(params);
@@ -41,13 +44,27 @@ export async function executeLspDiagnostics(
 				return text(message, details);
 			}
 
-				const output = await aggregateDiagnosticsForDirectory(
-					absPath,
-					extension,
+			const bun = await runBunDirectoryDiagnostics(absPath, extension, severity, signal, bunOptions);
+			if (bun !== undefined) {
+				const details: LspDiagnosticsDetails = {
+					filePath,
 					severity,
-					undefined,
-					signal === undefined ? {} : { signal },
-				);
+					mode: "directory",
+					diagnostics: [...bun.diagnostics],
+					totalDiagnostics: bun.diagnostics.length,
+					truncated: bun.diagnostics.length > DEFAULT_MAX_DIAGNOSTICS,
+					projectCommands: [...bun.projectCommands],
+				};
+				return text(bun.output, details);
+			}
+
+			const output = await aggregateDiagnosticsForDirectory(
+				absPath,
+				extension,
+				severity,
+				undefined,
+				signal === undefined ? {} : { signal },
+			);
 			const details: LspDiagnosticsDetails = {
 				filePath,
 				severity,

package/packages/lsp-core/src/tools/types.ts

@@ -51,6 +51,7 @@ export interface LspDiagnosticsDetails {
 	error?: string;
 	errorKind?: "freshness_timeout" | "missing_dependency" | "no_files" | "invalid_path";
 	fileFailures?: Array<{ file: string; error: string }>;
+	projectCommands?: string[];
 }
 
 export interface LspGotoDefinitionDetails {