@ashx-j/lunr-dev 0.2.13-dev.7.1 → 0.2.16-dev.9.1

package/dist/node-runtime/lsp-manager-3ASUSO4T.js

@@ -0,0 +1,1104 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  require_api,
+  require_api2
+} from "./chunk-SN6G4OU6.js";
+import {
+  getLanguageIdFromPath
+} from "./chunk-3X3KZKMI.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-BRJX2PRC.js";
+
+// node_modules/vscode-jsonrpc/lib/node/ril.js
+var require_ril = __commonJS({
+  "node_modules/vscode-jsonrpc/lib/node/ril.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    var util_1 = __require("util"), api_1 = require_api(), MessageBuffer = class _MessageBuffer extends api_1.AbstractMessageBuffer {
+      static emptyBuffer = Buffer.allocUnsafe(0);
+      constructor(encoding = "utf-8") {
+        super(encoding);
+      }
+      emptyBuffer() {
+        return _MessageBuffer.emptyBuffer;
+      }
+      fromString(value, encoding) {
+        return Buffer.from(value, encoding);
+      }
+      toString(value, encoding) {
+        return value instanceof Buffer ? value.toString(encoding) : new util_1.TextDecoder(encoding).decode(value);
+      }
+      asNative(buffer, length) {
+        return length === void 0 ? buffer instanceof Buffer ? buffer : Buffer.from(buffer) : buffer instanceof Buffer ? buffer.slice(0, length) : Buffer.from(buffer, 0, length);
+      }
+      allocNative(length) {
+        return Buffer.allocUnsafe(length);
+      }
+    }, ReadableStreamWrapper = class {
+      stream;
+      constructor(stream) {
+        this.stream = stream;
+      }
+      onClose(listener) {
+        return this.stream.on("close", listener), api_1.Disposable.create(() => this.stream.off("close", listener));
+      }
+      onError(listener) {
+        return this.stream.on("error", listener), api_1.Disposable.create(() => this.stream.off("error", listener));
+      }
+      onEnd(listener) {
+        return this.stream.on("end", listener), api_1.Disposable.create(() => this.stream.off("end", listener));
+      }
+      onData(listener) {
+        return this.stream.on("data", listener), api_1.Disposable.create(() => this.stream.off("data", listener));
+      }
+    }, WritableStreamWrapper = class {
+      stream;
+      constructor(stream) {
+        this.stream = stream;
+      }
+      onClose(listener) {
+        return this.stream.on("close", listener), api_1.Disposable.create(() => this.stream.off("close", listener));
+      }
+      onError(listener) {
+        return this.stream.on("error", listener), api_1.Disposable.create(() => this.stream.off("error", listener));
+      }
+      onEnd(listener) {
+        return this.stream.on("end", listener), api_1.Disposable.create(() => this.stream.off("end", listener));
+      }
+      write(data, encoding) {
+        return new Promise((resolve2, reject) => {
+          let callback = (error) => {
+            error == null ? resolve2() : reject(error);
+          };
+          typeof data == "string" ? this.stream.write(data, encoding, callback) : this.stream.write(data, callback);
+        });
+      }
+      end() {
+        this.stream.end();
+      }
+    }, _ril = Object.freeze({
+      messageBuffer: Object.freeze({
+        create: (encoding) => new MessageBuffer(encoding)
+      }),
+      applicationJson: Object.freeze({
+        encoder: Object.freeze({
+          name: "application/json",
+          encode: (msg, options) => {
+            try {
+              return Promise.resolve(Buffer.from(JSON.stringify(msg, void 0, 0), options.charset));
+            } catch (err) {
+              return Promise.reject(err);
+            }
+          }
+        }),
+        decoder: Object.freeze({
+          name: "application/json",
+          decode: (buffer, options) => {
+            try {
+              return buffer instanceof Buffer ? Promise.resolve(JSON.parse(buffer.toString(options.charset))) : Promise.resolve(JSON.parse(new util_1.TextDecoder(options.charset).decode(buffer)));
+            } catch (err) {
+              return Promise.reject(err);
+            }
+          }
+        })
+      }),
+      stream: Object.freeze({
+        asReadableStream: (stream) => new ReadableStreamWrapper(stream),
+        asWritableStream: (stream) => new WritableStreamWrapper(stream)
+      }),
+      console,
+      timer: Object.freeze({
+        setTimeout(callback, ms, ...args) {
+          let handle = setTimeout(callback, ms, ...args);
+          return { dispose: () => clearTimeout(handle) };
+        },
+        setImmediate(callback, ...args) {
+          let handle = setImmediate(callback, ...args);
+          return { dispose: () => clearImmediate(handle) };
+        },
+        setInterval(callback, ms, ...args) {
+          let handle = setInterval(callback, ms, ...args);
+          return { dispose: () => clearInterval(handle) };
+        }
+      })
+    });
+    function RIL() {
+      return _ril;
+    }
+    (function(RIL2) {
+      function install() {
+        api_1.RAL.install(_ril);
+      }
+      RIL2.install = install;
+    })(RIL || (RIL = {}));
+    exports.default = RIL;
+  }
+});
+
+// node_modules/vscode-jsonrpc/lib/node/main.js
+var require_main = __commonJS({
+  "node_modules/vscode-jsonrpc/lib/node/main.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      k2 === void 0 && (k2 = k);
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) && (desc = { enumerable: !0, get: function() {
+        return m[k];
+      } }), Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      k2 === void 0 && (k2 = k), o[k2] = m[k];
+    })), __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: !0, value: v });
+    }) : function(o, v) {
+      o.default = v;
+    }), __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        return ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) Object.prototype.hasOwnProperty.call(o2, k) && (ar[ar.length] = k);
+          return ar;
+        }, ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) k[i] !== "default" && __createBinding(result, mod, k[i]);
+        return __setModuleDefault(result, mod), result;
+      };
+    })(), __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p) && __createBinding(exports2, m, p);
+    }, __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { default: mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.StreamMessageWriter = exports.StreamMessageReader = exports.SocketMessageWriter = exports.SocketMessageReader = exports.PortMessageWriter = exports.PortMessageReader = exports.IPCMessageWriter = exports.IPCMessageReader = void 0;
+    exports.generateRandomPipeName = generateRandomPipeName;
+    exports.createClientPipeTransport = createClientPipeTransport;
+    exports.createServerPipeTransport = createServerPipeTransport;
+    exports.createClientSocketTransport = createClientSocketTransport;
+    exports.createServerSocketTransport = createServerSocketTransport;
+    exports.createMessageConnection = createMessageConnection2;
+    var ril_1 = __importDefault(require_ril());
+    ril_1.default.install();
+    var path = __importStar(__require("path")), os = __importStar(__require("os")), fs = __importStar(__require("fs")), crypto_1 = __require("crypto"), net_1 = __require("net"), api_1 = require_api();
+    __exportStar(require_api(), exports);
+    var IPCMessageReader = class extends api_1.AbstractMessageReader {
+      process;
+      constructor(process2) {
+        super(), this.process = process2;
+        let eventEmitter = this.process;
+        eventEmitter.on("error", (error) => this.fireError(error)), eventEmitter.on("close", () => this.fireClose());
+      }
+      listen(callback) {
+        return this.process.on("message", callback), api_1.Disposable.create(() => this.process.off("message", callback));
+      }
+    };
+    exports.IPCMessageReader = IPCMessageReader;
+    var IPCMessageWriter = class extends api_1.AbstractMessageWriter {
+      process;
+      errorCount;
+      constructor(process2) {
+        super(), this.process = process2, this.errorCount = 0;
+        let eventEmitter = this.process;
+        eventEmitter.on("error", (error) => this.fireError(error)), eventEmitter.on("close", () => this.fireClose);
+      }
+      write(msg) {
+        try {
+          return typeof this.process.send == "function" && this.process.send(msg, void 0, void 0, (error) => {
+            error ? (this.errorCount++, this.handleError(error, msg)) : this.errorCount = 0;
+          }), Promise.resolve();
+        } catch (error) {
+          return this.handleError(error, msg), Promise.reject(error);
+        }
+      }
+      handleError(error, msg) {
+        this.errorCount++, this.fireError(error, msg, this.errorCount);
+      }
+      end() {
+      }
+    };
+    exports.IPCMessageWriter = IPCMessageWriter;
+    var PortMessageReader = class extends api_1.AbstractMessageReader {
+      onData;
+      constructor(port) {
+        super(), this.onData = new api_1.Emitter(), port.on("close", () => this.fireClose), port.on("error", (error) => this.fireError(error)), port.on("message", (message) => {
+          this.onData.fire(message);
+        });
+      }
+      listen(callback) {
+        return this.onData.event(callback);
+      }
+    };
+    exports.PortMessageReader = PortMessageReader;
+    var PortMessageWriter = class extends api_1.AbstractMessageWriter {
+      port;
+      errorCount;
+      constructor(port) {
+        super(), this.port = port, this.errorCount = 0, port.on("close", () => this.fireClose()), port.on("error", (error) => this.fireError(error));
+      }
+      write(msg) {
+        try {
+          return this.port.postMessage(msg), Promise.resolve();
+        } catch (error) {
+          return this.handleError(error, msg), Promise.reject(error);
+        }
+      }
+      handleError(error, msg) {
+        this.errorCount++, this.fireError(error, msg, this.errorCount);
+      }
+      end() {
+      }
+    };
+    exports.PortMessageWriter = PortMessageWriter;
+    var SocketMessageReader2 = class extends api_1.ReadableStreamMessageReader {
+      constructor(socket, encoding = "utf-8") {
+        super((0, ril_1.default)().stream.asReadableStream(socket), encoding);
+      }
+    };
+    exports.SocketMessageReader = SocketMessageReader2;
+    var SocketMessageWriter2 = class extends api_1.WriteableStreamMessageWriter {
+      socket;
+      constructor(socket, options) {
+        super((0, ril_1.default)().stream.asWritableStream(socket), options), this.socket = socket;
+      }
+      dispose() {
+        super.dispose(), this.socket.destroy();
+      }
+    };
+    exports.SocketMessageWriter = SocketMessageWriter2;
+    var StreamMessageReader2 = class extends api_1.ReadableStreamMessageReader {
+      constructor(readable, encoding) {
+        super((0, ril_1.default)().stream.asReadableStream(readable), encoding);
+      }
+    };
+    exports.StreamMessageReader = StreamMessageReader2;
+    var StreamMessageWriter2 = class extends api_1.WriteableStreamMessageWriter {
+      constructor(writable, options) {
+        super((0, ril_1.default)().stream.asWritableStream(writable), options);
+      }
+    };
+    exports.StreamMessageWriter = StreamMessageWriter2;
+    var XDG_RUNTIME_DIR = process.env.XDG_RUNTIME_DIR, safeIpcPathLengths = /* @__PURE__ */ new Map([
+      ["linux", 107],
+      ["darwin", 102]
+    ]);
+    function generateRandomPipeName() {
+      if (process.platform === "win32")
+        return `\\\\.\\pipe\\lsp-${(0, crypto_1.randomBytes)(16).toString("hex")}-sock`;
+      let randomLength = 32, fixedLength = 10, tmpDir = fs.realpathSync(XDG_RUNTIME_DIR ?? os.tmpdir()), limit = safeIpcPathLengths.get(process.platform);
+      if (limit !== void 0 && (randomLength = Math.min(limit - tmpDir.length - fixedLength, randomLength)), randomLength < 16)
+        throw new Error(`Unable to generate a random pipe name with ${randomLength} characters.`);
+      let randomSuffix = (0, crypto_1.randomBytes)(Math.floor(randomLength / 2)).toString("hex");
+      return path.join(tmpDir, `lsp-${randomSuffix}.sock`);
+    }
+    function createClientPipeTransport(pipeName, encoding = "utf-8") {
+      let connectResolve, connected = new Promise((resolve2, _reject) => {
+        connectResolve = resolve2;
+      });
+      return new Promise((resolve2, reject) => {
+        let server = (0, net_1.createServer)((socket) => {
+          server.close(), connectResolve([
+            new SocketMessageReader2(socket, encoding),
+            new SocketMessageWriter2(socket, encoding)
+          ]);
+        });
+        server.on("error", reject), server.listen(pipeName, () => {
+          server.removeListener("error", reject), resolve2({
+            onConnected: () => connected
+          });
+        });
+      });
+    }
+    function createServerPipeTransport(pipeName, encoding = "utf-8") {
+      let socket = (0, net_1.createConnection)(pipeName);
+      return [
+        new SocketMessageReader2(socket, encoding),
+        new SocketMessageWriter2(socket, encoding)
+      ];
+    }
+    function createClientSocketTransport(port, encoding = "utf-8") {
+      let connectResolve, connected = new Promise((resolve2, _reject) => {
+        connectResolve = resolve2;
+      });
+      return new Promise((resolve2, reject) => {
+        let server = (0, net_1.createServer)((socket) => {
+          server.close(), connectResolve([
+            new SocketMessageReader2(socket, encoding),
+            new SocketMessageWriter2(socket, encoding)
+          ]);
+        });
+        server.on("error", reject), server.listen(port, "127.0.0.1", () => {
+          server.removeListener("error", reject), resolve2({
+            onConnected: () => connected
+          });
+        });
+      });
+    }
+    function createServerSocketTransport(port, encoding = "utf-8") {
+      let socket = (0, net_1.createConnection)(port, "127.0.0.1");
+      return [
+        new SocketMessageReader2(socket, encoding),
+        new SocketMessageWriter2(socket, encoding)
+      ];
+    }
+    function isReadableStream(value) {
+      let candidate = value;
+      return candidate.read !== void 0 && candidate.addListener !== void 0;
+    }
+    function isWritableStream(value) {
+      let candidate = value;
+      return candidate.write !== void 0 && candidate.addListener !== void 0;
+    }
+    function createMessageConnection2(input, output, logger, options) {
+      logger || (logger = api_1.NullLogger);
+      let reader = isReadableStream(input) ? new StreamMessageReader2(input) : input, writer = isWritableStream(output) ? new StreamMessageWriter2(output) : output;
+      return api_1.ConnectionStrategy.is(options) && (options = { connectionStrategy: options }), (0, api_1.createMessageConnection)(reader, writer, logger, options);
+    }
+  }
+});
+
+// node_modules/vscode-languageserver-protocol/lib/node/main.js
+var require_main2 = __commonJS({
+  "node_modules/vscode-languageserver-protocol/lib/node/main.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      k2 === void 0 && (k2 = k);
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) && (desc = { enumerable: !0, get: function() {
+        return m[k];
+      } }), Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      k2 === void 0 && (k2 = k), o[k2] = m[k];
+    })), __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p) && __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.createProtocolConnection = createProtocolConnection;
+    var node_1 = require_main();
+    __exportStar(require_main(), exports);
+    __exportStar(require_api2(), exports);
+    function createProtocolConnection(input, output, logger, options) {
+      return (0, node_1.createMessageConnection)(input, output, logger, options);
+    }
+  }
+});
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/lsp-manager.js
+import { resolve, join } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
+import { spawn as spawnChild } from "node:child_process";
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/lsp-client.js
+var import_node = __toESM(require_main2(), 1);
+import { spawn } from "node:child_process";
+import { connect as netConnect } from "node:net";
+import { pathToFileURL } from "node:url";
+var LspClient = class {
+  options;
+  process = null;
+  socket = null;
+  connection = null;
+  _serverCapabilities = null;
+  _diagnostics = /* @__PURE__ */ new Map();
+  _initialized = !1;
+  _disposed = !1;
+  /** True if connected to a daemon socket (server init handled by daemon) */
+  _isDaemonClient = !1;
+  languageId;
+  command;
+  rootDir;
+  constructor(options) {
+    this.options = options, this.languageId = options.languageId, this.command = options.command, this.rootDir = options.rootDir;
+  }
+  get initialized() {
+    return this._initialized;
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  get serverCapabilities() {
+    return this._serverCapabilities;
+  }
+  /** Get cached diagnostics for a URI */
+  getDiagnostics(uri) {
+    return this._diagnostics.get(uri) ?? [];
+  }
+  /** Get all cached diagnostics */
+  getAllDiagnostics() {
+    return new Map(this._diagnostics);
+  }
+  /** Start the LSP server and perform the initialize handshake */
+  async start() {
+    this._initialized || this._disposed || (this.options.socketPath ? await this.connectToSocket(this.options.socketPath) : await this.spawnDirect());
+  }
+  /** Register shared connection handlers (diagnostics, workspace/configuration, errors) */
+  registerConnectionHandlers() {
+    this.connection && (this.connection.onNotification("textDocument/publishDiagnostics", (params) => {
+      this._diagnostics.set(params.uri, params.diagnostics);
+    }), this.connection.onRequest("workspace/configuration", (params) => {
+      let settings = this.options.settings;
+      return params.items.map((item) => item.section && settings && item.section in settings ? settings[item.section] : {});
+    }), this.connection.onError(([err]) => {
+      console.error(`[LSP ${this.languageId}] Connection error: ${err.message}`);
+    }), this.connection.onClose(() => {
+      this._disposed || (this._initialized = !1);
+    }));
+  }
+  /** Connect to an existing LSP daemon via Unix socket (no init handshake needed) */
+  async connectToSocket(socketPath) {
+    return this._isDaemonClient = !0, new Promise((resolve2, reject) => {
+      let settled = !1, settle = (fn) => {
+        settled || (settled = !0, fn());
+      }, socket = netConnect(socketPath, () => {
+        this.socket = socket;
+        let reader = new import_node.SocketMessageReader(socket), writer = new import_node.SocketMessageWriter(socket);
+        this.connection = (0, import_node.createMessageConnection)(reader, writer), this.registerConnectionHandlers(), this.connection.listen(), this._initialized = !0, settle(() => resolve2());
+      });
+      socket.on("error", (err) => {
+        this._initialized ? this._initialized = !1 : settle(() => reject(new Error(`Failed to connect to LSP daemon: ${err.message}`)));
+      }), socket.on("close", () => {
+        this._disposed || (this._initialized = !1, this.options.onUnexpectedExit?.(null));
+      }), setTimeout(() => {
+        settled || (socket.destroy(), settle(() => reject(new Error("Timeout connecting to LSP daemon socket"))));
+      }, 1e4);
+    });
+  }
+  /** Spawn LSP server directly as child process with stdio */
+  async spawnDirect() {
+    let env = { ...process.env, ...this.options.env };
+    if (this.process = spawn(this.options.command, this.options.args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env,
+      cwd: this.rootDir
+    }), !this.process.stdout || !this.process.stdin)
+      throw new Error(`Failed to spawn LSP server: ${this.options.command}`);
+    await new Promise((resolve2, reject) => {
+      let onSpawn = () => {
+        cleanup(), resolve2();
+      }, onError = (err) => {
+        cleanup(), reject(new Error(`Failed to spawn LSP server "${this.options.command}": ${err.message}`));
+      }, cleanup = () => {
+        this.process?.removeListener("spawn", onSpawn), this.process?.removeListener("error", onError);
+      };
+      this.process.on("spawn", onSpawn), this.process.on("error", onError);
+    }), this.process.stderr?.resume();
+    let stdin = this.process.stdin, originalWrite = stdin.write;
+    stdin.write = function(...args) {
+      if (this.destroyed || this.writableEnded || this.writableFinished) {
+        let cb = args[args.length - 1];
+        return typeof cb == "function" && process.nextTick(cb), !1;
+      }
+      try {
+        return originalWrite.apply(this, args);
+      } catch (err) {
+        if (err?.code === "EPIPE" || err?.code === "ERR_STREAM_DESTROYED") {
+          let cb = args[args.length - 1];
+          return typeof cb == "function" && process.nextTick(cb), !1;
+        }
+        throw err;
+      }
+    }, stdin.on("error", (err) => {
+      err?.code !== "EPIPE" && console.error(`[LSP ${this.languageId}] stdin error: ${err.message}`);
+    }), this.process.on("error", (err) => {
+      console.error(`[LSP ${this.languageId}] Process error: ${err.message}`), this._initialized = !1, this.disposeConnection();
+    }), this.process.on("exit", (code) => {
+      this._disposed || (console.error(`[LSP ${this.languageId}] Server exited with code ${code}`), this._initialized = !1, this.disposeConnection(), this.options.onUnexpectedExit?.(code));
+    });
+    let reader = new import_node.StreamMessageReader(this.process.stdout), writer = new import_node.StreamMessageWriter(this.process.stdin);
+    this.connection = (0, import_node.createMessageConnection)(reader, writer), this.registerConnectionHandlers(), this.connection.listen();
+    let rootUri = pathToFileURL(this.rootDir).toString(), defaultFolder = { uri: rootUri, name: this.rootDir.split("/").pop() ?? "workspace" }, workspaceFolders = this.options.workspaceFolders && this.options.workspaceFolders.length > 0 ? this.options.workspaceFolders : [defaultFolder], initParams = {
+      processId: process.pid,
+      capabilities: {
+        textDocument: {
+          synchronization: {
+            didSave: !0,
+            dynamicRegistration: !1
+          },
+          hover: {
+            contentFormat: ["plaintext", "markdown"]
+          },
+          definition: {},
+          references: {},
+          documentSymbol: {
+            hierarchicalDocumentSymbolSupport: !0
+          },
+          rename: {
+            prepareSupport: !1
+          },
+          publishDiagnostics: {
+            relatedInformation: !0
+          },
+          completion: {
+            completionItem: {
+              snippetSupport: !1
+            }
+          }
+        },
+        workspace: {
+          workspaceFolders: !0,
+          symbol: {},
+          configuration: !0
+        }
+      },
+      rootUri,
+      workspaceFolders,
+      ...this.options.initializationOptions ? { initializationOptions: this.options.initializationOptions } : {}
+    }, result = await this.connection.sendRequest("initialize", initParams);
+    this._serverCapabilities = result.capabilities, this.connection.sendNotification("initialized", {}), this._initialized = !0;
+  }
+  /** Safely dispose the connection without throwing */
+  disposeConnection() {
+    try {
+      this.connection && this.connection.dispose();
+    } catch {
+    }
+    this.connection = null;
+  }
+  /** Send a request to the LSP server */
+  async sendRequest(method, params) {
+    if (!this.connection || !this._initialized)
+      throw new Error(`LSP ${this.languageId} not initialized`);
+    return this.connection.sendRequest(method, params);
+  }
+  /** Send a notification to the LSP server */
+  sendNotification(method, params) {
+    !this.connection || !this._initialized || this.connection.sendNotification(method, params);
+  }
+  /** Notify server of a newly opened document */
+  didOpen(uri, languageId, version, text) {
+    this.sendNotification("textDocument/didOpen", {
+      textDocument: { uri, languageId, version, text }
+    });
+  }
+  /** Notify server of a document change (full content sync) */
+  didChange(uri, version, text) {
+    this.sendNotification("textDocument/didChange", {
+      textDocument: { uri, version },
+      contentChanges: [{ text }]
+    });
+  }
+  /** Notify server of a closed document */
+  didClose(uri) {
+    this.sendNotification("textDocument/didClose", {
+      textDocument: { uri }
+    });
+  }
+  /** Gracefully shut down or disconnect from the server */
+  async shutdown() {
+    if (!this._disposed) {
+      if (this._disposed = !0, this._initialized = !1, this._isDaemonClient) {
+        this.disposeConnection(), this.socket && this.socket.destroy(), this.socket = null;
+        return;
+      }
+      try {
+        if (this.connection) {
+          let shutdownReq = this.connection.sendRequest("shutdown").catch(() => {
+          });
+          await Promise.race([
+            shutdownReq,
+            new Promise((resolve2) => setTimeout(resolve2, 3e3))
+          ]);
+          try {
+            this.connection.sendNotification("exit");
+          } catch {
+          }
+        }
+      } catch {
+      }
+      this.disposeConnection(), this.process && (this.process.kill("SIGTERM"), setTimeout(() => {
+        this.process && !this.process.killed && this.process.kill("SIGKILL");
+      }, 2e3)), this.process = null;
+    }
+  }
+};
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/workspace-provider.js
+var DefaultWorkspaceProvider = class {
+  type = "default";
+  workspaceRoot = null;
+  stateDir = null;
+  getWorkspaceFolders() {
+    return [];
+  }
+  async ensureReady() {
+    return !0;
+  }
+  getStatusText() {
+    return "";
+  }
+  shutdown() {
+  }
+};
+
+// packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/lsp-manager.js
+var DEFAULT_SERVERS = {
+  typescript: { command: "typescript-language-server", args: ["--stdio"] },
+  javascript: { command: "typescript-language-server", args: ["--stdio"] },
+  typescriptreact: { command: "typescript-language-server", args: ["--stdio"] },
+  javascriptreact: { command: "typescript-language-server", args: ["--stdio"] },
+  rust: { command: "rust-analyzer", args: [] },
+  python: { command: "pyright-langserver", args: ["--stdio"] },
+  go: { command: "gopls", args: ["serve"] },
+  java: { command: "jdtls", args: [] }
+}, LspManager = class _LspManager {
+  clients = /* @__PURE__ */ new Map();
+  serverConfigs;
+  rootDir;
+  startingServers = /* @__PURE__ */ new Map();
+  _workspace;
+  _workspaceReady = !1;
+  _workspaceReadying = null;
+  _callbacks;
+  _sessionId;
+  _lombokJarPath = null;
+  _shuttingDown = !1;
+  _restartAttempts = /* @__PURE__ */ new Map();
+  _restartBackoff = /* @__PURE__ */ new Map();
+  static MAX_RESTART_ATTEMPTS = 3;
+  static INITIAL_BACKOFF_MS = 1e3;
+  static MAX_BACKOFF_MS = 3e4;
+  constructor(rootDir, customConfigs, callbacks, sessionId, workspace) {
+    this.rootDir = resolve(rootDir), this.serverConfigs = new Map(Object.entries({
+      ...DEFAULT_SERVERS,
+      ...customConfigs
+    })), this._workspace = workspace ?? new DefaultWorkspaceProvider(), this._callbacks = callbacks ?? {}, this._sessionId = sessionId ?? `${process.pid}-${Date.now()}`;
+  }
+  /** Get the workspace provider */
+  get workspace() {
+    return this._workspace;
+  }
+  /** Replace the workspace provider (e.g. when an external extension registers one) */
+  setWorkspaceProvider(provider) {
+    this._workspace = provider, this._workspaceReady = !1, this._workspaceReadying = null;
+  }
+  /** Update or add a server configuration */
+  setServerConfig(languageId, config) {
+    this.serverConfigs.set(languageId, config);
+  }
+  /** Set an explicit path to a Lombok jar for Java/jdtls support */
+  setLombokJar(jarPath) {
+    this._lombokJarPath = resolve(this.rootDir, jarPath);
+  }
+  /** Get the currently configured Lombok jar path (if any) */
+  getLombokJar() {
+    return this.findLombokJar();
+  }
+  /**
+   * Auto-detect Lombok jar.
+   * Searches: explicit path, LOMBOK_JAR env var, workspace root env/ directories.
+   */
+  findLombokJar() {
+    if (this._lombokJarPath && existsSync(this._lombokJarPath))
+      return this._lombokJarPath;
+    let envJar = process.env.LOMBOK_JAR;
+    if (envJar) {
+      let resolved = resolve(this.rootDir, envJar);
+      if (existsSync(resolved))
+        return resolved;
+    }
+    let searchRoots = [this.rootDir], wsRoot = this._workspace.workspaceRoot;
+    wsRoot && wsRoot !== this.rootDir && searchRoots.unshift(wsRoot);
+    for (let root of searchRoots) {
+      let envDir = join(root, "env");
+      if (!existsSync(envDir))
+        continue;
+      try {
+        let lombokDirs = readdirSync(envDir).filter((d) => d.startsWith("Lombok-"));
+        for (let dir of lombokDirs) {
+          let libDir = join(envDir, dir, "runtime", "lib");
+          if (existsSync(libDir)) {
+            let jars = readdirSync(libDir).filter((f) => f.startsWith("lombok-") && f.endsWith(".jar"));
+            if (jars.length > 0)
+              return join(libDir, jars[0]);
+          }
+        }
+      } catch {
+      }
+      let gradleLombok = join(envDir, "gradle-cache-2", "org", "projectlombok", "lombok");
+      if (existsSync(gradleLombok))
+        try {
+          let versions = readdirSync(gradleLombok);
+          for (let ver of versions) {
+            let jarPath = join(gradleLombok, ver, `lombok-${ver}.jar`);
+            if (existsSync(jarPath))
+              return jarPath;
+          }
+        } catch {
+        }
+    }
+    return null;
+  }
+  /** Build initializationOptions for Java (jdtls) with Lombok support */
+  getJavaInitializationOptions() {
+    let lombokJar = this.findLombokJar();
+    if (lombokJar)
+      return {
+        settings: {
+          "java.jdt.ls.vmargs": `-javaagent:${lombokJar}`
+        }
+      };
+  }
+  /** Get all configured languages */
+  getConfiguredLanguages() {
+    return [...this.serverConfigs.keys()];
+  }
+  /** Resolve a file path to a language ID */
+  getLanguageId(filePath) {
+    return getLanguageIdFromPath(filePath);
+  }
+  /** Get a file URI from a path */
+  getFileUri(filePath) {
+    let abs = resolve(this.rootDir, filePath);
+    return pathToFileURL2(abs).toString();
+  }
+  /** Resolve an absolute path from potentially relative input */
+  resolvePath(filePath) {
+    return resolve(this.rootDir, filePath);
+  }
+  /**
+   * Get the LSP client for a language ONLY if it's already running.
+   * Does not start a new server. Returns null if no client is active.
+   */
+  getRunningClient(languageId) {
+    let existing = this.clients.get(languageId);
+    return existing && existing.initialized && !existing.disposed ? existing : null;
+  }
+  /**
+   * Get the LSP client for a file, starting the server if needed.
+   * Returns null if no server is configured for this file type.
+   */
+  async getClientForFile(filePath) {
+    let languageId = this.getLanguageId(filePath);
+    return languageId ? this.getClientForLanguage(languageId) : null;
+  }
+  /**
+   * Get a user-friendly message about why no client is available for a file.
+   */
+  getUnavailableReason(filePath) {
+    let languageId = this.getLanguageId(filePath);
+    if (!languageId)
+      return `No LSP server configured for file type: ${filePath}`;
+    let waitHint = this.getExpectedStartTime(languageId);
+    if (this.startingServers.has(languageId))
+      return `LSP server for ${languageId} is starting. ${waitHint} Retry shortly.`;
+    let existing = this.clients.get(languageId);
+    return existing && !existing.initialized && !existing.disposed ? `LSP server for ${languageId} is initializing. ${waitHint} Retry shortly.` : `No LSP server available for: ${filePath}. If you just opened this project, call any LSP tool on a file to trigger server startup.`;
+  }
+  /** Estimated startup time hint for a language server */
+  getExpectedStartTime(languageId) {
+    switch (languageId) {
+      case "java":
+        return "This typically takes 1-5 minutes for Java (project indexing).";
+      case "rust":
+        return "This typically takes 30s-2min for Rust (cargo metadata + indexing).";
+      case "typescript":
+      case "javascript":
+      case "typescriptreact":
+      case "javascriptreact":
+        return "This typically takes 10-30s for TypeScript/JavaScript.";
+      case "python":
+        return "This typically takes 10-30s for Python.";
+      case "go":
+        return "This typically takes 10-30s for Go.";
+      default:
+        return "This may take a few seconds to a minute.";
+    }
+  }
+  /**
+   * Get the LSP client for a language, starting the server if needed.
+   * In Brazil workspaces, connects to a shared daemon (or spawns one).
+   * Returns null if no server is configured for this language.
+   */
+  async getClientForLanguage(languageId) {
+    let existing = this.clients.get(languageId);
+    if (existing && existing.initialized && !existing.disposed)
+      return existing;
+    if (this.startingServers.get(languageId))
+      return null;
+    let config = this.serverConfigs.get(languageId);
+    if (!config)
+      return null;
+    let startPromise = this.startServer(languageId, config);
+    return this.startingServers.set(languageId, startPromise), startPromise.catch((err) => {
+      this.startingServers.delete(languageId);
+      let message = `Failed to start LSP server for ${languageId}: ${err.message}`;
+      this._callbacks.onServerError?.(languageId, message);
+    }), null;
+  }
+  /**
+   * Check if a server is currently starting up for a language.
+   */
+  isServerStarting(languageId) {
+    return this.startingServers.has(languageId);
+  }
+  /**
+   * Eagerly start LSP servers for the given languages in the background.
+   * Unlike getClientForLanguage (which returns null immediately), this method
+   * is fire-and-forget — intended for session_start auto-start.
+   */
+  startEagerly(languageIds) {
+    for (let languageId of languageIds) {
+      let existing = this.clients.get(languageId);
+      if (existing && existing.initialized && !existing.disposed || this.startingServers.has(languageId))
+        continue;
+      let config = this.serverConfigs.get(languageId);
+      if (!config)
+        continue;
+      let startPromise = this.startServer(languageId, config);
+      this.startingServers.set(languageId, startPromise), startPromise.catch((err) => {
+        this.startingServers.delete(languageId), this._callbacks.onServerError?.(languageId, `Auto-start failed: ${err.message}`);
+      });
+    }
+  }
+  /**
+   * Ensure workspace provider is ready (one-time per session).
+   * Deduplicates concurrent calls.
+   */
+  async ensureWorkspace() {
+    if (this._workspaceReady)
+      return;
+    if (this._workspaceReadying) {
+      await this._workspaceReadying;
+      return;
+    }
+    this._callbacks.onWorkspaceSetupStart?.();
+    let start = Date.now();
+    this._workspaceReadying = this._workspace.ensureReady(this._sessionId);
+    try {
+      let success = await this._workspaceReadying;
+      this._callbacks.onWorkspaceSetupEnd?.(success, Date.now() - start);
+    } finally {
+      this._workspaceReady = !0, this._workspaceReadying = null;
+    }
+  }
+  async startServer(languageId, config) {
+    await this.ensureWorkspace();
+    let stateDir = this._workspace.stateDir, folders = this._workspace.getWorkspaceFolders(), workspaceFolders = folders.length > 0 ? folders : void 0, initializationOptions = config.initializationOptions ?? (languageId === "java" ? this.getJavaInitializationOptions() : void 0), effectiveArgs = config.args;
+    if (languageId === "java") {
+      let lombokJar = this.findLombokJar();
+      lombokJar && (effectiveArgs = [`--jvm-arg=-javaagent:${lombokJar}`, ...config.args]);
+    }
+    let onUnexpectedExit = (code) => this.handleUnexpectedExit(languageId, code), socketPath = this.getSocketPath(languageId);
+    if (socketPath && this.isDaemonAlive(languageId)) {
+      this._callbacks.onServerStart?.(languageId, `${config.command} (shared)`);
+      try {
+        let client2 = new LspClient({
+          command: config.command,
+          args: effectiveArgs,
+          rootDir: this.rootDir,
+          languageId,
+          socketPath,
+          initializationOptions,
+          settings: config.settings,
+          onUnexpectedExit
+        });
+        return await client2.start(), this.clients.set(languageId, client2), this.startingServers.delete(languageId), this._callbacks.onServerReady?.(languageId), this._restartAttempts.delete(languageId), this._restartBackoff.delete(languageId), this.triggerPostInit(languageId, client2), client2;
+      } catch {
+      }
+    }
+    if (this._callbacks.onServerStart?.(languageId, config.command), stateDir)
+      try {
+        await this.spawnDaemon(languageId, config, effectiveArgs, workspaceFolders, initializationOptions), await new Promise((r) => setTimeout(r, 500));
+        let daemonSocket = this.getSocketPath(languageId), lastErr = null;
+        for (let attempt = 0; attempt < 60; attempt++)
+          try {
+            let client2 = new LspClient({
+              command: config.command,
+              args: effectiveArgs,
+              rootDir: this.rootDir,
+              languageId,
+              socketPath: daemonSocket,
+              initializationOptions,
+              settings: config.settings,
+              onUnexpectedExit
+            });
+            return await client2.start(), this.clients.set(languageId, client2), this.startingServers.delete(languageId), this._callbacks.onServerReady?.(languageId), this._restartAttempts.delete(languageId), this._restartBackoff.delete(languageId), this.triggerPostInit(languageId, client2), client2;
+          } catch (err) {
+            if (lastErr = err, !this.isDaemonAlive(languageId))
+              throw new Error(`Daemon for ${languageId} died during startup: ${err.message}`);
+            await new Promise((r) => setTimeout(r, 5e3));
+          }
+        throw lastErr ?? new Error("Failed to connect to daemon");
+      } catch (err) {
+        this._callbacks.onServerError?.(languageId, `Daemon mode failed, falling back to direct: ${err.message}`), this.startingServers.delete(languageId);
+      }
+    let client = new LspClient({
+      command: config.command,
+      args: effectiveArgs,
+      rootDir: this.rootDir,
+      languageId,
+      env: config.env,
+      workspaceFolders,
+      initializationOptions,
+      settings: config.settings,
+      onUnexpectedExit
+    });
+    try {
+      return await client.start(), this.clients.set(languageId, client), this.startingServers.delete(languageId), this._callbacks.onServerReady?.(languageId), this._restartAttempts.delete(languageId), this._restartBackoff.delete(languageId), this.triggerPostInit(languageId, client), client;
+    } catch (err) {
+      this.startingServers.delete(languageId);
+      let message = `Failed to start LSP server for ${languageId} (${config.command}): ${err.message}`;
+      throw this._callbacks.onServerError?.(languageId, message), new Error(message);
+    }
+  }
+  /**
+   * Post-initialization hook for language-specific setup.
+   * For Java/jdtls: triggers a workspace build so diagnostics refresh
+   * after Lombok annotation processing completes.
+   */
+  triggerPostInit(languageId, client) {
+    languageId === "java" && client.sendRequest("java/buildWorkspace", !0).catch(() => {
+    });
+  }
+  /** Get the socket path for a language's daemon */
+  getSocketPath(languageId) {
+    let stateDir = this._workspace.stateDir;
+    return stateDir ? join(stateDir, "sockets", `lsp-${languageId}.sock`) : null;
+  }
+  /** Check if a daemon is alive for this language */
+  isDaemonAlive(languageId) {
+    let stateDir = this._workspace.stateDir;
+    if (!stateDir)
+      return !1;
+    let pidPath = join(stateDir, "sockets", `lsp-${languageId}.pid`);
+    try {
+      if (!existsSync(pidPath))
+        return !1;
+      let pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+      return isNaN(pid) ? !1 : (process.kill(pid, 0), !0);
+    } catch {
+      return !1;
+    }
+  }
+  /** Spawn an LSP daemon as a detached background process */
+  async spawnDaemon(languageId, config, effectiveArgs, workspaceFolders, initializationOptions) {
+    let socketPath = this.getSocketPath(languageId), daemonScript = new URL("./lsp-daemon.ts", new URL("../builtin-extensions/pi-lsp-extension/src/lsp-manager.js", import.meta.url).href).pathname, launcherScript = new URL("./lsp-daemon-launcher.cjs", new URL("../builtin-extensions/pi-lsp-extension/src/lsp-manager.js", import.meta.url).href).pathname, jitiPath;
+    try {
+      jitiPath = __require.resolve("jiti");
+    } catch {
+      try {
+        jitiPath = __require.resolve("@mariozechner/jiti");
+      } catch {
+        throw new Error("Cannot resolve jiti for daemon spawn \u2014 jiti not found in module path");
+      }
+    }
+    let env = {
+      ...process.env,
+      ...config.env ?? {},
+      LSP_ROOT_DIR: this.rootDir,
+      LSP_LANGUAGE_ID: languageId
+    };
+    workspaceFolders && workspaceFolders.length > 0 && (env.LSP_WORKSPACE_FOLDERS = JSON.stringify(workspaceFolders)), initializationOptions && (env.LSP_INITIALIZATION_OPTIONS = JSON.stringify(initializationOptions)), config.settings && (env.LSP_SETTINGS = JSON.stringify(config.settings)), spawnChild(
+      process.execPath,
+      // node
+      [launcherScript, jitiPath, daemonScript, socketPath, config.command, ...effectiveArgs],
+      {
+        cwd: this.rootDir,
+        env,
+        detached: !0,
+        stdio: "ignore"
+      }
+    ).unref();
+  }
+  /** Get status of all configured/running servers */
+  getStatus() {
+    let statuses = [];
+    for (let [languageId, config] of this.serverConfigs) {
+      let client = this.clients.get(languageId), diagnosticsCount = 0;
+      if (client)
+        for (let diags of client.getAllDiagnostics().values())
+          diagnosticsCount += diags.length;
+      let daemonAlive = this.isDaemonAlive(languageId);
+      statuses.push({
+        languageId,
+        command: config.command,
+        running: client?.initialized === !0 && !client.disposed,
+        diagnosticsCount,
+        shared: daemonAlive
+      });
+    }
+    return statuses;
+  }
+  /**
+   * Handle an unexpected server exit. Attempts auto-restart with exponential backoff.
+   * Gives up after MAX_RESTART_ATTEMPTS failures per language per session.
+   */
+  handleUnexpectedExit(languageId, code) {
+    if (this._shuttingDown)
+      return;
+    this.clients.delete(languageId), this.startingServers.delete(languageId);
+    let attempts = this._restartAttempts.get(languageId) ?? 0;
+    if (attempts >= _LspManager.MAX_RESTART_ATTEMPTS) {
+      this._callbacks.onServerError?.(languageId, `LSP server for ${languageId} crashed ${attempts} times \u2014 giving up auto-restart`), this._callbacks.onServerCrash?.(languageId, !1, attempts);
+      return;
+    }
+    let backoff = this._restartBackoff.get(languageId) ?? _LspManager.INITIAL_BACKOFF_MS;
+    this._restartAttempts.set(languageId, attempts + 1), this._restartBackoff.set(languageId, Math.min(backoff * 2, _LspManager.MAX_BACKOFF_MS)), this._callbacks.onServerCrash?.(languageId, !0, attempts + 1), setTimeout(() => {
+      if (this._shuttingDown)
+        return;
+      let config = this.serverConfigs.get(languageId);
+      if (!config)
+        return;
+      let startPromise = this.startServer(languageId, config);
+      this.startingServers.set(languageId, startPromise), startPromise.catch((err) => {
+        this.startingServers.delete(languageId), this._callbacks.onServerError?.(languageId, `Auto-restart failed for ${languageId}: ${err.message}`), this.handleUnexpectedExit(languageId, null);
+      });
+    }, backoff);
+  }
+  /** Shut down all clients (disconnect from daemons, kill direct servers) */
+  async shutdownAll() {
+    this._workspace.shutdown(), this._shuttingDown = !0;
+    let shutdowns = [...this.clients.values()].map((client) => client.shutdown().catch(() => {
+    }));
+    await Promise.all(shutdowns), this.clients.clear(), this.startingServers.clear();
+  }
+  /**
+   * Restart a specific language server. Shuts down the existing client
+   * (and kills the daemon if shared), then starts a fresh server.
+   * Returns once the new server is initialized, or throws on failure.
+   */
+  async restartServer(languageId) {
+    let existing = this.clients.get(languageId);
+    existing && (await existing.shutdown().catch(() => {
+    }), this.clients.delete(languageId)), this.killDaemon(languageId);
+    let pending = this.startingServers.get(languageId);
+    pending && (await pending.catch(() => {
+    }), this.startingServers.delete(languageId));
+    let config = this.serverConfigs.get(languageId);
+    if (!config)
+      throw new Error(`No server configured for ${languageId}`);
+    await this.startServer(languageId, config);
+  }
+  /** Kill a running daemon for a language (if any) */
+  killDaemon(languageId) {
+    let stateDir = this._workspace.stateDir;
+    if (!stateDir)
+      return;
+    let pidPath = join(stateDir, "sockets", `lsp-${languageId}.pid`);
+    try {
+      if (!existsSync(pidPath))
+        return;
+      let pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+      if (isNaN(pid))
+        return;
+      process.kill(pid, "SIGTERM");
+      let socketPath = join(stateDir, "sockets", `lsp-${languageId}.sock`);
+      try {
+        unlinkSync(socketPath);
+      } catch {
+      }
+      try {
+        unlinkSync(pidPath);
+      } catch {
+      }
+    } catch {
+    }
+  }
+};
+export {
+  LspManager
+};