pybao-cli 1.3.83 → 1.3.86

package/dist/chunk-ARPANTL5.js

@@ -0,0 +1,1834 @@
+import { createRequire as __pybCreateRequire } from "node:module";
+const require = __pybCreateRequire(import.meta.url);
+import {
+  LspServerRegistry,
+  findNearestRoot
+} from "./chunk-XTZG3RFQ.js";
+import {
+  levenshtein
+} from "./chunk-UZ34JEUK.js";
+import {
+  getCwd
+} from "./chunk-XHAFEGQ4.js";
+
+// src/lsp/index.ts
+import { extname as extname2 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { readFile as readFile3 } from "fs/promises";
+import * as http from "http";
+
+// src/tools/search/LspTool/client/generic.ts
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node.js";
+import { spawn } from "child_process";
+import { pathToFileURL, fileURLToPath } from "url";
+import { EventEmitter } from "events";
+var DiagnosticsEventBus = class {
+  debounceMs;
+  lastEventAt = /* @__PURE__ */ new Map();
+  debounceTimers = /* @__PURE__ */ new Map();
+  waiting = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.debounceMs = options?.debounceMs ?? 150;
+  }
+  publish(uri) {
+    const now = Date.now();
+    this.lastEventAt.set(uri, now);
+    const existing = this.debounceTimers.get(uri);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(uri);
+      const waiters = this.waiting.get(uri);
+      if (!waiters || waiters.size === 0) return;
+      for (const resolver of Array.from(waiters)) {
+        resolver();
+      }
+    }, this.debounceMs);
+    this.debounceTimers.set(uri, timer);
+  }
+  waitForIdle(uri, timeoutMs) {
+    const last = this.lastEventAt.get(uri);
+    if (last !== void 0 && Date.now() - last >= this.debounceMs) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      let done = false;
+      const finish = () => {
+        if (done) return;
+        done = true;
+        clearTimeout(timeout);
+        const waiters2 = this.waiting.get(uri);
+        if (waiters2) {
+          waiters2.delete(finish);
+          if (waiters2.size === 0) this.waiting.delete(uri);
+        }
+        resolve();
+      };
+      const waiters = this.waiting.get(uri) ?? /* @__PURE__ */ new Set();
+      waiters.add(finish);
+      this.waiting.set(uri, waiters);
+      const timeout = setTimeout(() => {
+        finish();
+      }, timeoutMs);
+    });
+  }
+};
+var GenericLspClient = class {
+  constructor(serverCommand, serverArgs, cwd, rootPath, extraEnv, initializationOptions) {
+    this.rootPath = rootPath;
+    this.extraEnv = extraEnv;
+    this.initializationOptions = initializationOptions;
+    const env = {
+      ...process.env,
+      // Remove potentially conflicting variables
+      NODE_OPTIONS: void 0,
+      TS_NODE_PROJECT: void 0,
+      ELECTRON_RUN_AS_NODE: void 0,
+      ...this.extraEnv
+    };
+    const options = {
+      cwd,
+      stdio: "pipe",
+      env,
+      shell: false
+    };
+    this.process = spawn(serverCommand, serverArgs, options);
+    this.process.stderr.on("data", (data) => {
+      console.error(`[LSP Stderr] ${data}`);
+    });
+    this.connection = createMessageConnection(
+      new StreamMessageReader(this.process.stdout),
+      new StreamMessageWriter(this.process.stdin)
+    );
+    this.connection.onNotification((method, params) => {
+      if (method === "window/logMessage" || method === "$/progress") {
+        console.log(`[LSP Notification] ${method}:`, JSON.stringify(params));
+      }
+      if (method === "textDocument/publishDiagnostics") {
+        try {
+          const payload = params;
+          const uri = payload.uri ?? "";
+          let filePath = uri;
+          if (uri.startsWith("file://")) {
+            filePath = fileURLToPath(uri);
+          }
+          const normalizedUri = this.normalizeUri(filePath);
+          this.diagnosticsMap.set(normalizedUri, payload.diagnostics ?? []);
+          this.diagnosticsBus.publish(normalizedUri);
+          this.diagnosticEvents.emit("diagnostics", { uri, filePath, diagnostics: payload.diagnostics ?? [] });
+        } catch (e) {
+          console.error("[LSP] Error processing diagnostics:", e);
+        }
+      }
+    });
+    this.connection.onRequest((method, params) => {
+      if (method === "workspace/configuration") {
+        const payload = params;
+        const items = Array.isArray(payload.items) ? payload.items : [];
+        return items.map((item) => {
+          const section = String(item?.section ?? "");
+          if (section === "yaml" || section.startsWith("yaml.")) {
+            return { schemaStore: { enable: false }, schemas: {} };
+          }
+          return {};
+        });
+      }
+      if (method === "client/registerCapability") {
+        return null;
+      }
+      return null;
+    });
+    this.connection.listen();
+  }
+  connection;
+  process;
+  capabilities;
+  diagnosticEvents = new EventEmitter();
+  diagnosticsBus = new DiagnosticsEventBus();
+  diagnosticsMap = /* @__PURE__ */ new Map();
+  normalizeUri(filePath) {
+    let uri = pathToFileURL(filePath).href;
+    if (process.platform === "win32") {
+      uri = uri.replace(/^file:\/\/\/([a-zA-Z]):\//, (match, drive) => {
+        return `file:///${drive.toLowerCase()}%3A/`;
+      });
+    }
+    return uri;
+  }
+  async initialize() {
+    const rootUri = this.normalizeUri(this.rootPath);
+    console.log("[GenericLspClient] Initializing with normalized rootUri:", rootUri);
+    const params = {
+      processId: process.pid,
+      rootUri,
+      capabilities: {
+        textDocument: {
+          synchronization: {
+            didOpen: true,
+            didChange: true,
+            willSave: false,
+            willSaveWaitUntil: false,
+            didSave: true
+          },
+          hover: {
+            contentFormat: ["markdown", "plaintext"]
+          },
+          definition: {},
+          references: {}
+        },
+        workspace: {
+          workspaceFolders: true
+        }
+      },
+      workspaceFolders: [
+        {
+          name: "workspace",
+          uri: this.normalizeUri(this.rootPath)
+        }
+      ]
+    };
+    if (this.initializationOptions && Object.keys(this.initializationOptions).length > 0) {
+      params.initializationOptions = this.initializationOptions;
+    }
+    const result = await this.connection.sendRequest("initialize", params);
+    await this.connection.sendNotification("initialized", {});
+    await this.connection.sendNotification("workspace/didChangeConfiguration", {
+      settings: { yaml: { schemaStore: { enable: false }, schemas: {} } }
+    });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    this.capabilities = result.capabilities;
+    return result;
+  }
+  async shutdown() {
+    try {
+      await this.connection.sendRequest("shutdown");
+      await this.connection.sendNotification("exit");
+    } catch (error) {
+    }
+    this.connection.dispose();
+    this.process.kill();
+  }
+  async goToDefinition(filePath, line, character) {
+    const params = {
+      textDocument: { uri: this.normalizeUri(filePath) },
+      position: { line: line - 1, character: character - 1 }
+    };
+    return this.connection.sendRequest("textDocument/definition", params);
+  }
+  async findReferences(filePath, line, character) {
+    const params = {
+      textDocument: { uri: this.normalizeUri(filePath) },
+      position: { line: line - 1, character: character - 1 },
+      context: { includeDeclaration: true }
+    };
+    return this.connection.sendRequest("textDocument/references", params);
+  }
+  async hover(filePath, line, character) {
+    const params = {
+      textDocument: { uri: this.normalizeUri(filePath) },
+      position: { line: line - 1, character: character - 1 }
+    };
+    return this.connection.sendRequest("textDocument/hover", params);
+  }
+  async documentSymbol(filePath) {
+    const params = {
+      textDocument: { uri: this.normalizeUri(filePath) }
+    };
+    return this.connection.sendRequest("textDocument/documentSymbol", params);
+  }
+  async workspaceSymbol(query) {
+    const params = {
+      query
+    };
+    return this.connection.sendRequest("workspace/symbol", params);
+  }
+  async goToImplementation(filePath, line, character) {
+    const params = {
+      textDocument: { uri: this.normalizeUri(filePath) },
+      position: { line: line - 1, character: character - 1 }
+    };
+    return this.connection.sendRequest("textDocument/implementation", params);
+  }
+  async prepareCallHierarchy(filePath, line, character) {
+    const params = {
+      textDocument: { uri: this.normalizeUri(filePath) },
+      position: { line: line - 1, character: character - 1 }
+    };
+    return this.connection.sendRequest("textDocument/prepareCallHierarchy", params);
+  }
+  async incomingCalls(item) {
+    const params = { item };
+    return this.connection.sendRequest("callHierarchy/incomingCalls", params);
+  }
+  async outgoingCalls(item) {
+    const params = { item };
+    return this.connection.sendRequest("callHierarchy/outgoingCalls", params);
+  }
+  async didOpen(filePath, content, languageId) {
+    const params = {
+      textDocument: {
+        uri: this.normalizeUri(filePath),
+        languageId,
+        version: 1,
+        text: content
+      }
+    };
+    await this.connection.sendNotification("textDocument/didOpen", params);
+  }
+  async didChange(filePath, content, version) {
+    const params = {
+      textDocument: {
+        uri: this.normalizeUri(filePath),
+        version
+      },
+      contentChanges: [{ text: content }]
+    };
+    await this.connection.sendNotification("textDocument/didChange", params);
+  }
+  async didClose(filePath) {
+    const params = {
+      textDocument: {
+        uri: this.normalizeUri(filePath)
+      }
+    };
+    await this.connection.sendNotification("textDocument/didClose", params);
+  }
+  async waitForReadiness(filePath, timeoutMs = 3e3) {
+    const normalizedUri = this.normalizeUri(filePath);
+    await this.diagnosticsBus.waitForIdle(normalizedUri, timeoutMs);
+  }
+  on(event, handler) {
+    this.diagnosticEvents.on(event, handler);
+  }
+  off(event, handler) {
+    this.diagnosticEvents.off(event, handler);
+  }
+  getDiagnostics(filePath) {
+    return this.diagnosticsMap.get(this.normalizeUri(filePath)) || [];
+  }
+  getDiagnosticsSnapshot() {
+    const summaries = [];
+    for (const [uri, diagnostics] of this.diagnosticsMap.entries()) {
+      let filePath = uri;
+      try {
+        if (uri.startsWith("file://")) {
+          filePath = fileURLToPath(uri);
+        }
+      } catch {
+        filePath = uri;
+      }
+      const summary = {
+        uri,
+        filePath,
+        count: diagnostics.length,
+        errors: 0,
+        warnings: 0,
+        infos: 0,
+        hints: 0
+      };
+      for (const diagnostic of diagnostics) {
+        const severity = diagnostic?.severity;
+        if (severity === 1) summary.errors += 1;
+        else if (severity === 2) summary.warnings += 1;
+        else if (severity === 3) summary.infos += 1;
+        else if (severity === 4) summary.hints += 1;
+      }
+      summaries.push(summary);
+    }
+    return summaries;
+  }
+};
+
+// src/tools/search/LspTool/client/manager.ts
+import { extname, join, dirname, relative } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { readdir, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { minimatch } from "minimatch";
+var LspClientManager = class _LspClientManager {
+  static instance;
+  static clientFactory = null;
+  clients = /* @__PURE__ */ new Map();
+  spawning = /* @__PURE__ */ new Map();
+  broken = /* @__PURE__ */ new Set();
+  constructor() {
+  }
+  static getInstance() {
+    if (!_LspClientManager.instance) {
+      _LspClientManager.instance = new _LspClientManager();
+    }
+    return _LspClientManager.instance;
+  }
+  static setClientFactoryForTests(factory) {
+    _LspClientManager.clientFactory = factory;
+  }
+  getLanguageId(ext, serverInfo) {
+    if (serverInfo?.languageId) return serverInfo.languageId;
+    return LspServerRegistry.getInstance().getLanguageIdForExtension(ext);
+  }
+  async ensureWorkspaceClients(rootPath) {
+    try {
+      const files = await readdir(rootPath, { withFileTypes: true });
+      const extensionMap = /* @__PURE__ */ new Map();
+      const fileNames = new Set(files.map((f) => f.name));
+      if (fileNames.has("tsconfig.json") || fileNames.has("package.json")) {
+        if (!files.some((f) => f.isFile() && /\.(ts|tsx|js|jsx)$/.test(f.name))) {
+          try {
+            const srcFiles = await readdir(join(rootPath, "src"), { withFileTypes: true });
+            const triggerFile = srcFiles.find((f) => f.isFile() && /\.(ts|tsx|js|jsx)$/.test(f.name));
+            if (triggerFile) {
+              extensionMap.set(extname(triggerFile.name), join(rootPath, "src", triggerFile.name));
+            }
+          } catch (e) {
+          }
+        }
+      }
+      if (fileNames.has("go.mod")) {
+        extensionMap.set(".go", join(rootPath, "go.mod"));
+        if (fileNames.has("main.go")) extensionMap.set(".go", join(rootPath, "main.go"));
+      }
+      if (fileNames.has("Cargo.toml")) {
+        try {
+          if (existsSync(join(rootPath, "src", "main.rs"))) extensionMap.set(".rs", join(rootPath, "src", "main.rs"));
+          else if (existsSync(join(rootPath, "src", "lib.rs"))) extensionMap.set(".rs", join(rootPath, "src", "lib.rs"));
+        } catch (e) {
+        }
+      }
+      for (const file of files) {
+        if (file.isFile()) {
+          const ext = extname(file.name);
+          if (ext && !extensionMap.has(ext)) {
+            extensionMap.set(ext, join(rootPath, file.name));
+          }
+        }
+      }
+      for (const [ext, realPath] of extensionMap) {
+        const client = await this.getClient(realPath, rootPath);
+        if (client) {
+          try {
+            const content = await readFile(realPath, "utf-8");
+            const serverInfo = LspServerRegistry.getInstance().getServerForExtension(ext);
+            await client.didOpen(realPath, content, this.getLanguageId(ext, serverInfo ?? void 0));
+            await client.waitForReadiness(realPath, 2e3);
+          } catch (e) {
+          }
+        } else {
+        }
+      }
+    } catch (e) {
+    }
+  }
+  async getClientForFile(filePath) {
+    const rootPath = await this.resolveRootForFile(filePath);
+    return this.getClient(filePath, rootPath);
+  }
+  async resolveRootForFile(filePath) {
+    const ext = extname(filePath);
+    const serverInfo = LspServerRegistry.getInstance().getServerForExtension(ext);
+    if (serverInfo) {
+      return this.resolveRootForServer(filePath, serverInfo);
+    }
+    const cwd = getCwd();
+    if (filePath.startsWith(cwd)) {
+      return cwd;
+    }
+    return dirname(filePath);
+  }
+  async getClient(filePath, rootPath) {
+    const ext = extname(filePath);
+    const servers = LspServerRegistry.getInstance().getServersForExtension(ext);
+    if (servers.length === 0) return null;
+    for (const serverInfo of servers) {
+      const client = await this.getClientForServer(filePath, serverInfo, rootPath);
+      if (client) return client;
+    }
+    return null;
+  }
+  async getClientsForFile(filePath, rootPath) {
+    const ext = extname(filePath);
+    const servers = LspServerRegistry.getInstance().getServersForExtension(ext);
+    if (servers.length === 0) return [];
+    const clients = [];
+    for (const serverInfo of servers) {
+      const client = await this.getClientForServer(filePath, serverInfo, rootPath);
+      if (client) clients.push(client);
+    }
+    return clients;
+  }
+  async spawnClient(resolvedRoot, serverInfo, key) {
+    const cmd = await serverInfo.getCommand(resolvedRoot);
+    if (!cmd) {
+      return null;
+    }
+    const safeCwd = /[^\x00-\x7F]/.test(resolvedRoot) ? process.cwd() : resolvedRoot;
+    let initOpts = serverInfo.initializationOptions;
+    if (serverInfo.id === "pyright" || serverInfo.id === "ty") {
+      const { detectPythonVenv } = await import("./registry-6M7CIUP6.js");
+      const pythonPath = detectPythonVenv(resolvedRoot);
+      if (pythonPath) {
+        initOpts = { ...initOpts ?? {}, pythonPath };
+      }
+    }
+    const nextClient = (_LspClientManager.clientFactory ?? ((...args) => new GenericLspClient(...args)))(
+      cmd.command,
+      cmd.args,
+      safeCwd,
+      resolvedRoot,
+      serverInfo.env,
+      initOpts
+    );
+    await nextClient.initialize();
+    this.clients.set(key, nextClient);
+    return nextClient;
+  }
+  async shutdownAll() {
+    for (const client of this.clients.values()) {
+      await client.shutdown();
+    }
+    this.clients.clear();
+    this.broken.clear();
+    this.spawning.clear();
+  }
+  async workspaceSymbol(query, rootPath = getCwd(), options) {
+    if (this.clients.size === 0) {
+      await this.ensureWorkspaceClients(rootPath);
+    }
+    const results = [];
+    for (const client of this.clients.values()) {
+      try {
+        const symbols = await client.workspaceSymbol(query);
+        if (symbols && Array.isArray(symbols)) {
+          results.push(...symbols);
+        }
+      } catch (e) {
+      }
+    }
+    if (results.length === 0 && query.length > 0) {
+      for (const client of this.clients.values()) {
+        try {
+          const broadSymbols = await client.workspaceSymbol("");
+          if (broadSymbols && Array.isArray(broadSymbols)) {
+            for (const sym of broadSymbols) {
+              const dist = levenshtein(query, sym.name);
+              if (dist <= 2 || dist <= query.length * 0.3) {
+                results.push(sym);
+              }
+            }
+          }
+        } catch (e) {
+        }
+      }
+    }
+    const normalizedResults = results.map((sym) => {
+      if (!sym || typeof sym !== "object") return sym;
+      if (!sym.range && sym.location?.range) {
+        sym.range = sym.location.range;
+      }
+      if (!sym.uri && sym.location?.uri) {
+        sym.uri = sym.location.uri;
+      }
+      return sym;
+    });
+    const resolveFilePath = (uri) => {
+      try {
+        if (uri.startsWith("file://")) {
+          return fileURLToPath2(uri);
+        }
+      } catch {
+      }
+      return uri;
+    };
+    const flattenSymbols = (items, output = []) => {
+      for (const item of items) {
+        if (!item || typeof item !== "object") continue;
+        output.push(item);
+        if (Array.isArray(item.children) && item.children.length > 0) {
+          flattenSymbols(item.children, output);
+        }
+      }
+      return output;
+    };
+    const missingRange = normalizedResults.filter(
+      (sym) => sym && !sym.range && typeof sym.uri === "string" && sym.uri.length > 0
+    );
+    if (missingRange.length > 0) {
+      const byUri = /* @__PURE__ */ new Map();
+      for (const sym of missingRange) {
+        if (!byUri.has(sym.uri)) byUri.set(sym.uri, []);
+        byUri.get(sym.uri).push(sym);
+      }
+      const documentCache = /* @__PURE__ */ new Map();
+      for (const [uri, symbols] of byUri.entries()) {
+        const filePath = resolveFilePath(uri);
+        let documentSymbols = documentCache.get(filePath);
+        if (!documentSymbols) {
+          documentSymbols = await this.documentSymbol(filePath, rootPath) ?? [];
+          documentCache.set(filePath, documentSymbols);
+        }
+        const flat = flattenSymbols(documentSymbols);
+        for (const sym of symbols) {
+          let match = flat.find(
+            (item) => item?.name === sym.name && (sym.kind === void 0 || item?.kind === sym.kind)
+          );
+          if (!match) {
+            match = flat.find((item) => item?.name === sym.name);
+          }
+          const range = match?.range ?? match?.location?.range;
+          if (range) {
+            sym.range = range;
+          }
+        }
+      }
+    }
+    const finalResults = normalizedResults.filter((sym) => sym && sym.range && sym.name);
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = [];
+    for (const sym of finalResults) {
+      const uri = sym?.location?.uri ?? sym?.uri ?? "";
+      const line = sym?.range?.start?.line ?? sym?.location?.range?.start?.line ?? "";
+      const character = sym?.range?.start?.character ?? sym?.location?.range?.start?.character ?? "";
+      const kind = sym?.kind ?? "";
+      const key = `${sym?.name ?? ""}|${kind}|${uri}|${line}|${character}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        deduped.push(sym);
+      }
+    }
+    let filtered = deduped;
+    if (options?.filterKinds && options.filterKinds.length > 0) {
+      const allowedKinds = new Set(options.filterKinds);
+      filtered = filtered.filter((sym) => allowedKinds.has(sym?.kind));
+    }
+    if (options?.nameIncludes) {
+      const needle = options.nameIncludes.toLowerCase();
+      filtered = filtered.filter(
+        (sym) => String(sym?.name ?? "").toLowerCase().includes(needle)
+      );
+    }
+    if (options?.maxItems !== void 0 && filtered.length > options.maxItems) {
+      filtered = filtered.slice(0, options.maxItems);
+    }
+    return filtered;
+  }
+  async documentSymbol(filePath, rootPath = getCwd()) {
+    const client = await this.getClient(filePath, rootPath);
+    if (!client) {
+      return null;
+    }
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const ext = extname(filePath);
+      const serverInfo = LspServerRegistry.getInstance().getServerForExtension(ext);
+      const languageId = this.getLanguageId(ext, serverInfo ?? void 0);
+      await client.didOpen(filePath, content, languageId);
+      await client.waitForReadiness(filePath, 2e3);
+      const symbols = await client.documentSymbol(filePath);
+      return Array.isArray(symbols) ? symbols : [];
+    } catch (e) {
+      console.error(`Failed to get document symbols for ${filePath}:`, e);
+      return null;
+    }
+  }
+  async getDiagnostics(filePath, rootPath = getCwd()) {
+    const client = await this.getClient(filePath, rootPath);
+    if (!client) {
+      return [];
+    }
+    return client.getDiagnostics(filePath);
+  }
+  async getAllDiagnostics(filePath, rootPath = getCwd()) {
+    await this.getClientsForFile(filePath, rootPath);
+    const results = [];
+    for (const client of this.clients.values()) {
+      try {
+        const diagnostics = client.getDiagnostics(filePath);
+        if (diagnostics && diagnostics.length > 0) {
+          results.push(...diagnostics);
+        }
+      } catch (e) {
+      }
+    }
+    return results;
+  }
+  status() {
+    const diagnostics = [];
+    for (const [key, client] of this.clients.entries()) {
+      const snapshot = client.getDiagnosticsSnapshot?.();
+      if (Array.isArray(snapshot) && snapshot.length > 0) {
+        diagnostics.push({ client: key, entries: snapshot });
+      }
+    }
+    return {
+      clients: Array.from(this.clients.keys()),
+      spawning: Array.from(this.spawning.keys()),
+      broken: Array.from(this.broken.values()),
+      diagnostics
+    };
+  }
+  // New helper to expose waitForReadiness to clients who only have a manager
+  async waitForReadiness(filePath, rootPath = getCwd(), timeoutMs = 2e3) {
+    const client = await this.getClientForFile(filePath);
+    if (client) {
+      await client.waitForReadiness(filePath, timeoutMs);
+    }
+  }
+  matchesServerFilters(filePath, serverInfo) {
+    const normalizePath = (value) => value.replace(/\\/g, "/");
+    const normalizedFile = normalizePath(filePath);
+    const relativeToCwd = normalizePath(relative(getCwd(), filePath));
+    const matches = (patterns) => patterns.some((pattern) => {
+      if (minimatch(normalizedFile, pattern, { dot: true })) return true;
+      if (relativeToCwd && !relativeToCwd.startsWith("..")) {
+        return minimatch(relativeToCwd, pattern, { dot: true });
+      }
+      return false;
+    });
+    if (serverInfo.rootExclude && matches(serverInfo.rootExclude)) return false;
+    if (serverInfo.rootInclude && !matches(serverInfo.rootInclude)) return false;
+    return true;
+  }
+  async resolveRootForServer(filePath, serverInfo) {
+    const cwd = getCwd();
+    let defaultRoot;
+    if (serverInfo.rootMarkers.length > 0) {
+      defaultRoot = await findNearestRoot(dirname(filePath), serverInfo.rootMarkers, {
+        include: serverInfo.rootInclude,
+        exclude: serverInfo.rootExclude,
+        branches: serverInfo.rootBranches,
+        filePath
+      });
+    }
+    if (!defaultRoot) {
+      defaultRoot = filePath.startsWith(cwd) ? cwd : dirname(filePath);
+    }
+    if (serverInfo.resolveRoot) {
+      const resolved = await serverInfo.resolveRoot(filePath, defaultRoot);
+      return resolved || defaultRoot;
+    }
+    return defaultRoot;
+  }
+  async getClientForServer(filePath, serverInfo, rootPath) {
+    if (!this.matchesServerFilters(filePath, serverInfo)) {
+      return null;
+    }
+    const resolvedRoot = rootPath ?? await this.resolveRootForServer(filePath, serverInfo);
+    try {
+      const ready = await serverInfo.prepare();
+      if (!ready) {
+        return null;
+      }
+    } catch (e) {
+      return null;
+    }
+    const key = `${resolvedRoot}:${serverInfo.id}`;
+    if (this.broken.has(key)) {
+      return null;
+    }
+    const existingSpawn = this.spawning.get(key);
+    if (existingSpawn) {
+      return existingSpawn;
+    }
+    let client = this.clients.get(key);
+    if (!client) {
+      const spawnPromise = (async () => {
+        try {
+          return await this.spawnClient(resolvedRoot, serverInfo, key);
+        } catch (error) {
+          this.broken.add(key);
+          return null;
+        } finally {
+          this.spawning.delete(key);
+        }
+      })();
+      this.spawning.set(key, spawnPromise);
+      client = await spawnPromise;
+    }
+    return client;
+  }
+};
+
+// src/tools/search/LspTool/client/formatters.ts
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { relative as relative2 } from "path";
+var SYMBOL_KIND_MAP = {
+  1: "File",
+  2: "Module",
+  3: "Namespace",
+  4: "Package",
+  5: "Class",
+  6: "Method",
+  7: "Property",
+  8: "Field",
+  9: "Constructor",
+  10: "Enum",
+  11: "Interface",
+  12: "Function",
+  13: "Variable",
+  14: "Constant",
+  15: "String",
+  16: "Number",
+  17: "Boolean",
+  18: "Array",
+  19: "Object",
+  20: "Key",
+  21: "Null",
+  22: "EnumMember",
+  23: "Struct",
+  24: "Event",
+  25: "Operator",
+  26: "TypeParameter"
+};
+function toProjectRelative(filePath) {
+  const cwd = getCwd();
+  try {
+    const rel = relative2(cwd, filePath);
+    if (!rel || rel === "") return filePath;
+    if (rel.startsWith("..")) return filePath;
+    return rel;
+  } catch {
+    return filePath;
+  }
+}
+function formatLocation(uri, range) {
+  const filePath = fileURLToPath3(uri);
+  return `${toProjectRelative(filePath)}:${range.start.line + 1}:${range.start.character + 1}`;
+}
+function getSymbolKindName(kind) {
+  if (typeof kind === "number") return SYMBOL_KIND_MAP[kind] || `Kind(${kind})`;
+  if (typeof kind === "string") return kind;
+  return "Unknown";
+}
+function formatCallHierarchyItem(item) {
+  const kind = getSymbolKindName(item?.kind);
+  const range = item?.selectionRange ?? item?.range;
+  if (item?.uri && range) {
+    return {
+      label: `${item.name} (${kind}) at ${formatLocation(item.uri, range)}`,
+      uri: item.uri
+    };
+  }
+  if (item?.uri) {
+    return {
+      label: `${item.name} (${kind}) at ${toProjectRelative(fileURLToPath3(item.uri))}`,
+      uri: item.uri
+    };
+  }
+  return { label: `${item?.name ?? "Unknown"} (${kind})` };
+}
+function formatCallRanges(uri, ranges) {
+  const valid = Array.isArray(ranges) ? ranges : [];
+  if (valid.length === 0) return "";
+  return valid.map((range) => formatLocation(uri, range)).filter(Boolean).join(", ");
+}
+function formatGenericDefinitionResult(result) {
+  if (!result) {
+    return { formatted: "No definition found.", resultCount: 0, fileCount: 0 };
+  }
+  const locations = Array.isArray(result) ? result : [result];
+  if (locations.length === 0) {
+    return { formatted: "No definition found.", resultCount: 0, fileCount: 0 };
+  }
+  const fileCount = new Set(locations.map((l) => l.uri)).size;
+  if (locations.length === 1) {
+    return {
+      formatted: `Defined in ${formatLocation(locations[0].uri, locations[0].range)}`,
+      resultCount: 1,
+      fileCount
+    };
+  }
+  return {
+    formatted: `Found ${locations.length} definitions:
+${locations.map((l) => `  ${formatLocation(l.uri, l.range)}`).join("\n")}`,
+    resultCount: locations.length,
+    fileCount
+  };
+}
+function formatGenericReferencesResult(result) {
+  if (!result || !Array.isArray(result) || result.length === 0) {
+    return { formatted: "No references found.", resultCount: 0, fileCount: 0 };
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const ref of result) {
+    const file = toProjectRelative(fileURLToPath3(ref.uri));
+    if (!grouped.has(file)) grouped.set(file, []);
+    grouped.get(file).push(ref);
+  }
+  const lines = [`Found ${result.length} references across ${grouped.size} files:`];
+  for (const [file, refs] of grouped) {
+    lines.push(`
+${file}:`);
+    for (const ref of refs) {
+      lines.push(`  Line ${ref.range.start.line + 1}:${ref.range.start.character + 1}`);
+    }
+  }
+  return {
+    formatted: lines.join("\n"),
+    resultCount: result.length,
+    fileCount: grouped.size
+  };
+}
+function formatGenericHoverResult(result, line, character) {
+  if (!result || !result.contents) {
+    return { formatted: "No hover info.", resultCount: 0, fileCount: 0 };
+  }
+  let contents = "";
+  if (typeof result.contents === "string") {
+    contents = result.contents;
+  } else if (Array.isArray(result.contents)) {
+    contents = result.contents.map((c) => typeof c === "string" ? c : c.value).join("\n");
+  } else {
+    contents = result.contents.value;
+  }
+  return {
+    formatted: `Hover info at ${line}:${character}:
+
+${contents}`,
+    resultCount: 1,
+    fileCount: 1
+  };
+}
+function formatGenericDocumentSymbolResult(result) {
+  if (!result || !Array.isArray(result) || result.length === 0) {
+    return { formatted: "No symbols found.", resultCount: 0, fileCount: 0 };
+  }
+  const lines = result.map((s) => {
+    const kind = getSymbolKindName(s.kind);
+    return `${s.name} (${kind}) at ${s.range.start.line + 1}:${s.range.start.character + 1}`;
+  });
+  return {
+    formatted: ["Document symbols:", ...lines].join("\n"),
+    resultCount: result.length,
+    fileCount: 1
+  };
+}
+function formatGenericDiagnosticsResult(diagnostics) {
+  if (!diagnostics || diagnostics.length === 0) {
+    return { formatted: "No diagnostics found.", resultCount: 0, fileCount: 0 };
+  }
+  const lines = diagnostics.map((d) => {
+    return `[${d.severity === 1 ? "Error" : d.severity === 2 ? "Warning" : "Info"}] Line ${d.range.start.line + 1}: ${d.message}`;
+  });
+  return {
+    formatted: ["Diagnostics:", ...lines].join("\n"),
+    resultCount: diagnostics.length,
+    fileCount: 1
+  };
+}
+function formatGenericCallHierarchyItemsResult(items) {
+  if (!items || !Array.isArray(items) || items.length === 0) {
+    return { formatted: "No call hierarchy items found.", resultCount: 0, fileCount: 0 };
+  }
+  const uris = /* @__PURE__ */ new Set();
+  const lines = items.map((item) => {
+    const info = formatCallHierarchyItem(item);
+    if (info.uri) uris.add(info.uri);
+    return `- ${info.label}`;
+  });
+  return {
+    formatted: ["Call hierarchy items:", ...lines].join("\n"),
+    resultCount: items.length,
+    fileCount: uris.size
+  };
+}
+function formatGenericIncomingCallsResult(calls) {
+  if (!calls || !Array.isArray(calls) || calls.length === 0) {
+    return { formatted: "No incoming calls found.", resultCount: 0, fileCount: 0 };
+  }
+  const uris = /* @__PURE__ */ new Set();
+  const lines = ["Incoming calls:"];
+  for (const call of calls) {
+    const info = formatCallHierarchyItem(call?.from);
+    if (info.uri) uris.add(info.uri);
+    lines.push(`- ${info.label}`);
+    if (call?.from?.uri) {
+      const ranges = formatCallRanges(call.from.uri, call?.fromRanges ?? []);
+      if (ranges) {
+        lines.push(`  via ${ranges}`);
+      }
+    }
+  }
+  return {
+    formatted: lines.join("\n"),
+    resultCount: calls.length,
+    fileCount: uris.size
+  };
+}
+function formatGenericOutgoingCallsResult(calls) {
+  if (!calls || !Array.isArray(calls) || calls.length === 0) {
+    return { formatted: "No outgoing calls found.", resultCount: 0, fileCount: 0 };
+  }
+  const uris = /* @__PURE__ */ new Set();
+  const lines = ["Outgoing calls:"];
+  for (const call of calls) {
+    const info = formatCallHierarchyItem(call?.to);
+    if (info.uri) uris.add(info.uri);
+    lines.push(`- ${info.label}`);
+    if (call?.to?.uri) {
+      const ranges = formatCallRanges(call.to.uri, call?.fromRanges ?? []);
+      if (ranges) {
+        lines.push(`  via ${ranges}`);
+      }
+    }
+  }
+  return {
+    formatted: lines.join("\n"),
+    resultCount: calls.length,
+    fileCount: uris.size
+  };
+}
+
+// src/lsp/formatters.ts
+var severityOrder = {
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4
+};
+function severityLabel(severity) {
+  if (severity === 1) return "Error";
+  if (severity === 2) return "Warning";
+  if (severity === 3) return "Info";
+  if (severity === 4) return "Hint";
+  return "Unknown";
+}
+function formatDiagnosticsPretty(diagnostics, options = {}) {
+  if (!diagnostics || diagnostics.length === 0) return "";
+  const items = [...diagnostics].sort((a, b) => {
+    const aSeverity = severityOrder[a?.severity ?? 99] ?? 99;
+    const bSeverity = severityOrder[b?.severity ?? 99] ?? 99;
+    if (aSeverity !== bSeverity) return aSeverity - bSeverity;
+    const aLine = a?.range?.start?.line ?? 0;
+    const bLine = b?.range?.start?.line ?? 0;
+    if (aLine !== bLine) return aLine - bLine;
+    const aChar = a?.range?.start?.character ?? 0;
+    const bChar = b?.range?.start?.character ?? 0;
+    return aChar - bChar;
+  });
+  const limited = options.maxItems && options.maxItems > 0 ? items.slice(0, options.maxItems) : items;
+  return limited.map((d) => {
+    const line = (d?.range?.start?.line ?? 0) + 1;
+    const character = (d?.range?.start?.character ?? 0) + 1;
+    const label = severityLabel(d?.severity);
+    const message = d?.message ?? "Unknown diagnostic";
+    return `- ${label} ${line}:${character} ${message}`;
+  }).join("\n");
+}
+
+// src/utils/tree-sitter/registry.ts
+import path from "path";
+var ParserRegistry = class {
+  static extensionMap = {
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".js": "typescript",
+    // Use TS parser for JS
+    ".jsx": "tsx",
+    ".py": "python",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".rs": "rust",
+    ".go": "go",
+    ".java": "java",
+    ".cpp": "cpp",
+    ".c": "c",
+    ".h": "c",
+    ".cc": "cpp",
+    ".cs": "c_sharp",
+    ".scala": "scala",
+    ".sbt": "scala",
+    ".sc": "scala",
+    ".hs": "haskell",
+    ".lhs": "haskell",
+    ".jl": "julia",
+    ".ml": "ocaml",
+    ".mli": "ocaml",
+    ".swift": "swift",
+    ".nix": "nix",
+    ".rb": "ruby",
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".json": "json",
+    ".jsonc": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml"
+  };
+  /**
+   * Get the supported language ID for a given filename.
+   * Returns null if the extension is not supported.
+   */
+  static getLanguage(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    return this.extensionMap[ext] || null;
+  }
+  /**
+   * Register or override a file extension mapping.
+   */
+  static registerExtension(ext, lang) {
+    const normalizedExt = ext.startsWith(".") ? ext : `.${ext}`;
+    this.extensionMap[normalizedExt.toLowerCase()] = lang;
+  }
+};
+
+// src/utils/tree-sitter/loader.ts
+import { Parser, Language } from "web-tree-sitter";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import path2 from "path";
+var getDirname = () => {
+  try {
+    return __dirname;
+  } catch {
+    return path2.dirname(fileURLToPath4(import.meta.url));
+  }
+};
+var _dirname = getDirname();
+var parserCache = /* @__PURE__ */ new Map();
+var isInitialized = false;
+var LANGUAGE_MAP = {
+  bash: "tree-sitter-bash.wasm",
+  typescript: "tree-sitter-typescript.wasm",
+  tsx: "tree-sitter-tsx.wasm",
+  python: "tree-sitter-python.wasm",
+  rust: "tree-sitter-rust.wasm",
+  go: "tree-sitter-go.wasm",
+  java: "tree-sitter-java.wasm",
+  cpp: "tree-sitter-cpp.wasm",
+  c: "tree-sitter-c.wasm",
+  c_sharp: "tree-sitter-c_sharp.wasm",
+  scala: "tree-sitter-scala.wasm",
+  haskell: "tree-sitter-haskell.wasm",
+  julia: "tree-sitter-julia.wasm",
+  ocaml: "tree-sitter-ocaml.wasm",
+  swift: "tree-sitter-swift.wasm",
+  nix: "tree-sitter-nix.wasm",
+  ruby: "tree-sitter-ruby.wasm",
+  html: "tree-sitter-html.wasm",
+  css: "tree-sitter-css.wasm",
+  json: "tree-sitter-json.wasm",
+  yaml: "tree-sitter-yaml.wasm"
+};
+async function ensureInitialized() {
+  if (isInitialized) return;
+  let resourcesDir;
+  if (_dirname.includes("dist") || _dirname.includes("node_modules")) {
+    resourcesDir = path2.resolve(_dirname, "../resources/tree-sitter");
+  } else {
+    resourcesDir = path2.resolve(_dirname, "../../../resources/tree-sitter");
+  }
+  const treeWasmPath = path2.join(resourcesDir, "tree-sitter.wasm");
+  await Parser.init({
+    locateFile: () => treeWasmPath
+  });
+  isInitialized = true;
+}
+var loadLanguage = async (lang) => {
+  if (parserCache.has(lang)) {
+    return parserCache.get(lang);
+  }
+  await ensureInitialized();
+  const fileName = LANGUAGE_MAP[lang];
+  if (!fileName) {
+    throw new Error(`Unsupported language: ${lang}`);
+  }
+  try {
+    let resourcesDir;
+    if (_dirname.includes("dist") || _dirname.includes("node_modules")) {
+      resourcesDir = path2.resolve(_dirname, "../resources/tree-sitter");
+    } else {
+      resourcesDir = path2.resolve(_dirname, "../../../resources/tree-sitter");
+    }
+    const wasmPath = path2.join(resourcesDir, fileName);
+    const language = await Language.load(wasmPath);
+    const parser = new Parser();
+    parser.setLanguage(language);
+    parserCache.set(lang, parser);
+    return parser;
+  } catch (error) {
+    console.error(`Error loading language ${lang}:`, error);
+    throw new Error(`Failed to load language ${lang}: ${error}`);
+  }
+};
+var legacyParserInstance = null;
+var initParser = async () => {
+  if (legacyParserInstance) return legacyParserInstance;
+  legacyParserInstance = await loadLanguage("bash");
+  return legacyParserInstance;
+};
+
+// src/utils/tree-sitter/lsp-adapter.ts
+import { readFile as readFile2 } from "fs/promises";
+var SYMBOL_KIND_MAP2 = {
+  // TypeScript / JavaScript
+  function_declaration: "Function",
+  method_definition: "Method",
+  class_declaration: "Class",
+  interface_declaration: "Interface",
+  variable_declarator: "Variable",
+  export_statement: "Module",
+  // Python
+  function_definition: "Function",
+  class_definition: "Class",
+  // Bash
+  // function_definition is shared with Python/others
+  // C#
+  namespace_declaration: "Namespace",
+  method_declaration: "Method",
+  struct_declaration: "Struct",
+  enum_declaration: "Enum",
+  property_declaration: "Property",
+  // class_declaration shared
+  // interface_declaration shared
+  // Go
+  type_declaration: "Class",
+  // often struct/interface
+  field_declaration: "Field",
+  // function_declaration shared
+  // method_declaration shared
+  // Rust
+  function_item: "Function",
+  struct_item: "Struct",
+  enum_item: "Enum",
+  impl_item: "Class",
+  trait_item: "Interface",
+  mod_item: "Module",
+  // Java
+  // class_declaration shared
+  // method_declaration shared
+  // interface_declaration shared
+  // enum_declaration shared
+  // Scala
+  object_definition: "Class",
+  trait_definition: "Interface",
+  // class_definition shared with Python
+  // function_definition shared with Python
+  // Ruby
+  module: "Module"
+  // class shared
+  // method shared
+  // PHP
+  // class_declaration shared
+  // method_declaration shared
+  // function_definition shared
+};
+var TreeSitterLspAdapter = class {
+  static async getDocumentSymbols(filePath) {
+    const langId = ParserRegistry.getLanguage(filePath);
+    if (!langId) {
+      console.warn(`No language found for file: ${filePath}`);
+      return [];
+    }
+    try {
+      const parser = await loadLanguage(langId);
+      const content = await readFile2(filePath, "utf-8");
+      const tree = parser.parse(content);
+      return this.collectSymbols(tree.rootNode);
+    } catch (error) {
+      console.error(`Error parsing file ${filePath}:`, error);
+      return [];
+    }
+  }
+  static collectSymbols(node) {
+    const symbols = [];
+    const kind = SYMBOL_KIND_MAP2[node.type];
+    if (kind) {
+      const name = this.getName(node);
+      if (name) {
+        const symbol = {
+          name,
+          kind,
+          range: {
+            start: { line: node.startPosition.row, character: node.startPosition.column },
+            end: { line: node.endPosition.row, character: node.endPosition.column }
+          },
+          children: []
+        };
+        for (const child of node.namedChildren) {
+          symbol.children?.push(...this.collectSymbols(child));
+        }
+        symbols.push(symbol);
+        return symbols;
+      }
+    }
+    for (const child of node.namedChildren) {
+      symbols.push(...this.collectSymbols(child));
+    }
+    return symbols;
+  }
+  static getName(node) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) return nameNode.text;
+    for (const child of node.namedChildren) {
+      if (child.type === "identifier" || child.type === "type_identifier") {
+        return child.text;
+      }
+    }
+    return null;
+  }
+};
+
+// src/utils/tree-sitter/scope-analyzer.ts
+import { Query } from "web-tree-sitter";
+var QUERIES = {
+  python: `
+    (function_definition name: (identifier) @name)
+    (parameters (identifier) @param)
+    (assignment left: (identifier) @var)
+  `,
+  typescript: `
+    (function_declaration name: (identifier) @name)
+    (variable_declarator name: (identifier) @var)
+    (required_parameter pattern: (identifier) @param)
+    (optional_parameter pattern: (identifier) @param)
+  `
+};
+var ScopeAnalyzer = class {
+  static async getScope(filename, code, position) {
+    const langKey = ParserRegistry.getLanguage(filename);
+    if (!langKey) {
+      throw new Error(`Unsupported language for file: ${filename}`);
+    }
+    const parser = await loadLanguage(langKey);
+    const tree = parser.parse(code);
+    const node = tree.rootNode.descendantForPosition(position);
+    const ancestors = [];
+    let current = node;
+    while (current) {
+      ancestors.push(current);
+      current = current.parent;
+    }
+    const scopeNodes = ancestors.filter(
+      (n) => n.type === "function_definition" || n.type === "function_declaration" || n.type === "module" || // Python root
+      n.type === "program"
+      // TS root
+    );
+    const result = {
+      locals: [],
+      closure: []
+    };
+    if (scopeNodes.length === 0) return result;
+    const queryStr = QUERIES[langKey];
+    if (!queryStr) return result;
+    const language = parser.language;
+    if (!language) return result;
+    const query = new Query(language, queryStr);
+    for (let i = 0; i < scopeNodes.length; i++) {
+      const scopeNode = scopeNodes[i];
+      const captures = query.captures(scopeNode);
+      const names = /* @__PURE__ */ new Set();
+      for (const capture of captures) {
+        const defNode = capture.node;
+        let temp = defNode.parent;
+        if (temp && (temp.type === "function_definition" || temp.type === "function_declaration")) {
+          if (capture.name === "name") {
+            temp = temp.parent;
+          }
+        }
+        let isDirect = true;
+        while (temp && temp.id !== scopeNode.id) {
+          if (temp.type === "function_definition" || temp.type === "function_declaration") {
+            isDirect = false;
+            break;
+          }
+          temp = temp.parent;
+        }
+        if (isDirect) {
+          names.add(defNode.text);
+        }
+      }
+      if (i === 0) {
+        result.locals = Array.from(names);
+      } else {
+        for (const name of names) {
+          result.closure.push(name);
+        }
+      }
+    }
+    result.closure = Array.from(new Set(result.closure));
+    return result;
+  }
+};
+
+// src/lsp/index.ts
+function getLanguageId(ext) {
+  return LspServerRegistry.getInstance().getLanguageIdForExtension(ext);
+}
+function normalizeUri(filePath) {
+  let uri = pathToFileURL2(filePath).href;
+  if (process.platform === "win32") {
+    uri = uri.replace(/^file:\/\/\/([a-zA-Z]):\//, (_match, drive) => {
+      return `file:///${drive.toLowerCase()}%3A/`;
+    });
+  }
+  return uri;
+}
+function formatTreeSitterSymbols(symbols, depth = 0) {
+  let text = "";
+  const indent = "  ".repeat(depth);
+  for (const s of symbols) {
+    text += `${indent}- ${s.name} (${s.kind}) [Ln ${s.range.start.line + 1}]
+`;
+    if (s.children && s.children.length > 0) {
+      text += formatTreeSitterSymbols(s.children, depth + 1);
+    }
+  }
+  return text;
+}
+function formatTreeSitterDocumentSymbolResult(symbols) {
+  const formatted = symbols.length > 0 ? `Document symbols:
+${formatTreeSitterSymbols(symbols)}` : "No symbols found.";
+  return {
+    formatted,
+    resultCount: symbols.length,
+    fileCount: symbols.length > 0 ? 1 : 0
+  };
+}
+function normalizeWorkspaceSymbol(sym) {
+  if (!sym || typeof sym !== "object") return null;
+  const range = sym.range ?? sym.location?.range;
+  if (!range || !sym.name) return null;
+  const uri = sym.uri ?? sym.location?.uri;
+  return { ...sym, range, uri };
+}
+function sortWorkspaceSymbols(symbols) {
+  return [...symbols].sort((a, b) => {
+    const nameA = String(a?.name ?? "").toLowerCase();
+    const nameB = String(b?.name ?? "").toLowerCase();
+    if (nameA !== nameB) return nameA.localeCompare(nameB);
+    const uriA = String(a?.uri ?? a?.location?.uri ?? "");
+    const uriB = String(b?.uri ?? b?.location?.uri ?? "");
+    if (uriA !== uriB) return uriA.localeCompare(uriB);
+    const lineA = a?.range?.start?.line ?? a?.location?.range?.start?.line ?? 0;
+    const lineB = b?.range?.start?.line ?? b?.location?.range?.start?.line ?? 0;
+    if (lineA !== lineB) return lineA - lineB;
+    const charA = a?.range?.start?.character ?? a?.location?.range?.start?.character ?? 0;
+    const charB = b?.range?.start?.character ?? b?.location?.range?.start?.character ?? 0;
+    return charA - charB;
+  });
+}
+function serveStatusWithProvider(statusProvider, options) {
+  const host = options?.host ?? "127.0.0.1";
+  const port = typeof options?.port === "number" ? options.port : 7337;
+  const path3 = options?.path ?? "/lsp/status";
+  const allowCors = options?.allowCors ?? true;
+  const corsHeaders = allowCors ? {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET,OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type"
+  } : {};
+  const server = http.createServer((req, res) => {
+    const method = req.method ?? "GET";
+    const url = new URL(req.url ?? "/", `http://${host}`);
+    if (url.pathname !== path3) {
+      res.writeHead(404, corsHeaders);
+      res.end("Not Found");
+      return;
+    }
+    if (method === "OPTIONS") {
+      res.writeHead(204, corsHeaders);
+      res.end();
+      return;
+    }
+    if (method !== "GET") {
+      res.writeHead(405, corsHeaders);
+      res.end("Method Not Allowed");
+      return;
+    }
+    const status = statusProvider();
+    res.writeHead(200, { "Content-Type": "application/json", ...corsHeaders });
+    res.end(JSON.stringify(status, null, 2));
+  });
+  server.port = port;
+  server.listen(port, host);
+  return server;
+}
+var LspAPI = {
+  async run(input) {
+    const rootPath = input.rootPath ?? getCwd();
+    const client = await LspClientManager.getInstance().getClient(
+      input.filePath,
+      rootPath
+    );
+    if (client) {
+      try {
+        switch (input.operation) {
+          case "goToDefinition": {
+            if (input.line === void 0 || input.character === void 0) {
+              return {
+                formatted: "Error performing goToDefinition: Missing line/character",
+                resultCount: 0,
+                fileCount: 0
+              };
+            }
+            const result = await client.goToDefinition(
+              input.filePath,
+              input.line,
+              input.character
+            );
+            return formatGenericDefinitionResult(result);
+          }
+          case "findReferences": {
+            if (input.line === void 0 || input.character === void 0) {
+              return {
+                formatted: "Error performing findReferences: Missing line/character",
+                resultCount: 0,
+                fileCount: 0
+              };
+            }
+            const result = await client.findReferences(
+              input.filePath,
+              input.line,
+              input.character
+            );
+            return formatGenericReferencesResult(result);
+          }
+          case "hover": {
+            if (input.line === void 0 || input.character === void 0) {
+              return {
+                formatted: "Error performing hover: Missing line/character",
+                resultCount: 0,
+                fileCount: 0
+              };
+            }
+            const result = await client.hover(
+              input.filePath,
+              input.line,
+              input.character
+            );
+            return formatGenericHoverResult(result, input.line, input.character);
+          }
+          case "documentSymbol": {
+            const result = await client.documentSymbol(input.filePath);
+            return formatGenericDocumentSymbolResult(result);
+          }
+          case "workspaceSymbol": {
+            const query = input.query ?? input.filePath;
+            const results = await LspClientManager.getInstance().workspaceSymbol(
+              query,
+              rootPath
+            );
+            return formatGenericDocumentSymbolResult(results);
+          }
+          case "goToImplementation": {
+            if (input.line === void 0 || input.character === void 0) {
+              return {
+                formatted: "Error performing goToImplementation: Missing line/character",
+                resultCount: 0,
+                fileCount: 0
+              };
+            }
+            const result = await client.goToImplementation(
+              input.filePath,
+              input.line,
+              input.character
+            );
+            return formatGenericDefinitionResult(result);
+          }
+          case "prepareCallHierarchy": {
+            if (input.line === void 0 || input.character === void 0) {
+              return {
+                formatted: "Error performing prepareCallHierarchy: Missing line/character",
+                resultCount: 0,
+                fileCount: 0
+              };
+            }
+            const result = await client.prepareCallHierarchy(
+              input.filePath,
+              input.line,
+              input.character
+            );
+            return formatGenericCallHierarchyItemsResult(
+              Array.isArray(result) ? result : []
+            );
+          }
+          case "incomingCalls": {
+            if (input.line === void 0 || input.character === void 0) {
+              return {
+                formatted: "Error performing incomingCalls: Missing line/character",
+                resultCount: 0,
+                fileCount: 0
+              };
+            }
+            const items = await client.prepareCallHierarchy(
+              input.filePath,
+              input.line,
+              input.character
+            );
+            const callResults = await Promise.all(
+              (Array.isArray(items) ? items : []).map(
+                (item) => client.incomingCalls(item)
+              )
+            );
+            const calls = callResults.flat().filter(Boolean);
+            return formatGenericIncomingCallsResult(calls);
+          }
+          case "outgoingCalls": {
+            if (input.line === void 0 || input.character === void 0) {
+              return {
+                formatted: "Error performing outgoingCalls: Missing line/character",
+                resultCount: 0,
+                fileCount: 0
+              };
+            }
+            const items = await client.prepareCallHierarchy(
+              input.filePath,
+              input.line,
+              input.character
+            );
+            const callResults = await Promise.all(
+              (Array.isArray(items) ? items : []).map(
+                (item) => client.outgoingCalls(item)
+              )
+            );
+            const calls = callResults.flat().filter(Boolean);
+            return formatGenericOutgoingCallsResult(calls);
+          }
+          case "diagnostics": {
+            if (input.waitForDiagnostics) {
+              await client.waitForReadiness(
+                input.filePath,
+                input.timeoutMs ?? 5e3
+              );
+            }
+            const diagnostics = client.getDiagnostics(input.filePath);
+            return formatGenericDiagnosticsResult(diagnostics);
+          }
+          default: {
+            return {
+              formatted: `Operation ${input.operation} not supported by generic client yet.`,
+              resultCount: 0,
+              fileCount: 0
+            };
+          }
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          formatted: `Error performing ${input.operation} with generic client: ${message}`,
+          resultCount: 0,
+          fileCount: 0
+        };
+      }
+    }
+    const ext = extname2(input.filePath);
+    return {
+      formatted: `No LSP server available for file type: ${ext}`,
+      resultCount: 0,
+      fileCount: 0
+    };
+  },
+  async runAll(inputs) {
+    return Promise.all(inputs.map((input) => this.run(input)));
+  },
+  async touchFile(filePath, options = {}) {
+    const client = await LspClientManager.getInstance().getClientForFile(filePath);
+    if (!client) return false;
+    const content = await readFile3(filePath, "utf-8");
+    const languageId = getLanguageId(extname2(filePath));
+    await client.didOpen(filePath, content, languageId);
+    if (options.wait) {
+      await client.waitForReadiness(filePath, options.timeoutMs ?? 2e3);
+    }
+    return true;
+  },
+  async diagnostics(filePath, rootPath) {
+    return LspClientManager.getInstance().getAllDiagnostics(filePath, rootPath);
+  },
+  async diagnosticsPretty(filePath, options) {
+    const diagnostics = await LspClientManager.getInstance().getAllDiagnostics(
+      filePath,
+      options?.rootPath
+    );
+    return formatDiagnosticsPretty(diagnostics, { maxItems: options?.maxItems });
+  },
+  async documentSymbolRaw(filePath, rootPath) {
+    const manager = LspClientManager.getInstance();
+    const resolvedRoot = rootPath ?? getCwd();
+    const managerDocumentSymbol = manager.documentSymbol;
+    if (typeof managerDocumentSymbol === "function") {
+      return managerDocumentSymbol.call(manager, filePath, resolvedRoot);
+    }
+    const client = await manager.getClient(filePath, resolvedRoot);
+    if (!client) return null;
+    const clientDocumentSymbol = client.documentSymbol;
+    if (typeof clientDocumentSymbol !== "function") return [];
+    try {
+      const symbols = await clientDocumentSymbol.call(client, filePath);
+      return Array.isArray(symbols) ? symbols : [];
+    } catch {
+      return [];
+    }
+  },
+  async findReferencesRaw(filePath, line, character, rootPath) {
+    const client = await LspClientManager.getInstance().getClient(
+      filePath,
+      rootPath ?? getCwd()
+    );
+    if (!client) return null;
+    return await client.findReferences(filePath, line, character);
+  },
+  normalizeUri,
+  async workspaceSymbol(query, options) {
+    const { rootPath, ...rest } = options ?? {};
+    return LspClientManager.getInstance().workspaceSymbol(
+      query,
+      rootPath ?? getCwd(),
+      rest
+    );
+  },
+  serveStatus(options) {
+    return serveStatusWithProvider(() => LspAPI.status(), options);
+  },
+  status() {
+    return LspClientManager.getInstance().status();
+  }
+};
+var LspFacade = {
+  async run(input) {
+    const rootPath = input.rootPath ?? getCwd();
+    if (input.operation === "documentSymbol") {
+      const lang = ParserRegistry.getLanguage(input.filePath);
+      if (lang) {
+        try {
+          const symbols = await TreeSitterLspAdapter.getDocumentSymbols(input.filePath);
+          return formatTreeSitterDocumentSymbolResult(symbols);
+        } catch {
+        }
+      }
+    }
+    if (input.operation === "getScope") {
+      if (input.line === void 0 || input.character === void 0) {
+        return {
+          formatted: "Error performing getScope: Missing line/character",
+          resultCount: 0,
+          fileCount: 0
+        };
+      }
+      const lang = ParserRegistry.getLanguage(input.filePath);
+      if (!lang) {
+        return {
+          formatted: "getScope not supported for this language",
+          resultCount: 0,
+          fileCount: 0
+        };
+      }
+      try {
+        const code = await readFile3(input.filePath, "utf-8");
+        const scope = await ScopeAnalyzer.getScope(input.filePath, code, {
+          row: input.line - 1,
+          column: input.character - 1
+        });
+        let resultText = "";
+        if (scope.locals.length > 0) {
+          resultText += `Locals: ${scope.locals.join(", ")}
+`;
+        } else {
+          resultText += "Locals: (none)\n";
+        }
+        if (scope.closure.length > 0) {
+          resultText += `Closure: ${scope.closure.join(", ")}
+`;
+        } else {
+          resultText += "Closure: (none)\n";
+        }
+        return {
+          formatted: resultText,
+          resultCount: scope.locals.length + scope.closure.length,
+          fileCount: 1
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          formatted: `Error performing getScope: ${message}`,
+          resultCount: 0,
+          fileCount: 0
+        };
+      }
+    }
+    if (input.operation !== "workspaceSymbol") {
+      await LspAPI.touchFile(input.filePath, {
+        wait: input.operation === "diagnostics" && input.waitForDiagnostics,
+        timeoutMs: input.timeoutMs,
+        rootPath
+      });
+    }
+    if (input.operation === "workspaceSymbol") {
+      const query = input.query ?? input.filePath;
+      const symbols = await LspAPI.workspaceSymbol(query, { rootPath });
+      const normalized = symbols.map(normalizeWorkspaceSymbol).filter(Boolean);
+      const sorted = sortWorkspaceSymbols(normalized);
+      return formatGenericDocumentSymbolResult(sorted);
+    }
+    const { operation, ...rest } = input;
+    return LspAPI.run({
+      ...rest,
+      operation,
+      rootPath
+    });
+  },
+  async runAll(inputs) {
+    return Promise.all(inputs.map((input) => this.run(input)));
+  },
+  async touchFile(filePath, options = {}) {
+    return LspAPI.touchFile(filePath, options);
+  },
+  async diagnosticsPretty(filePath, options) {
+    return LspAPI.diagnosticsPretty(filePath, options);
+  },
+  async checkFileReferences(filePath) {
+    const rootPath = getCwd();
+    const fileUri = LspAPI.normalizeUri(filePath);
+    const symbols = await LspAPI.documentSymbolRaw(filePath, rootPath);
+    if (symbols === null) {
+      throw new Error("LSP unavailable");
+    }
+    const checkSymbolRefs = async (sym) => {
+      const range = sym.selectionRange || sym.range || (sym.location ? sym.location.range : null);
+      if (!range) return null;
+      const refs = await LspAPI.findReferencesRaw(
+        filePath,
+        range.start.line + 1,
+        range.start.character + 1,
+        rootPath
+      );
+      if (refs && Array.isArray(refs)) {
+        const externalRefs = refs.filter((r) => r.uri !== fileUri);
+        if (externalRefs.length > 0) {
+          const refFiles = externalRefs.map((r) => r.uri).slice(0, 3).join(", ");
+          return `Symbol '${sym.name}' referenced by ${externalRefs.length} locations (e.g. ${refFiles})`;
+        }
+      }
+      return null;
+    };
+    if (symbols && Array.isArray(symbols) && symbols.length > 0) {
+      for (const sym of symbols) {
+        const result = await checkSymbolRefs(sym);
+        if (result) return result;
+      }
+    } else {
+      const refs = await LspAPI.findReferencesRaw(filePath, 1, 1, rootPath);
+      if (refs && Array.isArray(refs)) {
+        const externalRefs = refs.filter((r) => r.uri !== fileUri);
+        if (externalRefs.length > 0) {
+          return `File referenced by ${externalRefs.length} locations`;
+        }
+      }
+    }
+    return null;
+  },
+  serveStatus(options) {
+    return serveStatusWithProvider(() => LspFacade.status(), options);
+  },
+  status() {
+    return LspAPI.status();
+  }
+};
+
+export {
+  formatDiagnosticsPretty,
+  ParserRegistry,
+  loadLanguage,
+  initParser,
+  LspAPI,
+  LspFacade
+};