lazycodex-ai 5.1.48 → 5.1.54

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

@@ -0,0 +1,156 @@
+import { executeLspDiagnostics } from "./diagnostics.js";
+import { executeLspFormat } from "./format.js";
+import { executeLspInstallDecision } from "./install-decision.js";
+import { executeLspFindReferences, executeLspGotoDefinition } from "./navigation.js";
+import { executeLspPrepareRename, executeLspRename } from "./rename.js";
+import { objectSchema } from "./schema.js";
+import { executeLspStatus } from "./status.js";
+import { executeLspSymbols } from "./symbols.js";
+import type { LspMcpTool } from "./types.js";
+
+export const LSP_MCP_TOOLS: LspMcpTool[] = [
+	{
+		name: "status",
+		aliases: ["lsp_status"],
+		title: "LSP Status",
+		description: "List configured and active LSP servers without starting a new language server.",
+		inputSchema: objectSchema({}),
+		execute: executeLspStatus,
+	},
+	{
+		name: "diagnostics",
+		aliases: ["lsp_diagnostics"],
+		title: "LSP Diagnostics",
+		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." },
+				severity: {
+					type: "string",
+					enum: ["error", "warning", "information", "hint", "all"],
+					description: "Severity filter. Defaults to all.",
+				},
+			},
+			["filePath"],
+		),
+		execute: executeLspDiagnostics,
+	},
+	{
+		name: "goto_definition",
+		aliases: ["lsp_goto_definition"],
+		title: "LSP Goto Definition",
+		description: "Find where a symbol is defined.",
+		inputSchema: objectSchema(
+			{
+				filePath: { type: "string", description: "Source file containing the symbol." },
+				line: { type: "number", description: "1-based line number." },
+				character: { type: "number", description: "0-based column." },
+			},
+			["filePath", "line", "character"],
+		),
+		execute: executeLspGotoDefinition,
+	},
+	{
+		name: "find_references",
+		aliases: ["lsp_find_references"],
+		title: "LSP Find References",
+		description: "Find references of a symbol across the workspace.",
+		inputSchema: objectSchema(
+			{
+				filePath: { type: "string", description: "Source file containing the symbol." },
+				line: { type: "number", description: "1-based line number." },
+				character: { type: "number", description: "0-based column." },
+				includeDeclaration: { type: "boolean", description: "Include the declaration. Defaults to true." },
+			},
+			["filePath", "line", "character"],
+		),
+		execute: executeLspFindReferences,
+	},
+	{
+		name: "symbols",
+		aliases: ["lsp_symbols"],
+		title: "LSP Symbols",
+		description: "List document symbols or search workspace symbols.",
+		inputSchema: objectSchema(
+			{
+				filePath: { type: "string", description: "File path used as LSP context." },
+				scope: {
+					type: "string",
+					enum: ["document", "workspace"],
+					description: "Use document for file outline or workspace for project-wide search.",
+				},
+				query: { type: "string", description: "Workspace symbol query." },
+				limit: { type: "number", description: "Maximum number of symbols to return." },
+			},
+			["filePath", "scope"],
+		),
+		execute: executeLspSymbols,
+	},
+	{
+		name: "prepare_rename",
+		aliases: ["lsp_prepare_rename"],
+		title: "LSP Prepare Rename",
+		description: "Check whether a symbol can be renamed at a position.",
+		inputSchema: objectSchema(
+			{
+				filePath: { type: "string", description: "Source file path." },
+				line: { type: "number", description: "1-based line number." },
+				character: { type: "number", description: "0-based column." },
+			},
+			["filePath", "line", "character"],
+		),
+		execute: executeLspPrepareRename,
+	},
+	{
+		name: "rename",
+		aliases: ["lsp_rename"],
+		title: "LSP Rename",
+		description: "Rename a symbol across the workspace and apply the returned workspace edit.",
+		inputSchema: objectSchema(
+			{
+				filePath: { type: "string", description: "Source file path." },
+				line: { type: "number", description: "1-based line number." },
+				character: { type: "number", description: "0-based column." },
+				newName: { type: "string", description: "New symbol name." },
+			},
+			["filePath", "line", "character", "newName"],
+		),
+		execute: executeLspRename,
+	},
+	{
+		name: "format",
+		aliases: ["lsp_format"],
+		title: "LSP Format",
+		description: "Format a source file with its language server and write the returned edits to disk.",
+		inputSchema: objectSchema(
+			{
+				filePath: { type: "string", description: "Source file path to format." },
+			},
+			["filePath"],
+		),
+		execute: executeLspFormat,
+	},
+	{
+		name: "install_decision",
+		aliases: ["lsp_install_decision"],
+		title: "LSP Install Decision",
+		description:
+			"Record whether the user allowed or declined installing a missing LSP server. Record 'declined' when the user declines, or has not explicitly asked for LSP installation, to silence future prompts.",
+		inputSchema: objectSchema(
+			{
+				server_id: {
+					type: "string",
+					description: "The LSP server id from the not-installed message (e.g. 'rust').",
+				},
+				decision: {
+					type: "string",
+					enum: ["declined", "allowed"],
+					description: "'declined' silences future prompts; 'allowed' pre-authorizes installation.",
+				},
+			},
+			["server_id", "decision"],
+		),
+		execute: executeLspInstallDecision,
+	},
+];

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

