@greppleai/grip 0.0.0-stage → 0.1.3

package/dist/core/lsp/client.js

@@ -0,0 +1,586 @@
+import { CodeActionKind, ResourceOperationKind, TextDocumentSyncKind } from "vscode-languageserver-protocol";
+import { CancellationTokenSource, createMessageConnection, } from "vscode-languageserver-protocol/node.js";
+import { waitForAbort } from "./abort.js";
+import { pathApi, pathFlavor, portablePathToFileUri } from "./portable-path.js";
+const MAX_INVALIDATION_CLOSE_MS = 3000;
+function createDeadline(timeoutMs) {
+    return {
+        timeoutMs,
+        expiresAt: timeoutMs !== undefined && timeoutMs > 0 ? Date.now() + timeoutMs : undefined,
+    };
+}
+async function waitForOperation(promise, deadline, description, options = {}) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let timer;
+        const cleanup = () => {
+            if (timer)
+                clearTimeout(timer);
+            options.signal?.removeEventListener("abort", abort);
+        };
+        const succeed = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(value);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error);
+        };
+        const abort = () => {
+            fail(new Error(options.abortMessage ?? `${description} was aborted`));
+            options.onAbort?.();
+        };
+        promise.then(succeed, fail);
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+        if (!settled && deadline.expiresAt !== undefined) {
+            const remainingMs = deadline.expiresAt - Date.now();
+            if (remainingMs <= 0) {
+                const timeoutError = new Error(`${description} timed out after ${deadline.timeoutMs}ms`);
+                fail(timeoutError);
+                options.onTimeout?.();
+            }
+            else {
+                timer = setTimeout(() => {
+                    const timeoutError = new Error(`${description} timed out after ${deadline.timeoutMs}ms`);
+                    fail(timeoutError);
+                    options.onTimeout?.();
+                }, remainingMs);
+            }
+        }
+    });
+}
+function withTimeout(promise, timeoutMs, description, onTimeout) {
+    return waitForOperation(promise, createDeadline(timeoutMs), description, { onTimeout });
+}
+function settingsForSection(settings, section) {
+    if (settings === undefined)
+        return null;
+    if (!section)
+        return settings;
+    let current = settings;
+    for (const segment of section.split(".")) {
+        if (typeof current !== "object" ||
+            current === null ||
+            Array.isArray(current) ||
+            !Object.hasOwn(current, segment)) {
+            return null;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+export class LspClient {
+    serverId;
+    languageId;
+    rootDir;
+    rootUri;
+    options;
+    connectionHandle;
+    connection;
+    capabilities;
+    diagnostics = new Map();
+    initialized = false;
+    disposed = false;
+    closing = false;
+    startController;
+    startPromise;
+    shutdownPromise;
+    lifecycleGeneration = 0;
+    handleClosePromises = new WeakMap();
+    endpoint;
+    transportError;
+    requestError;
+    stderr = "";
+    state = "idle";
+    constructor(options) {
+        this.options = options;
+        this.serverId = options.serverId;
+        this.languageId = options.languageId;
+        this.rootDir = options.rootDir;
+        this.rootUri = options.rootUri ?? portablePathToFileUri(options.rootDir);
+    }
+    get isInitialized() {
+        return this.initialized;
+    }
+    get isDisposed() {
+        return this.disposed;
+    }
+    get serverCapabilities() {
+        return this.capabilities;
+    }
+    get documentSyncCapabilities() {
+        const synchronization = this.serverCapabilities?.textDocumentSync;
+        if (typeof synchronization === "number") {
+            return {
+                openClose: synchronization !== TextDocumentSyncKind.None,
+                change: synchronization,
+                save: false,
+                saveIncludeText: false,
+            };
+        }
+        if (!synchronization) {
+            return { openClose: false, change: TextDocumentSyncKind.None, save: false, saveIncludeText: false };
+        }
+        const save = synchronization.save;
+        return {
+            openClose: synchronization.openClose === true,
+            change: synchronization.change ?? TextDocumentSyncKind.None,
+            save: save === true || typeof save === "object",
+            saveIncludeText: typeof save === "object" && save.includeText === true,
+        };
+    }
+    get connectionEndpoint() {
+        return this.endpoint;
+    }
+    get lastTransportError() {
+        return this.transportError;
+    }
+    get lastRequestError() {
+        return this.requestError;
+    }
+    get stderrOutput() {
+        return this.stderr;
+    }
+    get connectionState() {
+        return this.state;
+    }
+    get ownership() {
+        return this.options.ownership ?? "managed";
+    }
+    get workspaceFolder() {
+        return { uri: this.rootUri, name: pathApi(pathFlavor(this.rootDir)).basename(this.rootDir) || this.rootDir };
+    }
+    getDiagnostics(uri) {
+        return this.diagnostics.get(uri) ?? [];
+    }
+    getAllDiagnostics() {
+        return new Map(this.diagnostics);
+    }
+    start() {
+        if (this.startPromise)
+            return this.startPromise;
+        this.startPromise = (async () => {
+            try {
+                return await this.startInternal();
+            }
+            finally {
+                this.startPromise = undefined;
+            }
+        })();
+        return this.startPromise;
+    }
+    async connectForStartup(controller) {
+        let resolvedHandle;
+        let discardHandle = false;
+        const handlePromise = Promise.resolve().then(() => this.options.connectionFactory({
+            serverId: this.serverId,
+            workspaceRoot: this.rootDir,
+            workspaceUri: this.rootUri,
+            signal: controller.signal,
+            connectTimeoutMs: this.options.connectTimeoutMs,
+            onStderr: (text) => {
+                this.stderr = `${this.stderr}${text}`.slice(-16_384);
+                this.options.onStderr?.(text);
+            },
+        }));
+        void handlePromise.then((handle) => {
+            resolvedHandle = handle;
+            if (discardHandle)
+                void this.closeConnectionHandle(handle);
+        }, () => undefined);
+        try {
+            return await waitForOperation(handlePromise, createDeadline(this.options.connectTimeoutMs), `Connecting to LSP server ${this.serverId}`, {
+                signal: controller.signal,
+                onTimeout: () => controller.abort(),
+                abortMessage: `LSP client startup for ${this.serverId} was aborted`,
+            });
+        }
+        catch (error) {
+            discardHandle = true;
+            controller.abort();
+            if (resolvedHandle)
+                void this.closeConnectionHandle(resolvedHandle);
+            throw error;
+        }
+    }
+    attachConnectionHandle(handle) {
+        this.connectionHandle = handle;
+        this.state = "initializing";
+        this.endpoint = handle.endpoint;
+        handle.onError((error) => {
+            if (this.connectionHandle === handle)
+                this.recordTransportError(error);
+        });
+        handle.onClose(() => {
+            if (this.connectionHandle !== handle)
+                return;
+            this.initialized = false;
+            void this.closeHandle();
+            if (!this.closing)
+                this.state = this.disposed ? "disposed" : "closed";
+            this.disposeConnection();
+            if (!this.disposed && !this.closing)
+                this.options.onUnexpectedClose?.(this.transportError);
+        });
+        this.connection = createMessageConnection(handle.reader, handle.writer);
+        this.registerConnectionHandlers();
+        this.connection.listen();
+    }
+    createInitializeParams() {
+        return {
+            processId: this.ownership === "attached" ? null : process.pid,
+            rootUri: this.rootUri,
+            workspaceFolders: [this.workspaceFolder],
+            capabilities: {
+                textDocument: {
+                    synchronization: { didSave: true, dynamicRegistration: false },
+                    hover: { contentFormat: ["plaintext", "markdown"] },
+                    definition: {},
+                    references: {},
+                    rename: { prepareSupport: false },
+                    publishDiagnostics: { relatedInformation: true },
+                    codeAction: {
+                        dynamicRegistration: false,
+                        codeActionLiteralSupport: {
+                            codeActionKind: {
+                                valueSet: [
+                                    CodeActionKind.Empty,
+                                    CodeActionKind.QuickFix,
+                                    CodeActionKind.Refactor,
+                                    CodeActionKind.RefactorExtract,
+                                    CodeActionKind.RefactorInline,
+                                    CodeActionKind.RefactorRewrite,
+                                    CodeActionKind.Source,
+                                    CodeActionKind.SourceOrganizeImports,
+                                    CodeActionKind.SourceFixAll,
+                                ],
+                            },
+                        },
+                        isPreferredSupport: true,
+                        dataSupport: true,
+                    },
+                },
+                workspace: {
+                    configuration: true,
+                    workspaceFolders: true,
+                    workspaceEdit: {
+                        documentChanges: true,
+                        resourceOperations: [
+                            ResourceOperationKind.Create,
+                            ResourceOperationKind.Rename,
+                            ResourceOperationKind.Delete,
+                        ],
+                    },
+                },
+            },
+            clientInfo: this.options.clientInfo ?? { name: "@greppleai/grip" },
+            ...(this.options.initializationOptions === undefined
+                ? {}
+                : { initializationOptions: this.options.initializationOptions }),
+            ...(this.options.locale === undefined ? {} : { locale: this.options.locale }),
+            ...(this.options.trace === undefined ? {} : { trace: this.options.trace }),
+        };
+    }
+    async initializeConnection(generation, controller, handle) {
+        if (!this.connection)
+            throw new Error(`Connection to LSP server ${this.serverId} closed during initialization`);
+        const deadline = createDeadline(this.options.initializeTimeoutMs);
+        const description = `Initializing LSP server ${this.serverId}`;
+        const cancellation = new CancellationTokenSource();
+        let result;
+        try {
+            result = await waitForOperation(this.connection.sendRequest("initialize", this.createInitializeParams(), cancellation.token), deadline, description, {
+                signal: controller.signal,
+                onTimeout: () => cancellation.cancel(),
+                onAbort: () => cancellation.cancel(),
+                abortMessage: `LSP client startup for ${this.serverId} was aborted`,
+            });
+        }
+        finally {
+            cancellation.dispose();
+        }
+        this.assertStartupCurrent(generation, controller, handle);
+        await waitForOperation(this.connection.sendNotification("initialized", {}), deadline, description, {
+            signal: controller.signal,
+            abortMessage: `LSP client startup for ${this.serverId} was aborted`,
+        });
+        this.assertStartupCurrent(generation, controller, handle);
+        if (this.options.settings !== undefined) {
+            await waitForOperation(this.connection.sendNotification("workspace/didChangeConfiguration", { settings: this.options.settings }), deadline, description, { signal: controller.signal, abortMessage: `LSP client startup for ${this.serverId} was aborted` });
+        }
+        this.assertStartupCurrent(generation, controller, handle);
+        return result;
+    }
+    async recordStartupFailure(error) {
+        const failure = error instanceof Error ? error : new Error(String(error));
+        if (!this.disposed) {
+            this.state = "failed";
+            this.recordTransportError(failure);
+        }
+        this.closing = true;
+        this.disposeConnection();
+        try {
+            await this.closeHandle(createDeadline(this.options.shutdownTimeoutMs ?? 3000), `Closing connection to LSP server ${this.serverId}`);
+        }
+        catch (closeError) {
+            this.recordTransportError(closeError instanceof Error ? closeError : new Error(String(closeError)));
+        }
+        finally {
+            this.closing = false;
+        }
+        return failure;
+    }
+    async startInternal() {
+        if (this.disposed)
+            throw new Error(`LSP client for ${this.serverId} is disposed`);
+        if (this.initialized && this.capabilities && this.endpoint) {
+            return { capabilities: this.capabilities, endpoint: this.endpoint };
+        }
+        const generation = ++this.lifecycleGeneration;
+        this.state = "connecting";
+        const controller = new AbortController();
+        this.startController = controller;
+        this.transportError = undefined;
+        try {
+            const handle = await this.connectForStartup(controller);
+            this.assertStartupCurrent(generation, controller);
+            this.attachConnectionHandle(handle);
+            const result = await this.initializeConnection(generation, controller, handle);
+            this.capabilities = result.capabilities;
+            this.initialized = true;
+            this.state = "running";
+            return { capabilities: result.capabilities, endpoint: handle.endpoint };
+        }
+        catch (error) {
+            throw await this.recordStartupFailure(error);
+        }
+        finally {
+            if (this.startController === controller)
+                this.startController = undefined;
+        }
+    }
+    assertStartupCurrent(generation, controller, handle) {
+        if (this.disposed || controller.signal.aborted || this.lifecycleGeneration !== generation) {
+            throw new Error(`LSP client startup for ${this.serverId} was aborted`);
+        }
+        if (handle !== undefined && (this.connectionHandle !== handle || !this.connection)) {
+            throw new Error(`Connection to LSP server ${this.serverId} closed during initialization`);
+        }
+    }
+    async sendRequest(method, params, signal) {
+        if (!this.connection || !this.initialized)
+            throw new Error(`LSP client for ${this.serverId} is not initialized`);
+        if (signal?.aborted)
+            throw new Error(`LSP request ${method} was aborted`);
+        const cancellation = new CancellationTokenSource();
+        let rejectAbort;
+        const abortPromise = new Promise((_resolve, reject) => {
+            rejectAbort = reject;
+        });
+        const onAbort = () => {
+            cancellation.cancel();
+            rejectAbort?.(new Error(`LSP request ${method} was aborted`));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        if (signal?.aborted)
+            onAbort();
+        try {
+            return await withTimeout(Promise.race([this.connection.sendRequest(method, params, cancellation.token), abortPromise]), this.options.requestTimeoutMs, `LSP request ${method} to ${this.serverId}`, () => cancellation.cancel());
+        }
+        catch (error) {
+            const failure = error instanceof Error ? error : new Error(String(error));
+            this.requestError = failure;
+            this.options.onRequestError?.(failure);
+            throw failure;
+        }
+        finally {
+            signal?.removeEventListener("abort", onAbort);
+            cancellation.dispose();
+        }
+    }
+    async sendNotification(method, params, signal) {
+        if (!this.connection || !this.initialized) {
+            throw new Error(`LSP client for ${this.serverId} is not initialized`);
+        }
+        try {
+            await waitForAbort(this.connection.sendNotification(method, params), signal);
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            const failure = error instanceof Error ? error : new Error(String(error));
+            this.recordTransportError(failure);
+            throw failure;
+        }
+    }
+    async didOpen(uri, languageId, version, text, signal) {
+        await this.sendNotification("textDocument/didOpen", {
+            textDocument: { uri, languageId, version, text },
+        }, signal);
+    }
+    async didChange(uri, version, text, signal) {
+        await this.sendNotification("textDocument/didChange", {
+            textDocument: { uri, version },
+            contentChanges: [{ text }],
+        }, signal);
+    }
+    async didChangeIncremental(uri, version, range, text, signal) {
+        await this.sendNotification("textDocument/didChange", {
+            textDocument: { uri, version },
+            contentChanges: [{ range, text }],
+        }, signal);
+    }
+    async didSave(uri, text, signal) {
+        await this.sendNotification("textDocument/didSave", {
+            textDocument: { uri },
+            ...(text === undefined ? {} : { text }),
+        }, signal);
+    }
+    async didClose(uri, signal) {
+        await this.sendNotification("textDocument/didClose", { textDocument: { uri } }, signal);
+    }
+    invalidate() {
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
+        this.disposed = true;
+        this.lifecycleGeneration++;
+        this.state = "disposed";
+        this.closing = true;
+        this.initialized = false;
+        this.startController?.abort();
+        this.disposeConnection();
+        const configuredTimeout = this.options.shutdownTimeoutMs;
+        const timeoutMs = configuredTimeout !== undefined && configuredTimeout > 0
+            ? Math.min(configuredTimeout, MAX_INVALIDATION_CLOSE_MS)
+            : MAX_INVALIDATION_CLOSE_MS;
+        const invalidation = this.closeHandle(createDeadline(timeoutMs), `Invalidating connection to LSP server ${this.serverId}`)
+            .catch((error) => {
+            this.recordTransportError(error instanceof Error ? error : new Error(String(error)));
+        })
+            .finally(() => {
+            this.closing = false;
+        });
+        this.shutdownPromise = invalidation;
+        return invalidation;
+    }
+    shutdown() {
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
+        if (this.disposed)
+            return Promise.resolve();
+        const shutdown = this.shutdownInternal();
+        this.shutdownPromise = shutdown;
+        return shutdown;
+    }
+    async requestServerShutdown(connection, deadline) {
+        const cancellation = new CancellationTokenSource();
+        try {
+            await waitForOperation(connection.sendRequest("shutdown", undefined, cancellation.token), deadline, `Shutting down LSP server ${this.serverId}`, { onTimeout: () => cancellation.cancel() });
+        }
+        catch (error) {
+            this.recordTransportError(error instanceof Error ? error : new Error(String(error)));
+        }
+        finally {
+            cancellation.dispose();
+        }
+    }
+    async notifyServerExit(connection, deadline) {
+        try {
+            await waitForOperation(connection.sendNotification("exit"), deadline, `Sending exit to LSP server ${this.serverId}`);
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        catch (error) {
+            this.recordTransportError(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    async shutdownInternal() {
+        this.disposed = true;
+        this.lifecycleGeneration++;
+        this.state = "disposed";
+        this.closing = true;
+        this.initialized = false;
+        this.startController?.abort();
+        const deadline = createDeadline(this.options.shutdownTimeoutMs ?? 3000);
+        try {
+            const connection = this.connection;
+            if (connection && this.options.shutdownMode !== "disconnect") {
+                await this.requestServerShutdown(connection, deadline);
+                await this.notifyServerExit(connection, deadline);
+            }
+        }
+        finally {
+            this.disposeConnection();
+            try {
+                await this.closeHandle(deadline, `Closing connection to LSP server ${this.serverId}`);
+            }
+            catch (error) {
+                this.recordTransportError(error instanceof Error ? error : new Error(String(error)));
+            }
+            this.closing = false;
+        }
+    }
+    registerConnectionHandlers() {
+        this.connection?.onNotification("textDocument/publishDiagnostics", (params) => {
+            this.diagnostics.set(params.uri, params.diagnostics);
+        });
+        this.connection?.onRequest("workspace/configuration", (params) => params.items.map((item) => settingsForSection(this.options.settings, item.section)));
+        this.connection?.onRequest("workspace/workspaceFolders", () => [this.workspaceFolder]);
+        this.connection?.onError((data) => {
+            const candidate = data[0];
+            this.recordTransportError(candidate instanceof Error ? candidate : new Error(String(candidate)));
+        });
+        this.connection?.onClose(() => {
+            this.initialized = false;
+            if (!this.disposed && !this.closing)
+                this.state = "closed";
+        });
+    }
+    recordTransportError(error) {
+        this.transportError = error;
+        this.options.onTransportError?.(error);
+    }
+    closeConnectionHandle(handle) {
+        const existing = this.handleClosePromises.get(handle);
+        if (existing)
+            return existing;
+        const close = (async () => {
+            try {
+                await handle.close();
+            }
+            catch (error) {
+                this.recordTransportError(error instanceof Error ? error : new Error(String(error)));
+            }
+        })();
+        this.handleClosePromises.set(handle, close);
+        return close;
+    }
+    closeHandle(deadline, description) {
+        const handle = this.connectionHandle;
+        this.connectionHandle = undefined;
+        if (!handle)
+            return Promise.resolve();
+        const close = this.closeConnectionHandle(handle);
+        return deadline && description ? waitForOperation(close, deadline, description) : close;
+    }
+    disposeConnection() {
+        try {
+            this.connection?.dispose();
+        }
+        catch {
+            // Already disposed.
+        }
+        this.connection = undefined;
+    }
+}
+export function getTextFromToolContent(content) {
+    return content.type === "text" ? content.text : undefined;
+}
+//# sourceMappingURL=client.js.map