oh-my-opencode 5.0.0-beta.4 → 5.0.0-beta.42

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

@@ -71,6 +71,9 @@ export async function runMcpStdioServer(
 	await runJsonRpcStdioServer({
 		input,
 		output,
+		// Idle stays disabled: hosts of this CLI (legacy opencode configs and
+		// standalone lsp-tools-mcp users) have no evidenced respawn for an exited
+		// stdio server; opencode in particular marks it failed without retry.
 		idleTimeoutMs: 0,
 		parentWatchdog: options.parentWatchdog ?? {},
 		handler: (request) => runWithRequestContext(requestContext, () => handleLspMcpRequest(request)),

package/packages/lsp-core/src/request-context.test.ts

@@ -168,4 +168,33 @@ describe("LspRequestContext", () => {
 			capabilities: { installDecisionTool: true },
 		});
 	});
+
+	it("#given an injected LSP cwd #when standalone context is created #then it wins over process cwd without reading global env", () => {
+		const sessionRoot = tempRoot("lsp-context-session-");
+		const processRoot = tempRoot("lsp-context-process-");
+		const home = tempRoot("lsp-context-env-home-");
+
+		const context = createStandaloneMcpRequestContext({
+			env: {
+				LSP_TOOLS_MCP_CWD: sessionRoot,
+			},
+			homeDir: home,
+		});
+
+		expect(context.cwd).toBe(sessionRoot);
+		expect(context.projectConfigPaths).toEqual([join(sessionRoot, ".codex", "lsp-client.json")]);
+		expect(processRoot).not.toBe(context.cwd);
+	});
+
+	it("#given explicit cwd and an injected LSP cwd #when standalone context is created #then explicit cwd wins", () => {
+		const explicitRoot = tempRoot("lsp-context-explicit-");
+		const injectedRoot = tempRoot("lsp-context-injected-");
+
+		const context = createStandaloneMcpRequestContext({
+			cwd: explicitRoot,
+			env: { LSP_TOOLS_MCP_CWD: injectedRoot },
+		});
+
+		expect(context.cwd).toBe(explicitRoot);
+	});
 });

package/packages/lsp-core/src/request-context.ts

@@ -72,7 +72,7 @@ export function createStandaloneMcpRequestContext(
 	input: StandaloneMcpRequestContextInput = {},
 ): LspRequestContext {
 	const env = input.env ?? process.env;
-	const cwd = canonicalCwd(input.cwd ?? process.cwd());
+	const cwd = canonicalCwd(input.cwd ?? env["LSP_TOOLS_MCP_CWD"] ?? process.cwd());
 	const home = input.homeDir ?? homedir();
 	const projectConfigPaths = translateProjectConfigEnv(env["LSP_TOOLS_MCP_PROJECT_CONFIG"], cwd);
 	const userConfigPath = translateHomeConfigEnv(env["LSP_TOOLS_MCP_USER_CONFIG"], home, ".codex/lsp-client.json");

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

@@ -104,6 +104,18 @@ const expectedToolSurface = [
 			required: ["filePath", "line", "character", "newName"],
 		},
 	},
