lazycodex-ai 5.0.0-beta.3 → 5.0.0-beta.30

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

@@ -23,28 +23,22 @@ var DEFAULT_MAX_DIRECTORY_FILES = 50;
 var REQUEST_TIMEOUT_MS = 15000;
 var INIT_TIMEOUT_MS = 60000;
 var IDLE_TIMEOUT_MS = 5 * 60000;
+var MAX_RESIDENT_CLIENTS = 6;
 var REAPER_INTERVAL_MS = 60000;
 var STOP_HARD_KILL_TIMEOUT_MS = 5000;
 var STOP_SIGKILL_GRACE_MS = 1000;
 
 // ../lsp-core/src/lsp/errors.ts
 class LspConnectionClosedError extends Error {
-  serverId;
-  root;
-  name = "LspConnectionClosedError";
   constructor(serverId, root, message) {
     super(message ?? `LSP connection closed for ${serverId} at ${root}`);
     this.serverId = serverId;
     this.root = root;
+    this.name = "LspConnectionClosedError";
   }
 }
 
 class LspProcessExitedError extends Error {
-  serverId;
-  root;
-  exitCode;
-  stderrTail;
-  name = "LspProcessExitedError";
   constructor(serverId, root, exitCode, stderrTail) {
     const stderrSuffix = stderrTail ? `
 stderr tail: ${stderrTail}` : "";
@@ -53,46 +47,49 @@ stderr tail: ${stderrTail}` : "";
     this.root = root;
     this.exitCode = exitCode;
     this.stderrTail = stderrTail;
+    this.name = "LspProcessExitedError";
   }
 }
 
 class LspRequestTimeoutError extends Error {
-  method;
-  stderrTail;
-  name = "LspRequestTimeoutError";
   constructor(method, stderrTail) {
     const stderrSuffix = stderrTail ? `
 recent stderr: ${stderrTail}` : "";
     super(`LSP request timeout (method: ${method})${stderrSuffix}`);
     this.method = method;
     this.stderrTail = stderrTail;
+    this.name = "LspRequestTimeoutError";
   }
 }
 
 class LspInvalidPathError extends Error {
-  name = "LspInvalidPathError";
+  constructor() {
+    super(...arguments);
+    this.name = "LspInvalidPathError";
+  }
 }
 
 class LspServerLookupError extends Error {
-  lookup;
-  name = "LspServerLookupError";
   constructor(message, lookup) {
     super(message);
     this.lookup = lookup;
+    this.name = "LspServerLookupError";
   }
 }
 
 class LspServerInitializingError extends Error {
-  originalError;
-  name = "LspServerInitializingError";
   constructor(originalError) {
     super(`LSP server is still initializing. Please retry in a few seconds. Original error: ${originalError.message}`);
     this.originalError = originalError;
+    this.name = "LspServerInitializingError";
   }
 }
 
 class LspProcessSpawnError extends Error {
-  name = "LspProcessSpawnError";
+  constructor() {
+    super(...arguments);
+    this.name = "LspProcessSpawnError";
+  }
 }
 function isLspDeadConnectionError(err) {
   return err instanceof LspConnectionClosedError || err instanceof LspProcessExitedError;
@@ -108,20 +105,31 @@ var METHOD_NOT_FOUND = -32601;
 var INTERNAL_ERROR = -32603;
 
 class JsonRpcConnection {
-  reader;
-  writer;
-  pendingRequests = new Map;
-  notificationHandlers = new Map;
-  requestHandlers = new Map;
-  closeHandlers = [];
-  errorHandlers = [];
-  inputBuffer = Buffer.alloc(0);
-  nextRequestId = 1;
-  listening = false;
-  disposed = false;
   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)
@@ -242,19 +250,6 @@ class JsonRpcConnection {
     this.notificationHandlers.clear();
     this.requestHandlers.clear();
   }
-  handleData = (chunk) => {
-    const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
-    this.inputBuffer = Buffer.concat([this.inputBuffer, chunkBuffer]);
-    this.drainInputBuffer();
-  };
-  handleClose = () => {
-    for (const handler of this.closeHandlers) {
-      handler();
-    }
-  };
-  handleStreamError = (error) => {
-    this.emitError(error);
-  };
   drainInputBuffer() {
     while (true) {
       const headerEnd = this.inputBuffer.indexOf(HEADER_SEPARATOR);
@@ -602,31 +597,26 @@ function isPosition(value) {
 
 // ../lsp-core/src/lsp/transport.ts
 class LspClientNotStartedError extends Error {
-  serverId;
-  root;
-  name = "LspClientNotStartedError";
   constructor(serverId, root) {
     super("LSP client not started");
     this.serverId = serverId;
     this.root = root;
+    this.name = "LspClientNotStartedError";
   }
 }
 
 class LspClientTransport {
-  root;
-  server;
-  proc = null;
-  connection = null;
-  stderrBuffer = [];
-  processExited = false;
-  diagnosticsStore = new Map;
-  requestTimeoutMs;
-  initializeTimeoutMs;
-  workspaceApplyEditHandler = null;
-  diagnosticPullSupported = false;
   constructor(root, server, timeouts = {}) {
     this.root = root;
     this.server = server;
+    this.proc = null;
+    this.connection = null;
+    this.stderrBuffer = [];
+    this.processExited = false;
+    this.diagnosticsStore = new Map;
+    this.workspaceApplyEditHandler = null;
+    this.diagnosticPullSupported = false;
+    this.documentFormattingSupported = false;
     this.requestTimeoutMs = timeouts.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
     this.initializeTimeoutMs = timeouts.initializeTimeoutMs ?? INIT_TIMEOUT_MS;
   }
@@ -648,6 +638,12 @@ class LspClientTransport {
   isDiagnosticPullSupported() {
     return this.diagnosticPullSupported;
   }
+  setDocumentFormattingSupported(supported) {
+    this.documentFormattingSupported = supported;
+  }
+  isDocumentFormattingSupported() {
+    return this.documentFormattingSupported;
+  }
   handlePublishDiagnostics(params) {
     this.diagnosticsStore.set(params.uri, [...params.diagnostics]);
   }
@@ -861,6 +857,14 @@ function supportsDiagnosticPull(capabilities) {
     return false;
   return Object.hasOwn(capabilities, "diagnosticProvider");
 }
+function supportsDocumentFormatting(capabilities) {
+  if (capabilities === undefined)
+    return false;
+  const provider = capabilities.documentFormattingProvider;
+  if (provider === undefined || provider === null || provider === false)
+    return false;
+  return provider === true || typeof provider === "object";
+}
 
 class LspClientConnection extends LspClientTransport {
   async initialize() {
@@ -877,6 +881,7 @@ class LspClientConnection extends LspClientTransport {
           references: {},
           documentSymbol: { hierarchicalDocumentSymbolSupport: true },
           publishDiagnostics: {},
+          formatting: { dynamicRegistration: false },
           rename: {
             prepareSupport: true,
             prepareSupportDefaultBehavior: 1
@@ -918,6 +923,7 @@ class LspClientConnection extends LspClientTransport {
       initializationOptions: this.server.initialization
     }, { timeoutMs: this.initializeTimeoutMs });
     this.setDiagnosticPullSupported(supportsDiagnosticPull(result?.capabilities));
+    this.setDocumentFormattingSupported(supportsDocumentFormatting(result?.capabilities));
     await this.sendNotification("initialized", {});
     await this.sendNotification("workspace/didChangeConfiguration", {
       settings: { json: { validate: { enable: true } } }
@@ -1133,16 +1139,12 @@ function movedPath(candidate, oldPath, newPath) {
 }
 
 class WorkspaceDocumentState {
-  sendNotification;
-  clearDiagnostics;
-  openDocuments = new Map;
-  openByUri = new Map;
-  openPromises = new Map;
-  now;
-  versionlessPublishQuiescenceMs;
   constructor(sendNotification, clearDiagnostics, options = {}) {
     this.sendNotification = sendNotification;
     this.clearDiagnostics = clearDiagnostics;
+    this.openDocuments = new Map;
+    this.openByUri = new Map;
+    this.openPromises = new Map;
     this.now = options.now ?? (() => Date.now());
     this.versionlessPublishQuiescenceMs = options.versionlessPublishQuiescenceMs ?? DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS;
   }
@@ -1406,13 +1408,11 @@ import { dirname, isAbsolute, relative as relative2, resolve as resolve2 } from
 import { fileURLToPath } from "node:url";
 
 class WorkspaceEditPathError extends Error {
-  path;
-  detail;
-  name = "WorkspaceEditPathError";
   constructor(path, detail) {
     super(`${detail}: ${path}`);
     this.path = path;
     this.detail = detail;
+    this.name = "WorkspaceEditPathError";
   }
 }
 function isPathInsideWorkspace(filePath, workspaceRoot) {
@@ -1704,13 +1704,11 @@ function canonicalFingerprint(operations) {
 
 // ../lsp-core/src/lsp/workspace-edit-types.ts
 class WorkspaceEditValidationError extends Error {
-  changeIndex;
-  detail;
-  name = "WorkspaceEditValidationError";
   constructor(changeIndex, detail) {
     super(`change ${changeIndex}: ${detail}`);
     this.changeIndex = changeIndex;
     this.detail = detail;
+    this.name = "WorkspaceEditValidationError";
   }
 }
 
@@ -2208,10 +2206,9 @@ function simulateDelete(operation, virtual) {
 import { existsSync as existsSync4, lstatSync as lstatSync3, readdirSync as readdirSync2 } from "node:fs";
 import { dirname as dirname3, resolve as resolve4 } from "node:path";
 class WorkspaceSnapshotBuilder {
-  workspaceRoot;
-  snapshots = new Map;
   constructor(workspaceRoot) {
     this.workspaceRoot = workspaceRoot;
+    this.snapshots = new Map;
   }
   build(operations) {
     this.add(this.workspaceRoot, false);
@@ -2255,8 +2252,10 @@ function snapshotOperations(operations, workspaceRoot) {
 
 // ../lsp-core/src/lsp/workspace-edit-plan.ts
 class PlanPathIndex {
-  firstChangeByPath = new Map;
-  reportedPathByCanonical = new Map;
+  constructor() {
+    this.firstChangeByPath = new Map;
+    this.reportedPathByCanonical = new Map;
+  }
   build(operations) {
     for (const operation of operations) {
       switch (operation.kind) {
@@ -2345,14 +2344,11 @@ function isRecord3(value) {
 }
 
 class WorkspaceMutationController {
-  workspaceRoot;
-  documents;
-  activeLease = null;
-  nextLeaseId = 1;
-  io;
   constructor(workspaceRoot, documents) {
     this.workspaceRoot = workspaceRoot;
     this.documents = documents;
+    this.activeLease = null;
+    this.nextLeaseId = 1;
   }
   setIo(io) {
     this.io = io;
@@ -2465,12 +2461,9 @@ var DIAGNOSTICS_FRESHNESS_TIMEOUT_MS = 3000;
 var VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
 
 class LspClient extends LspClientConnection {
-  diagnosticPullErrors = [];
-  documents;
-  workspaceMutations;
-  diagnosticsFreshnessTimeoutMs;
   constructor(root, server, options = {}) {
     super(root, server, options);
+    this.diagnosticPullErrors = [];
     this.diagnosticsFreshnessTimeoutMs = options.diagnosticsFreshnessTimeoutMs ?? DIAGNOSTICS_FRESHNESS_TIMEOUT_MS;
     this.documents = new WorkspaceDocumentState((method, params) => this.sendNotification(method, params), (uri) => this.diagnosticsStore.delete(uri), {
       versionlessPublishQuiescenceMs: options.versionlessPublishQuiescenceMs ?? VERSIONLESS_PUBLISH_QUIESCENCE_MS
@@ -2525,6 +2518,18 @@ class LspClient extends LspClientConnection {
       textDocument: { uri: pathToFileURL3(absPath).href }
     }, options);
   }
+  async formatDocument(filePath, options, signal) {
+    if (!this.isDocumentFormattingSupported())
+      return null;
+    const absPath = this.resolveWorkspacePath(filePath);
+    await this.openFile(absPath);
+    const requestOptions = signal === undefined ? {} : { signal };
+    const edits = await this.sendRequest("textDocument/formatting", {
+      textDocument: { uri: pathToFileURL3(absPath).href },
+      options
+    }, requestOptions);
+    return edits ?? [];
+  }
   async workspaceSymbols(query, signal) {
     const options = signal === undefined ? {} : { signal };
     return this.sendRequest("workspace/symbol", { query }, options);
@@ -2770,18 +2775,14 @@ function awaitWithSignal(promise, signal) {
 }
 
 class LspManager {
-  clients = new Map;
-  reaperHandle = null;
-  signalDisposer = null;
-  disposed = false;
-  idleTimeoutMs;
-  initTimeoutMs;
-  reaperIntervalMs;
-  clientFactory;
-  now;
   constructor(options = {}) {
+    this.clients = new Map;
+    this.reaperHandle = null;
+    this.signalDisposer = null;
+    this.disposed = false;
     this.idleTimeoutMs = options.idleTimeoutMs ?? IDLE_TIMEOUT_MS;
     this.initTimeoutMs = options.initTimeoutMs ?? INIT_TIMEOUT_MS;
+    this.maxResidentClients = options.maxResidentClients ?? MAX_RESIDENT_CLIENTS;
     this.reaperIntervalMs = options.reaperIntervalMs ?? REAPER_INTERVAL_MS;
     this.clientFactory = options.clientFactory ?? ((root, server) => new LspClient(root, server));
     this.now = options.now ?? (() => Date.now());
@@ -2815,6 +2816,26 @@ class LspManager {
       }
     }
   }
+  evictForAdmission() {
+    while (this.clients.size >= this.maxResidentClients) {
+      const victim = this.leastRecentlyUsedIdleClient();
+      if (!victim)
+        return;
+      this.clients.delete(victim.key);
+      stopClientBestEffort(victim.managed.client);
+    }
+  }
+  leastRecentlyUsedIdleClient() {
+    let candidate = null;
+    for (const [key, managed] of this.clients) {
+      if (managed.refCount > 0 || managed.pendingWaiters > 0 || managed.isInitializing)
+        continue;
+      if (candidate === null || managed.lastUsedAt < candidate.managed.lastUsedAt) {
+        candidate = { key, managed };
+      }
+    }
+    return candidate;
+  }
   async tryDeleteIfOrphaned(key, managed) {
     if (managed.refCount === 0 && managed.pendingWaiters === 0 && !managed.isInitializing && this.clients.get(key) === managed) {
       this.clients.delete(key);
@@ -2861,6 +2882,7 @@ class LspManager {
       managed.lastUsedAt = this.now();
       return managed.client;
     }
+    this.evictForAdmission();
     const client = this.clientFactory(root, server);
     const initStartedAt = this.now();
     const initPromise = (async () => {
@@ -2923,6 +2945,7 @@ class LspManager {
     const key = this.getKey(root, server.id);
     if (this.clients.has(key))
       return;
+    this.evictForAdmission();
     const client = this.clientFactory(root, server);
     const initStartedAt = this.now();
     const initPromise = (async () => {
@@ -3011,7 +3034,7 @@ async function disposeDefaultLspManager() {
   }
 }
 export {
-  getLspManager,
+  LspManager,
   disposeDefaultLspManager,
-  LspManager
+  getLspManager
 };