@@ -0,0 +1,133 @@
+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";
+
+function asDiagnosticArray(result: { items?: Diagnostic[] } | Diagnostic[] | null | undefined): Diagnostic[] {
+	if (!result) return [];
+	if (Array.isArray(result)) return result;
+	return result.items ?? [];
+}
+
+export async function executeLspDiagnostics(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+	bunOptions: BunProjectChecksOptions = {},
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+	const severity = severityFilter(params);
+
+	try {
+		const absPath = resolveReadablePathInsideContext(filePath);
+		if (isDirectoryPath(absPath)) {
+			const extension = inferExtensionFromDirectory(absPath);
+			if (!extension) {
+				const message = `No supported source files found in directory: ${absPath}`;
+				const details: LspDiagnosticsDetails = {
+					filePath,
+					severity,
+					mode: "directory",
+					diagnostics: [],
+					totalDiagnostics: 0,
+					truncated: false,
+					error: message,
+					errorKind: "no_files",
+				};
+				return text(message, details);
+			}
+
+			const bun = await runBunDirectoryDiagnostics(absPath, extension, severity, signal, bunOptions);
+			if (bun !== undefined) {
+				const details: LspDiagnosticsDetails = {
+					filePath,
+					severity,
+					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,
+				mode: "directory",
+				diagnostics: [],
+				totalDiagnostics: output.totalDiagnostics,
+				truncated: false,
+				fileFailures: [...output.fileFailures],
+			};
+			return text(output.output, details);
+		}
+
+		const result = await withLspClient(
+				filePath,
+				async (client, _workspaceRoot, resolvedFilePath) => client.diagnostics(resolvedFilePath, signal),
+				"diagnostics",
+				clientOptions(signal),
+			);
+		if (result.transientError) {
+			const message = result.transientError.message;
+			const details: LspDiagnosticsDetails = {
+				filePath,
+				severity,
+				mode: "file",
+				diagnostics: [],
+				totalDiagnostics: 0,
+				truncated: false,
+				error: message,
+				errorKind: result.transientError.kind,
+			};
+			return text(message, details, true);
+		}
+
+		const diagnostics = filterDiagnosticsBySeverity(asDiagnosticArray(result), severity);
+		const total = diagnostics.length;
+		const truncated = total > DEFAULT_MAX_DIAGNOSTICS;
+		const limited = truncated ? diagnostics.slice(0, DEFAULT_MAX_DIAGNOSTICS) : diagnostics;
+		const output =
+			total === 0
+				? "No diagnostics found"
+				: [
+						...(truncated ? [`Found ${total} diagnostics (showing first ${DEFAULT_MAX_DIAGNOSTICS}):`] : []),
+						...limited.map(formatDiagnostic),
+					].join("\n");
+		const details: LspDiagnosticsDetails = {
+			filePath,
+			severity,
+			mode: "file",
+			diagnostics: diagnostics.map((diagnostic) => ({ file: absPath, diagnostic })),
+			totalDiagnostics: total,
+			truncated,
+		};
+		return text(output, details);
+	} catch (error) {
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			severity,
+			mode: "file",
+			diagnostics: [],
+			totalDiagnostics: 0,
+			truncated: false,
+		} satisfies Omit<LspDiagnosticsDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}

package/packages/lsp-core/src/tools/format.test.ts

@@ -0,0 +1,56 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { parseLspRequestContext, runWithRequestContext } from "../request-context.js";
+import { executeLspFormat } from "./format.js";
+import type { LspFormatDetails } from "./types.js";
+
+const workspaces: string[] = [];
+
+afterEach(() => {
+	for (const workspace of workspaces.splice(0)) rmSync(workspace, { recursive: true, force: true });
+});
+
+function workspaceWith(fileName: string, content: string): { readonly root: string; readonly filePath: string } {
+	const root = mkdtempSync(join(tmpdir(), "lsp-format-tool-"));
+	workspaces.push(root);
+	const filePath = join(root, fileName);
+	writeFileSync(filePath, content, "utf-8");
+	return { root, filePath };
+}
+
+function contextFor(root: string) {
+	return parseLspRequestContext({
+		cwd: root,
+		projectConfigPaths: [join(root, "lsp.json")],
+		userConfigPath: join(root, "user-lsp.json"),
+		installDecisionsPath: join(root, "install-decisions.json"),
+		capabilities: { installDecisionTool: false },
+	});
+}
+
+describe("executeLspFormat", () => {
+	it("#given an extension with no configured server #when format runs #then the missing dependency result is returned and the file is untouched", async () => {
+		// given
+		const original = "value\n";
+		const { root, filePath } = workspaceWith("module.wat", original);
+
+		// when
+		const result = await runWithRequestContext(contextFor(root), () => executeLspFormat({ filePath }));
+
+		// then
+		const details = result.details as LspFormatDetails;
+		expect(details.errorKind).toBe("missing_dependency");
+		expect(details.status).toBe("unavailable");
+		expect(result.content[0]?.text).toContain("No LSP server configured for extension: .wat");
+		expect(readFileSync(filePath)).toEqual(Buffer.from(original));
+	});
+
+	it("#given a missing filePath argument #when format runs #then the parameter contract is enforced", async () => {
+		// given / when / then
+		await expect(executeLspFormat({})).rejects.toThrow(/filePath/);
+	});
+});

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

@@ -0,0 +1,56 @@
+import { withLspClient } from "../lsp/client-wrapper.js";
+import { type FormatDocumentResult, formatDocumentWithClient } from "../lsp/format-document.js";
+import { missingDependencyResult } from "../missing-dependency-result.js";
+import { clientOptions, requireString } from "./parameters.js";
+import { text } from "./result.js";
+import type { LspFormatDetails, ToolExecutionResult } from "./types.js";
+
+export async function executeLspFormat(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+
+	try {
+		const result = await withLspClient(
+			filePath,
+			async (client, _workspaceRoot, resolvedFilePath) =>
+				formatDocumentWithClient(client, resolvedFilePath, signal === undefined ? {} : { signal }),
+			"format",
+			clientOptions(signal),
+		);
+		return text(describeResult(filePath, result), formatDetails(filePath, result));
+	} catch (error) {
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			status: "unavailable",
+			reason: "server_unavailable",
+			linesAdded: 0,
+			linesRemoved: 0,
+		} satisfies Omit<LspFormatDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}
+
+function formatDetails(filePath: string, result: FormatDocumentResult): LspFormatDetails {
+	if (result.status === "unavailable") {
+		return { filePath, status: "unavailable", reason: result.reason, linesAdded: 0, linesRemoved: 0 };
+	}
+	return {
+		filePath,
+		status: result.status,
+		linesAdded: result.linesAdded,
+		linesRemoved: result.linesRemoved,
+	};
+}
+
+function describeResult(filePath: string, result: FormatDocumentResult): string {
+	if (result.status === "unavailable") {
+		return `Formatting unavailable for ${filePath}: the language server does not advertise documentFormattingProvider.`;
+	}
+	if (result.status === "unchanged") {
+		return `Already formatted: ${filePath}`;
+	}
+	return `Formatted ${filePath} (+${result.linesAdded}/-${result.linesRemoved} lines)`;
+}

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

@@ -0,0 +1,11 @@
+export { executeLspDiagnostics } from "./diagnostics.js";
+export { LSP_MCP_TOOLS } from "./definitions.js";
+export { executeLspFormat } from "./format.js";
+export { executeLspInstallDecision } from "./install-decision.js";
+export { executeLspFindReferences, executeLspGotoDefinition } from "./navigation.js";
+export { isRecord } from "./parameters.js";
+export { executeLspPrepareRename, executeLspRename } from "./rename.js";
+export { executeLspStatus } from "./status.js";
+export { executeLspSymbols } from "./symbols.js";
+export type * from "./types.js";
+export { coerceToolArguments, executeLspTool } from "./runtime.js";

package/packages/lsp-core/src/tools/install-decision.ts

@@ -0,0 +1,39 @@
+import { getMergedServers } from "../lsp/config-loader.js";
+import { type InstallDecision, isInstallDecision, recordInstallDecision } from "../lsp/server-install-state.js";
+import { requireString } from "./parameters.js";
+import { text } from "./result.js";
+import type { ToolExecutionResult } from "./types.js";
+
+export async function executeLspInstallDecision(params: Record<string, unknown>): Promise<ToolExecutionResult> {
+	const serverId = requireString(params, "server_id");
+	const decision = params["decision"];
+	if (!isInstallDecision(decision)) {
+		return text(
+			`Invalid decision '${String(decision)}'. Expected "declined" or "allowed".`,
+			{ serverId, errorKind: "invalid_decision" },
+			true,
+		);
+	}
+
+	const serverIds = [...new Set(getMergedServers().map((server) => server.id))];
+	if (!serverIds.includes(serverId)) {
+		const preview = serverIds.slice(0, 20).join(", ");
+		return text(
+			`Unknown LSP server '${serverId}'. Known servers: ${preview}${serverIds.length > 20 ? "..." : ""}`,
+			{ serverId, errorKind: "unknown_server" },
+			true,
+		);
+	}
+
+	recordInstallDecision(serverId, decision);
+	return text(`Recorded install decision for '${serverId}': ${decision}. ${decisionFollowUp(decision)}`, {
+		serverId,
+		decision,
+	});
+}
+
+function decisionFollowUp(decision: InstallDecision): string {
+	return decision === "declined"
+		? "Future LSP lookups for this server stay quiet; proceed without LSP."
+		: "Future LSP lookups keep install instructions without asking the user.";
+}