+	{
+		name: "format",
+		title: "LSP Format",
+		description: "Format a source file with its language server and write the returned edits to disk.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				filePath: { type: "string", description: "Source file path to format." },
+			},
+			required: ["filePath"],
+		},
+	},
 	{
 		name: "install_decision",
 		title: "LSP Install Decision",
@@ -128,7 +140,7 @@ const expectedToolSurface = [
 ];
 
 describe("LSP core tool surface", () => {
-	test("#given tool descriptors #when listed #then the public eight-tool schemas are pinned", () => {
+	test("#given tool descriptors #when listed #then the public nine-tool schemas are pinned", () => {
 		// given / when
 		const surface = LSP_MCP_TOOLS.map((tool) => ({
 			name: tool.name,

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

@@ -1,4 +1,5 @@
 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";
@@ -116,6 +117,19 @@ export const LSP_MCP_TOOLS: LspMcpTool[] = [
 		),
 		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"],

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

@@ -1,4 +1,4 @@
-import { isDirectoryPath, resolvePathInsideContext, withLspClient } from "../lsp/client-wrapper.js";
+import { isDirectoryPath, resolveReadablePathInsideContext, withLspClient } from "../lsp/client-wrapper.js";
 import { DEFAULT_MAX_DIAGNOSTICS } from "../lsp/constants.js";
 import { aggregateDiagnosticsForDirectory } from "../lsp/directory-diagnostics.js";
 import { filterDiagnosticsBySeverity, formatDiagnostic } from "../lsp/formatters.js";
@@ -23,7 +23,7 @@ export async function executeLspDiagnostics(
 	const severity = severityFilter(params);
 
 	try {
-		const absPath = resolvePathInsideContext(filePath);
+		const absPath = resolveReadablePathInsideContext(filePath);
 		if (isDirectoryPath(absPath)) {
 			const extension = inferExtensionFromDirectory(absPath);
 			if (!extension) {
@@ -62,7 +62,7 @@ export async function executeLspDiagnostics(
 
 		const result = await withLspClient(
 				filePath,
-				async (client) => client.diagnostics(filePath, signal),
+				async (client, _workspaceRoot, resolvedFilePath) => client.diagnostics(resolvedFilePath, signal),
 				"diagnostics",
 				clientOptions(signal),
 			);

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

@@ -1,5 +1,6 @@
 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";

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

@@ -17,7 +17,8 @@ export async function executeLspGotoDefinition(
 	try {
 			const result = await withLspClient(
 				filePath,
-				async (client) => client.definition(filePath, line, character, signal),
+				async (client, _workspaceRoot, resolvedFilePath) =>
+					client.definition(resolvedFilePath, line, character, signal),
 				"definition",
 				clientOptions(signal),
 			);
@@ -49,7 +50,8 @@ export async function executeLspFindReferences(
 	try {
 			const result = await withLspClient(
 				filePath,
-				async (client) => client.references(filePath, line, character, includeDeclaration, signal),
+				async (client, _workspaceRoot, resolvedFilePath) =>
+					client.references(resolvedFilePath, line, character, includeDeclaration, signal),
 				"references",
 				clientOptions(signal),
 			);

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

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+	clientOptions,
+	optionalBoolean,
+	optionalNumber,
+	optionalString,
+	requireNumber,
+	requireString,
+	severityFilter,
+} from "./parameters.js";
+
+describe("LSP tool parameter helpers", () => {
+	test("#given required string parameter #when value is missing or empty #then throws clear error", () => {
+		expect(requireString({ filePath: "index.ts" }, "filePath")).toBe("index.ts");
+		expect(() => requireString({}, "filePath")).toThrow("Missing required string parameter 'filePath'");
+		expect(() => requireString({ filePath: "" }, "filePath")).toThrow("Missing required string parameter 'filePath'");
+		expect(() => requireString({ filePath: 42 }, "filePath")).toThrow("Missing required string parameter 'filePath'");
+	});
+
+	test("#given required number parameter #when value is non-finite #then throws clear error", () => {
+		expect(requireNumber({ line: 3 }, "line")).toBe(3);
+		expect(() => requireNumber({}, "line")).toThrow("Missing required number parameter 'line'");
+		expect(() => requireNumber({ line: Number.NaN }, "line")).toThrow("Missing required number parameter 'line'");
+		expect(() => requireNumber({ line: Number.POSITIVE_INFINITY }, "line")).toThrow(
+			"Missing required number parameter 'line'",
+		);
+	});
+
+	test("#given optional parameters #when values have wrong type #then ignores them", () => {
+		expect(optionalString({ query: "symbol" }, "query")).toBe("symbol");
+		expect(optionalString({ query: 7 }, "query")).toBeUndefined();
+		expect(optionalNumber({ limit: 10 }, "limit")).toBe(10);
+		expect(optionalNumber({ limit: Number.NaN }, "limit")).toBeUndefined();
+		expect(optionalBoolean({ includeDeclaration: false }, "includeDeclaration")).toBe(false);
+		expect(optionalBoolean({ includeDeclaration: "false" }, "includeDeclaration")).toBeUndefined();
+	});
+
+	test("#given severity parameter #when value is unknown #then defaults to all", () => {
+		expect(severityFilter({ severity: "warning" })).toBe("warning");
+		expect(severityFilter({ severity: "fatal" })).toBe("all");
+		expect(severityFilter({})).toBe("all");
+	});
+
+	test("#given optional abort signal #when building client options #then includes only defined signal", () => {
+		const controller = new AbortController();
+
+		expect(clientOptions(undefined)).toEqual({});
+		expect(clientOptions(controller.signal)).toEqual({ signal: controller.signal });
+	});
+});

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

@@ -16,7 +16,8 @@ export async function executeLspPrepareRename(
 	try {
 			const result = await withLspClient(
 				filePath,
-				async (client) => client.prepareRename(filePath, line, character, signal),
+				async (client, _workspaceRoot, resolvedFilePath) =>
+					client.prepareRename(resolvedFilePath, line, character, signal),
 				"prepareRename",
 				clientOptions(signal),
 			);
@@ -46,7 +47,8 @@ export async function executeLspRename(
 	try {
 		const result = await withLspClient(
 			filePath,
-			async (client) => client.rename(filePath, line, character, newName, signal),
+			async (client, _workspaceRoot, resolvedFilePath) =>
+				client.rename(resolvedFilePath, line, character, newName, signal),
 			"rename",
 			clientOptions(signal),
 		);

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

@@ -47,7 +47,7 @@ export async function executeLspSymbols(
 
 			const symbols = await withLspClient(
 				filePath,
-				async (client) => client.documentSymbols(filePath, signal),
+				async (client, _workspaceRoot, resolvedFilePath) => client.documentSymbols(resolvedFilePath, signal),
 				"documentSymbols",
 				clientOptions(signal),
 			);

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

@@ -93,6 +93,16 @@ export interface LspPrepareRenameDetails {
 	errorKind?: "missing_dependency";
 }
 
+export interface LspFormatDetails {
+	filePath: string;
+	status: "formatted" | "unchanged" | "unavailable";
+	reason?: "capability_not_advertised" | "server_unavailable";
+	linesAdded: number;
+	linesRemoved: number;
+	error?: string;
+	errorKind?: "missing_dependency";
+}
+
 export interface LspRenameDetails {
 	filePath: string;
 	line: number;