@garuda-agent/garuda 0.0.1 → 0.14.1

package/dist/chunk-EU7PA45O.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+
+// src/lsp/servers.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, realpathSync as realpathSync2, statSync } from "fs";
+import { homedir } from "os";
+import { delimiter as delimiter2, dirname as dirname2, extname, isAbsolute as isAbsolute2, join as join2, sep } from "path";
+
+// src/lsp/jdtls.ts
+import { createHash } from "crypto";
+import { existsSync, readdirSync, readFileSync, realpathSync } from "fs";
+import { delimiter, dirname, isAbsolute, join } from "path";
+var JDTLS_VERSION = "1.61.0";
+var JDTLS_BASE_URL = `https://download.eclipse.org/jdtls/milestones/${JDTLS_VERSION}`;
+var JDTLS_MIN_JAVA = 21;
+var JDTLS_READY = {
+  method: "language/status",
+  test: (params) => {
+    const type = params?.type;
+    return type === "Started" || type === "Error";
+  }
+};
+var JDTLS_INIT_OPTIONS = {
+  settings: {
+    java: {
+      import: {
+        generatesMetadataFilesAtProjectRoot: false,
+        maven: { offline: { enabled: true } },
+        gradle: { offline: { enabled: true } }
+      },
+      autobuild: { enabled: true }
+    }
+  }
+};
+function releaseMajor(text) {
+  const match = /^JAVA_VERSION="([^"]+)"/m.exec(text);
+  if (match?.[1] === void 0) return void 0;
+  const parts = match[1].split(".").map((p) => Number.parseInt(p, 10));
+  const major = parts[0] === 1 ? parts[1] : parts[0];
+  return major !== void 0 && Number.isFinite(major) ? major : void 0;
+}
+function runtimeAt(home) {
+  const java = join(home, "bin", "java");
+  const release = join(home, "release");
+  if (!existsSync(java) || !existsSync(release)) return void 0;
+  const major = releaseMajor(readFileSync(release, "utf8"));
+  return major === void 0 ? void 0 : { java, major };
+}
+var JDK_FOLDERS = [
+  "/Library/Java/JavaVirtualMachines",
+  "/opt/homebrew/opt",
+  "/usr/local/opt",
+  "/usr/lib/jvm"
+];
+function findJava(search = {}) {
+  const env = search.env ?? process.env;
+  const homes = [];
+  if (env.JAVA_HOME) homes.push(env.JAVA_HOME);
+  homes.push(...search.hints ?? []);
+  for (const dir of (env.PATH ?? "").split(delimiter)) {
+    if (!isAbsolute(dir)) continue;
+    const java = join(dir, "java");
+    if (!existsSync(java)) continue;
+    try {
+      homes.push(dirname(dirname(realpathSync(java))));
+    } catch {
+    }
+  }
+  for (const folder of search.jdkFolders ?? JDK_FOLDERS) {
+    let names = [];
+    try {
+      names = readdirSync(folder).sort().reverse();
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      homes.push(
+        join(folder, name),
+        join(folder, name, "Contents", "Home"),
+        join(folder, name, "libexec", "openjdk.jdk", "Contents", "Home")
+      );
+    }
+  }
+  for (const home of homes) {
+    const runtime = runtimeAt(home);
+    if (runtime !== void 0 && runtime.major >= JDTLS_MIN_JAVA) return runtime;
+  }
+  return void 0;
+}
+function jdtlsHome(script) {
+  let real = script;
+  try {
+    real = realpathSync(script);
+  } catch {
+    return void 0;
+  }
+  let text = "";
+  try {
+    text = readFileSync(real, "utf8").slice(0, 2e4);
+  } catch {
+  }
+  const quoted = [...text.matchAll(/["'](\/[^"'\s]+)["']/g)].map((m) => m[1]);
+  const hints = [...text.matchAll(/JAVA_HOME[=:]\s*["']?(\/[^"'\s]+)/g)].map((m) => m[1]);
+  const up = dirname(dirname(real));
+  const candidates = [
+    up,
+    join(up, "libexec"),
+    ...quoted.flatMap((p) => [p, dirname(p), dirname(dirname(p))])
+  ];
+  for (const dir of candidates) {
+    if (existsSync(join(dir, "plugins")) && launcherJar(dir) !== void 0) {
+      return { home: dir, hints };
+    }
+  }
+  return void 0;
+}
+function launcherJar(home) {
+  try {
+    const jar = readdirSync(join(home, "plugins")).find(
+      (n) => n.startsWith("org.eclipse.equinox.launcher_") && n.endsWith(".jar")
+    );
+    return jar === void 0 ? void 0 : join(home, "plugins", jar);
+  } catch {
+    return void 0;
+  }
+}
+function configDir(home, platform = process.platform, arch = process.arch) {
+  const os = platform === "darwin" ? "mac" : platform === "win32" ? "win" : "linux";
+  const names = arch === "arm64" ? [`config_${os}_arm`, `config_${os}`] : [`config_${os}`];
+  return names.map((n) => join(home, n)).find((p) => existsSync(p));
+}
+function jdtlsLaunch(script, context) {
+  const install = jdtlsHome(script);
+  if (install === void 0) return { problem: `no jdtls install folder (plugins/) for ${script}` };
+  const jar = launcherJar(install.home);
+  const config = configDir(install.home, context.platform, context.arch);
+  if (config === void 0) return { problem: `no config_* folder in ${install.home}` };
+  const java = findJava({
+    ...context.env === void 0 ? {} : { env: context.env },
+    hints: install.hints,
+    ...context.jdkFolders === void 0 ? {} : { jdkFolders: context.jdkFolders }
+  });
+  if (java === void 0) {
+    return { problem: `jdtls needs Java ${JDTLS_MIN_JAVA} or later; set JAVA_HOME to such a JDK` };
+  }
+  const cache = join(context.home, ".cache", "garuda", "jdtls");
+  const id = (text) => createHash("sha256").update(text).digest("hex").slice(0, 16);
+  return {
+    argv: [
+      java.java,
+      "-Declipse.application=org.eclipse.jdt.ls.core.id1",
+      "-Dosgi.bundles.defaultStartLevel=4",
+      "-Declipse.product=org.eclipse.jdt.ls.core.product",
+      // The install is read-only in the sandbox: its configuration is shared, ours is in the cache.
+      `-Dosgi.sharedConfiguration.area=${config}`,
+      "-Dosgi.sharedConfiguration.area.readOnly=true",
+      "-Dosgi.checkConfiguration=true",
+      "-Dosgi.configuration.cascaded=true",
+      "-Dlog.level=WARNING",
+      "-Xmx1G",
+      "--add-modules=ALL-SYSTEM",
+      "--add-opens",
+      "java.base/java.util=ALL-UNNAMED",
+      "--add-opens",
+      "java.base/java.lang=ALL-UNNAMED",
+      "-jar",
+      jar,
+      "-configuration",
+      join(cache, `config-${id(install.home)}`),
+      "-data",
+      join(cache, "workspace", id(context.root))
+    ]
+  };
+}
+function jdtlsInstallCommand(dir, quote) {
+  const d = quote(dir);
+  return [
+    `cd ${d}`,
+    `B=${JDTLS_BASE_URL}`,
+    `f=$(curl -fsSL "$B/latest.txt" 2>/dev/null || curl -fsSL "$B/" | grep -o 'jdt-language-server-[0-9.]*-[0-9]*\\.tar\\.gz' | head -1)`,
+    `test -n "$f" || { echo "No jdtls ${JDTLS_VERSION} file at $B" >&2; exit 1; }`,
+    `curl -fsSL -o jdtls.tar.gz "$B/$f"`,
+    `want=$(curl -fsSL "$B/$f.sha256") || { echo "No checksum file for $f, so Garuda does not install it" >&2; rm -f jdtls.tar.gz; exit 1; }`,
+    `got=$( (sha256sum jdtls.tar.gz 2>/dev/null || shasum -a 256 jdtls.tar.gz) | cut -d' ' -f1)`,
+    `test -n "$got" && test "$(echo "$want" | cut -d' ' -f1)" = "$got" || { echo "Checksum mismatch for $f" >&2; rm -f jdtls.tar.gz; exit 1; }`,
+    "rm -rf jdtls && mkdir jdtls && tar -xzf jdtls.tar.gz -C jdtls && rm jdtls.tar.gz"
+  ].join(" && ");
+}
+
+// src/lsp/servers.ts
+var LSP_LANGUAGES = ["typescript", "python", "java"];
+var EXTENSIONS = {
+  ".ts": { language: "typescript", id: "typescript" },
+  ".mts": { language: "typescript", id: "typescript" },
+  ".cts": { language: "typescript", id: "typescript" },
+  ".tsx": { language: "typescript", id: "typescriptreact" },
+  ".js": { language: "typescript", id: "javascript" },
+  ".mjs": { language: "typescript", id: "javascript" },
+  ".cjs": { language: "typescript", id: "javascript" },
+  ".jsx": { language: "typescript", id: "javascriptreact" },
+  ".py": { language: "python", id: "python" },
+  ".pyi": { language: "python", id: "python" },
+  ".java": { language: "java", id: "java" }
+};
+function languageOf(path) {
+  return EXTENSIONS[extname(path).toLowerCase()];
+}
+var SERVERS = {
+  typescript: [
+    // TypeScript 7 (native) has a built-in language server.
+    { name: "tsc", bin: "tsc", args: ["--lsp", "--stdio"], accept: isTypeScript7 },
+    { name: "tsgo", bin: "tsgo", args: ["--lsp", "--stdio"] },
+    { name: "typescript-language-server", bin: "typescript-language-server", args: ["--stdio"] }
+  ],
+  python: [
+    { name: "basedpyright", bin: "basedpyright-langserver", args: ["--stdio"] },
+    { name: "pyright", bin: "pyright-langserver", args: ["--stdio"] }
+  ],
+  java: [
+    {
+      name: "jdtls",
+      bin: "jdtls",
+      args: [],
+      managed: join2("jdtls", "bin", "jdtls"),
+      launch: jdtlsLaunch,
+      initializationOptions: JDTLS_INIT_OPTIONS,
+      ready: JDTLS_READY,
+      // The first import of a Maven or Gradle project takes a while.
+      firstTimeoutMs: 12e4
+    }
+  ]
+};
+var MANAGED = {
+  typescript: { kind: "npm", packages: ["typescript@7.0.2"] },
+  python: { kind: "npm", packages: ["pyright@1.1.414"] },
+  java: { kind: "eclipse" }
+};
+function managedLabel(language) {
+  const m = MANAGED[language];
+  return m.kind === "npm" ? m.packages.join(", ") : `jdtls ${JDTLS_VERSION} (from download.eclipse.org)`;
+}
+function managedDir(language, home = homedir()) {
+  return join2(home, ".garuda", "lsp", language);
+}
+function discoverServer(language, options) {
+  return findServer(language, options).server;
+}
+function findServer(language, options) {
+  const home = options.home ?? homedir();
+  const managed = managedDir(language, home);
+  const dirs = (options.path ?? process.env.PATH ?? "").split(delimiter2).filter((dir) => isAbsolute2(dir) && !inside(options.root, dir));
+  const problems = [];
+  const context = {
+    root: options.root,
+    home,
+    ...options.env === void 0 ? {} : { env: options.env },
+    ...options.jdkFolders === void 0 ? {} : { jdkFolders: options.jdkFolders }
+  };
+  for (const source of ["managed", "path"]) {
+    for (const spec of SERVERS[language]) {
+      const paths = source === "managed" ? [join2(managed, spec.managed ?? join2("node_modules", ".bin", spec.bin))] : dirs.map((dir) => join2(dir, spec.bin));
+      for (const path of paths) {
+        if (!isProgram(path)) continue;
+        if (spec.accept !== void 0 && !spec.accept(path)) continue;
+        const launch = spec.launch?.(path, context) ?? { argv: [path, ...spec.args] };
+        if ("problem" in launch) {
+          problems.push(launch.problem);
+          continue;
+        }
+        return { server: { spec, path, source, argv: launch.argv }, problems };
+      }
+    }
+  }
+  return { problems };
+}
+function inside(root, dir) {
+  let real = dir;
+  try {
+    real = realpathSync2(dir);
+  } catch {
+  }
+  return real === root || real.startsWith(`${root}${sep}`);
+}
+function isProgram(path) {
+  try {
+    const stat = statSync(path);
+    return stat.isFile() && (stat.mode & 73) !== 0;
+  } catch {
+    return false;
+  }
+}
+function isTypeScript7(path) {
+  let dir;
+  try {
+    dir = dirname2(realpathSync2(path));
+  } catch {
+    return false;
+  }
+  const candidates = [join2(dir, "..", "typescript", "package.json")];
+  for (let i = 0; i < 4; i++, dir = dirname2(dir)) candidates.push(join2(dir, "package.json"));
+  for (const file of candidates) {
+    if (!existsSync2(file)) continue;
+    try {
+      const pkg = JSON.parse(readFileSync2(file, "utf8"));
+      if (pkg.name === "typescript") return Number.parseInt(pkg.version ?? "0", 10) >= 7;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+export {
+  jdtlsInstallCommand,
+  LSP_LANGUAGES,
+  languageOf,
+  SERVERS,
+  MANAGED,
+  managedLabel,
+  managedDir,
+  discoverServer,
+  findServer,
+  isTypeScript7
+};
+//# sourceMappingURL=chunk-EU7PA45O.js.map

package/dist/chunk-FARS4R67.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+import {
+  serverCallText,
+  serverResultSummary
+} from "./chunk-A2QAIRQL.js";
+
+// src/cli/renderer.ts
+import { styleText } from "util";
+var PlainRenderer = class {
+  out;
+  err;
+  color;
+  /** True when the last text did not end with a new line. */
+  openLine = false;
+  /** /details (0.9): show the result line of each tool call. */
+  details = true;
+  /** Thinking text is streaming (0.9). */
+  thinking = false;
+  endThinking() {
+    if (!this.thinking) return;
+    this.thinking = false;
+    this.err.write("\n");
+  }
+  constructor(streams = { out: process.stdout, err: process.stderr }, color = process.stderr.isTTY === true && !process.env.NO_COLOR) {
+    this.out = streams.out;
+    this.err = streams.err;
+    this.color = color;
+  }
+  event(event) {
+    switch (event.type) {
+      case "thinking_delta":
+        if (!this.thinking) this.line(this.paint("dim", "\u273B thinking"));
+        this.thinking = true;
+        this.err.write(this.paint("dim", event.text));
+        return;
+      case "text_delta":
+        this.endThinking();
+        this.out.write(event.text);
+        this.openLine = !event.text.endsWith("\n");
+        return;
+      case "tool_call":
+        this.endThinking();
+        this.line(
+          `${this.paint("cyan", "\u25CF")} ${this.paint("bold", event.call.name)} ${summariseCall(event.call)}`
+        );
+        return;
+      case "tool_result": {
+        const text = summariseResult(event.call, event.outcome);
+        if (this.details || event.outcome.isError) {
+          this.line(
+            `  ${this.paint("dim", "\u23BF")} ${event.outcome.isError ? this.paint("red", text) : this.paint("dim", text)}`
+          );
+        }
+        for (const line of todoLines(event.call, event.outcome)) this.line(`    ${line}`);
+        return;
+      }
+      case "compaction": {
+        const { stage, beforeTokens, afterTokens } = event.result;
+        this.info(`Context compacted (${stage}): ${beforeTokens} \u2192 about ${afterTokens} tokens.`);
+        return;
+      }
+      case "model_retry":
+        this.warn(retryText(event));
+        return;
+      case "notice":
+        this.info(event.text);
+        return;
+      case "server_tool": {
+        const { call, result } = serverToolText(event);
+        const failed = event.result?.error !== void 0;
+        this.line(`${this.paint("cyan", "\u25CF")} ${this.paint("bold", call)}`);
+        if (this.details || failed) {
+          this.line(`  ${this.paint("dim", "\u23BF")} ${this.paint(failed ? "red" : "dim", result)}`);
+        }
+        return;
+      }
+      case "step_end":
+        this.endThinking();
+        return;
+      // Live status lines need a live view; plain output stays one line per call.
+      case "tool_progress":
+        return;
+    }
+  }
+  info(text) {
+    this.line(this.paint("dim", text));
+  }
+  warn(text) {
+    this.line(this.paint("yellow", text));
+  }
+  error(text) {
+    this.line(this.paint("red", text));
+  }
+  /** A line on stderr. It starts on a new line if model text is still open. */
+  line(text) {
+    if (this.openLine) {
+      this.out.write("\n");
+      this.openLine = false;
+    }
+    this.err.write(`${text}
+`);
+  }
+  paint(style, text) {
+    return this.color ? styleText(style, text) : text;
+  }
+};
+function todoLines(call, outcome) {
+  if (call.name !== "todo_write" || outcome.isError) return [];
+  const marks = { "[x]": "\u2714", "[>]": "\u25B6", "[ ]": "\u25CB" };
+  return outcome.content.split("\n").map((line) => /^(\[[x> ]\]) (.*)$/.exec(line)).filter((m) => m !== null).map((m) => `${marks[m[1] ?? ""] ?? "\u25CB"} ${m[2] ?? ""}`);
+}
+function serverToolText(event) {
+  return {
+    call: `${event.call.name} (Claude) ${cut(serverCallText(event.call), 100)}`,
+    result: serverResultSummary(event.result)
+  };
+}
+function serverToolOutput(event) {
+  const result = event.result;
+  if (result === void 0 || result.results.length === 0) return serverResultSummary(result);
+  return result.results.map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}${r.age === void 0 ? "" : ` (${r.age})`}`).join("\n");
+}
+function retryText(event) {
+  return `The connection to the model broke (${event.reason}). Retrying (${event.attempt}/${event.maxRetries})\u2026`;
+}
+var cut = (text, max) => text.length <= max ? text : `${text.slice(0, max - 1)}\u2026`;
+function summariseCall(call) {
+  const input = call.input ?? {};
+  const str = (key) => typeof input[key] === "string" ? input[key] : "";
+  switch (call.name) {
+    case "read_file":
+    case "write_file":
+    case "edit_file":
+      return str("path");
+    case "glob":
+      return str("pattern");
+    case "grep":
+      return `/${str("pattern")}/${str("path") ? ` in ${str("path")}` : ""}`;
+    case "bash":
+      return cut(str("command").split("\n")[0] ?? "", 100);
+    case "explore":
+      return cut(str("question").split("\n")[0] ?? "", 100);
+    case "todo_write": {
+      const todos = Array.isArray(input.todos) ? input.todos : [];
+      return `${todos.length} step(s)`;
+    }
+    default:
+      return cut(JSON.stringify(call.input), 100);
+  }
+}
+function summariseResult(call, outcome) {
+  const all = outcome.content.split("\n");
+  const first = ((all[0]?.startsWith("<mcp_result ") ? all[1] : all[0]) ?? "").trim();
+  if (outcome.isError) return cut(first.replace(/^Error: /, ""), 160);
+  const lines = outcome.content === "" ? 0 : outcome.content.split("\n").length;
+  switch (call.name) {
+    case "read_file":
+      return `${lines} line(s)`;
+    case "glob":
+    case "grep":
+      return first.startsWith("No ") ? first : `${lines} result line(s)`;
+    case "bash":
+      return first;
+    case "todo_write":
+      return /\((\d+ of \d+ done)\)/.exec(first)?.[1] ?? first;
+    case "web_search": {
+      const count = outcome.content.split("\n").filter((l) => /^\d+\. /.test(l)).length;
+      return count === 0 ? "no results" : `${count} result${count === 1 ? "" : "s"}`;
+    }
+    case "web_fetch": {
+      const title = / title="([^"]*)"/.exec(first)?.[1];
+      const range = /^\[characters (\d+)–(\d+) of (\d+)\]$/m.exec(outcome.content);
+      const size = range === null ? `${lines} line(s)` : range[1] === "0" && range[2] === range[3] ? `${Number(range[3]).toLocaleString("en")} characters` : `characters ${range[1]}\u2013${range[2]} of ${Number(range[3]).toLocaleString("en")}`;
+      return title === void 0 ? size : `${cut(title, 80)} \xB7 ${size}`;
+    }
+    case "skill": {
+      const file = / path="([^"]*)"/.exec(first)?.[1];
+      const name = / name="([^"]*)"/.exec(first)?.[1] ?? / skill="([^"]*)"/.exec(first)?.[1];
+      return file === void 0 ? `loaded ${name ?? "the skill"}` : `read ${file}`;
+    }
+    case "agent": {
+      const trailer = /^\[agent (.*)\]$/m.exec(outcome.content)?.[1];
+      const answerLines = outcome.content.split("\n[agent ")[0]?.trim().split("\n").length ?? 0;
+      return `answer (${answerLines} line(s))${trailer === void 0 ? "" : ` \xB7 ${trailer}`}`;
+    }
+    case "explore": {
+      const trailer = /^\[explore: (.*)\]$/m.exec(outcome.content)?.[1];
+      const answerLines = outcome.content.split("\n[explore: ")[0]?.trim().split("\n").length ?? 0;
+      return `answer (${answerLines} line(s))${trailer === void 0 ? "" : ` \xB7 ${trailer}`}`;
+    }
+    default:
+      return cut(first, 160);
+  }
+}
+
+export {
+  PlainRenderer,
+  todoLines,
+  serverToolText,
+  serverToolOutput,
+  retryText,
+  summariseCall,
+  summariseResult
+};
+//# sourceMappingURL=chunk-FARS4R67.js.map

package/dist/chunk-G2AX7MGS.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+// src/lsp/config.ts
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { z } from "zod";
+var LSP_CONFIG_FILE = join(".garuda", "lsp.json");
+var schema = z.strictObject({ autoInstall: z.boolean().optional() });
+async function loadLspConfig(home = homedir()) {
+  const file = join(home, LSP_CONFIG_FILE);
+  let text;
+  try {
+    text = await readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return { autoInstall: false };
+    throw error;
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`${file} is not valid JSON: ${error.message}`);
+  }
+  const parsed = schema.safeParse(json);
+  if (!parsed.success) {
+    throw new Error(`${file}: ${parsed.error.issues.map((i) => i.message).join("; ")}`);
+  }
+  return { autoInstall: parsed.data.autoInstall === true };
+}
+
+export {
+  LSP_CONFIG_FILE,
+  loadLspConfig
+};
+//# sourceMappingURL=chunk-G2AX7MGS.js.map