wave-agent-sdk 1.0.4 → 1.0.6

package/src/managers/lspManager.ts

@@ -1,470 +0,0 @@
-import { ChildProcess, spawn } from "child_process";
-import {
-  LspConfig,
-  LspServerConfig,
-  ILspManager,
-  LspCallHierarchyItem,
-} from "../types/index.js";
-import { join, isAbsolute, extname } from "path";
-import { promises as fs } from "fs";
-import { Container } from "../utils/container.js";
-
-interface LspProcess {
-  process: ChildProcess;
-  config: LspServerConfig;
-  language: string;
-  initialized: boolean;
-  requestId: number;
-  pendingRequests: Map<
-    number,
-    { resolve: (value: unknown) => void; reject: (reason?: unknown) => void }
-  >;
-  openedFiles: Set<string>;
-}
-
-import { logger } from "../utils/globalLogger.js";
-
-export class LspManager implements ILspManager {
-  private processes: Map<string, LspProcess> = new Map();
-  private workdir: string = "";
-  private config: LspConfig = {};
-
-  constructor(private container: Container) {}
-
-  async initialize(workdir: string): Promise<void> {
-    this.workdir = workdir;
-    await this.loadConfig();
-  }
-
-  registerServer(language: string, config: LspServerConfig): void {
-    this.config[language] = config;
-    logger?.debug(`Registered LSP server for ${language}`);
-  }
-
-  private async loadConfig(): Promise<void> {
-    const lspJsonPath = join(this.workdir, ".lsp.json");
-    try {
-      const content = await fs.readFile(lspJsonPath, "utf-8");
-      const newConfig = JSON.parse(content);
-      this.config = { ...this.config, ...newConfig };
-      logger?.debug(`Loaded LSP config from ${lspJsonPath}`);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-        logger?.error(`Failed to load .lsp.json: ${error}`);
-      }
-    }
-  }
-
-  async getProcessForFile(filePath: string): Promise<LspProcess | null> {
-    const extension = extname(filePath);
-    let language: string | null = null;
-
-    for (const [lang, cfg] of Object.entries(this.config)) {
-      if (cfg.extensionToLanguage[extension]) {
-        language = lang;
-        break;
-      }
-    }
-
-    if (!language) return null;
-
-    let lspProc = this.processes.get(language);
-    if (!lspProc) {
-      const serverConfig = this.config[language];
-      const startedProc = await this.startServer(language, serverConfig);
-      if (startedProc) {
-        this.processes.set(language, startedProc);
-        lspProc = startedProc;
-      }
-    }
-
-    return lspProc || null;
-  }
-
-  private async startServer(
-    language: string,
-    config: LspServerConfig,
-  ): Promise<LspProcess | null> {
-    logger?.info(
-      `Starting LSP server for ${language}: ${config.command} ${config.args?.join(" ") || ""}`,
-    );
-
-    try {
-      const env = { ...process.env, ...config.env };
-
-      // For plugin servers, substitute ${WAVE_PLUGIN_ROOT} and ${CLAUDE_PLUGIN_ROOT}
-      let command = config.command;
-      let args = config.args || [];
-      if (config.pluginRoot) {
-        env.WAVE_PLUGIN_ROOT = config.pluginRoot;
-        env.CLAUDE_PLUGIN_ROOT = config.pluginRoot;
-        command = command.replace(/\$\{WAVE_PLUGIN_ROOT\}/g, config.pluginRoot);
-        command = command.replace(
-          /\$\{CLAUDE_PLUGIN_ROOT\}/g,
-          config.pluginRoot,
-        );
-        args = args.map((arg) => {
-          let result = arg.replace(
-            /\$\{WAVE_PLUGIN_ROOT\}/g,
-            config.pluginRoot!,
-          );
-          result = result.replace(
-            /\$\{CLAUDE_PLUGIN_ROOT\}/g,
-            config.pluginRoot!,
-          );
-          return result;
-        });
-        // Also expand plugin root in user-provided env values
-        if (config.env) {
-          for (const [key, value] of Object.entries(config.env)) {
-            let expanded = value.replace(
-              /\$\{WAVE_PLUGIN_ROOT\}/g,
-              config.pluginRoot!,
-            );
-            expanded = expanded.replace(
-              /\$\{CLAUDE_PLUGIN_ROOT\}/g,
-              config.pluginRoot!,
-            );
-            env[key] = expanded;
-          }
-        }
-      }
-      const proc = spawn(command, args, {
-        cwd: config.workspaceFolder || this.workdir,
-        env,
-        stdio: ["pipe", "pipe", "pipe"],
-      });
-
-      const lspProc: LspProcess = {
-        process: proc,
-        config,
-        language,
-        initialized: false,
-        requestId: 0,
-        pendingRequests: new Map(),
-        openedFiles: new Set(),
-      };
-
-      let buffer = Buffer.alloc(0);
-      let contentLength = -1;
-
-      proc.stdout!.on("data", (data: Buffer) => {
-        buffer = Buffer.concat([buffer, data]);
-
-        while (true) {
-          const str = buffer.toString("utf-8");
-          if (contentLength === -1) {
-            const headerEnd = str.indexOf("\r\n\r\n");
-            if (headerEnd === -1) break;
-
-            const headers = str.substring(0, headerEnd).split("\r\n");
-            const contentLengthHeader = headers.find((h) =>
-              h.startsWith("Content-Length: "),
-            );
-            if (contentLengthHeader) {
-              contentLength = parseInt(contentLengthHeader.substring(16), 10);
-            }
-            buffer = buffer.subarray(headerEnd + 4);
-            continue;
-          }
-
-          if (buffer.length >= contentLength) {
-            const content = buffer.subarray(0, contentLength).toString("utf-8");
-            buffer = buffer.subarray(contentLength);
-            contentLength = -1;
-
-            try {
-              const message = JSON.parse(content);
-              this.handleMessage(lspProc, message);
-            } catch (e) {
-              logger?.error(`Failed to parse LSP message: ${e}`);
-            }
-          } else {
-            break;
-          }
-        }
-      });
-
-      proc.stderr!.on("data", (data) => {
-        logger?.debug(`LSP [${language}] stderr: ${data}`);
-      });
-
-      proc.on("close", (code) => {
-        logger?.info(`LSP server for ${language} exited with code ${code}`);
-        this.processes.delete(language);
-      });
-
-      // Initialize
-      await this.sendRequest(
-        lspProc,
-        "initialize",
-        {
-          processId: process.pid,
-          rootUri: `file://${this.workdir}`,
-          capabilities: {},
-          initializationOptions: config.initializationOptions,
-        },
-        config.startupTimeout,
-      );
-      await this.sendNotification(lspProc, "initialized", {});
-      lspProc.initialized = true;
-
-      return lspProc;
-    } catch (error) {
-      logger?.error(`Failed to start LSP server for ${language}: ${error}`);
-      return null;
-    }
-  }
-
-  private handleMessage(
-    lspProc: LspProcess,
-    message: { id?: number; error?: unknown; result?: unknown },
-  ) {
-    if (message.id !== undefined) {
-      const pending = lspProc.pendingRequests.get(message.id);
-      if (pending) {
-        lspProc.pendingRequests.delete(message.id);
-        if (message.error) {
-          pending.reject(message.error);
-        } else {
-          pending.resolve(message.result);
-        }
-      }
-    }
-  }
-
-  private async sendRequest(
-    lspProc: LspProcess,
-    method: string,
-    params: unknown,
-    timeout?: number,
-  ): Promise<unknown> {
-    const id = lspProc.requestId++;
-    const message = {
-      jsonrpc: "2.0",
-      id,
-      method,
-      params,
-    };
-
-    const json = JSON.stringify(message);
-    const header = `Content-Length: ${Buffer.byteLength(json, "utf-8")}\r\n\r\n`;
-
-    return new Promise((resolve, reject) => {
-      let timer: NodeJS.Timeout | undefined;
-      if (timeout) {
-        timer = setTimeout(() => {
-          lspProc.pendingRequests.delete(id);
-          reject(
-            new Error(`LSP request ${method} timed out after ${timeout}ms`),
-          );
-        }, timeout);
-      }
-
-      lspProc.pendingRequests.set(id, {
-        resolve: (value) => {
-          if (timer) clearTimeout(timer);
-          resolve(value);
-        },
-        reject: (reason) => {
-          if (timer) clearTimeout(timer);
-          reject(reason);
-        },
-      });
-      lspProc.process.stdin!.write(header + json);
-    });
-  }
-
-  private async sendNotification(
-    lspProc: LspProcess,
-    method: string,
-    params: unknown,
-  ): Promise<void> {
-    const message = {
-      jsonrpc: "2.0",
-      method,
-      params,
-    };
-
-    const json = JSON.stringify(message);
-    const header = `Content-Length: ${Buffer.byteLength(json, "utf-8")}\r\n\r\n`;
-    lspProc.process.stdin!.write(header + json);
-  }
-
-  async execute(args: {
-    operation: string;
-    filePath: string;
-    line: number;
-    character: number;
-  }): Promise<{ success: boolean; content: string }> {
-    const { operation, filePath, line, character } = args;
-    const absolutePath = isAbsolute(filePath)
-      ? filePath
-      : join(this.workdir, filePath);
-    const lspProc = await this.getProcessForFile(absolutePath);
-
-    if (!lspProc) {
-      return {
-        success: false,
-        content: `No LSP server configured for file: ${filePath}`,
-      };
-    }
-
-    const uri = `file://${absolutePath}`;
-    const position = { line: line - 1, character: character - 1 };
-
-    if (!lspProc.openedFiles.has(absolutePath)) {
-      try {
-        const content = await fs.readFile(absolutePath, "utf-8");
-        await this.sendNotification(lspProc, "textDocument/didOpen", {
-          textDocument: {
-            uri,
-            languageId: lspProc.language,
-            version: 1,
-            text: content,
-          },
-        });
-        lspProc.openedFiles.add(absolutePath);
-      } catch (error) {
-        logger?.error(`Failed to read file for LSP didOpen: ${error}`);
-      }
-    }
-
-    try {
-      let result: unknown;
-      switch (operation) {
-        case "goToDefinition":
-          result = await this.sendRequest(lspProc, "textDocument/definition", {
-            textDocument: { uri },
-            position,
-          });
-          break;
-        case "hover":
-          result = await this.sendRequest(lspProc, "textDocument/hover", {
-            textDocument: { uri },
-            position,
-          });
-          break;
-        case "findReferences":
-          result = await this.sendRequest(lspProc, "textDocument/references", {
-            textDocument: { uri },
-            position,
-            context: { includeDeclaration: true },
-          });
-          break;
-        case "documentSymbol":
-          result = await this.sendRequest(
-            lspProc,
-            "textDocument/documentSymbol",
-            {
-              textDocument: { uri },
-            },
-          );
-          break;
-        case "workspaceSymbol":
-          result = await this.sendRequest(lspProc, "workspace/symbol", {
-            query: "", // For now, use empty query to get all symbols or let server decide
-          });
-          break;
-        case "goToImplementation":
-          result = await this.sendRequest(
-            lspProc,
-            "textDocument/implementation",
-            {
-              textDocument: { uri },
-              position,
-            },
-          );
-          break;
-        case "prepareCallHierarchy":
-          result = await this.sendRequest(
-            lspProc,
-            "textDocument/prepareCallHierarchy",
-            {
-              textDocument: { uri },
-              position,
-            },
-          );
-          break;
-        case "incomingCalls": {
-          const items = (await this.sendRequest(
-            lspProc,
-            "textDocument/prepareCallHierarchy",
-            {
-              textDocument: { uri },
-              position,
-            },
-          )) as LspCallHierarchyItem[];
-          if (items && items.length > 0) {
-            result = await this.sendRequest(
-              lspProc,
-              "callHierarchy/incomingCalls",
-              {
-                item: items[0],
-              },
-            );
-          } else {
-            result = [];
-          }
-          break;
-        }
-        case "outgoingCalls": {
-          const items = (await this.sendRequest(
-            lspProc,
-            "textDocument/prepareCallHierarchy",
-            {
-              textDocument: { uri },
-              position,
-            },
-          )) as LspCallHierarchyItem[];
-          if (items && items.length > 0) {
-            result = await this.sendRequest(
-              lspProc,
-              "callHierarchy/outgoingCalls",
-              {
-                item: items[0],
-              },
-            );
-          } else {
-            result = [];
-          }
-          break;
-        }
-        // Add more operations as needed
-        default:
-          return {
-            success: false,
-            content: `Unsupported LSP operation: ${operation}`,
-          };
-      }
-
-      return { success: true, content: JSON.stringify(result) };
-    } catch (error) {
-      return { success: false, content: `LSP error: ${JSON.stringify(error)}` };
-    }
-  }
-
-  async cleanup(): Promise<void> {
-    for (const [language, lspProc] of this.processes.entries()) {
-      try {
-        // Try graceful shutdown
-        const timeout = lspProc.config.shutdownTimeout || 2000;
-        await this.sendRequest(lspProc, "shutdown", {}, timeout);
-        await this.sendNotification(lspProc, "exit", {});
-        // Give it a moment to exit
-        if (timeout > 100) {
-          await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-      } catch (error) {
-        logger?.debug(
-          `Failed to gracefully shutdown LSP for ${language}: ${error}`,
-        );
-      } finally {
-        if (!lspProc.process.killed) {
-          lspProc.process.kill();
-        }
-      }
-    }
-    this.processes.clear();
-  }
-}