@garuda-agent/garuda 0.0.1 → 0.14.1

package/dist/chunk-36GQIVGT.js

@@ -0,0 +1,526 @@
+#!/usr/bin/env node
+import {
+  LSP_LANGUAGES,
+  discoverServer,
+  findServer,
+  languageOf
+} from "./chunk-EU7PA45O.js";
+import {
+  cleanText
+} from "./chunk-PZS3V6P3.js";
+
+// src/lsp/client.ts
+import { pathToFileURL } from "url";
+var LspTimeoutError = class extends Error {
+  constructor(ms) {
+    super(`The language server gave no diagnostics within ${ms / 1e3} s.`);
+  }
+};
+var LspClient = class _LspClient {
+  constructor(connection, process2, options) {
+    this.connection = connection;
+    this.process = process2;
+    this.options = options;
+    this.isReady = options.ready === void 0 ? Promise.resolve() : new Promise((resolve) => {
+      this.markReady = resolve;
+    });
+    this.isReady.then(() => {
+      this.readyNow = true;
+    });
+  }
+  connection;
+  process;
+  options;
+  documents = /* @__PURE__ */ new Map();
+  /** Diagnostics from publishDiagnostics, by URI, with the version they are for. */
+  published = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Set();
+  pull = false;
+  /** Resolves when the `ready` notification came, or at once when there is none. */
+  isReady;
+  markReady = () => {
+  };
+  readyNow = false;
+  /** True after a first check timed out while the server was not ready. */
+  readyWaited = false;
+  answered = false;
+  closed = false;
+  /** Connect to a started server and run the LSP handshake. */
+  static async start(process2, options, signal) {
+    const rpc = await import("vscode-jsonrpc/node");
+    const connection = rpc.createMessageConnection(
+      new rpc.StreamMessageReader(process2.stdout),
+      new rpc.StreamMessageWriter(process2.stdin)
+    );
+    const client = new _LspClient(connection, process2, options);
+    client.listen();
+    connection.listen();
+    await client.initialize(signal);
+    return client;
+  }
+  listen() {
+    const c = this.connection;
+    c.onRequest(
+      "workspace/configuration",
+      (params) => (params?.items ?? []).map(() => null)
+    );
+    c.onRequest(() => null);
+    c.onNotification(
+      "textDocument/publishDiagnostics",
+      (params) => {
+        this.published.set(params.uri, {
+          ...params.version === void 0 ? {} : { version: params.version },
+          items: params.diagnostics ?? []
+        });
+        for (const wake of this.waiters) wake();
+      }
+    );
+    const ready = this.options.ready;
+    if (ready !== void 0) {
+      c.onNotification(ready.method, (params) => {
+        if (ready.test(params)) this.markReady();
+      });
+    }
+    c.onNotification(() => {
+    });
+    c.onClose(() => this.finish());
+    c.onError(() => {
+    });
+    this.process.onExit(() => this.finish());
+  }
+  async initialize(signal) {
+    const rootUri = pathToFileURL(this.options.root).href;
+    const result = await this.request(
+      "initialize",
+      {
+        processId: process.pid,
+        clientInfo: { name: "garuda" },
+        rootUri,
+        rootPath: this.options.root,
+        workspaceFolders: [{ uri: rootUri, name: "root" }],
+        ...this.options.initializationOptions === void 0 ? {} : { initializationOptions: this.options.initializationOptions },
+        capabilities: {
+          textDocument: {
+            synchronization: { dynamicRegistration: false, didSave: false },
+            publishDiagnostics: { versionSupport: true, relatedInformation: false },
+            diagnostic: { dynamicRegistration: false, relatedDocumentSupport: false }
+          },
+          workspace: { configuration: true, workspaceFolders: true },
+          window: { workDoneProgress: false }
+        }
+      },
+      this.options.initTimeoutMs ?? 3e4,
+      signal
+    );
+    this.pull = result?.capabilities?.diagnosticProvider != null;
+    await this.connection.sendNotification("initialized", {});
+  }
+  /** True when the server answers diagnostic requests (pull), not only publishDiagnostics. */
+  get usesPull() {
+    return this.pull;
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  /**
+   * Send the file's text and return its diagnostics. It throws LspTimeoutError when the server
+   * is too slow; the caller then shows nothing.
+   */
+  async diagnostics(path, languageId, text, signal) {
+    if (this.closed) throw new Error("The language server has stopped.");
+    const uri = pathToFileURL(path).href;
+    const ms = this.answered ? this.options.timeoutMs ?? 5e3 : this.options.firstTimeoutMs ?? 3e4;
+    if (!this.readyNow) {
+      if (this.readyWaited) throw new LspTimeoutError(0);
+      try {
+        await this.waitReady(ms, signal);
+      } catch (error) {
+        if (error instanceof LspTimeoutError) this.readyWaited = true;
+        throw error;
+      }
+    }
+    const version = await this.sync(uri, languageId, text);
+    const items = this.pull ? await this.pullDiagnostics(uri, ms, signal) : await this.waitPublished(uri, version, ms, signal);
+    this.answered = true;
+    return items.map(toDiagnostic);
+  }
+  waitReady(ms, signal) {
+    if (signal.aborted) return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+      const done = (fn) => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", onAbort);
+        fn();
+      };
+      const onAbort = () => done(() => reject(signal.reason));
+      const timer = setTimeout(() => done(() => reject(new LspTimeoutError(ms))), ms);
+      signal.addEventListener("abort", onAbort, { once: true });
+      this.isReady.then(() => done(resolve));
+    });
+  }
+  /** Resolves when the server is ready (a warm start waits for it), or when it stops. */
+  get ready() {
+    return this.isReady;
+  }
+  /**
+   * didOpen the first time, then didChange with the full text. Returns the new version. Old
+   * published diagnostics are dropped before the send, so a fast answer is never lost.
+   */
+  async sync(uri, languageId, text) {
+    this.published.delete(uri);
+    const open = this.documents.get(uri);
+    if (open === void 0) {
+      this.documents.set(uri, { version: 1, text });
+      await this.connection.sendNotification("textDocument/didOpen", {
+        textDocument: { uri, languageId, version: 1, text }
+      });
+      return 1;
+    }
+    const version = open.version + 1;
+    this.documents.set(uri, { version, text });
+    await this.connection.sendNotification("textDocument/didChange", {
+      textDocument: { uri, version },
+      contentChanges: [{ text }]
+    });
+    return version;
+  }
+  async pullDiagnostics(uri, ms, signal) {
+    const report = await this.request(
+      "textDocument/diagnostic",
+      { textDocument: { uri } },
+      ms,
+      signal
+    );
+    return report?.items ?? [];
+  }
+  /** Wait for publishDiagnostics for this version (or any new result, if it sends no version). */
+  waitPublished(uri, version, ms, signal) {
+    const ready = () => {
+      const got = this.published.get(uri);
+      if (got === void 0) return void 0;
+      if (got.version !== void 0 && got.version < version) return void 0;
+      return got.items;
+    };
+    if (signal.aborted) return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+      const done = (fn) => {
+        clearTimeout(timer);
+        this.waiters.delete(check);
+        signal.removeEventListener("abort", onAbort);
+        fn();
+      };
+      const check = () => {
+        const items = ready();
+        if (items !== void 0) done(() => resolve(items));
+        else if (this.closed) done(() => reject(new Error("The language server has stopped.")));
+      };
+      const onAbort = () => done(() => reject(signal.reason));
+      const timer = setTimeout(() => done(() => reject(new LspTimeoutError(ms))), ms);
+      this.waiters.add(check);
+      signal.addEventListener("abort", onAbort, { once: true });
+      check();
+    });
+  }
+  async request(method, params, ms, signal) {
+    if (signal.aborted) throw signal.reason;
+    const rpc = await import("vscode-jsonrpc/node");
+    const cancel = new rpc.CancellationTokenSource();
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const done = (fn) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        signal.removeEventListener("abort", onAbort);
+        cancel.dispose();
+        fn();
+      };
+      const onAbort = () => {
+        cancel.cancel();
+        done(() => reject(signal.reason));
+      };
+      const timer = setTimeout(() => {
+        cancel.cancel();
+        done(() => reject(new LspTimeoutError(ms)));
+      }, ms);
+      signal.addEventListener("abort", onAbort, { once: true });
+      this.connection.sendRequest(method, params, cancel.token).then(
+        (value) => done(() => resolve(value)),
+        (error) => done(() => reject(error))
+      );
+    });
+  }
+  /** Polite stop: shutdown and exit, then stop the process in any case. */
+  async close() {
+    if (!this.closed) {
+      const quick = AbortSignal.timeout(2e3);
+      try {
+        await this.request("shutdown", null, 2e3, quick);
+        await this.connection.sendNotification("exit");
+      } catch {
+      }
+    }
+    this.finish();
+    this.process.stop();
+  }
+  finish() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const wake of this.waiters) wake();
+    this.markReady();
+    this.connection.dispose();
+  }
+};
+function toDiagnostic(raw) {
+  const start = raw.range?.start;
+  const code = raw.code;
+  return {
+    line: (start?.line ?? 0) + 1,
+    character: (start?.character ?? 0) + 1,
+    ...typeof raw.severity === "number" ? { severity: raw.severity } : {},
+    message: typeof raw.message === "string" ? raw.message : String(raw.message ?? ""),
+    ...typeof code === "string" || typeof code === "number" ? { code } : {}
+  };
+}
+
+// src/lsp/format.ts
+var MAX_ERROR_LINES = 20;
+var MAX_MESSAGE_CHARS = 300;
+function formatDiagnostics(shown, server, items) {
+  const errors = items.filter((d) => d.severity === void 0 || d.severity === 1).sort((a, b) => a.line - b.line || a.character - b.character);
+  if (errors.length === 0) return `No errors in ${shown} (${server}).`;
+  const lines = errors.slice(0, MAX_ERROR_LINES).map((d) => {
+    const first = cleanText(d.message).split("\n")[0]?.trim() ?? "";
+    const message = first.length > MAX_MESSAGE_CHARS ? `${first.slice(0, MAX_MESSAGE_CHARS)}\u2026` : first;
+    const code = d.code === void 0 ? "" : ` [${cleanText(String(d.code))}]`;
+    return `  ${d.line}:${d.character} ${message}${code}`;
+  });
+  if (errors.length > MAX_ERROR_LINES) {
+    lines.push(`  \u2026 and ${errors.length - MAX_ERROR_LINES} more.`);
+  }
+  const noun = errors.length === 1 ? "error" : "errors";
+  return [`${errors.length} ${noun} in ${shown} after this change (${server}):`, ...lines].join(
+    "\n"
+  );
+}
+
+// src/lsp/manager.ts
+var LANGUAGE_LABELS = {
+  typescript: "TypeScript/JavaScript",
+  python: "Python",
+  java: "Java"
+};
+var LspManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  slots = /* @__PURE__ */ new Map();
+  closed = false;
+  /** Aborted by close(): it stops warm starts. */
+  lifetime = new AbortController();
+  /**
+   * The diagnostics text for a file that a tool just wrote, or undefined: not a known language,
+   * no server, a timeout, or Ctrl-C. `shown` is the path as the model sees it.
+   */
+  async diagnostics(absolute, shown, text, signal) {
+    const lang = languageOf(absolute);
+    if (lang === void 0 || this.closed) return void 0;
+    const slot = this.slot(lang.language);
+    const client = await this.client(lang.language, slot, signal);
+    if (client === void 0 || slot.server === void 0) return void 0;
+    try {
+      const items = await client.diagnostics(absolute, lang.id, text, signal);
+      return formatDiagnostics(shown, slot.server.spec.name, items);
+    } catch (error) {
+      if (signal.aborted) return void 0;
+      if (error instanceof LspTimeoutError) {
+        if (!slot.slowNoticed) {
+          slot.slowNoticed = true;
+          this.notify(`${slot.server.spec.name}: ${error.message} Edits go on without it.`);
+        }
+        return void 0;
+      }
+      this.fail(lang.language, slot, error.message);
+      return void 0;
+    }
+  }
+  /** One line per language, for /lsp and `garuda lsp`. */
+  status() {
+    return LSP_LANGUAGES.map((language) => {
+      const slot = this.slots.get(language);
+      const found = slot?.server === void 0 ? findServer(language, this.discoverOptions()) : void 0;
+      const server = slot?.server ?? found?.server;
+      const state = slot?.state ?? (server === void 0 ? "missing" : "idle");
+      return {
+        language,
+        state,
+        ...server === void 0 ? {} : { server },
+        ...slot?.reason === void 0 ? {} : { reason: slot.reason },
+        ...found !== void 0 && found.problems.length > 0 ? { problems: found.problems } : {}
+      };
+    });
+  }
+  /**
+   * Start a language's server now, in the background, so the first edit does not wait for the
+   * project import (jdtls). It never asks to install, and failures only give the usual notice.
+   */
+  warm(language) {
+    if (this.closed) return;
+    const slot = this.slot(language);
+    if (slot.state !== "idle") return;
+    if (discoverServer(language, this.discoverOptions()) === void 0) return;
+    void this.client(language, slot, this.lifetime.signal).then((client) => client?.ready).catch(() => void 0);
+  }
+  /** Forget a missing or failed server, so the next edit looks again (after an install). */
+  reset(language) {
+    const slot = this.slots.get(language);
+    if (slot === void 0 || slot.state === "running" || slot.state === "starting") return;
+    this.slots.delete(language);
+  }
+  async close() {
+    this.closed = true;
+    this.lifetime.abort(new Error("Garuda is closing."));
+    const slots = [...this.slots.values()];
+    await Promise.all(
+      slots.map(async (slot) => {
+        const client = slot.client ?? await slot.starting?.catch(() => void 0);
+        if (client !== void 0) await client.close();
+        else slot.process?.stop();
+      })
+    );
+  }
+  slot(language) {
+    let slot = this.slots.get(language);
+    if (slot === void 0) {
+      slot = { state: "idle", stderr: [] };
+      this.slots.set(language, slot);
+    }
+    return slot;
+  }
+  async client(language, slot, signal) {
+    if (slot.state === "missing" || slot.state === "failed") return void 0;
+    if (slot.client !== void 0) {
+      if (!slot.client.isClosed) return slot.client;
+      this.fail(language, slot, this.stopped(slot));
+      return void 0;
+    }
+    slot.starting ??= this.start(language, slot, signal).finally(() => {
+      slot.starting = void 0;
+    });
+    return slot.starting;
+  }
+  async start(language, slot, signal) {
+    slot.state = "starting";
+    let server = discoverServer(language, this.discoverOptions());
+    if (server === void 0 && this.options.install !== void 0) {
+      if (await this.options.install(language, signal).catch(() => false)) {
+        server = discoverServer(language, this.discoverOptions());
+      }
+    }
+    if (server === void 0) {
+      slot.state = "missing";
+      slot.reason = `no server found. Run "garuda lsp install ${language}".`;
+      return void 0;
+    }
+    slot.server = server;
+    if (this.options.executor.isolation === "none") {
+      this.fail(language, slot, "it needs the OS sandbox, and this session has none");
+      return void 0;
+    }
+    try {
+      const process2 = this.options.executor.start(server.argv, this.options.policy());
+      slot.process = process2;
+      process2.stderr.on("data", (chunk) => {
+        for (const line of chunk.toString("utf8").split("\n")) {
+          if (line.trim() === "") continue;
+          slot.stderr.push(line.slice(0, 300));
+          if (slot.stderr.length > 20) slot.stderr.shift();
+        }
+      });
+      process2.onError(() => {
+      });
+      const { spec } = server;
+      const firstTimeoutMs = this.options.firstTimeoutMs ?? spec.firstTimeoutMs;
+      const client = await LspClient.start(
+        process2,
+        {
+          root: this.options.root,
+          ...firstTimeoutMs === void 0 ? {} : { firstTimeoutMs },
+          ...spec.initializationOptions === void 0 ? {} : { initializationOptions: spec.initializationOptions },
+          ...spec.ready === void 0 ? {} : { ready: spec.ready },
+          ...this.options.timeoutMs === void 0 ? {} : { timeoutMs: this.options.timeoutMs }
+        },
+        signal
+      );
+      if (this.closed) {
+        await client.close();
+        return void 0;
+      }
+      slot.client = client;
+      slot.state = "running";
+      return client;
+    } catch (error) {
+      slot.process?.stop();
+      if (signal.aborted) {
+        slot.state = "idle";
+        return void 0;
+      }
+      const why = error instanceof LspTimeoutError ? error.message : this.stopped(slot, error);
+      this.fail(language, slot, why);
+      return void 0;
+    }
+  }
+  stopped(slot, error) {
+    const last = slot.stderr.at(-1);
+    const base = error instanceof Error ? error.message : "the server stopped";
+    return last === void 0 ? base : `${base} (${last})`;
+  }
+  fail(language, slot, reason) {
+    if (slot.state === "failed") return;
+    slot.state = "failed";
+    slot.reason = reason;
+    slot.process?.stop();
+    const name = slot.server?.spec.name ?? "the language server";
+    this.notify(
+      `${LANGUAGE_LABELS[language]} diagnostics are off for this session: ${name}: ${reason}`
+    );
+  }
+  notify(text) {
+    this.options.notify?.(text);
+  }
+  discoverOptions() {
+    const o = this.options;
+    return {
+      root: o.root,
+      ...o.home === void 0 ? {} : { home: o.home },
+      ...o.path === void 0 ? {} : { path: o.path },
+      ...o.env === void 0 ? {} : { env: o.env },
+      ...o.jdkFolders === void 0 ? {} : { jdkFolders: o.jdkFolders }
+    };
+  }
+};
+function lspStatusText(statuses, enabled) {
+  const lines = [
+    enabled.on ? "LSP diagnostics are on: edit_file and write_file add the errors of the changed file." : `LSP diagnostics are off. ${enabled.how}`
+  ];
+  for (const s of statuses) {
+    const label = LANGUAGE_LABELS[s.language];
+    if (s.server === void 0) {
+      const why = s.problems === void 0 ? "" : ` (${s.problems.join("; ")})`;
+      lines.push(`  ${label}: not found${why}. Run "garuda lsp install ${s.language}".`);
+      continue;
+    }
+    const where = s.server.source === "managed" ? "managed" : "PATH";
+    const state = s.state === "failed" ? `failed: ${s.reason ?? "unknown"}` : s.state === "running" ? "running" : "found";
+    lines.push(`  ${label}: ${s.server.spec.name} (${where}, ${s.server.path}), ${state}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  LANGUAGE_LABELS,
+  LspManager,
+  lspStatusText
+};
+//# sourceMappingURL=chunk-36GQIVGT.js.map