@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-O6F2EF2Z.js

@@ -0,0 +1,73 @@
+import {
+  ContextLimitError,
+  LLMError,
+  LLMRateLimitError
+} from "./chunk-FUOKLKR2.js";
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/llm/client-base.ts
+init_esm_shims();
+var LLMClientBase = class {
+  constructor(config) {
+    this.config = config;
+    this.provider = config.provider;
+    this.model = config.model;
+    this.temperature = config.temperature ?? 0.3;
+    this.maxTokens = config.maxTokens ?? 8192;
+    this.timeout = config.timeout ?? 12e4;
+    this.retryMaxAttempts = config.retryMaxAttempts ?? 3;
+    this.enableStreaming = config.enableStreaming ?? true;
+    this.initClient();
+  }
+  provider;
+  model;
+  temperature;
+  maxTokens;
+  timeout;
+  retryMaxAttempts;
+  enableStreaming;
+  usage = {
+    records: [],
+    totalPromptTokens: 0,
+    totalCompletionTokens: 0,
+    totalTokens: 0,
+    requestCount: 0
+  };
+  recordUsage(usage) {
+    this.usage.records.push(usage);
+    this.usage.totalPromptTokens += usage.promptTokens;
+    this.usage.totalCompletionTokens += usage.completionTokens;
+    this.usage.totalTokens += usage.totalTokens;
+    this.usage.requestCount++;
+  }
+  getUsage() {
+    return { ...this.usage };
+  }
+  async withRetry(fn, maxAttempts) {
+    const attempts = maxAttempts ?? this.retryMaxAttempts;
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (err instanceof ContextLimitError) throw err;
+        if (err instanceof LLMRateLimitError) {
+          const waitMs = (err.retryAfter ?? attempt * 2) * 1e3;
+          await new Promise((r) => setTimeout(r, waitMs));
+          continue;
+        }
+        if (attempt === attempts) break;
+        const backoff = Math.min(1e3 * Math.pow(2, attempt - 1), 3e4);
+        await new Promise((r) => setTimeout(r, backoff));
+      }
+    }
+    throw lastError ?? new LLMError("Unknown LLM error");
+  }
+};
+
+export {
+  LLMClientBase
+};

package/dist/chunk-OG4MIQJ6.js

@@ -0,0 +1,335 @@
+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
+};