lazycodex-ai 5.1.47 → 5.1.51

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

@@ -0,0 +1,398 @@
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { LspClientConnection } from "./connection.js";
+import type { LspClientTimeoutOptions } from "./transport.js";
+import type {
+	Diagnostic,
+	DocumentSymbol,
+	FormattingOptions,
+	Location,
+	LocationLink,
+	PrepareRenameDefaultBehavior,
+	PrepareRenameResult,
+	Range,
+	ResolvedServer,
+	SymbolInfo,
+	TextEdit,
+	WorkspaceEdit,
+} from "./types.js";
+import { LspRequestTimeoutError } from "./errors.js";
+import { WorkspaceDocumentState } from "./workspace-document-state.js";
+import type { TimerProvider } from "./timer-provider.js";
+import type { LspRenameResult, WorkspaceEditCommitIo } from "./workspace-edit-types.js";
+import { WorkspaceMutationController } from "./workspace-mutation-controller.js";
+
+const DIAGNOSTICS_FRESHNESS_TIMEOUT_MS = 3_000;
+const VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
+
+export interface LspDiagnosticsResult {
+	readonly items: Diagnostic[];
+	readonly transientError?: {
+		readonly kind: "freshness_timeout";
+		readonly message: string;
+	};
+}
+
+export interface LspClientOptions extends LspClientTimeoutOptions {
+	readonly diagnosticsFreshnessTimeoutMs?: number;
+	readonly versionlessPublishQuiescenceMs?: number;
+	readonly timerProvider?: TimerProvider;
+}
+
+export class LspClient extends LspClientConnection {
+	private readonly diagnosticPullErrors: Error[] = [];
+	private readonly documents: WorkspaceDocumentState;
+	private readonly workspaceMutations: WorkspaceMutationController;
+	private readonly diagnosticsFreshnessTimeoutMs: number;
+
+	constructor(root: string, server: ResolvedServer, options: LspClientOptions = {}) {
+		super(root, server, options);
+		this.diagnosticsFreshnessTimeoutMs =
+			options.diagnosticsFreshnessTimeoutMs ?? DIAGNOSTICS_FRESHNESS_TIMEOUT_MS;
+		this.documents = new WorkspaceDocumentState(
+			(method, params) => this.sendNotification(method, params),
+			(uri) => this.diagnosticsStore.delete(uri),
+			{
+				timerProvider: this.timerProvider,
+				versionlessPublishQuiescenceMs:
+					options.versionlessPublishQuiescenceMs ?? VERSIONLESS_PUBLISH_QUIESCENCE_MS,
+			},
+		);
+		this.workspaceMutations = new WorkspaceMutationController(root, this.documents);
+		this.setWorkspaceApplyEditHandler((params) => this.workspaceMutations.handleApplyEdit(params));
+	}
+
+	getDiagnosticPullErrors(): readonly Error[] {
+		return this.diagnosticPullErrors;
+	}
+
+	async openFile(filePath: string): Promise<void> {
+		const absPath = this.resolveWorkspacePath(filePath);
+		await this.documents.openFile(absPath);
+	}
+
+	getOpenDocumentVersion(filePath: string): number | undefined {
+		return this.documents.getVersion(this.resolveWorkspacePath(filePath));
+	}
+
+	override getStoredDiagnostics(uri: string): Diagnostic[] {
+		return [...this.documents.getStoredDiagnostics(uri)];
+	}
+
+	setWorkspaceEditIo(io: Partial<WorkspaceEditCommitIo>): void {
+		this.workspaceMutations.setIo(io);
+	}
+
+	protected override handlePublishDiagnostics(params: {
+		readonly uri: string;
+		readonly diagnostics: readonly Diagnostic[];
+		readonly version?: number;
+	}): void {
+		super.handlePublishDiagnostics(params);
+		this.documents.recordPublishedDiagnostics(params);
+	}
+
+	async definition(
+		filePath: string,
+		line: number,
+		character: number,
+		signal?: AbortSignal,
+	): Promise<Location | LocationLink | Array<Location | LocationLink> | null> {
+		const absPath = this.resolveWorkspacePath(filePath);
+		await this.openFile(absPath);
+		const options = signal === undefined ? {} : { signal };
+		return this.sendRequest<Location | LocationLink | Array<Location | LocationLink> | null>(
+			"textDocument/definition",
+			{
+				textDocument: { uri: pathToFileURL(absPath).href },
+				position: { line: line - 1, character },
+			},
+			options,
+		);
+	}
+
+	async references(
+		filePath: string,
+		line: number,
+		character: number,
+		includeDeclaration = true,
+		signal?: AbortSignal,
+	): Promise<Location[]> {
+		const absPath = this.resolveWorkspacePath(filePath);
+		await this.openFile(absPath);
+		const options = signal === undefined ? {} : { signal };
+		return this.sendRequest<Location[]>("textDocument/references", {
+			textDocument: { uri: pathToFileURL(absPath).href },
+			position: { line: line - 1, character },
+			context: { includeDeclaration },
+		}, options);
+	}
+
+	async documentSymbols(filePath: string, signal?: AbortSignal): Promise<Array<DocumentSymbol | SymbolInfo>> {
+		const absPath = this.resolveWorkspacePath(filePath);
+		await this.openFile(absPath);
+		const options = signal === undefined ? {} : { signal };
+		return this.sendRequest<Array<DocumentSymbol | SymbolInfo>>("textDocument/documentSymbol", {
+			textDocument: { uri: pathToFileURL(absPath).href },
+		}, options);
+	}
+
+	/**
+	 * Requests whole-document formatting edits, returning null when the server never advertised the
+	 * capability so callers can report unavailability instead of surfacing a method-not-found error.
+	 */
+	async formatDocument(
+		filePath: string,
+		options: FormattingOptions,
+		signal?: AbortSignal,
+	): Promise<TextEdit[] | null> {
+		if (!this.isDocumentFormattingSupported()) return null;
+		const absPath = this.resolveWorkspacePath(filePath);
+		await this.openFile(absPath);
+		const requestOptions = signal === undefined ? {} : { signal };
+		const edits = await this.sendRequest<TextEdit[] | null>(
+			"textDocument/formatting",
+			{
+				textDocument: { uri: pathToFileURL(absPath).href },
+				options,
+			},
+			requestOptions,
+		);
+		return edits ?? [];
+	}
+
+	async workspaceSymbols(query: string, signal?: AbortSignal): Promise<SymbolInfo[]> {
+		const options = signal === undefined ? {} : { signal };
+		return this.sendRequest<SymbolInfo[]>("workspace/symbol", { query }, options);
+	}
+
+	private isUnsupportedDiagnosticPullError(error: unknown): boolean {
+		if (!(error instanceof Error)) return false;
+		const code = "code" in error && typeof error.code === "number" ? error.code : undefined;
+		if (code === -32601) return true;
+		return /unsupported|not supported|method not found|unknown request/i.test(error.message);
+	}
+
+	private freshnessTimeout(absPath: string): LspDiagnosticsResult {
+		return {
+			items: [],
+			transientError: {
+				kind: "freshness_timeout",
+				message: `Timed out waiting for fresh diagnostics for ${absPath} within ${this.diagnosticsFreshnessTimeoutMs}ms.`,
+			},
+		};
+	}
+
+	private parseDiagnosticPullReport(value: { items?: Diagnostic[]; kind?: string; resultId?: string }): {
+		readonly type: "full";
+		readonly diagnostics: readonly Diagnostic[];
+		readonly resultId?: string;
+	} | {
+		readonly type: "unchanged";
+		readonly resultId?: string;
+	} {
+		if (value.kind === "unchanged") {
+			return {
+				type: "unchanged",
+				...(value.resultId === undefined ? {} : { resultId: value.resultId }),
+			};
+		}
+		return {
+			type: "full",
+			diagnostics: value.items ?? [],
+			...(value.resultId === undefined ? {} : { resultId: value.resultId }),
+		};
+	}
+
+	async diagnostics(filePath: string, signal?: AbortSignal): Promise<LspDiagnosticsResult> {
+		signal?.throwIfAborted();
+		const absPath = this.resolveWorkspacePath(filePath);
+		const uri = pathToFileURL(absPath).href;
+		await this.openFile(absPath);
+		const deadlineAt = this.timerProvider.now() + this.diagnosticsFreshnessTimeoutMs;
+
+		for (;;) {
+			signal?.throwIfAborted();
+			const snapshot = this.documents.captureDiagnosticSnapshot(absPath);
+			if (!snapshot) return this.freshnessTimeout(absPath);
+			const push = this.documents.resolvePushDiagnostics(snapshot);
+			if (push.status === "ready") return { items: [...push.diagnostics] };
+
+			let pushFallbackOnly = !this.isDiagnosticPullSupported();
+			if (!pushFallbackOnly) {
+				const cached = this.documents.getPullCache(snapshot);
+				try {
+					const remainingMs = deadlineAt - this.timerProvider.now();
+					if (remainingMs <= 0) return this.freshnessTimeout(absPath);
+					const result = await this.sendRequest<{ items?: Diagnostic[]; kind?: string; resultId?: string }>(
+						"textDocument/diagnostic",
+						{
+							textDocument: { uri },
+							...(cached?.resultId === undefined ? {} : { previousResultId: cached.resultId }),
+						},
+						{ timeoutMs: remainingMs, ...(signal === undefined ? {} : { signal }) },
+					);
+					if (!this.documents.isCurrentSnapshot(snapshot)) continue;
+					const report = this.parseDiagnosticPullReport(result);
+					if (report.type === "full") {
+						this.documents.recordPullDiagnostics(snapshot, {
+							kind: "full",
+							diagnostics: report.diagnostics,
+							...(report.resultId === undefined ? {} : { resultId: report.resultId }),
+						});
+						return { items: [...report.diagnostics] };
+					}
+					if (
+						cached !== null &&
+						cached.documentVersion === snapshot.version &&
+						cached.resultId === report.resultId
+					) {
+						return { items: [...cached.diagnostics] };
+					}
+				} catch (error) {
+					if (this.isUnsupportedDiagnosticPullError(error)) {
+						this.setDiagnosticPullSupported(false);
+						// A publish may have landed while the pull was in flight. Re-capture the
+						// snapshot and re-resolve push state instead of deciding on the stale ones.
+						continue;
+					} else if (error instanceof LspRequestTimeoutError) {
+						pushFallbackOnly = true;
+					} else {
+						this.diagnosticPullErrors.push(error instanceof Error ? error : new Error(String(error)));
+						throw error;
+					}
+				}
+			}
+
+			if (!pushFallbackOnly) continue;
+
+			const remainingMs = deadlineAt - this.timerProvider.now();
+			if (remainingMs <= 0) {
+				// A server that never advertised pull diagnostics (or rejected the pull
+				// method) and has never published for this document stays silent for a
+				// clean file (e.g. Marksman, #6131). Resolve with the version-current
+				// pull cache or explicit empty instead of a freshness timeout; a stale
+				// pull cache from an older document version is never returned. Servers
+				// that have published before keep timing out via publishGeneration > 0,
+				// and a hung advertised pull keeps timing out because pull stays supported.
+				if (!this.isDiagnosticPullSupported() && snapshot.publishGeneration === 0) {
+					const cached = this.documents.getPullCache(snapshot);
+					return { items: cached === null ? [] : [...cached.diagnostics] };
+				}
+				return this.freshnessTimeout(absPath);
+			}
+			const waitMs = push.status === "wait" ? Math.min(push.waitMs, remainingMs) : remainingMs;
+			await waitForDiagnosticsActivity(this.documents.waitForDiagnosticsActivity(snapshot, waitMs), signal);
+		}
+	}
+
+	async prepareRename(
+		filePath: string,
+		line: number,
+		character: number,
+		signal?: AbortSignal,
+	): Promise<PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null> {
+		const absPath = this.resolveWorkspacePath(filePath);
+		await this.openFile(absPath);
+		const options = signal === undefined ? {} : { signal };
+		return this.sendRequest<PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null>(
+			"textDocument/prepareRename",
+			{
+				textDocument: { uri: pathToFileURL(absPath).href },
+				position: { line: line - 1, character },
+			},
+			options,
+		);
+	}
+
+	async rename(
+		filePath: string,
+		line: number,
+		character: number,
+		newName: string,
+		signal?: AbortSignal,
+	): Promise<LspRenameResult> {
+		const absPath = this.resolveWorkspacePath(filePath);
+		await this.openFile(absPath);
+		const acquired = this.workspaceMutations.acquire(signal);
+		if (!acquired.success) return { edit: null, apply: acquired.result };
+		const preCommitSignal = createPreCommitAbortSignal(signal, () =>
+			this.workspaceMutations.isBeforeCommit(acquired.lease),
+		);
+		try {
+			const renameParams = {
+				textDocument: { uri: pathToFileURL(absPath).href },
+				position: { line: line - 1, character },
+				newName,
+			};
+			const edit =
+				preCommitSignal === undefined
+					? await this.sendRequest<WorkspaceEdit | null>("textDocument/rename", renameParams)
+					: await this.sendRequest<WorkspaceEdit | null>("textDocument/rename", renameParams, {
+							signal: preCommitSignal.signal,
+						});
+			return await this.workspaceMutations.reconcileRename(acquired.lease, edit);
+		} finally {
+			preCommitSignal?.dispose();
+			this.workspaceMutations.release(acquired.lease);
+			}
+	}
+
+	private resolveWorkspacePath(filePath: string): string {
+		return resolve(this.root, filePath);
+	}
+}
+
+function waitForDiagnosticsActivity(wait: Promise<void>, signal: AbortSignal | undefined): Promise<void> {
+	if (!signal) return wait;
+	if (signal.aborted) return Promise.reject(abortError(signal));
+	return new Promise((resolve, reject) => {
+		const onAbort = (): void => {
+			signal.removeEventListener("abort", onAbort);
+			reject(abortError(signal));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		wait.then(
+			() => {
+				signal.removeEventListener("abort", onAbort);
+				resolve();
+			},
+			(error) => {
+				signal.removeEventListener("abort", onAbort);
+				reject(error);
+			},
+		);
+	});
+}
+
+function createPreCommitAbortSignal(
+	source: AbortSignal | undefined,
+	isBeforeCommit: () => boolean,
+): { readonly signal: AbortSignal; readonly dispose: () => void } | undefined {
+	if (!source) return undefined;
+	const controller = new AbortController();
+	const onAbort = (): void => {
+		if (isBeforeCommit() && !controller.signal.aborted) controller.abort(preCommitAbortReason(source));
+	};
+	if (source.aborted) onAbort();
+	else source.addEventListener("abort", onAbort, { once: true });
+	return {
+		signal: controller.signal,
+		dispose: () => source.removeEventListener("abort", onAbort),
+	};
+}
+
+function preCommitAbortReason(source: AbortSignal): Error {
+	const reason = source.reason;
+	if (reason instanceof Error && reason.name !== "AbortError") return reason;
+	return new Error("LSP request cancelled before workspace edit commit");
+}
+
+function abortError(signal: AbortSignal): Error {
+	const reason = signal.reason;
+	if (reason instanceof Error) return reason;
+	const error = new Error(typeof reason === "string" ? reason : "operation cancelled");
+	error.name = "AbortError";
+	return error;
+}

package/packages/lsp-core/src/lsp/config-loader.ts

@@ -0,0 +1,254 @@
+import { existsSync, readFileSync } from "node:fs";
+
+import { lspRequestContext } from "../request-context.js";
+import { BUILTIN_SERVERS } from "./server-definitions.js";
+import type { ResolvedServer } from "./types.js";
+
+interface LspEntry {
+	disabled?: boolean;
+	command?: string[];
+	extensions?: string[];
+	priority?: number;
+	env?: Record<string, string>;
+	initialization?: Record<string, unknown>;
+}
+
+interface ConfigJson {
+	lsp?: Record<string, unknown>;
+}
+
+type ConfigSource = "project" | "user";
+
+export interface ServerWithSource extends ResolvedServer {
+	source: "project" | "user" | "builtin";
+}
+
+export function getConfigPaths(): { project: string; user: string } {
+	return {
+		project: getProjectConfigPaths()[0] ?? lspRequestContext().projectConfigPaths[0] ?? "",
+		user: getUserConfigPath(),
+	};
+}
+
+function getProjectConfigPaths(): readonly string[] {
+	return lspRequestContext().projectConfigPaths;
+}
+
+function getUserConfigPath(): string {
+	return lspRequestContext().userConfigPath;
+}
+
+function loadJsonFile(path: string): ConfigJson | null {
+	if (!existsSync(path)) return null;
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(path, "utf-8"));
+		return isConfigJson(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+
+export function loadAllConfigs(): Map<ConfigSource, ConfigJson> {
+	const configs = new Map<ConfigSource, ConfigJson>();
+
+	const project = loadFirstJsonFile(getProjectConfigPaths());
+	if (project) configs.set("project", project);
+
+	const user = loadJsonFile(getUserConfigPath());
+	if (user) configs.set("user", user);
+
+	return configs;
+}
+
+function loadFirstJsonFile(paths: readonly string[]): ConfigJson | null {
+	for (const path of paths) {
+		const config = loadJsonFile(path);
+		if (config) return config;
+	}
+	return null;
+}
+
+export function getMergedServers(): ServerWithSource[] {
+	const configs = loadAllConfigs();
+	const servers: ServerWithSource[] = [];
+	const disabled = new Set<string>();
+	const seen = new Set<string>();
+
+	const sources: ConfigSource[] = ["project", "user"];
+
+	for (const source of sources) {
+		const config = configs.get(source);
+		if (!config?.lsp) continue;
+
+		for (const [id, rawEntry] of Object.entries(config.lsp)) {
+			const entry = parseLspEntry(rawEntry);
+			if (!entry) continue;
+			if (entry.disabled) {
+				disabled.add(id);
+				continue;
+			}
+
+			if (seen.has(id)) continue;
+			const server = createServerFromEntry(id, entry, source);
+			if (!server) continue;
+
+			servers.push(server);
+			seen.add(id);
+		}
+	}
+
+	for (const [id, config] of Object.entries(BUILTIN_SERVERS)) {
+		if (disabled.has(id) || seen.has(id)) continue;
+
+		servers.push({
+			id,
+			command: config.command,
+			extensions: config.extensions,
+			priority: -100,
+			source: "builtin",
+		});
+	}
+
+	return servers.sort((a, b) => {
+		if (a.source !== b.source) {
+			const order: Record<"project" | "user" | "builtin", number> = {
+				project: 0,
+				user: 1,
+				builtin: 2,
+			};
+			return order[a.source] - order[b.source];
+		}
+		return b.priority - a.priority;
+	});
+}
+
+function createServerFromEntry(id: string, entry: LspEntry, source: ConfigSource): ServerWithSource | null {
+	const builtin = BUILTIN_SERVERS[id];
+	if (source === "project") {
+		if (!builtin) return null;
+		const server = createServer({
+			id,
+			command: builtin.command,
+			extensions: entry.extensions ?? builtin.extensions,
+			priority: entry.priority ?? 0,
+			source,
+		});
+		if (entry.initialization !== undefined) {
+			server.initialization = entry.initialization;
+		}
+		return server;
+	}
+
+	if (entry.command && entry.extensions) {
+		const server = createServer({
+			id,
+			command: entry.command,
+			extensions: entry.extensions,
+			priority: entry.priority ?? 0,
+			source,
+		});
+		applyOptionalServerFields(server, entry);
+		return server;
+	}
+
+	if (!builtin) return null;
+	const server = createServer({
+		id,
+		command: entry.command ?? builtin.command,
+		extensions: entry.extensions ?? builtin.extensions,
+		priority: entry.priority ?? 0,
+		source,
+	});
+	applyOptionalServerFields(server, entry);
+	return server;
+}
+
+function createServer(input: {
+	readonly id: string;
+	readonly command: string[];
+	readonly extensions: string[];
+	readonly priority: number;
+	readonly source: ConfigSource;
+	readonly env?: Record<string, string>;
+	readonly initialization?: Record<string, unknown>;
+}): ServerWithSource {
+	const server: ServerWithSource = {
+		id: input.id,
+		command: input.command,
+		extensions: input.extensions,
+		priority: input.priority,
+		source: input.source,
+	};
+	if (input.env !== undefined) {
+		server.env = input.env;
+	}
+	if (input.initialization !== undefined) {
+		server.initialization = input.initialization;
+	}
+	return server;
+}
+
+function applyOptionalServerFields(server: ServerWithSource, entry: LspEntry): void {
+	if (entry.env !== undefined) {
+		server.env = entry.env;
+	}
+	if (entry.initialization !== undefined) {
+		server.initialization = entry.initialization;
+	}
+}
+
+function isConfigJson(value: unknown): value is ConfigJson {
+	if (!isRecord(value)) return false;
+	const lsp = value["lsp"];
+	return lsp === undefined || isRecord(lsp);
+}
+
+function parseLspEntry(value: unknown): LspEntry | null {
+	return isLspEntry(value) ? value : null;
+}
+
+function isLspEntry(value: unknown): value is LspEntry {
+	if (!isRecord(value)) return false;
+	const disabled = value["disabled"];
+	const command = value["command"];
+	const extensions = value["extensions"];
+	const priority = value["priority"];
+	const env = value["env"];
+	const initialization = value["initialization"];
+	return (
+		(disabled === undefined || typeof disabled === "boolean") &&
+		(command === undefined || isStringArray(command)) &&
+		(extensions === undefined || isStringArray(extensions)) &&
+		(priority === undefined || typeof priority === "number") &&
+		(env === undefined || isStringRecord(env)) &&
+		(initialization === undefined || isRecord(initialization))
+	);
+}
+
+function isStringArray(value: unknown): value is string[] {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+	return isRecord(value) && Object.values(value).every((item) => typeof item === "string");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function getDisabledServerIds(): Set<string> {
+	const configs = loadAllConfigs();
+	const disabled = new Set<string>();
+
+	for (const config of configs.values()) {
+		if (!config.lsp) continue;
+		for (const [id, rawEntry] of Object.entries(config.lsp)) {
+			const entry = parseLspEntry(rawEntry);
+			if (!entry) continue;
+			if (entry.disabled) disabled.add(id);
+		}
+	}
+
+	return disabled;
+}