@cjhyy/code-shell 0.1.0-alpha.0 → 0.1.0-alpha.2

package/dist/chunk-OG4MIQJ6.js

@@ -1,335 +0,0 @@
-import {
-  init_esm_shims
-} from "./chunk-DI7RDLOS.js";
-
-// src/lsp/manager.ts
-init_esm_shims();
-
-// src/lsp/client.ts
-init_esm_shims();
-import { spawn } from "child_process";
-import { EventEmitter } from "events";
-var LSPClient = class extends EventEmitter {
-  constructor(command, args = [], cwd) {
-    super();
-    this.command = command;
-    this.args = args;
-    this.cwd = cwd;
-  }
-  process;
-  nextId = 1;
-  pending = /* @__PURE__ */ new Map();
-  buffer = "";
-  contentLength = -1;
-  initialized = false;
-  async start() {
-    this.process = spawn(this.command, this.args, {
-      cwd: this.cwd,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    this.process.stdout?.on("data", (data) => this.handleData(data.toString()));
-    this.process.stderr?.on("data", (_data) => {
-    });
-    this.process.on("exit", (code) => {
-      this.emit("exit", code);
-      this.rejectAll(new Error(`LSP server exited with code ${code}`));
-    });
-    this.process.unref();
-  }
-  async initialize(rootUri) {
-    const result = await this.request("initialize", {
-      processId: process.pid,
-      rootUri,
-      capabilities: {
-        textDocument: {
-          definition: { dynamicRegistration: false },
-          references: { dynamicRegistration: false },
-          hover: { contentFormat: ["plaintext", "markdown"] },
-          documentSymbol: { dynamicRegistration: false },
-          completion: { dynamicRegistration: false }
-        },
-        workspace: {
-          symbol: { dynamicRegistration: false }
-        }
-      }
-    });
-    await this.notify("initialized", {});
-    this.initialized = true;
-    return result;
-  }
-  async request(method, params) {
-    if (!this.process?.stdin) throw new Error("LSP server not started");
-    const id = this.nextId++;
-    const message = { jsonrpc: "2.0", id, method, params };
-    const content = JSON.stringify(message);
-    const header = `Content-Length: ${Buffer.byteLength(content)}\r
-\r
-`;
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        if (this.pending.has(id)) {
-          this.pending.delete(id);
-          reject(new Error(`LSP request "${method}" timed out`));
-        }
-      }, 3e4);
-      timer.unref?.();
-      this.pending.set(id, {
-        resolve: (value) => {
-          clearTimeout(timer);
-          resolve(value);
-        },
-        reject: (err) => {
-          clearTimeout(timer);
-          reject(err);
-        }
-      });
-      this.process.stdin.write(header + content);
-    });
-  }
-  async notify(method, params) {
-    if (!this.process?.stdin) throw new Error("LSP server not started");
-    const message = { jsonrpc: "2.0", method, params };
-    const content = JSON.stringify(message);
-    const header = `Content-Length: ${Buffer.byteLength(content)}\r
-\r
-`;
-    this.process.stdin.write(header + content);
-  }
-  async shutdown() {
-    if (!this.process) return;
-    try {
-      await this.request("shutdown", {});
-      await this.notify("exit", {});
-    } catch {
-    }
-    this.process.stdout?.removeAllListeners();
-    this.process.stderr?.removeAllListeners();
-    this.process.removeAllListeners();
-    this.process.kill();
-    this.process = void 0;
-    for (const { reject } of this.pending.values()) {
-      reject(new Error("LSP server shut down"));
-    }
-    this.pending.clear();
-  }
-  get isInitialized() {
-    return this.initialized;
-  }
-  get isAlive() {
-    return this.process !== void 0 && !this.process.killed;
-  }
-  handleData(data) {
-    this.buffer += data;
-    while (true) {
-      if (this.contentLength < 0) {
-        const headerEnd = this.buffer.indexOf("\r\n\r\n");
-        if (headerEnd < 0) break;
-        const header = this.buffer.slice(0, headerEnd);
-        const match = header.match(/Content-Length:\s*(\d+)/i);
-        if (!match) {
-          this.buffer = this.buffer.slice(headerEnd + 4);
-          continue;
-        }
-        this.contentLength = parseInt(match[1], 10);
-        this.buffer = this.buffer.slice(headerEnd + 4);
-      }
-      if (this.buffer.length < this.contentLength) break;
-      const content = this.buffer.slice(0, this.contentLength);
-      this.buffer = this.buffer.slice(this.contentLength);
-      this.contentLength = -1;
-      try {
-        const message = JSON.parse(content);
-        if ("id" in message && this.pending.has(message.id)) {
-          const { resolve, reject } = this.pending.get(message.id);
-          this.pending.delete(message.id);
-          if (message.error) {
-            reject(new Error(`LSP error: ${message.error.message}`));
-          } else {
-            resolve(message.result);
-          }
-        } else if ("method" in message && !("id" in message)) {
-          this.emit("notification", message);
-        }
-      } catch {
-      }
-    }
-  }
-  rejectAll(error) {
-    for (const { reject } of this.pending.values()) {
-      reject(error);
-    }
-    this.pending.clear();
-  }
-};
-
-// src/lsp/servers.ts
-init_esm_shims();
-var BUILTIN_LSP_SERVERS = [
-  {
-    name: "typescript",
-    language: "typescript",
-    extensions: [".ts", ".tsx", ".js", ".jsx"],
-    command: "typescript-language-server",
-    args: ["--stdio"],
-    installHint: "npm install -g typescript-language-server typescript"
-  },
-  {
-    name: "python",
-    language: "python",
-    extensions: [".py"],
-    command: "pylsp",
-    args: [],
-    installHint: "pip install python-lsp-server"
-  },
-  {
-    name: "go",
-    language: "go",
-    extensions: [".go"],
-    command: "gopls",
-    args: ["serve"],
-    installHint: "go install golang.org/x/tools/gopls@latest"
-  },
-  {
-    name: "rust",
-    language: "rust",
-    extensions: [".rs"],
-    command: "rust-analyzer",
-    args: [],
-    installHint: "rustup component add rust-analyzer"
-  },
-  {
-    name: "json",
-    language: "json",
-    extensions: [".json"],
-    command: "vscode-json-languageserver",
-    args: ["--stdio"],
-    installHint: "npm install -g vscode-langservers-extracted"
-  },
-  {
-    name: "css",
-    language: "css",
-    extensions: [".css", ".scss", ".less"],
-    command: "vscode-css-languageserver",
-    args: ["--stdio"],
-    installHint: "npm install -g vscode-langservers-extracted"
-  }
-];
-function detectLSPServer(filePath) {
-  const ext = filePath.slice(filePath.lastIndexOf("."));
-  return BUILTIN_LSP_SERVERS.find((s) => s.extensions.includes(ext));
-}
-
-// src/lsp/manager.ts
-import { execSync } from "child_process";
-import { pathToFileURL } from "url";
-var LSPServerManager = class {
-  servers = /* @__PURE__ */ new Map();
-  rootUri;
-  constructor(cwd) {
-    this.rootUri = pathToFileURL(cwd).href;
-    for (const config of BUILTIN_LSP_SERVERS) {
-      this.servers.set(config.name, { config, client: void 0, state: "stopped" });
-    }
-  }
-  /**
-   * Get or start a language server by name.
-   */
-  async getClient(serverName) {
-    const managed = this.servers.get(serverName);
-    if (!managed) return void 0;
-    if (managed.state === "ready" && managed.client?.isAlive) {
-      return managed.client;
-    }
-    if (managed.state === "starting") {
-      await new Promise((r) => setTimeout(r, 2e3));
-      return managed.client;
-    }
-    return this.startServer(serverName);
-  }
-  /**
-   * Start a specific language server.
-   */
-  async startServer(name) {
-    const managed = this.servers.get(name);
-    if (!managed) return void 0;
-    if (!this.isCommandAvailable(managed.config.command)) {
-      managed.state = "error";
-      managed.error = `${managed.config.command} not found. Install: ${managed.config.installHint}`;
-      return void 0;
-    }
-    managed.state = "starting";
-    try {
-      const client = new LSPClient(managed.config.command, managed.config.args, this.rootUri.replace("file://", ""));
-      await client.start();
-      await client.initialize(this.rootUri);
-      managed.client = client;
-      managed.state = "ready";
-      return client;
-    } catch (err) {
-      managed.state = "error";
-      managed.error = err.message;
-      return void 0;
-    }
-  }
-  /**
-   * Check if any LSP server is connected.
-   */
-  isConnected() {
-    for (const server of this.servers.values()) {
-      if (server.state === "ready" && server.client?.isAlive) return true;
-    }
-    return false;
-  }
-  /**
-   * List server statuses.
-   */
-  listServers() {
-    return [...this.servers.values()].map((s) => ({
-      name: s.config.name,
-      language: s.config.language,
-      state: s.state,
-      error: s.error
-    }));
-  }
-  /**
-   * Shutdown all servers.
-   */
-  async shutdownAll() {
-    for (const server of this.servers.values()) {
-      if (server.client?.isAlive) {
-        try {
-          await server.client.shutdown();
-        } catch {
-        }
-      }
-      server.state = "stopped";
-      server.client = void 0;
-    }
-  }
-  isCommandAvailable(command) {
-    try {
-      execSync(`which ${command} 2>/dev/null || where ${command} 2>nul`, {
-        encoding: "utf-8",
-        timeout: 5e3
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
-var _manager;
-function initializeLSPManager(cwd) {
-  _manager = new LSPServerManager(cwd);
-  return _manager;
-}
-function getLSPManager() {
-  return _manager;
-}
-
-export {
-  detectLSPServer,
-  LSPServerManager,
-  initializeLSPManager,
-  getLSPManager
-};