lazycodex-ai 5.1.47 → 5.1.51

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

@@ -0,0 +1,144 @@
+import { fileURLToPath } from "node:url";
+
+import { SEVERITY_MAP, SYMBOL_KIND_MAP } from "./language-mappings.js";
+import type {
+	Diagnostic,
+	DocumentSymbol,
+	Location,
+	LocationLink,
+	PrepareRenameDefaultBehavior,
+	PrepareRenameResult,
+	Range,
+	SeverityFilter,
+	SymbolInfo,
+} from "./types.js";
+import type { ApplyResult } from "./workspace-edit.js";
+
+type FilteredSeverity = Exclude<SeverityFilter, "all">;
+
+const DIAGNOSTIC_SEVERITY_FILTERS = {
+	error: 1,
+	warning: 2,
+	information: 3,
+	hint: 4,
+} as const satisfies Readonly<Record<FilteredSeverity, number>>;
+
+export function uriToPath(uri: string): string {
+	return fileURLToPath(uri);
+}
+
+export function formatLocation(loc: Location | LocationLink): string {
+	if ("targetUri" in loc) {
+		const uri = uriToPath(loc.targetUri);
+		const line = loc.targetRange.start.line + 1;
+		const char = loc.targetRange.start.character;
+		return `${uri}:${line}:${char}`;
+	}
+
+	const uri = uriToPath(loc.uri);
+	const line = loc.range.start.line + 1;
+	const char = loc.range.start.character;
+	return `${uri}:${line}:${char}`;
+}
+
+export function formatSymbolKind(kind: number): string {
+	return SYMBOL_KIND_MAP[kind] ?? `Unknown(${kind})`;
+}
+
+export function formatSeverity(severity: number | undefined): string {
+	if (!severity) return "unknown";
+	return SEVERITY_MAP[severity] ?? `unknown(${severity})`;
+}
+
+export function formatDocumentSymbol(symbol: DocumentSymbol, indent = 0): string {
+	const prefix = "  ".repeat(indent);
+	const kind = formatSymbolKind(symbol.kind);
+	const line = symbol.range.start.line + 1;
+	let result = `${prefix}${symbol.name} (${kind}) - line ${line}`;
+
+	if (symbol.children && symbol.children.length > 0) {
+		for (const child of symbol.children) {
+			result += `\n${formatDocumentSymbol(child, indent + 1)}`;
+		}
+	}
+
+	return result;
+}
+
+export function formatSymbolInfo(symbol: SymbolInfo): string {
+	const kind = formatSymbolKind(symbol.kind);
+	const loc = formatLocation(symbol.location);
+	const container = symbol.containerName ? ` (in ${symbol.containerName})` : "";
+	return `${symbol.name} (${kind})${container} - ${loc}`;
+}
+
+export function formatDiagnostic(diag: Diagnostic): string {
+	const severity = formatSeverity(diag.severity);
+	const line = diag.range.start.line + 1;
+	const char = diag.range.start.character;
+	const source = diag.source ? `[${diag.source}]` : "";
+	const code = diag.code ? ` (${diag.code})` : "";
+	return `${severity}${source}${code} at ${line}:${char}: ${diag.message}`;
+}
+
+export function filterDiagnosticsBySeverity(diagnostics: Diagnostic[], severityFilter?: SeverityFilter): Diagnostic[] {
+	if (!severityFilter || severityFilter === "all") {
+		return diagnostics;
+	}
+
+	const targetSeverity = DIAGNOSTIC_SEVERITY_FILTERS[severityFilter];
+	return diagnostics.filter((d) => d.severity === targetSeverity);
+}
+
+export function formatPrepareRenameResult(
+	result: PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null,
+): string {
+	if (!result) return "Cannot rename at this position";
+
+	if ("defaultBehavior" in result) {
+		return result.defaultBehavior ? "Rename supported (using default behavior)" : "Cannot rename at this position";
+	}
+
+	if ("range" in result && result.range) {
+		const startLine = result.range.start.line + 1;
+		const startChar = result.range.start.character;
+		const endLine = result.range.end.line + 1;
+		const endChar = result.range.end.character;
+		const placeholder = result.placeholder ? ` (current: "${result.placeholder}")` : "";
+		return `Rename available at ${startLine}:${startChar}-${endLine}:${endChar}${placeholder}`;
+	}
+
+	if ("start" in result && "end" in result) {
+		const startLine = result.start.line + 1;
+		const startChar = result.start.character;
+		const endLine = result.end.line + 1;
+		const endChar = result.end.character;
+		return `Rename available at ${startLine}:${startChar}-${endLine}:${endChar}`;
+	}
+
+	return "Cannot rename at this position";
+}
+
+export function formatApplyResult(result: ApplyResult): string {
+	const lines: string[] = [];
+
+	if (result.success) {
+		lines.push(`Applied ${result.totalEdits} edit(s) to ${result.filesModified.length} file(s):`);
+		for (const file of result.filesModified) {
+			lines.push(`  - ${file}`);
+		}
+		if (result.lateAbort) {
+			lines.push("Cancellation arrived after the filesystem commit began; the committed edit completed.");
+		}
+	} else {
+		lines.push("Failed to apply some changes:");
+		for (const err of result.errors) {
+			lines.push(`  Error: ${err}`);
+		}
+		if (result.filesModified.length > 0) {
+			lines.push(`Successfully modified: ${result.filesModified.join(", ")}`);
+		}
+	}
+
+	return lines.join("\n");
+}

