@code-yeongyu/lazycodex 0.1.1

package/packages/lsp-tools-mcp/dist/lsp/directory-diagnostics.js

@@ -0,0 +1,123 @@
+import { existsSync, lstatSync, readdirSync } from "node:fs";
+import { extname, join, resolve } from "node:path";
+import { findWorkspaceRoot, formatServerLookupError } from "./client-wrapper.js";
+import { DEFAULT_MAX_DIAGNOSTICS, DEFAULT_MAX_DIRECTORY_FILES } from "./constants.js";
+import { LspInvalidPathError, LspServerLookupError } from "./errors.js";
+import { filterDiagnosticsBySeverity, formatDiagnostic } from "./formatters.js";
+import { getLspManager } from "./manager.js";
+import { findServerForExtension } from "./server-resolution.js";
+const SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
+export function collectFilesWithExtension(dir, extension, maxFiles) {
+    const files = [];
+    function walk(currentDir) {
+        if (files.length >= maxFiles)
+            return;
+        let entries = [];
+        try {
+            entries = readdirSync(currentDir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (files.length >= maxFiles)
+                return;
+            const fullPath = join(currentDir, entry);
+            let stat;
+            try {
+                stat = lstatSync(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (!stat || stat.isSymbolicLink())
+                continue;
+            if (stat.isDirectory()) {
+                if (!SKIP_DIRECTORIES.has(entry)) {
+                    walk(fullPath);
+                }
+            }
+            else if (stat.isFile() && extname(fullPath) === extension) {
+                files.push(fullPath);
+            }
+        }
+    }
+    walk(dir);
+    return files;
+}
+export async function aggregateDiagnosticsForDirectory(directory, extension, severity, maxFiles = DEFAULT_MAX_DIRECTORY_FILES) {
+    if (!extension.startsWith(".")) {
+        throw new LspInvalidPathError(`Extension must start with a dot (e.g., ".ts", not "${extension}"). Use ".${extension}" instead.`);
+    }
+    const absDir = resolve(directory);
+    if (!existsSync(absDir)) {
+        throw new LspInvalidPathError(`Directory does not exist: ${absDir}`);
+    }
+    const serverResult = findServerForExtension(extension);
+    if (serverResult.status !== "found") {
+        throw new LspServerLookupError(formatServerLookupError(serverResult));
+    }
+    const server = serverResult.server;
+    const allFiles = collectFilesWithExtension(absDir, extension, maxFiles + 1);
+    const wasCapped = allFiles.length > maxFiles;
+    const filesToProcess = allFiles.slice(0, maxFiles);
+    if (filesToProcess.length === 0) {
+        return [
+            `Directory: ${absDir}`,
+            `Extension: ${extension}`,
+            "Files scanned: 0",
+            `No files found with extension "${extension}".`,
+        ].join("\n");
+    }
+    const root = findWorkspaceRoot(absDir);
+    const manager = getLspManager();
+    const allDiagnostics = [];
+    const fileErrors = [];
+    const client = await manager.getClient(root, server);
+    try {
+        for (const file of filesToProcess) {
+            try {
+                const result = await client.diagnostics(file);
+                const filtered = filterDiagnosticsBySeverity(result.items, severity);
+                allDiagnostics.push(...filtered.map((diagnostic) => ({
+                    filePath: file,
+                    diagnostic,
+                })));
+            }
+            catch (e) {
+                fileErrors.push({
+                    file,
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+    }
+    finally {
+        manager.releaseClient(root, server.id);
+    }
+    const displayDiagnostics = allDiagnostics.slice(0, DEFAULT_MAX_DIAGNOSTICS);
+    const wasDiagCapped = allDiagnostics.length > DEFAULT_MAX_DIAGNOSTICS;
+    const lines = [
+        `Directory: ${absDir}`,
+        `Extension: ${extension}`,
+        `Files scanned: ${filesToProcess.length}${wasCapped ? ` (capped at ${maxFiles})` : ""}`,
+        `Files with errors: ${fileErrors.length}`,
+        `Total diagnostics: ${allDiagnostics.length}`,
+    ];
+    if (fileErrors.length > 0) {
+        lines.push("", "File processing errors:");
+        for (const { file, error } of fileErrors) {
+            lines.push(`  ${file}: ${error}`);
+        }
+    }
+    if (displayDiagnostics.length > 0) {
+        lines.push("");
+        for (const { filePath, diagnostic } of displayDiagnostics) {
+            lines.push(`${filePath}: ${formatDiagnostic(diagnostic)}`);
+        }
+        if (wasDiagCapped) {
+            lines.push("", `... (${allDiagnostics.length - DEFAULT_MAX_DIAGNOSTICS} more diagnostics not shown)`);
+        }
+    }
+    return lines.join("\n");
+}

package/packages/lsp-tools-mcp/dist/lsp/errors.d.ts

@@ -0,0 +1,35 @@
+export declare class LspConnectionClosedError extends Error {
+    readonly serverId: string;
+    readonly root: string;
+    readonly name = "LspConnectionClosedError";
+    constructor(serverId: string, root: string, message?: string);
+}
+export declare class LspProcessExitedError extends Error {
+    readonly serverId: string;
+    readonly root: string;
+    readonly exitCode: number | null;
+    readonly stderrTail?: string | undefined;
+    readonly name = "LspProcessExitedError";
+    constructor(serverId: string, root: string, exitCode: number | null, stderrTail?: string | undefined);
+}
+export declare class LspRequestTimeoutError extends Error {
+    readonly method: string;
+    readonly stderrTail?: string | undefined;
+    readonly name = "LspRequestTimeoutError";
+    constructor(method: string, stderrTail?: string | undefined);
+}
+export declare class LspInvalidPathError extends Error {
+    readonly name = "LspInvalidPathError";
+}
+export declare class LspServerLookupError extends Error {
+    readonly name = "LspServerLookupError";
+}
+export declare class LspServerInitializingError extends Error {
+    readonly originalError: LspRequestTimeoutError;
+    readonly name = "LspServerInitializingError";
+    constructor(originalError: LspRequestTimeoutError);
+}
+export declare class LspProcessSpawnError extends Error {
+    readonly name = "LspProcessSpawnError";
+}
+export declare function isLspDeadConnectionError(err: unknown): err is LspConnectionClosedError | LspProcessExitedError;

package/packages/lsp-tools-mcp/dist/lsp/errors.js

@@ -0,0 +1,56 @@
+export class LspConnectionClosedError extends Error {
+    constructor(serverId, root, message) {
+        super(message ?? `LSP connection closed for ${serverId} at ${root}`);
+        this.serverId = serverId;
+        this.root = root;
+        this.name = "LspConnectionClosedError";
+    }
+}
+export class LspProcessExitedError extends Error {
+    constructor(serverId, root, exitCode, stderrTail) {
+        const stderrSuffix = stderrTail ? `\nstderr tail: ${stderrTail}` : "";
+        super(`LSP server ${serverId} at ${root} exited with code ${exitCode ?? "null"}${stderrSuffix}`);
+        this.serverId = serverId;
+        this.root = root;
+        this.exitCode = exitCode;
+        this.stderrTail = stderrTail;
+        this.name = "LspProcessExitedError";
+    }
+}
+export class LspRequestTimeoutError extends Error {
+    constructor(method, stderrTail) {
+        const stderrSuffix = stderrTail ? `\nrecent stderr: ${stderrTail}` : "";
+        super(`LSP request timeout (method: ${method})${stderrSuffix}`);
+        this.method = method;
+        this.stderrTail = stderrTail;
+        this.name = "LspRequestTimeoutError";
+    }
+}
+export class LspInvalidPathError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "LspInvalidPathError";
+    }
+}
+export class LspServerLookupError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "LspServerLookupError";
+    }
+}
+export class LspServerInitializingError extends Error {
+    constructor(originalError) {
+        super(`LSP server is still initializing. Please retry in a few seconds. Original error: ${originalError.message}`);
+        this.originalError = originalError;
+        this.name = "LspServerInitializingError";
+    }
+}
+export class LspProcessSpawnError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "LspProcessSpawnError";
+    }
+}
+export function isLspDeadConnectionError(err) {
+    return err instanceof LspConnectionClosedError || err instanceof LspProcessExitedError;
+}

package/packages/lsp-tools-mcp/dist/lsp/formatters.d.ts

@@ -0,0 +1,12 @@
+import type { Diagnostic, DocumentSymbol, Location, LocationLink, PrepareRenameDefaultBehavior, PrepareRenameResult, Range, SeverityFilter, SymbolInfo } from "./types.js";
+import type { ApplyResult } from "./workspace-edit.js";
+export declare function uriToPath(uri: string): string;
+export declare function formatLocation(loc: Location | LocationLink): string;
+export declare function formatSymbolKind(kind: number): string;
+export declare function formatSeverity(severity: number | undefined): string;
+export declare function formatDocumentSymbol(symbol: DocumentSymbol, indent?: number): string;
+export declare function formatSymbolInfo(symbol: SymbolInfo): string;
+export declare function formatDiagnostic(diag: Diagnostic): string;
+export declare function filterDiagnosticsBySeverity(diagnostics: Diagnostic[], severityFilter?: SeverityFilter): Diagnostic[];
+export declare function formatPrepareRenameResult(result: PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null): string;
+export declare function formatApplyResult(result: ApplyResult): string;

package/packages/lsp-tools-mcp/dist/lsp/formatters.js

@@ -0,0 +1,106 @@
+import { fileURLToPath } from "node:url";
+import { SEVERITY_MAP, SYMBOL_KIND_MAP } from "./language-mappings.js";
+const DIAGNOSTIC_SEVERITY_FILTERS = {
+    error: 1,
+    warning: 2,
+    information: 3,
+    hint: 4,
+};
+export function uriToPath(uri) {
+    return fileURLToPath(uri);
+}
+export function formatLocation(loc) {
+    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) {
+    return SYMBOL_KIND_MAP[kind] ?? `Unknown(${kind})`;
+}
+export function formatSeverity(severity) {
+    if (!severity)
+        return "unknown";
+    return SEVERITY_MAP[severity] ?? `unknown(${severity})`;
+}
+export function formatDocumentSymbol(symbol, indent = 0) {
+    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) {
+    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) {
+    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, severityFilter) {
+    if (!severityFilter || severityFilter === "all") {
+        return diagnostics;
+    }
+    const targetSeverity = DIAGNOSTIC_SEVERITY_FILTERS[severityFilter];
+    return diagnostics.filter((d) => d.severity === targetSeverity);
+}
+export function formatPrepareRenameResult(result) {
+    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) {
+    const lines = [];
+    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}`);
+        }
+    }
+    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-tools-mcp/dist/lsp/infer-extension.d.ts

@@ -0,0 +1 @@
+export declare function inferExtensionFromDirectory(directory: string): string | null;

package/packages/lsp-tools-mcp/dist/lsp/infer-extension.js

@@ -0,0 +1,58 @@
+import { lstatSync, readdirSync } from "node:fs";
+import { extname, join } from "node:path";
+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) {
+    const extensionCounts = new Map();
+    let scanned = 0;
+    function walk(dir) {
+        if (scanned >= MAX_SCAN_ENTRIES)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (scanned >= MAX_SCAN_ENTRIES)
+                return;
+            const fullPath = join(dir, entry);
+            let stat;
+            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 = extname(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-tools-mcp/dist/lsp/json-rpc-connection.d.ts

@@ -0,0 +1,36 @@
+type NotificationHandler = (params: unknown) => void;
+type RequestHandler = (params: unknown) => Promise<unknown> | unknown;
+export declare class JsonRpcConnection {
+    private readonly reader;
+    private readonly writer;
+    private readonly pendingRequests;
+    private readonly notificationHandlers;
+    private readonly requestHandlers;
+    private readonly closeHandlers;
+    private readonly errorHandlers;
+    private inputBuffer;
+    private nextRequestId;
+    private listening;
+    private disposed;
+    constructor(reader: NodeJS.ReadableStream, writer: NodeJS.WritableStream);
+    listen(): void;
+    onNotification(method: string, handler: NotificationHandler): void;
+    onRequest(method: string, handler: RequestHandler): void;
+    onClose(handler: () => void): void;
+    onError(handler: (error: Error) => void): void;
+    sendRequest<T>(method: string, params?: unknown): Promise<T>;
+    sendNotification(method: string, params?: unknown): Promise<void>;
+    dispose(): void;
+    private readonly handleData;
+    private readonly handleClose;
+    private readonly handleStreamError;
+    private drainInputBuffer;
+    private dispatchBody;
+    private handleResponse;
+    private handleNotification;
+    private handleRequest;
+    private writeError;
+    private writeMessage;
+    private emitError;
+}
+export {};

package/packages/lsp-tools-mcp/dist/lsp/json-rpc-connection.js

@@ -0,0 +1,247 @@
+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 {
+    constructor(reader, writer) {
+        this.reader = reader;
+        this.writer = writer;
+        this.pendingRequests = new Map();
+        this.notificationHandlers = new Map();
+        this.requestHandlers = new Map();
+        this.closeHandlers = [];
+        this.errorHandlers = [];
+        this.inputBuffer = Buffer.alloc(0);
+        this.nextRequestId = 1;
+        this.listening = false;
+        this.disposed = false;
+        this.handleData = (chunk) => {
+            const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
+            this.inputBuffer = Buffer.concat([this.inputBuffer, chunkBuffer]);
+            this.drainInputBuffer();
+        };
+        this.handleClose = () => {
+            for (const handler of this.closeHandlers) {
+                handler();
+            }
+        };
+        this.handleStreamError = (error) => {
+            this.emitError(error);
+        };
+    }
+    listen() {
+        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, handler) {
+        this.notificationHandlers.set(method, handler);
+    }
+    onRequest(method, handler) {
+        this.requestHandlers.set(method, handler);
+    }
+    onClose(handler) {
+        this.closeHandlers.push(handler);
+    }
+    onError(handler) {
+        this.errorHandlers.push(handler);
+    }
+    async sendRequest(method, params) {
+        if (this.disposed)
+            throw new Error("JSON-RPC connection is disposed");
+        const id = this.nextRequestId;
+        this.nextRequestId += 1;
+        const message = params === undefined ? { jsonrpc: "2.0", id, method } : { jsonrpc: "2.0", id, method, params };
+        const responsePromise = new Promise((resolve, reject) => {
+            this.pendingRequests.set(String(id), {
+                resolve(result) {
+                    resolve(result);
+                },
+                reject,
+            });
+        });
+        try {
+            await this.writeMessage(message);
+        }
+        catch (error) {
+            this.pendingRequests.delete(String(id));
+            throw error;
+        }
+        return responsePromise;
+    }
+    async sendNotification(method, params) {
+        if (this.disposed)
+            return;
+        const message = params === undefined ? { jsonrpc: "2.0", method } : { jsonrpc: "2.0", method, params };
+        await this.writeMessage(message);
+    }
+    dispose() {
+        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.reject(new Error("JSON-RPC connection disposed"));
+        }
+        this.pendingRequests.clear();
+        this.notificationHandlers.clear();
+        this.requestHandlers.clear();
+    }
+    drainInputBuffer() {
+        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);
+        }
+    }
+    dispatchBody(body) {
+        let parsed;
+        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"]);
+    }
+    handleResponse(message) {
+        const id = getMessageId(message);
+        if (id === undefined)
+            return;
+        const pending = this.pendingRequests.get(String(id));
+        if (!pending)
+            return;
+        this.pendingRequests.delete(String(id));
+        if ("error" in message) {
+            pending.reject(jsonRpcErrorToError(message["error"]));
+            return;
+        }
+        pending.resolve(message["result"]);
+    }
+    handleNotification(method, params) {
+        const handler = this.notificationHandlers.get(method);
+        if (!handler)
+            return;
+        try {
+            handler(params);
+        }
+        catch (error) {
+            this.emitError(toError(error));
+        }
+    }
+    handleRequest(message) {
+        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)));
+    }
+    async writeError(id, code, message) {
+        await this.writeMessage({ jsonrpc: "2.0", id, error: { code, message } });
+    }
+    writeMessage(message) {
+        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) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    emitError(error) {
+        for (const handler of this.errorHandlers) {
+            handler(error);
+        }
+    }
+}
+function parseContentLength(headers) {
+    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) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getMessageId(message) {
+    const id = message["id"];
+    if (typeof id === "number" || typeof id === "string" || id === null)
+        return id;
+    return undefined;
+}
+function jsonRpcErrorToError(value) {
+    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) {
+    return error instanceof Error ? error : new Error(String(error));
+}

package/packages/lsp-tools-mcp/dist/lsp/language-mappings.d.ts

@@ -0,0 +1,4 @@
+export declare const SYMBOL_KIND_MAP: Record<number, string>;
+export declare const SEVERITY_MAP: Record<number, string>;
+export declare const EXT_TO_LANG: Record<string, string>;
+export declare function getLanguageId(ext: string): string;