oh-my-opencode 5.0.0-beta.21 → 5.0.0-beta.23

package/packages/lsp-core/src/lsp/server-resolution-local-binary.test.ts

@@ -0,0 +1,170 @@
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { runWithRequestContext } from "../request-context.js";
+import { formatServerLookupError } from "./client-wrapper.js";
+import { __resetServerBinaryResolutionCacheForTests } from "./server-installation.js";
+import { findServerForExtension } from "./server-resolution.js";
+
+const tempDirectories: string[] = [];
+let previousPath: string | undefined;
+
+function makeTempRoot(prefix: string): string {
+	const root = mkdtempSync(join(tmpdir(), prefix));
+	tempDirectories.push(root);
+	return root;
+}
+
+function writeExecutable(path: string): string {
+	mkdirSync(join(path, ".."), { recursive: true });
+	writeFileSync(path, "#!/bin/sh\nexit 0\n");
+	chmodSync(path, 0o755);
+	return path;
+}
+
+function contextFor(cwd: string) {
+	return {
+		cwd,
+		projectConfigPaths: [join(cwd, ".codex", "lsp-client.json")],
+		userConfigPath: join(cwd, "home-config", "lsp-client.json"),
+		installDecisionsPath: join(cwd, "home-config", "lsp-install-decisions.json"),
+		capabilities: { installDecisionTool: true },
+	} as const;
+}
+
+beforeEach(() => {
+	previousPath = process.env["PATH"];
+	__resetServerBinaryResolutionCacheForTests();
+});
+
+afterEach(() => {
+	if (previousPath === undefined) delete process.env["PATH"];
+	else process.env["PATH"] = previousPath;
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+	__resetServerBinaryResolutionCacheForTests();
+});
+
+describe("findServerForExtension local binary substitution", () => {
+	test("#given a repo-local biome #when looking up a typescript file #then the command spawns the absolute local path", () => {
+		// given
+		const root = makeTempRoot("lsp-resolution-local-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		const binaryPath = writeExecutable(join(root, "node_modules", ".bin", "biome"));
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".ts"));
+
+		// then
+		expect(result.status).toBe("found");
+		if (result.status !== "found") throw new Error("expected a found server");
+		expect(result.server.command[0]).toBe(binaryPath);
+		expect(result.server.command.slice(1)).toEqual(["lsp-proxy", "--stdio"]);
+	});
+
+	test("#given a PATH-only server #when looking up #then the resolved PATH entry is substituted", () => {
+		// given
+		const root = makeTempRoot("lsp-resolution-path-root-");
+		writeFileSync(join(root, "package.json"), "{}\n");
+		const pathDir = makeTempRoot("lsp-resolution-path-");
+		const pathBinary = writeExecutable(join(pathDir, "biome"));
+		process.env["PATH"] = pathDir;
+
+		// when
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".ts"));
+
+		// then
+		expect(result.status).toBe("found");
+		if (result.status !== "found") throw new Error("expected a found server");
+		expect(result.server.command[0]).toBe(pathBinary);
+	});
+
+	test("#given no server anywhere #when looking up #then the not_installed result is preserved", () => {
+		// given
+		const root = makeTempRoot("lsp-resolution-missing-");
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".ts"));
+
+		// then
+		expect(result.status).toBe("not_installed");
+		if (result.status !== "not_installed") throw new Error("expected not_installed");
+		expect(result.installHint.length).toBeGreaterThan(0);
+	});
+
+	test("#given an unknown extension #when looking up #then the not_configured result is preserved", () => {
+		// given
+		const root = makeTempRoot("lsp-resolution-unknown-");
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		// when
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".unknown-ext"));
+
+		// then
+		expect(result.status).toBe("not_configured");
+	});
+});
+
+describe("not-installed message repo-local guidance", () => {
+	test("#given a missing biome #when formatting the message #then the repo-local install is suggested before the global hint", () => {
+		// given: .css is served by biome alone, so the lookup cannot fall through to typescript
+		const root = makeTempRoot("lsp-message-biome-");
+		process.env["PATH"] = join(root, "definitely-empty");
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".css"));
+		if (result.status !== "not_installed") throw new Error("expected not_installed");
+		expect(result.server.id).toBe("biome");
+
+		// when
+		const message = runWithRequestContext(contextFor(root), () => formatServerLookupError(result));
+
+		// then
+		expect(message).toContain("bun add -d @biomejs/biome");
+		expect(message).toContain("npm install -g @biomejs/biome");
+		expect(message.indexOf("bun add -d @biomejs/biome")).toBeLessThan(message.indexOf("npm install -g @biomejs/biome"));
+		expect(message).toContain("ACTION REQUIRED");
+		expect(message).toContain("NOT INSTALLED");
+	});
+
+	test("#given a server with no repo-local route #when formatting the message #then only the global hint is shown", () => {
+		// given
+		const root = makeTempRoot("lsp-message-global-");
+		process.env["PATH"] = join(root, "definitely-empty");
+		const result = runWithRequestContext(contextFor(root), () => findServerForExtension(".rs"));
+		if (result.status !== "not_installed") throw new Error("expected not_installed");
+
+		// when
+		const message = runWithRequestContext(contextFor(root), () => formatServerLookupError(result));
+
+		// then
+		expect(message).toContain("To install, run:");
+		expect(message).not.toContain("THIS repository");
+		expect(message).toContain("ACTION REQUIRED");
+	});
+
+	test("#given a pre-authorized install #when formatting the message #then both install routes stay visible", () => {
+		// given
+		const root = makeTempRoot("lsp-message-allowed-");
+		process.env["PATH"] = join(root, "definitely-empty");
+		const context = contextFor(root);
+		mkdirSync(join(root, "home-config"), { recursive: true });
+		writeFileSync(
+			context.installDecisionsPath,
+			`${JSON.stringify({ biome: { decision: "allowed", decidedAt: new Date().toISOString() } })}\n`,
+		);
+		const result = runWithRequestContext(context, () => findServerForExtension(".css"));
+		if (result.status !== "not_installed") throw new Error("expected not_installed");
+
+		// when
+		const message = runWithRequestContext(context, () => formatServerLookupError(result));
+
+		// then
+		expect(message).toContain("pre-authorized");
+		expect(message).toContain("bun add -d @biomejs/biome");
+		expect(message).toContain("npm install -g @biomejs/biome");
+	});
+});