package/packages/lsp-core/src/lsp/infer-extension.ts

@@ -0,0 +1,66 @@
+import { lstatSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+import { effectiveExtension } from "./effective-extension.js";
+import { EXT_TO_LANG } from "./language-mappings.js";
+
+const SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
+const MAX_SCAN_ENTRIES = 500;
+
+export function inferExtensionFromDirectory(directory: string): string | null {
+	const extensionCounts = new Map<string, number>();
+	let scanned = 0;
+
+	function walk(dir: string): void {
+		if (scanned >= MAX_SCAN_ENTRIES) return;
+
+		let entries: string[];
+		try {
+			entries = readdirSync(dir);
+		} catch {
+			return;
+		}
+
+		for (const entry of entries) {
+			if (scanned >= MAX_SCAN_ENTRIES) return;
+
+			const fullPath = join(dir, entry);
+
+			let stat: ReturnType<typeof lstatSync> | undefined;
+			try {
+				stat = lstatSync(fullPath);
+			} catch {
+				continue;
+			}
+
+			if (stat.isSymbolicLink()) continue;
+			scanned++;
+
+			if (stat.isDirectory()) {
+				if (!SKIP_DIRECTORIES.has(entry)) {
+					walk(fullPath);
+				}
+			} else if (stat.isFile()) {
+				const ext = effectiveExtension(fullPath);
+				if (ext && ext in EXT_TO_LANG) {
+					extensionCounts.set(ext, (extensionCounts.get(ext) ?? 0) + 1);
+				}
+			}
+		}
+	}
+
+	walk(directory);
+
+	if (extensionCounts.size === 0) return null;
+
+	let maxExt = "";
+	let maxCount = 0;
+	for (const [ext, count] of extensionCounts) {
+		if (count > maxCount) {
+			maxCount = count;
+			maxExt = ext;
+		}
+	}
+
+	return maxExt || null;
+}

package/packages/lsp-core/src/lsp/json-rpc-connection-cancellation.test.ts

@@ -0,0 +1,97 @@
+import { PassThrough } from "node:stream";
+
+import { describe, expect, it } from "bun:test";
+
+import { JsonRpcConnection } from "./json-rpc-connection.js";
+
+type JsonMessage = Record<string, unknown>;
+
+function messageId(message: JsonMessage): string | number | null | undefined {
+	const id = message["id"];
+	return typeof id === "string" || typeof id === "number" || id === null ? id : undefined;
+}
+
+function cancelTarget(message: JsonMessage): string | number | undefined {
+	const params = message["params"];
+	if (!params || typeof params !== "object" || Array.isArray(params)) return undefined;
+	const id = Reflect.get(params, "id");
+	return typeof id === "string" || typeof id === "number" ? id : undefined;
+}
+
+function encodeMessage(message: JsonMessage): string {
+	const body = JSON.stringify(message);
+	return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+
+function recordJsonRpcMessages(stream: PassThrough) {
+	const messages: JsonMessage[] = [];
+	const waiters: Array<() => void> = [];
+	let buffer = Buffer.alloc(0);
+	stream.on("data", (chunk: Buffer) => {
+		buffer = Buffer.concat([buffer, chunk]);
+		for (;;) {
+			const headerEnd = buffer.indexOf("\r\n\r\n");
+			if (headerEnd === -1) return;
+			const header = buffer.subarray(0, headerEnd).toString("ascii");
+			const match = /content-length:\s*(\d+)/i.exec(header);
+			if (!match?.[1]) throw new Error("missing content-length");
+			const bodyStart = headerEnd + 4;
+			const bodyEnd = bodyStart + Number.parseInt(match[1], 10);
+			if (buffer.length < bodyEnd) return;
+			const parsed: unknown = JSON.parse(buffer.subarray(bodyStart, bodyEnd).toString("utf8"));
+			buffer = buffer.subarray(bodyEnd);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+				messages.push(Object.fromEntries(Object.entries(parsed)));
+			}
+			for (const wake of waiters.splice(0)) wake();
+		}
+	});
+	return {
+		messages,
+		waitForCount(count: number): Promise<void> {
+			if (messages.length >= count) return Promise.resolve();
+			return new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					reject(new Error(`waited for ${count} JSON-RPC messages, observed ${messages.length}`));
+				}, 1_000);
+				const wake = (): void => {
+					if (messages.length < count) {
+						waiters.push(wake);
+						return;
+					}
+					clearTimeout(timer);
+					resolve();
+				};
+				waiters.push(wake);
+			});
+		},
+	};
+}
+
+describe("JsonRpcConnection cancellation", () => {
+	it("#given an active request #when its signal aborts #then cancel uses the same id and late responses are ignored", async () => {
+		const serverToClient = new PassThrough();
+		const clientToServer = new PassThrough();
+		const recorder = recordJsonRpcMessages(clientToServer);
+		const connection = new JsonRpcConnection(serverToClient, clientToServer);
+		connection.listen();
+		const controller = new AbortController();
+
+		const request = connection.sendRequest("textDocument/diagnostic", { textDocument: { uri: "file:///a.ts" } }, {
+			signal: controller.signal,
+		});
+		await recorder.waitForCount(1);
+		const requestId = messageId(recorder.messages[0] ?? {});
+		expect(typeof requestId === "string" || typeof requestId === "number").toBe(true);
+
+		controller.abort(new Error("caller cancelled"));
+		await recorder.waitForCount(2);
+		await expect(request).rejects.toThrow("caller cancelled");
+		expect(connection.pendingRequestCount()).toBe(0);
+		expect(recorder.messages[1]?.["method"]).toBe("$/cancelRequest");
+		expect(cancelTarget(recorder.messages[1] ?? {})).toBe(typeof requestId === "number" || typeof requestId === "string" ? requestId : undefined);
+
+		serverToClient.write(encodeMessage({ jsonrpc: "2.0", id: requestId ?? null, result: { items: [] } }));
+		expect(connection.pendingRequestCount()).toBe(0);
+	});
+});

