@garuda-agent/garuda 0.0.1 → 0.15.0

package/dist/server-R3GNIC33.js

@@ -0,0 +1,676 @@
+#!/usr/bin/env node
+import {
+  HIDDEN_WARNING,
+  hasHidden,
+  headerText,
+  visible
+} from "./chunk-4JSUUDFQ.js";
+import {
+  BUILTIN_COMMANDS
+} from "./chunk-23FXBNBB.js";
+
+// src/acp/server.ts
+import { randomUUID } from "crypto";
+import { statSync } from "fs";
+import { isAbsolute as isAbsolute2 } from "path";
+import {
+  agent,
+  methods,
+  ndJsonStream,
+  PROTOCOL_VERSION,
+  RequestError
+} from "@agentclientprotocol/sdk";
+
+// src/acp/toolCalls.ts
+import { resolve } from "path";
+var TITLE_MAX = 200;
+var KINDS = {
+  read_file: "read",
+  skill: "read",
+  glob: "search",
+  grep: "search",
+  find_symbol: "search",
+  find_references: "search",
+  find_callers: "search",
+  repo_map: "search",
+  ast_query: "search",
+  impact_analysis: "search",
+  write_file: "edit",
+  edit_file: "edit",
+  remember: "edit",
+  bash: "execute",
+  process_manager: "execute",
+  web_fetch: "fetch",
+  web_search: "fetch",
+  explore: "think",
+  agent: "think",
+  delegate_expert: "think",
+  todo_write: "think"
+};
+function oneLine(text, max = TITLE_MAX) {
+  const line = visible(text.replace(/\r?\n/g, " \u21B5 "));
+  return line.length <= max ? line : `${line.slice(0, max - 1)}\u2026`;
+}
+function viewOf(name, input, root) {
+  const args = typeof input === "object" && input !== null ? input : {};
+  const text = (key) => typeof args[key] === "string" ? args[key] : void 0;
+  const path = text("path");
+  const kind = KINDS[name] ?? "other";
+  const locations = path === void 0 || !["read", "edit", "search"].includes(kind) ? [] : [
+    {
+      path: resolve(root, path),
+      ...typeof args.offset === "number" ? { line: args.offset } : {}
+    }
+  ];
+  return { title: oneLine(titleOf(name, text, path)), kind, locations };
+}
+function titleOf(name, text, path) {
+  switch (name) {
+    case "read_file":
+      return `Read ${path ?? ""}`;
+    case "write_file":
+      return `Write ${path ?? ""}`;
+    case "edit_file":
+      return `Edit ${path ?? ""}`;
+    case "glob":
+      return `Find files ${text("pattern") ?? ""}`;
+    case "grep":
+      return `Search ${text("pattern") ?? ""}${path === void 0 ? "" : ` in ${path}`}`;
+    case "bash":
+      return `$ ${text("command") ?? ""}`;
+    case "web_fetch":
+      return `Fetch ${text("url") ?? ""}`;
+    case "web_search":
+      return `Search the web: ${text("query") ?? ""}`;
+    case "explore":
+      return "Subagent: explore";
+    case "agent":
+      return `Subagent: ${text("agent") ?? "agent"}`;
+    case "delegate_expert":
+      return `Subagent: ${text("language") ?? "expert"} expert`;
+    case "todo_write":
+      return "Update the plan";
+    case "remember":
+      return "Remember a note";
+    case "skill":
+      return `Skill: ${text("name") ?? ""}`;
+    default: {
+      const mcp = /^mcp__(.+?)__(.+)$/.exec(name);
+      if (mcp !== null) return `${mcp[1]}/${mcp[2]}`;
+      const symbol = text("symbol") ?? text("name") ?? text("query");
+      return symbol === void 0 ? name : `${name} ${symbol}`;
+    }
+  }
+}
+
+// src/acp/updates.ts
+var RESULT_MAX_CHARS = 5e4;
+function textContent(text) {
+  return { type: "content", content: { type: "text", text } };
+}
+var SessionChannel = class {
+  constructor(sessionId) {
+    this.sessionId = sessionId;
+  }
+  sessionId;
+  client;
+  chain = Promise.resolve();
+  waiting = [];
+  stopped = false;
+  stoppedCalls = [];
+  /** The prompt starts: send to this client, and send the notices that waited. */
+  open(client) {
+    this.client = client;
+    this.stopped = false;
+    this.stoppedCalls.length = 0;
+    for (const text of this.waiting.splice(0)) this.message(text);
+  }
+  /** The editor stopped the running prompt: tool calls that end from now on were cancelled. */
+  cancel() {
+    this.stopped = true;
+  }
+  get cancelled() {
+    return this.stopped;
+  }
+  /** A tool call that the stop ended (its title), for the message at the end of the turn. */
+  noteCancelled(title) {
+    this.stoppedCalls.push(title);
+  }
+  /** The titles of the tool calls that the stop ended, once. */
+  takeCancelled() {
+    return this.stoppedCalls.splice(0);
+  }
+  /** The prompt ends: wait for every update, then stop sending. */
+  async close() {
+    await this.chain;
+    this.client = void 0;
+  }
+  get current() {
+    return this.client;
+  }
+  update(update) {
+    const client = this.client;
+    if (client === void 0) return;
+    this.chain = this.chain.then(() => client.notify("session/update", { sessionId: this.sessionId, update })).catch((error) => {
+      process.stderr.write(`garuda acp: session/update failed: ${String(error)}
+`);
+    });
+  }
+  /** Every update so far has gone out. */
+  flush() {
+    return this.chain;
+  }
+  /** A line from Garuda (not the model), as message text. Kept for the next prompt if none runs. */
+  notice(text) {
+    if (this.client === void 0) this.waiting.push(text);
+    else this.message(text);
+  }
+  message(text) {
+    this.update({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text: `
+
+Garuda: ${text}
+
+` }
+    });
+  }
+};
+var KnownCalls = class {
+  titles = /* @__PURE__ */ new Map();
+  add(id, title) {
+    this.titles.set(id, title);
+  }
+  title(id) {
+    return this.titles.get(id);
+  }
+};
+var SETTLE_MS = 3e3;
+var EventMapper = class {
+  constructor(channel, calls, root) {
+    this.channel = channel;
+    this.calls = calls;
+    this.root = root;
+  }
+  channel;
+  calls;
+  root;
+  /** Tool calls that started and have no result yet. */
+  open = /* @__PURE__ */ new Set();
+  changed = () => {
+  };
+  event(event) {
+    const send = (update) => this.channel.update(update);
+    switch (event.type) {
+      case "text_delta":
+        send({ sessionUpdate: "agent_message_chunk", content: { type: "text", text: event.text } });
+        break;
+      case "thinking_delta":
+        send({ sessionUpdate: "agent_thought_chunk", content: { type: "text", text: event.text } });
+        break;
+      case "tool_call": {
+        const view = viewOf(event.call.name, event.call.input, this.root);
+        this.calls.add(event.call.id, view.title);
+        this.open.add(event.call.id);
+        send({
+          sessionUpdate: "tool_call",
+          toolCallId: event.call.id,
+          title: view.title,
+          kind: view.kind,
+          status: "pending",
+          locations: view.locations,
+          rawInput: event.call.input
+        });
+        break;
+      }
+      case "tool_progress":
+        send({
+          sessionUpdate: "tool_call_update",
+          toolCallId: event.call.id,
+          status: "in_progress",
+          content: [textContent(oneLine(event.text))]
+        });
+        break;
+      case "tool_result": {
+        if (!this.open.delete(event.call.id)) break;
+        this.changed();
+        const stopped = this.channel.cancelled;
+        if (stopped) {
+          this.channel.noteCancelled(this.calls.title(event.call.id) ?? event.call.name);
+        }
+        send({
+          sessionUpdate: "tool_call_update",
+          toolCallId: event.call.id,
+          status: stopped || event.outcome.isError ? "failed" : "completed",
+          content: [textContent(cut(event.outcome.content))]
+        });
+        break;
+      }
+      case "server_tool": {
+        const input = event.call.input;
+        const query = typeof input?.query === "string" ? input.query : "";
+        const title = oneLine(`Search the web: ${query}`);
+        this.calls.add(event.call.id, title);
+        send({
+          sessionUpdate: "tool_call",
+          toolCallId: event.call.id,
+          title,
+          kind: "fetch",
+          status: event.result === void 0 ? "in_progress" : "completed"
+        });
+        if (event.result !== void 0) {
+          const lines = event.result.results.map((r) => `${r.title} ${r.url}`);
+          send({
+            sessionUpdate: "tool_call_update",
+            toolCallId: event.call.id,
+            status: event.result.error === void 0 ? "completed" : "failed",
+            content: [textContent(cut(event.result.error ?? lines.join("\n")))]
+          });
+        }
+        break;
+      }
+      case "notice":
+        this.channel.notice(event.text);
+        break;
+      case "compaction":
+        this.channel.notice("the conversation was summarised to fit the context window.");
+        break;
+      case "model_retry":
+        this.channel.notice(
+          `the model connection broke (${oneLine(event.reason)}). Retry ${event.attempt} of ${event.maxRetries}: the answer starts again below.`
+        );
+        break;
+      case "step_end":
+        break;
+    }
+  }
+  /**
+   * After a stop: wait (at most `ms`) until every running tool call reported its result. A call
+   * that has not reported by then ends here as failed and counts as cancelled, so no call stays
+   * "running" in the editor.
+   */
+  async settle(ms = SETTLE_MS) {
+    if (this.open.size > 0) {
+      await new Promise((resolve2) => {
+        const timer = setTimeout(resolve2, ms);
+        this.changed = () => {
+          if (this.open.size > 0) return;
+          clearTimeout(timer);
+          resolve2();
+        };
+      });
+      this.changed = () => {
+      };
+    }
+    for (const id of this.open) {
+      this.channel.noteCancelled(this.calls.title(id) ?? id);
+      this.channel.update({
+        sessionUpdate: "tool_call_update",
+        toolCallId: id,
+        status: "failed",
+        content: [textContent("Cancelled.")]
+      });
+    }
+    this.open.clear();
+  }
+};
+function cut(text) {
+  return text.length <= RESULT_MAX_CHARS ? text : `${text.slice(0, RESULT_MAX_CHARS)}
+[Garuda: cut at ${RESULT_MAX_CHARS} characters for the editor; the model has all of it]`;
+}
+
+// src/acp/approver.ts
+var DIFF_MAX_CHARS = 1e6;
+var DEFAULT_CHOICES = ["once", "session", "deny"];
+var KINDS2 = {
+  once: "allow_once",
+  session: "allow_always",
+  deny: "reject_once"
+};
+var NAMES = {
+  once: "Allow once",
+  // "Always" in Garuda is this session only (session rules), as in the terminal.
+  session: "Allow for this session",
+  deny: "Deny"
+};
+var AcpApprover = class {
+  constructor(channel, calls) {
+    this.channel = channel;
+    this.calls = calls;
+  }
+  channel;
+  calls;
+  questions = 0;
+  async ask(request, signal) {
+    const client = this.channel.current;
+    if (client === void 0 || signal.aborted) return "deny";
+    const known = request.callId === void 0 ? void 0 : this.calls.title(request.callId);
+    const toolCallId = known !== void 0 && request.callId !== void 0 ? request.callId : `garuda-question-${++this.questions}`;
+    const title = oneLine(request.title ?? known ?? headerText(request).replace(/:$/, ""));
+    if (known === void 0) {
+      this.channel.update({
+        sessionUpdate: "tool_call",
+        toolCallId,
+        title,
+        kind: "other",
+        status: "pending"
+      });
+    }
+    await this.channel.flush();
+    const choices = request.choices ?? DEFAULT_CHOICES;
+    const options = choices.map((choice) => ({
+      optionId: choice,
+      name: request.labels?.[choice] ?? NAMES[choice],
+      kind: KINDS2[choice]
+    }));
+    const answer = client.request("session/request_permission", {
+      sessionId: this.channel.sessionId,
+      toolCall: { toolCallId, title, status: "pending", content: questionContent(request) },
+      options
+    }).catch(() => void 0);
+    let onAbort;
+    const aborted = new Promise((resolve2) => {
+      onAbort = () => resolve2(void 0);
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+      const response = await Promise.race([answer, aborted]);
+      if (response === void 0 || response.outcome.outcome !== "selected") return "deny";
+      const picked = response.outcome.optionId;
+      return choices.find((c) => c === picked) ?? "deny";
+    } finally {
+      if (onAbort !== void 0) signal.removeEventListener("abort", onAbort);
+    }
+  }
+};
+function questionContent(request) {
+  const content = [];
+  const change = request.change;
+  if (change !== void 0 && (change.oldText?.length ?? 0) + change.newText.length <= DIFF_MAX_CHARS) {
+    content.push({
+      type: "diff",
+      path: change.path,
+      oldText: change.oldText,
+      newText: change.newText
+    });
+  }
+  const lines = [headerText(request)];
+  if (request.question !== void 0) lines.push(visible(request.question));
+  const preview = request.target.kind === "command" ? `$ ${request.preview}` : request.preview;
+  lines.push(visible(preview));
+  if (hasHidden(request.preview)) lines.push(HIDDEN_WARNING);
+  content.push(textContent(lines.join("\n")));
+  return content;
+}
+
+// src/acp/prompt.ts
+import { isAbsolute, relative, sep } from "path";
+import { fileURLToPath } from "url";
+var EMBEDDED_MAX_CHARS = 1e5;
+function promptText(blocks, root) {
+  const parts = [];
+  for (const block of blocks) {
+    switch (block.type) {
+      case "text":
+        parts.push(block.text);
+        break;
+      case "resource_link":
+        parts.push(linkText(block.uri, block.name, root));
+        break;
+      case "resource": {
+        const resource = block.resource;
+        if ("text" in resource) {
+          const text = resource.text.length <= EMBEDDED_MAX_CHARS ? resource.text : `${resource.text.slice(0, EMBEDDED_MAX_CHARS)}
+[Garuda: cut at ${EMBEDDED_MAX_CHARS} characters]`;
+          parts.push(`${resource.uri}:
+${fence(text)}`);
+        } else {
+          parts.push(`[Garuda: ${resource.uri} is binary; it was not attached]`);
+        }
+        break;
+      }
+      default:
+        parts.push(`[Garuda: a ${block.type} block was not attached; Garuda takes text only]`);
+    }
+  }
+  return parts.join("\n\n");
+}
+function linkText(uri, name, root) {
+  let path;
+  try {
+    path = uri.startsWith("file:") ? fileURLToPath(uri) : void 0;
+  } catch {
+    path = void 0;
+  }
+  if (path !== void 0) {
+    const inner = relative(root, path);
+    const inside = inner !== "" && !inner.startsWith("..") && !isAbsolute(inner);
+    if (inside && !/\s/.test(inner)) return `@${inner.split(sep).join("/")}`;
+  }
+  return `${name} (${uri})`;
+}
+function fence(text) {
+  const longest = Math.max(2, ...[...text.matchAll(/`+/g)].map((m) => m[0].length));
+  const mark = "`".repeat(longest + 1);
+  return `${mark}
+${text}
+${mark}`;
+}
+
+// src/acp/server.ts
+var INTERNAL_ERROR = -32603;
+var MODES = {
+  build: { name: "Build", description: "Edits and commands, each one asks first." },
+  plan: {
+    name: "Plan",
+    description: "Reads and plans. No edits; commands cannot write the project."
+  }
+};
+var STOP_REASONS = {
+  done: "end_turn",
+  max_tokens: "max_tokens",
+  refusal: "refusal",
+  max_steps: "max_turn_requests",
+  token_budget: "max_turn_requests",
+  repeated_calls: "max_turn_requests"
+};
+function acpServer(options) {
+  const sessions = /* @__PURE__ */ new Map();
+  const sessionOf = (id) => {
+    const session = sessions.get(id);
+    if (session === void 0) throw RequestError.resourceNotFound(`session:${id}`);
+    return session;
+  };
+  let connection;
+  const app = agent({ name: "garuda" }).onConnect((c) => {
+    connection = c.client;
+  }).onRequest(
+    methods.agent.initialize,
+    () => ({
+      protocolVersion: PROTOCOL_VERSION,
+      agentInfo: { name: "garuda", title: "Garuda", version: options.version },
+      agentCapabilities: {
+        loadSession: false,
+        promptCapabilities: { image: false, audio: false, embeddedContext: true },
+        mcpCapabilities: { http: false, sse: false }
+      },
+      // The keys come from the environment, as in the terminal.
+      authMethods: []
+    })
+  ).onRequest(methods.agent.authenticate, () => ({})).onRequest(methods.agent.session.new, async (c) => {
+    const root = c.params.cwd;
+    if (!isAbsolute2(root) || !isFolder(root)) {
+      throw RequestError.invalidParams(
+        void 0,
+        `cwd must be an absolute path to a folder: ${root}`
+      );
+    }
+    const id = randomUUID();
+    const channel = new SessionChannel(id);
+    const calls = new KnownCalls();
+    const events = new EventMapper(channel, calls, root);
+    let runtime;
+    try {
+      runtime = await options.createRuntime({
+        root,
+        approver: new AcpApprover(channel, calls),
+        onEvent: (event) => events.event(event),
+        onNotice: (text) => channel.notice(text)
+      });
+    } catch (error) {
+      throw new RequestError(INTERNAL_ERROR, error.message);
+    }
+    if (runtime.executorNotice !== void 0) channel.notice(runtime.executorNotice);
+    const skipped = editorServers(c.params.mcpServers);
+    if (skipped !== void 0) channel.notice(skipped);
+    sessions.set(id, { id, root, runtime, channel, events });
+    setImmediate(() => {
+      void connection?.notify("session/update", {
+        sessionId: id,
+        update: {
+          sessionUpdate: "available_commands_update",
+          availableCommands: commandsOf(runtime)
+        }
+      }).catch(() => {
+      });
+    });
+    return { sessionId: id, modes: modesOf(runtime.mode) };
+  }).onRequest(methods.agent.session.setMode, (c) => {
+    const session = sessionOf(c.params.sessionId);
+    const mode = c.params.modeId;
+    if (mode !== "build" && mode !== "plan") {
+      throw RequestError.invalidParams(void 0, `Unknown mode "${mode}": use build or plan.`);
+    }
+    session.runtime.setMode(mode);
+    return {};
+  }).onNotification(methods.agent.session.cancel, (c) => {
+    const session = sessions.get(c.params.sessionId);
+    if (session?.running === void 0) return;
+    session.channel.cancel();
+    session.running.abort();
+  }).onRequest(methods.agent.session.prompt, async (c) => {
+    const session = sessionOf(c.params.sessionId);
+    if (session.running !== void 0) {
+      throw RequestError.invalidRequest(
+        void 0,
+        "A prompt is already running in this session."
+      );
+    }
+    const controller = new AbortController();
+    session.running = controller;
+    const onCancel = () => {
+      session.channel.cancel();
+      controller.abort();
+    };
+    c.signal.addEventListener("abort", onCancel, { once: true });
+    session.channel.open(c.client);
+    try {
+      return {
+        stopReason: await turn(
+          session,
+          promptText(c.params.prompt, session.root),
+          controller.signal
+        )
+      };
+    } finally {
+      c.signal.removeEventListener("abort", onCancel);
+      session.running = void 0;
+      await session.channel.close();
+    }
+  });
+  return {
+    app,
+    async serve(output, input) {
+      await app.connect(ndJsonStream(output, input)).closed;
+    },
+    shutdown() {
+      for (const session of sessions.values()) session.runtime.executor.shutdown();
+    },
+    async close() {
+      for (const session of sessions.values()) {
+        session.running?.abort();
+        await session.runtime.close().catch(() => {
+        });
+        session.runtime.executor.shutdown();
+      }
+      sessions.clear();
+    }
+  };
+}
+async function turn(session, text, signal) {
+  const { runtime, channel, events } = session;
+  let prompt = text;
+  const command = /^\/([A-Za-z0-9][\w:.-]*)(?:\s|$)/.exec(text.trim());
+  if (command !== null) {
+    const name = command[1];
+    if (BUILTIN_COMMANDS.includes(name)) {
+      channel.notice(
+        name === "plan" ? "use the editor's mode menu (Plan) for plan mode." : `/${name} is a terminal command; it is not available in editors yet.`
+      );
+      return "end_turn";
+    }
+    const resolved = await runtime.resolveCommand(text.trim(), signal);
+    if (resolved.kind === "denied") {
+      channel.notice(resolved.message);
+      return "end_turn";
+    }
+    if (resolved.kind === "prompt") prompt = resolved.prompt;
+  }
+  try {
+    const result = await runtime.runTurn(prompt, signal);
+    return STOP_REASONS[result.stopReason];
+  } catch (error) {
+    if (signal.aborted) {
+      runtime.recordStop("interrupted");
+      await events.settle();
+      const calls = channel.takeCancelled();
+      channel.notice(
+        calls.length === 0 ? "the turn was cancelled." : calls.map((title) => `${title} cancelled.`).join("\n")
+      );
+      return "cancelled";
+    }
+    runtime.recordStop("error");
+    throw new RequestError(INTERNAL_ERROR, error.message);
+  }
+}
+function modesOf(current) {
+  return {
+    currentModeId: current,
+    availableModes: Object.keys(MODES).map((id) => ({ id, ...MODES[id] }))
+  };
+}
+function commandsOf(runtime) {
+  const list = [];
+  for (const skill of runtime.skills.filter((s) => s.userInvocable)) {
+    list.push({
+      name: skill.name,
+      description: skill.description,
+      ...skill.argumentHint === void 0 ? {} : { input: { hint: skill.argumentHint } }
+    });
+  }
+  for (const command of runtime.commands) {
+    if (list.some((c) => c.name === command.name)) continue;
+    list.push({
+      name: command.name,
+      description: command.description ?? `/${command.name} (${command.source} command)`,
+      ...command.argumentHint === void 0 ? {} : { input: { hint: command.argumentHint } }
+    });
+  }
+  return list;
+}
+function editorServers(servers) {
+  if (servers.length === 0) return void 0;
+  const names = servers.map((s) => s.name).join(", ");
+  return `the editor's MCP servers are not started in this version (${names}). Garuda's own MCP servers (~/.garuda/mcp.json and the project's) work as in the terminal.`;
+}
+function isFolder(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+export {
+  acpServer
+};
+//# sourceMappingURL=server-R3GNIC33.js.map

package/dist/servers-6YDGWOZ6.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  LSP_LANGUAGES,
+  MANAGED,
+  SERVERS,
+  discoverServer,
+  findServer,
+  isTypeScript7,
+  languageOf,
+  managedDir,
+  managedLabel
+} from "./chunk-EU7PA45O.js";
+export {
+  LSP_LANGUAGES,
+  MANAGED,
+  SERVERS,
+  discoverServer,
+  findServer,
+  isTypeScript7,
+  languageOf,
+  managedDir,
+  managedLabel
+};
+//# sourceMappingURL=servers-6YDGWOZ6.js.map

package/dist/text-J2GD647J.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  jobPrompt,
+  jobReport
+} from "./chunk-YQTGMCU6.js";
+import "./chunk-OUCV3FCT.js";
+export {
+  jobPrompt,
+  jobReport
+};
+//# sourceMappingURL=text-J2GD647J.js.map