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

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

@@ -49,35 +49,6 @@ export const LSP_INSTALL_HINTS: Record<string, string> = {
 		"Install: dotnet tool install -g roslyn-language-server --prerelease (requires v5.8.0+). See https://github.com/dotnet/razor",
 };
 
-/**
- * Repo-local install commands, offered ahead of the global hints in `LSP_INSTALL_HINTS`.
- *
- * A devDependency (or project venv) is resolvable by `resolveServerBinary()` without any
- * global install, and it pins the version the project actually expects. Only servers that
- * are genuinely distributed per-project belong here; toolchain-wide servers (rust-analyzer,
- * gopls, clangd, ...) keep their global hint alone.
- */
-export const LSP_LOCAL_INSTALL_HINTS: Record<string, string> = {
-	typescript: "bun add -d typescript-language-server typescript",
-	vue: "bun add -d @vue/language-server",
-	eslint: "bun add -d vscode-langservers-extracted",
-	oxlint: "bun add -d oxlint",
-	biome: "bun add -d @biomejs/biome",
-	svelte: "bun add -d svelte-language-server",
-	astro: "bun add -d @astrojs/language-server",
-	bash: "bun add -d bash-language-server",
-	"bash-ls": "bun add -d bash-language-server",
-	"yaml-ls": "bun add -d yaml-language-server",
-	php: "bun add -d intelephense",
-	prisma: "bun add -d prisma",
-	dockerfile: "bun add -d dockerfile-language-server-nodejs",
-	pyright: "uv add --dev pyright",
-	basedpyright: "uv add --dev basedpyright",
-	ruff: "uv add --dev ruff",
-	ty: "uv add --dev ty",
-	"ruby-lsp": "bundle add ruby-lsp --group development",
-};
-
 export const BUILTIN_SERVERS: Record<string, Omit<LspServerConfig, "id">> = {
 	typescript: {
 		command: ["typescript-language-server", "--stdio"],

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

@@ -1,218 +1,45 @@
 import { existsSync } from "node:fs";
-import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
+import { delimiter, join } from "node:path";
 
-/**
- * Project markers that authorize probing a set of repo-local binary directories.
- *
- * A local bin directory is only trusted when the sibling marker proves the directory
- * belongs to a project of that ecosystem. An unmarked `node_modules/.bin` is ignored so
- * that a stray directory cannot inject an executable into the resolution order.
- */
-interface LocalBinRule {
-	readonly markers: readonly string[];
-	readonly binDirs: readonly string[];
-}
-
-const LOCAL_BIN_RULES: readonly LocalBinRule[] = [
-	{
-		markers: ["package.json", "bun.lock", "bun.lockb", "package-lock.json", "yarn.lock", "pnpm-lock.yaml"],
-		binDirs: [join("node_modules", ".bin")],
-	},
-	{
-		markers: [
-			"pyproject.toml",
-			"ty.toml",
-			"requirements.txt",
-			"setup.py",
-			"setup.cfg",
-			"Pipfile",
-			"pyrightconfig.json",
-			"ruff.toml",
-			".ruff.toml",
-		],
-		binDirs: [
-			join(".venv", "bin"),
-			join(".venv", "Scripts"),
-			join("venv", "bin"),
-			join("venv", "Scripts"),
-			join(".env", "bin"),
-			join(".env", "Scripts"),
-		],
-	},
-	{
-		markers: ["Gemfile", "Gemfile.lock"],
-		binDirs: [join("vendor", "bundle", "bin"), "bin"],
-	},
-	{
-		markers: ["go.mod", "go.sum", "go.work"],
-		binDirs: ["bin"],
-	},
-];
-
-export interface ResolveServerBinaryOptions {
-	/**
-	 * Upward walk boundary. The walk never ascends above this directory, which lets callers
-	 * confine resolution to a trusted request cwd.
-	 */
-	readonly stopAt?: string;
-	readonly platform?: NodeJS.Platform;
-	readonly pathExt?: string;
-	readonly pathEnv?: string;
-}
-
-const resolutionCache = new Map<string, string | null>();
-let probeCount = 0;
-
-/** Test seam: clears the per-process resolution cache. */
-export function __resetServerBinaryResolutionCacheForTests(): void {
-	resolutionCache.clear();
-	probeCount = 0;
-}
-
-/** Test seam: counts filesystem probes so cache hits are observable. */
-export function __serverBinaryProbeCountForTests(): number {
-	return probeCount;
-}
-
-function probe(path: string): boolean {
-	probeCount += 1;
-	return existsSync(path);
-}
+export function isServerInstalled(command: string[], _workingDirectory?: string): boolean {
+	if (command.length === 0) return false;
 
-function executableSuffixes(platform: NodeJS.Platform, pathExt: string | undefined): readonly string[] {
-	if (platform !== "win32") return [""];
-	const configured = pathExt ?? process.env["PATHEXT"] ?? "";
-	// PATHEXT is conventionally uppercase, but the on-disk shims npm/bun write are lowercase.
-	// Probe lowercase first so the returned path matches the real filename on case-sensitive
-	// filesystems; the resolved path is spawned, so its casing has to be exact.
-	const systemExts = configured
-		.split(";")
-		.filter((entry) => entry.length > 0)
-		.map((entry) => entry.toLowerCase());
-	return [...new Set(["", ...systemExts, ".exe", ".cmd", ".bat", ".ps1"])];
-}
+	const [cmd] = command;
+	if (!cmd) return false;
 
-function probeWithSuffixes(directory: string, command: string, suffixes: readonly string[]): string | null {
-	for (const suffix of suffixes) {
-		const candidate = join(directory, command + suffix);
-		if (probe(candidate)) return candidate;
+	if (cmd.includes("/") || cmd.includes("\\")) {
+		if (existsSync(cmd)) return true;
 	}
-	return null;
-}
 
-function resolveLocal(
-	command: string,
-	workingDirectory: string,
-	suffixes: readonly string[],
-	stopAt: string | undefined,
-): string | null {
-	const boundary = stopAt === undefined ? undefined : resolve(stopAt);
-	let current = resolve(workingDirectory);
+	const isWindows = process.platform === "win32";
 
-	while (true) {
-		for (const rule of LOCAL_BIN_RULES) {
-			if (!rule.markers.some((marker) => probe(join(current, marker)))) continue;
-			for (const binDir of rule.binDirs) {
-				const found = probeWithSuffixes(join(current, binDir), command, suffixes);
-				if (found !== null) return found;
-			}
+	let exts = [""];
+	if (isWindows) {
+		const pathExt = process.env["PATHEXT"] ?? "";
+		if (pathExt) {
+			const systemExts = pathExt.split(";").filter(Boolean);
+			exts = [...new Set([...exts, ...systemExts, ".exe", ".cmd", ".bat", ".ps1"])];
+		} else {
+			exts = ["", ".exe", ".cmd", ".bat", ".ps1"];
 		}
-
-		// A repository root ends the walk: tooling above it belongs to a different project.
-		if (probe(join(current, ".git"))) return null;
-		if (boundary !== undefined && current === boundary) return null;
-
-		const parent = dirname(current);
-		if (parent === current) return null;
-		current = parent;
 	}
-}
 
-function resolveFromPath(
-	command: string,
-	suffixes: readonly string[],
-	platform: NodeJS.Platform,
-	pathEnvOverride: string | undefined,
-): string | null {
-	let pathEnv = pathEnvOverride ?? process.env["PATH"] ?? "";
-	if (platform === "win32" && !pathEnv) {
+	let pathEnv = process.env["PATH"] ?? "";
+	if (isWindows && !pathEnv) {
 		pathEnv = process.env["Path"] ?? "";
 	}
 
-	for (const entry of pathEnv.split(delimiter)) {
-		if (entry.length === 0) continue;
-		const found = probeWithSuffixes(entry, command, suffixes);
-		if (found !== null) return found;
-	}
-	return null;
-}
-
-/**
- * Resolves the absolute path of an LSP server binary.
- *
- * Probing order:
- * 1. a path-shaped command is validated as-is,
- * 2. marker-gated repo-local bin directories, walking up from `workingDirectory`,
- * 3. `PATH` (including Windows executable suffixes),
- * 4. `null` when nothing matches.
- *
- * Results are cached per process, keyed by working directory and command.
- */
-export function resolveServerBinary(
-	command: string[],
-	workingDirectory?: string,
-	options: ResolveServerBinaryOptions = {},
-): string | null {
-	if (command.length === 0) return null;
-	const [cmd] = command;
-	if (cmd === undefined || cmd.length === 0) return null;
-
-	const platform = options.platform ?? process.platform;
-	const suffixes = executableSuffixes(platform, options.pathExt);
-
-	if (cmd.includes("/") || cmd.includes("\\")) {
-		const explicit = isAbsolute(cmd) ? cmd : resolve(workingDirectory ?? process.cwd(), cmd);
-		return probe(explicit) ? explicit : null;
-	}
-
-	const cacheKey = JSON.stringify([
-		workingDirectory ?? "",
-		cmd,
-		platform,
-		options.stopAt ?? "",
-		options.pathExt ?? "",
-		options.pathEnv ?? process.env["PATH"] ?? "",
-	]);
-	const cached = resolutionCache.get(cacheKey);
-	if (cached !== undefined) return cached;
+	const paths = pathEnv.split(delimiter);
 
-	let resolved: string | null = null;
-	if (workingDirectory !== undefined && workingDirectory.length > 0) {
-		resolved = resolveLocal(cmd, workingDirectory, suffixes, options.stopAt);
+	for (const p of paths) {
+		for (const suffix of exts) {
+			if (existsSync(join(p, cmd + suffix))) {
+				return true;
+			}
+		}
 	}
-	resolved ??= resolveFromPath(cmd, suffixes, platform, options.pathEnv);
-	// A configured server may be launched through the interpreter itself, e.g.
-	// { command: ["node", "my-ls.js"] }. isServerInstalled() has always treated bare `node`
-	// as available regardless of PATH, so keep those servers selectable instead of
-	// regressing them into a not_installed result. The name is returned unresolved so the
-	// spawn still goes through `node`; rewriting it to process.execPath would silently
-	// substitute a different interpreter (bun) for the one the config asked for.
-	if (resolved === null && cmd === "node") resolved = cmd;
 
-	resolutionCache.set(cacheKey, resolved);
-	return resolved;
-}
+	if (cmd === "node") return true;
 
-/**
- * Reports whether an LSP server binary is available.
- *
- * Retained for existing consumers; `resolveServerBinary` is the richer entry point.
- */
-export function isServerInstalled(
-	command: string[],
-	workingDirectory?: string,
-	options: ResolveServerBinaryOptions = {},
-): boolean {
-	if (command.length === 0) return false;
-	return resolveServerBinary(command, workingDirectory, options) !== null;
+	return false;
 }

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

@@ -1,28 +1,16 @@
-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, resolveServerBinary } from "./server-installation.js";
+import { isServerInstalled } 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)) continue;
-		const binaryPath = resolveServerBinary(server.command, workingDirectory);
-		if (binaryPath !== null) {
+		if (server.extensions.includes(ext) && isServerInstalled(server.command)) {
 			const resolvedServer = {
 				id: server.id,
-				command: withResolvedCommand(server.command, binaryPath),
+				command: server.command,
 				extensions: server.extensions,
 				priority: server.priority,
 			};
@@ -82,7 +70,6 @@ export interface ServerStatus {
 export function getAllServers(): ServerStatus[] {
 	const servers = getMergedServers();
 	const disabled = getDisabledServerIds();
-	const workingDirectory = contextCwd();
 
 	const result: ServerStatus[] = [];
 	const seen = new Set<string>();
@@ -91,7 +78,7 @@ export function getAllServers(): ServerStatus[] {
 		if (seen.has(server.id)) continue;
 		result.push({
 			id: server.id,
-			installed: isServerInstalled(server.command, workingDirectory),
+			installed: isServerInstalled(server.command),
 			extensions: server.extensions,
 			disabled: false,
 			source: server.source,
@@ -105,7 +92,7 @@ export function getAllServers(): ServerStatus[] {
 		const builtin = BUILTIN_SERVERS[id];
 		result.push({
 			id,
-			installed: builtin ? isServerInstalled(builtin.command, workingDirectory) : false,
+			installed: builtin ? isServerInstalled(builtin.command) : false,
 			extensions: builtin?.extensions ?? [],
 			disabled: true,
 			source: "disabled",

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

@@ -37,7 +37,6 @@ export class LspClientTransport {
 	protected readonly initializeTimeoutMs: number;
 	private workspaceApplyEditHandler: WorkspaceApplyEditHandler | null = null;
 	private diagnosticPullSupported = false;
-	private documentFormattingSupported = false;
 
 	constructor(
 		protected readonly root: string,
@@ -72,14 +71,6 @@ 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,14 +72,6 @@ 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,18 +104,6 @@ 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",
@@ -140,7 +128,7 @@ const expectedToolSurface = [
 ];
 
 describe("LSP core tool surface", () => {
-	test("#given tool descriptors #when listed #then the public nine-tool schemas are pinned", () => {
+	test("#given tool descriptors #when listed #then the public eight-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,5 +1,4 @@
 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";
@@ -117,19 +116,6 @@ 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/index.ts

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