package/packages/lsp-core/src/lsp/json-rpc-connection.ts

@@ -0,0 +1,369 @@
+type JsonRpcId = number | string | null;
+
+interface PendingRequest {
+	resolve(result: unknown): void;
+	reject(error: Error): void;
+	cleanup(): void;
+}
+
+type NotificationHandler = (params: unknown) => void;
+type RequestHandler = (params: unknown) => Promise<unknown> | unknown;
+
+export interface JsonRpcRequestOptions {
+	readonly signal?: AbortSignal;
+}
+
+const HEADER_SEPARATOR = "\r\n\r\n";
+const PARSE_ERROR = -32700;
+const INVALID_REQUEST = -32600;
+const METHOD_NOT_FOUND = -32601;
+const INTERNAL_ERROR = -32603;
+
+export class JsonRpcConnection {
+	private readonly pendingRequests = new Map<string, PendingRequest>();
+	private readonly notificationHandlers = new Map<string, NotificationHandler>();
+	private readonly requestHandlers = new Map<string, RequestHandler>();
+	private readonly closeHandlers: Array<() => void> = [];
+	private readonly errorHandlers: Array<(error: Error) => void> = [];
+	private inputBuffer = Buffer.alloc(0);
+	private nextRequestId = 1;
+	private listening = false;
+	private disposed = false;
+
+	constructor(
+		private readonly reader: NodeJS.ReadableStream,
+		private readonly writer: NodeJS.WritableStream,
+	) {}
+
+	listen(): void {
+		if (this.listening) return;
+		this.listening = true;
+		this.reader.on("data", this.handleData);
+		this.reader.on("close", this.handleClose);
+		this.reader.on("end", this.handleClose);
+		this.reader.on("error", this.handleStreamError);
+		this.writer.on("error", this.handleStreamError);
+	}
+
+	onNotification(method: string, handler: NotificationHandler): void {
+		this.notificationHandlers.set(method, handler);
+	}
+
+	onRequest(method: string, handler: RequestHandler): void {
+		this.requestHandlers.set(method, handler);
+	}
+
+	onClose(handler: () => void): void {
+		this.closeHandlers.push(handler);
+	}
+
+	onError(handler: (error: Error) => void): void {
+		this.errorHandlers.push(handler);
+	}
+
+	async sendRequest<T>(method: string, params?: unknown, options: JsonRpcRequestOptions = {}): Promise<T> {
+		if (this.disposed) throw new Error("JSON-RPC connection is disposed");
+
+		const id = this.nextRequestId;
+		this.nextRequestId += 1;
+		const key = String(id);
+		const message = params === undefined ? { jsonrpc: "2.0", id, method } : { jsonrpc: "2.0", id, method, params };
+		let requestWritten = false;
+		let cancelAfterWrite = false;
+		let settled = false;
+		const writeCancel = (): Promise<void> => this.writeMessage({ jsonrpc: "2.0", method: "$/cancelRequest", params: { id } });
+
+		let rejectAfterCancelWrite: (() => Promise<void>) | undefined;
+		const responsePromise = new Promise<T>((resolve, reject) => {
+			const cleanup = (): void => {
+				options.signal?.removeEventListener("abort", onAbort);
+			};
+			const settleCancel = (): void => {
+				if (settled) return;
+				settled = true;
+				this.pendingRequests.delete(key);
+				cleanup();
+				const rejectCancelled = (): void => reject(abortError(options.signal));
+				rejectAfterCancelWrite = async (): Promise<void> => {
+					try {
+						await writeCancel();
+					} catch (error) {
+						this.emitError(toError(error));
+					}
+					rejectCancelled();
+				};
+				if (!requestWritten) {
+					cancelAfterWrite = true;
+					return;
+				}
+				void rejectAfterCancelWrite();
+			};
+			const onAbort = (): void => settleCancel();
+			this.pendingRequests.set(key, {
+				resolve(result) {
+					settled = true;
+					cleanup();
+					resolve(result as T);
+				},
+				reject(error) {
+					settled = true;
+					cleanup();
+					reject(error);
+				},
+				cleanup,
+			});
+			if (options.signal?.aborted) {
+				settleCancel();
+				return;
+			}
+			options.signal?.addEventListener("abort", onAbort, { once: true });
+		});
+
+		if (settled) return responsePromise;
+		try {
+			await this.writeMessage(message);
+			requestWritten = true;
+			if (cancelAfterWrite) await rejectAfterCancelWrite?.();
+		} catch (error) {
+			if (settled) return responsePromise;
+			const pending = this.pendingRequests.get(key);
+			if (pending) {
+				pending.cleanup();
+				this.pendingRequests.delete(key);
+			}
+			throw error;
+		}
+
+		return responsePromise;
+	}
+
+	pendingRequestCount(): number {
+		return this.pendingRequests.size;
+	}
+
+	async sendNotification(method: string, params?: unknown): Promise<void> {
+		if (this.disposed) return;
+		const message = params === undefined ? { jsonrpc: "2.0", method } : { jsonrpc: "2.0", method, params };
+		await this.writeMessage(message);
+	}
+
+	dispose(): void {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.reader.off("data", this.handleData);
+		this.reader.off("close", this.handleClose);
+		this.reader.off("end", this.handleClose);
+		this.reader.off("error", this.handleStreamError);
+		this.writer.off("error", this.handleStreamError);
+		for (const pending of this.pendingRequests.values()) {
+			pending.cleanup();
+			pending.reject(new Error("JSON-RPC connection disposed"));
+		}
+		this.pendingRequests.clear();
+		this.notificationHandlers.clear();
+		this.requestHandlers.clear();
+	}
+
+	private readonly handleData = (chunk: Buffer | string): void => {
+		const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
+		this.inputBuffer = Buffer.concat([this.inputBuffer, chunkBuffer]);
+		this.drainInputBuffer();
+	};
+
+	private readonly handleClose = (): void => {
+		for (const handler of this.closeHandlers) {
+			handler();
+		}
+	};
+
+	private readonly handleStreamError = (error: Error): void => {
+		this.emitError(error);
+	};
+
+	private drainInputBuffer(): void {
+		while (true) {
+			const headerEnd = this.inputBuffer.indexOf(HEADER_SEPARATOR);
+			if (headerEnd === -1) return;
+
+			const headers = this.inputBuffer.subarray(0, headerEnd).toString("ascii");
+			const contentLength = parseContentLength(headers);
+			if (contentLength === null) {
+				this.inputBuffer = Buffer.alloc(0);
+				this.emitError(new Error("JSON-RPC message is missing Content-Length header"));
+				return;
+			}
+
+			const bodyStart = headerEnd + Buffer.byteLength(HEADER_SEPARATOR);
+			const bodyEnd = bodyStart + contentLength;
+			if (this.inputBuffer.length < bodyEnd) return;
+
+			const body = this.inputBuffer.subarray(bodyStart, bodyEnd).toString("utf8");
+			this.inputBuffer = this.inputBuffer.subarray(bodyEnd);
+			this.dispatchBody(body);
+		}
+	}
+
+	private dispatchBody(body: string): void {
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(body);
+		} catch (error) {
+			void this.writeError(null, PARSE_ERROR, error instanceof Error ? error.message : "Parse error").catch(
+				(writeError) => this.emitError(toError(writeError)),
+			);
+			return;
+		}
+
+		if (!isJsonRpcObject(parsed)) {
+			void this.writeError(null, INVALID_REQUEST, "Invalid JSON-RPC message").catch((error) =>
+				this.emitError(toError(error)),
+			);
+			return;
+		}
+
+		if ("id" in parsed && ("result" in parsed || "error" in parsed)) {
+			this.handleResponse(parsed);
+			return;
+		}
+
+		if (typeof parsed["method"] !== "string") {
+			const id = getMessageId(parsed) ?? null;
+			void this.writeError(id, INVALID_REQUEST, "Invalid JSON-RPC method").catch((error) =>
+				this.emitError(toError(error)),
+			);
+			return;
+		}
+
+		if ("id" in parsed) {
+			this.handleRequest(parsed);
+			return;
+		}
+
+		this.handleNotification(parsed["method"], parsed["params"]);
+	}
+
+	private handleResponse(message: Record<string, unknown>): void {
+		const id = getMessageId(message);
+		if (id === undefined) return;
+		const pending = this.pendingRequests.get(String(id));
+		if (!pending) return;
+		this.pendingRequests.delete(String(id));
+		pending.cleanup();
+
+		if ("error" in message) {
+			pending.reject(jsonRpcErrorToError(message["error"]));
+			return;
+		}
+
+		pending.resolve(message["result"]);
+	}
+
+	private handleNotification(method: string, params: unknown): void {
+		const handler = this.notificationHandlers.get(method);
+		if (!handler) return;
+		try {
+			handler(params);
+		} catch (error) {
+			if (error instanceof Error) {
+				this.emitError(error);
+				return;
+			}
+			this.emitError(new Error(String(error)));
+		}
+	}
+
+	private handleRequest(message: Record<string, unknown>): void {
+		const id = getMessageId(message);
+		if (id === undefined) {
+			void this.writeError(null, INVALID_REQUEST, "Invalid JSON-RPC id").catch((error) =>
+				this.emitError(toError(error)),
+			);
+			return;
+		}
+
+		const method = typeof message["method"] === "string" ? message["method"] : "";
+		const handler = this.requestHandlers.get(method);
+		if (!handler) {
+			void this.writeError(id, METHOD_NOT_FOUND, `Method not found: ${method}`).catch((error) =>
+				this.emitError(toError(error)),
+			);
+			return;
+		}
+
+		Promise.resolve()
+			.then(() => handler(message["params"]))
+			.then(
+				(result) => this.writeMessage({ jsonrpc: "2.0", id, result }),
+				(error) => this.writeError(id, INTERNAL_ERROR, toError(error).message),
+			)
+			.catch((error) => this.emitError(toError(error)));
+	}
+
+	private async writeError(id: JsonRpcId, code: number, message: string): Promise<void> {
+		await this.writeMessage({ jsonrpc: "2.0", id, error: { code, message } });
+	}
+
+	private writeMessage(message: Record<string, unknown>): Promise<void> {
+		const body = JSON.stringify(message);
+		const payload = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+		return new Promise((resolve, reject) => {
+			this.writer.write(payload, (error?: Error | null) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve();
+			});
+		});
+	}
+
+	private emitError(error: Error): void {
+		for (const handler of this.errorHandlers) {
+			handler(error);
+		}
+	}
+}
+
+function abortError(signal: AbortSignal | undefined): Error {
+	const reason = signal?.reason;
+	if (reason instanceof Error) return reason;
+	const error = new Error(typeof reason === "string" ? reason : "LSP request cancelled");
+	error.name = "AbortError";
+	return error;
+}
+
+function parseContentLength(headers: string): number | null {
+	for (const line of headers.split("\r\n")) {
+		const separatorIndex = line.indexOf(":");
+		if (separatorIndex === -1) continue;
+		const name = line.slice(0, separatorIndex).trim().toLowerCase();
+		if (name !== "content-length") continue;
+		const value = Number.parseInt(line.slice(separatorIndex + 1).trim(), 10);
+		return Number.isFinite(value) && value >= 0 ? value : null;
+	}
+	return null;
+}
+
+function isJsonRpcObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function getMessageId(message: Record<string, unknown>): JsonRpcId | undefined {
+	const id = message["id"];
+	if (typeof id === "number" || typeof id === "string" || id === null) return id;
+	return undefined;
+}
+
+function jsonRpcErrorToError(value: unknown): Error {
+	if (!isJsonRpcObject(value)) return new Error("JSON-RPC request failed");
+	const message = typeof value["message"] === "string" ? value["message"] : "JSON-RPC request failed";
+	const error = new Error(message);
+	if (typeof value["code"] === "number") {
+		error.name = `JsonRpcError(${value["code"]})`;
+	}
+	return error;
+}
+
+function toError(error: unknown): Error {
+	return error instanceof Error ? error : new Error(String(error));
+}