package/packages/lsp-core/src/lsp/server-resolution.ts

@@ -1,16 +1,28 @@
+import { contextCwd } from "../request-context.js";
 import { getDisabledServerIds, getMergedServers } from "./config-loader.js";
 import { BUILTIN_SERVERS, LSP_INSTALL_HINTS } from "./server-definitions.js";
-import { isServerInstalled } from "./server-installation.js";
+import { isServerInstalled, resolveServerBinary } from "./server-installation.js";
 import type { ServerLookupResult } from "./types.js";
 
+/**
+ * Replaces the command name with the absolute binary path so the client spawns the exact
+ * binary that was resolved -- in particular a repo-local one that is absent from PATH.
+ */
+function withResolvedCommand(command: string[], binaryPath: string): string[] {
+	return [binaryPath, ...command.slice(1)];
+}
+
 export function findServerForExtension(ext: string): ServerLookupResult {
 	const servers = getMergedServers();
+	const workingDirectory = contextCwd();
 
 	for (const server of servers) {
-		if (server.extensions.includes(ext) && isServerInstalled(server.command)) {
+		if (!server.extensions.includes(ext)) continue;
+		const binaryPath = resolveServerBinary(server.command, workingDirectory);
+		if (binaryPath !== null) {
 			const resolvedServer = {
 				id: server.id,
-				command: server.command,
+				command: withResolvedCommand(server.command, binaryPath),
 				extensions: server.extensions,
 				priority: server.priority,
 			};
@@ -70,6 +82,7 @@ export interface ServerStatus {
 export function getAllServers(): ServerStatus[] {
 	const servers = getMergedServers();
 	const disabled = getDisabledServerIds();
+	const workingDirectory = contextCwd();
 
 	const result: ServerStatus[] = [];
 	const seen = new Set<string>();
@@ -78,7 +91,7 @@ export function getAllServers(): ServerStatus[] {
 		if (seen.has(server.id)) continue;
 		result.push({
 			id: server.id,
-			installed: isServerInstalled(server.command),
+			installed: isServerInstalled(server.command, workingDirectory),
 			extensions: server.extensions,
 			disabled: false,
 			source: server.source,
@@ -92,7 +105,7 @@ export function getAllServers(): ServerStatus[] {
 		const builtin = BUILTIN_SERVERS[id];
 		result.push({
 			id,
-			installed: builtin ? isServerInstalled(builtin.command) : false,
+			installed: builtin ? isServerInstalled(builtin.command, workingDirectory) : false,
 			extensions: builtin?.extensions ?? [],
 			disabled: true,
 			source: "disabled",

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

@@ -37,6 +37,7 @@ export class LspClientTransport {
 	protected readonly initializeTimeoutMs: number;
 	private workspaceApplyEditHandler: WorkspaceApplyEditHandler | null = null;
 	private diagnosticPullSupported = false;
+	private documentFormattingSupported = false;
 
 	constructor(
 		protected readonly root: string,
@@ -71,6 +72,14 @@ export class LspClientTransport {
 		return this.diagnosticPullSupported;
 	}
 
+	protected setDocumentFormattingSupported(supported: boolean): void {
+		this.documentFormattingSupported = supported;
+	}
+
+	isDocumentFormattingSupported(): boolean {
+		return this.documentFormattingSupported;
+	}
+
 	protected handlePublishDiagnostics(params: {
 		readonly uri: string;
 		readonly diagnostics: readonly Diagnostic[];

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

@@ -72,6 +72,14 @@ export interface Diagnostic {
 	message: string;
 }
 
+export interface FormattingOptions {
+	tabSize: number;
+	insertSpaces: boolean;
+	trimTrailingWhitespace?: boolean;
+	insertFinalNewline?: boolean;
+	trimFinalNewlines?: boolean;
+}
+
 export interface TextDocumentIdentifier {
 	uri: string;
 }

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/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/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;