@garuda-agent/garuda 0.18.0 → 0.18.1

package/dist/chunk-TLA2PDGM.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+import {
+  summariseCall,
+  summariseResult
+} from "./chunk-DQSCCE77.js";
+import {
+  hasReceipt
+} from "./chunk-4QRTTRVK.js";
+import {
+  serverCallText,
+  serverResultSummary
+} from "./chunk-A2QAIRQL.js";
+import {
+  receiptText
+} from "./chunk-2OYTNNUJ.js";
+
+// src/cli/exportHtml.ts
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var OUTPUT_CHARS = 4e3;
+var cutOutput = (text) => text.length <= OUTPUT_CHARS ? text : `${text.slice(0, OUTPUT_CHARS)}
+\u2026 ${text.length - OUTPUT_CHARS} more characters in the session file.`;
+function callChange(call) {
+  const input = call.input ?? {};
+  const lines = (text, sign) => typeof text === "string" ? text.split("\n").map((l) => `${sign}${l}`) : [];
+  if (call.name === "edit_file") {
+    return [...lines(input.old_string, "-"), ...lines(input.new_string, "+")].join("\n");
+  }
+  if (call.name === "write_file") return lines(input.content, "+").join("\n");
+  return void 0;
+}
+function diffHtml(text) {
+  return text.split("\n").map((line) => {
+    const cls = line.startsWith("+") ? "add" : line.startsWith("-") ? "del" : "ctx";
+    return `<span class="${cls}">${escapeHtml(line)}</span>`;
+  }).join("\n");
+}
+var STYLE = `
+:root { --bg: #fbf7ef; --fg: #222; --dim: #6b6b6b; --line: #e4dccb; --accent: #d97706;
+  --add: #e6f4e6; --addfg: #17602a; --del: #fbe7e7; --delfg: #8f1d1d; --you: #0e7490; }
+@media (prefers-color-scheme: dark) { :root { --bg: #1d1d1b; --fg: #e8e4dc; --dim: #a19c92;
+  --line: #3a3833; --add: #183522; --addfg: #9ee2ad; --del: #3b1d1d; --delfg: #f4a9a9; } }
+body { background: var(--bg); color: var(--fg); font: 15px/1.55 system-ui, sans-serif;
+  max-width: 920px; margin: 32px auto; padding: 0 16px; }
+h1 { font-size: 20px; } .meta { color: var(--dim); font-size: 13px; }
+.you { border-left: 4px solid var(--you); padding: 4px 12px; margin: 24px 0 8px; font-weight: 600;
+  white-space: pre-wrap; }
+.answer { white-space: pre-wrap; margin: 8px 0; }
+.answer::before { content: "\u2726 "; color: var(--accent); }
+details { border: 1px solid var(--line); border-radius: 6px; margin: 6px 0; padding: 4px 10px; }
+summary { cursor: pointer; font-family: ui-monospace, monospace; font-size: 13px; }
+pre { font: 12.5px/1.45 ui-monospace, monospace; white-space: pre-wrap; overflow-wrap: anywhere;
+  margin: 6px 0; }
+.add { background: var(--add); color: var(--addfg); display: inline-block; width: 100%; }
+.del { background: var(--del); color: var(--delfg); display: inline-block; width: 100%; }
+.receipt { border: 1px solid var(--accent); border-radius: 6px; padding: 6px 10px; }
+.note { color: var(--dim); font-style: italic; }
+.failed summary { color: var(--delfg); }
+`;
+function sessionHtml(records, sessionId) {
+  const body = [];
+  const start = records.find((r) => r.type === "start");
+  body.push(`<h1>Garuda session ${escapeHtml(sessionId)}</h1>`);
+  if (start?.type === "start") {
+    body.push(
+      `<p class="meta">${escapeHtml(start.root)} \xB7 ${escapeHtml(start.model)} \xB7 ${escapeHtml(start.t)}</p>`
+    );
+  }
+  const calls = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    switch (record.type) {
+      case "user": {
+        const prompt = record.message.content[0];
+        body.push(
+          `<div class="you">${escapeHtml(prompt?.type === "text" ? prompt.text : "")}</div>`
+        );
+        break;
+      }
+      case "assistant":
+        for (const block of record.response.content) {
+          if (block.type === "text" && block.text.trim() !== "") {
+            body.push(`<div class="answer">${escapeHtml(block.text.trim())}</div>`);
+          }
+          if (block.type === "tool_use") calls.set(block.id, block);
+          if (block.type === "server_tool_result") {
+            const call = record.response.content.find(
+              (b) => b.type === "server_tool_use" && b.id === block.toolUseId
+            );
+            const query = call?.type === "server_tool_use" ? ` ${serverCallText(call)}` : "";
+            const pages = block.results.map((r) => `${r.title}
+  ${r.url}`).join("\n");
+            body.push(
+              `<details><summary>${escapeHtml(`\u25CF ${block.name} (Claude)${query} \u2192 ${serverResultSummary(block)}`)}</summary><pre>${escapeHtml(pages)}</pre></details>`
+            );
+          }
+        }
+        break;
+      case "tool_results":
+        for (const block of record.message.content) {
+          if (block.type !== "tool_result") continue;
+          const call = calls.get(block.toolUseId);
+          if (call === void 0) continue;
+          const summary = summariseResult(call, { content: block.content, isError: block.isError });
+          const head = `\u25CF ${[call.name, summariseCall(call)].filter((p) => p !== "").join(" ")} \u2192 ${block.isError ? `failed: ${summary}` : summary}`;
+          const change = callChange(call);
+          const inner = change === void 0 ? `<pre>${escapeHtml(cutOutput(block.content))}</pre>` : `<pre>${diffHtml(cutOutput(change))}</pre>`;
+          body.push(
+            `<details${block.isError ? ' class="failed"' : ""}><summary>${escapeHtml(head)}</summary>${inner}</details>`
+          );
+        }
+        break;
+      case "receipt":
+        if (hasReceipt(record.receipt)) {
+          body.push(`<pre class="receipt">${escapeHtml(receiptText(record.receipt))}</pre>`);
+        }
+        break;
+      case "undo":
+        body.push('<p class="note">/undo: the last turn was taken back.</p>');
+        break;
+      case "redo":
+        body.push('<p class="note">/redo: the turn came back.</p>');
+        break;
+      case "compaction":
+        body.push('<p class="note">The conversation was compacted here.</p>');
+        break;
+      case "fork":
+        body.push(
+          `<p class="note">This session starts as a fork of session ${escapeHtml(record.from.sessionId)}, at turn ${record.from.turn}.</p>`
+        );
+        break;
+      default:
+        break;
+    }
+  }
+  return [
+    "<!doctype html>",
+    '<html lang="en"><head><meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    // No script may run, and nothing loads from outside: the page's own policy says so too.
+    `<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'">`,
+    `<title>Garuda session ${escapeHtml(sessionId)}</title>`,
+    `<style>${STYLE}</style></head><body>`,
+    ...body,
+    "</body></html>",
+    ""
+  ].join("\n");
+}
+
+export {
+  escapeHtml,
+  OUTPUT_CHARS,
+  callChange,
+  sessionHtml
+};
+//# sourceMappingURL=chunk-TLA2PDGM.js.map

package/dist/{chunk-5B5HDTUR.js → chunk-TWQ7V2L6.js}

@@ -2,7 +2,7 @@
 import {
   hostCommand,
   shellWord
-} from "./chunk-6XHON3Q6.js";
+} from "./chunk-QXTHEFKP.js";
 import {
   JOBS_DIR
 } from "./chunk-VTMD5IHD.js";
@@ -154,4 +154,4 @@ export {
   nightAgentTime,
   removeAgent
 };
-//# sourceMappingURL=chunk-5B5HDTUR.js.map
+//# sourceMappingURL=chunk-TWQ7V2L6.js.map

package/dist/chunk-ULAJPMY7.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import {
+  cleanLine
+} from "./chunk-PZS3V6P3.js";
+import {
+  formatRule
+} from "./chunk-3NJNVZTK.js";
+
+// src/permissions/projectSettings.ts
+import { createHash } from "crypto";
+function settingsRisk(settings) {
+  const risk = {
+    executorHost: settings.executor === "host",
+    allow: settings.allow.map(formatRule),
+    writePaths: [...settings.sandbox?.writePaths ?? []],
+    envAllow: [...settings.envAllow],
+    allowLocalhost: settings.web?.allowLocalhost === true
+  };
+  const formatterCommands = Object.entries(settings.formatters?.commands ?? {}).flatMap(
+    ([name, f]) => f === false ? [] : [`${name}: ${f.command.join(" ")}`]
+  );
+  if (formatterCommands.length > 0) risk.formatterCommands = formatterCommands;
+  const none = !risk.executorHost && risk.allow.length === 0 && risk.writePaths.length === 0 && risk.envAllow.length === 0 && !risk.allowLocalhost && risk.formatterCommands === void 0;
+  return none ? void 0 : risk;
+}
+function settingsRiskHash(risk) {
+  return createHash("sha256").update(JSON.stringify(risk)).digest("hex");
+}
+function settingsRiskLines(risk) {
+  const lines = [];
+  if (risk.executorHost) lines.push('executor: "host" (commands run with no OS sandbox)');
+  if (risk.allow.length > 0) {
+    lines.push(`permissions.allow (no question for these): ${risk.allow.join(", ")}`);
+  }
+  if (risk.writePaths.length > 0) {
+    lines.push(`sandbox.writePaths (commands may write there): ${risk.writePaths.join(", ")}`);
+  }
+  if (risk.envAllow.length > 0) {
+    lines.push(`env.allow (commands see these variables): ${risk.envAllow.join(", ")}`);
+  }
+  if (risk.allowLocalhost) lines.push("web.allowLocalhost (web_fetch may reach this machine)");
+  if (risk.formatterCommands !== void 0) {
+    lines.push(
+      `formatters.commands (run after each edit): ${risk.formatterCommands.map(cleanLine).join("; ")}`
+    );
+  }
+  return lines;
+}
+function withoutRisk(settings) {
+  const { sandbox, web, formatters, ...rest } = settings;
+  const { writePaths: _writePaths, ...sandboxRest } = sandbox ?? {};
+  const keptCommands = Object.fromEntries(
+    Object.entries(formatters?.commands ?? {}).filter(([, f]) => f === false)
+  );
+  return {
+    ...rest,
+    ...formatters === void 0 ? {} : { formatters: { ...formatters, commands: keptCommands } },
+    executor: settings.executor === "host" ? "auto" : settings.executor,
+    allow: [],
+    envAllow: [],
+    ...sandbox === void 0 ? {} : { sandbox: sandboxRest },
+    ...web === void 0 ? {} : { web: { ...web, allowLocalhost: false } }
+  };
+}
+async function gateProjectSettings(options) {
+  const risk = settingsRisk(options.settings);
+  if (risk === void 0) return { settings: options.settings };
+  const hash = settingsRiskHash(risk);
+  const known = options.trust?.settingsHash(options.root);
+  if (known === hash) return { settings: options.settings };
+  const lines = settingsRiskLines(risk);
+  if (options.ask !== void 0) {
+    const choice = await options.ask({
+      tool: "settings",
+      target: { kind: "input", json: "" },
+      title: "Project settings that loosen safety",
+      preview: [
+        `This project's .garuda/settings.json ${known === void 0 ? "asks for" : "changed and now asks for"}:`,
+        ...lines.map((line) => `  - ${line}`),
+        "A cloned repository can ship this file. Without your yes, Garuda uses safe defaults for these",
+        "parts; the rest of the file applies."
+      ].join("\n"),
+      isolation: options.isolation ?? "os",
+      question: "Use these project settings?",
+      choices: ["once", "session", "deny"],
+      labels: {
+        once: "Yes, for this run",
+        session: "Yes, and remember (asks again when they change)",
+        deny: "No, use safe defaults"
+      }
+    });
+    if (choice === "session") await options.trust?.setSettingsHash(options.root, hash);
+    if (choice !== "deny") return { settings: options.settings };
+  }
+  return {
+    settings: withoutRisk(options.settings),
+    notice: [
+      `Project settings not applied (not approved): ${lines.join("; ")}.`,
+      "Start the chat in a terminal and answer yes to use them."
+    ].join(" ")
+  };
+}
+
+export {
+  gateProjectSettings
+};
+//# sourceMappingURL=chunk-ULAJPMY7.js.map

package/dist/chunk-VISKX36R.js

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+
+// src/cli/approver.ts
+import { styleText } from "util";
+
+// src/cli/diffView.ts
+var SIDE_BY_SIDE_COLUMNS = 140;
+function tokens(line) {
+  return line.match(/\s+|[\p{L}\p{N}_]+|[^\s\p{L}\p{N}_]/gu) ?? [];
+}
+var MAX_CELLS = 4e4;
+function wordDiff(a, b) {
+  const x = tokens(a);
+  const y = tokens(b);
+  if (x.length * y.length > MAX_CELLS || x.length + y.length === 0) return void 0;
+  const n = x.length;
+  const m = y.length;
+  const table = new Uint16Array((n + 1) * (m + 1));
+  const at = (i2, j2) => i2 * (m + 1) + j2;
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      table[at(i2, j2)] = x[i2] === y[j2] ? (table[at(i2 + 1, j2 + 1)] ?? 0) + 1 : Math.max(table[at(i2 + 1, j2)] ?? 0, table[at(i2, j2 + 1)] ?? 0);
+    }
+  }
+  const common = table[at(0, 0)] ?? 0;
+  const solid = (t) => t.filter((s) => s.trim() !== "").length;
+  if (common === 0 || common / Math.max(1, Math.max(solid(x), solid(y))) < 0.4) return void 0;
+  const outA = [];
+  const outB = [];
+  let i = 0;
+  let j = 0;
+  while (i < n || j < m) {
+    if (i < n && j < m && x[i] === y[j]) {
+      outA.push({ text: x[i], changed: false });
+      outB.push({ text: y[j], changed: false });
+      i++;
+      j++;
+    } else if (j < m && (i >= n || (table[at(i, j + 1)] ?? 0) >= (table[at(i + 1, j)] ?? 0))) {
+      outB.push({ text: y[j], changed: true });
+      j++;
+    } else {
+      outA.push({ text: x[i], changed: true });
+      i++;
+    }
+  }
+  return { a: outA, b: outB };
+}
+function paintParts(parts, base, paint) {
+  const runs = [];
+  for (const p of parts) {
+    const last = runs.at(-1);
+    if (last !== void 0 && last.changed === p.changed) last.text += p.text;
+    else runs.push({ ...p });
+  }
+  return runs.map(
+    (r) => r.changed && r.text.trim() !== "" ? paint([base, "inverse"], r.text) : paint([base], r.text)
+  ).join("");
+}
+function unifiedDiff(text, paint) {
+  const lines = text.split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (isFileHeader(line)) {
+      out.push(paint(["bold"], line));
+      i++;
+      continue;
+    }
+    if (line.startsWith("@@")) {
+      out.push(paint(["cyan"], line));
+      i++;
+      continue;
+    }
+    if (line.startsWith("-")) {
+      const removed = [];
+      while (i < lines.length && isRemoved(lines[i])) removed.push(lines[i++]);
+      const added = [];
+      while (i < lines.length && isAdded(lines[i])) added.push(lines[i++]);
+      const marks = removed.map((r, k) => {
+        const a = added[k];
+        return a === void 0 ? void 0 : wordDiff(r.slice(1), a.slice(1));
+      });
+      removed.forEach((r, k) => {
+        const m = marks[k];
+        out.push(
+          m === void 0 ? paint(["red"], r) : paint(["red"], "-") + paintParts(m.a, "red", paint)
+        );
+      });
+      added.forEach((a, k) => {
+        const m = marks[k];
+        out.push(
+          m === void 0 ? paint(["green"], a) : paint(["green"], "+") + paintParts(m.b, "green", paint)
+        );
+      });
+      continue;
+    }
+    out.push(line.startsWith("+") ? paint(["green"], line) : line);
+    i++;
+  }
+  return out.join("\n");
+}
+var isFileHeader = (line) => line.startsWith("+++") || line.startsWith("---") || line.startsWith("diff --git");
+var isRemoved = (line) => line.startsWith("-") && !line.startsWith("---");
+var isAdded = (line) => line.startsWith("+") && !line.startsWith("+++");
+function fitWidth(text, width) {
+  const chars = [...text];
+  if (chars.length > width) return `${chars.slice(0, Math.max(0, width - 1)).join("")}\u2026`;
+  return text + " ".repeat(width - chars.length);
+}
+function sideBySide(text, columns, paint) {
+  const half = Math.floor((columns - 3) / 2);
+  const body = half - 6;
+  const out = [];
+  let oldNo = 0;
+  let newNo = 0;
+  const cell = (no, mark, content, style) => {
+    const head = no === void 0 ? "     " : String(no).padStart(4);
+    const shown = fitWidth(`${mark}${content}`, body + 1);
+    return `${paint(["dim"], head)} ${style === void 0 ? shown : paint([style], shown)}`;
+  };
+  const markedCell = (no, sign, parts, style) => {
+    let room = body;
+    const kept = [];
+    for (const p of parts) {
+      if (room <= 0) break;
+      const chars = [...p.text];
+      const piece = chars.length > room ? `${chars.slice(0, Math.max(0, room - 1)).join("")}\u2026` : p.text;
+      kept.push({ text: piece, changed: p.changed });
+      room -= [...piece].length;
+    }
+    const pad = " ".repeat(Math.max(0, room));
+    return `${paint(["dim"], String(no).padStart(4))} ${paint([style], sign)}${paintParts(kept, style, paint)}${pad}`;
+  };
+  const empty = " ".repeat(half);
+  const lines = text.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (isFileHeader(line)) {
+      out.push(paint(["bold"], line));
+      i++;
+      continue;
+    }
+    const hunk = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
+    if (hunk !== null) {
+      oldNo = Number(hunk[1]);
+      newNo = Number(hunk[2]);
+      out.push(paint(["cyan"], line));
+      i++;
+      continue;
+    }
+    if (isRemoved(line) || isAdded(line)) {
+      const removed = [];
+      while (i < lines.length && isRemoved(lines[i])) removed.push(lines[i++]);
+      const added = [];
+      while (i < lines.length && isAdded(lines[i])) added.push(lines[i++]);
+      for (let k = 0; k < Math.max(removed.length, added.length); k++) {
+        const r = removed[k];
+        const a = added[k];
+        const m = r !== void 0 && a !== void 0 ? wordDiff(r.slice(1), a.slice(1)) : void 0;
+        const left = r === void 0 ? empty : m !== void 0 ? markedCell(oldNo++, "-", m.a, "red") : cell(oldNo++, "-", r.slice(1), "red");
+        const right = a === void 0 ? "" : m !== void 0 ? markedCell(newNo++, "+", m.b, "green") : cell(newNo++, "+", a.slice(1), "green");
+        out.push(`${left} ${paint(["dim"], "\u2502")} ${right}`.trimEnd());
+      }
+      continue;
+    }
+    if (line.startsWith("\\")) {
+      out.push(paint(["dim"], line));
+      i++;
+      continue;
+    }
+    if (i === lines.length - 1 && line === "") break;
+    const content = line.startsWith(" ") ? line.slice(1) : line;
+    out.push(
+      `${cell(oldNo++, " ", content)} ${paint(["dim"], "\u2502")} ${cell(newNo++, " ", content)}`.trimEnd()
+    );
+    i++;
+  }
+  return out.join("\n");
+}
+function terminalDiff(text, columns, paint) {
+  if (hunkCount(text) === 0) return plainColours(text, paint);
+  return columns !== void 0 && columns >= SIDE_BY_SIDE_COLUMNS ? sideBySide(text, columns, paint) : unifiedDiff(text, paint);
+}
+function plainColours(text, paint) {
+  return text.split("\n").map(
+    (line) => isFileHeader(line) ? paint(["bold"], line) : line.startsWith("+") ? paint(["green"], line) : line.startsWith("-") ? paint(["red"], line) : line
+  ).join("\n");
+}
+function hunkCount(text) {
+  return text.split("\n").filter((line) => line.startsWith("@@")).length;
+}
+
+// src/cli/approver.ts
+var TerminalApprover = class {
+  /** Set by the CLI: it aborts the current turn. */
+  onInterrupt = () => {
+  };
+  /** One question at a time (0.14.1, review): two prompts at once mixed their keys. */
+  ask(request, signal) {
+    const next = this.asking === 0 ? this.askNow(request, signal) : this.queue.then(() => this.askNow(request, signal));
+    this.asking++;
+    this.queue = next.catch(() => {
+    }).finally(() => {
+      this.asking--;
+    });
+    return next;
+  }
+  asking = 0;
+  queue = Promise.resolve();
+  async askNow(request, signal) {
+    signal.throwIfAborted();
+    const out = process.stderr;
+    out.write(`
+${header(request)}
+${colorPreview(request, out.columns)}
+`);
+    if (!process.stdin.isTTY) {
+      out.write("No terminal to ask for approval, so Garuda denies this call.\n");
+      return "deny";
+    }
+    const sessionLabel = request.labels?.session ?? (request.target.kind === "command" ? "Yes, and allow this exact command for this session" : request.target.kind === "url" ? `Yes, and allow ${request.target.host} for this session` : `Yes, and allow all ${request.tool} calls for this session`);
+    const { select } = await import("@inquirer/prompts");
+    try {
+      return await select(
+        {
+          message: request.question ?? "Allow?",
+          choices: [
+            { name: request.labels?.once ?? "Yes, once", value: "once" },
+            { name: sessionLabel, value: "session" },
+            { name: request.labels?.deny ?? "No, deny", value: "deny" }
+          ].filter((c) => request.choices?.includes(c.value) ?? true)
+        },
+        { signal, output: out }
+      );
+    } catch (error) {
+      if (error.name === "ExitPromptError") this.onInterrupt();
+      throw error;
+    }
+  }
+};
+var SwitchApprover = class {
+  constructor(current) {
+    this.current = current;
+  }
+  current;
+  /** Called before each question: the chat's notifier (0.6). */
+  onAsk = () => {
+  };
+  ask(request, signal) {
+    this.onAsk(request);
+    return this.current.ask(request, signal);
+  }
+};
+function visible(text) {
+  return text.replace(/[\u0000-\u0008\u000b-\u001f]/g, (c) => String.fromCodePoint(9216 + c.charCodeAt(0))).replace(/\u007f/g, "\u2421").replace(
+    /[\u0080-\u009f\u200b-\u200f\u202a-\u202e\u2060-\u2064\u2066-\u2069\ufeff\u{e0000}-\u{e007f}]/gu,
+    (c) => `[U+${(c.codePointAt(0) ?? 0).toString(16).toUpperCase().padStart(4, "0")}]`
+  );
+}
+function hasHidden(text) {
+  return visible(text) !== text;
+}
+var HIDDEN_WARNING = "! This holds hidden or control characters, shown as \u240D, \u241B or [U+\u2026]. Read it with care.";
+function headerText(request) {
+  const { tool, target, isolation } = request;
+  if (request.title !== void 0) return visible(request.title);
+  if (target.kind === "command") {
+    const where = isolation === "none" ? "on your machine, no sandbox" : target.outsideSandbox ? "OUTSIDE the sandbox: network on, writes anywhere" : `sandbox: ${isolation}`;
+    return `${tool} wants to run a command (${where}):`;
+  }
+  if (target.kind === "input") return `${tool} wants to run with this input:`;
+  if (target.kind === "url") return `${tool} wants to fetch from ${visible(target.host)}:`;
+  return `${tool} wants to change ${visible(target.path)}:`;
+}
+function header(request) {
+  return styleText("bold", headerText(request));
+}
+function colorPreview({ target, preview }, columns) {
+  const warning = hasHidden(preview) ? `
+${styleText("yellow", `  ${HIDDEN_WARNING}`)}` : "";
+  if (target.kind === "command") return `${styleText("cyan", `  $ ${visible(preview)}`)}${warning}`;
+  if (target.kind === "url") return `${visible(preview)}${warning}`;
+  return `${colorDiff(visible(preview), columns)}${warning}`;
+}
+var terminalPaint = (styles, text) => styles.length === 0 ? text : styleText([...styles], text);
+function colorDiff(text, columns, paint = terminalPaint) {
+  return terminalDiff(text, columns, paint);
+}
+
+export {
+  unifiedDiff,
+  hunkCount,
+  TerminalApprover,
+  SwitchApprover,
+  visible,
+  hasHidden,
+  HIDDEN_WARNING,
+  headerText,
+  header,
+  colorPreview,
+  terminalPaint,
+  colorDiff
+};
+//# sourceMappingURL=chunk-VISKX36R.js.map

package/dist/{chunk-55CFEEIN.js → chunk-WK5NE6RY.js}

@@ -2,7 +2,7 @@
 import {
   JobGitError,
   git
-} from "./chunk-6XHON3Q6.js";
+} from "./chunk-QXTHEFKP.js";
 import {
   inWriteScope
 } from "./chunk-UIRJOQQS.js";
@@ -155,4 +155,4 @@ export {
   outsideScope,
   jobChanges
 };
-//# sourceMappingURL=chunk-55CFEEIN.js.map
+//# sourceMappingURL=chunk-WK5NE6RY.js.map

package/dist/chunk-Y62J7PTD.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import {
+  folderKind
+} from "./chunk-42DSA4EA.js";
+import {
+  detectTestCommand
+} from "./chunk-AOGFYUKG.js";
+
+// src/cli/tour.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+function detectStack(root, profiles) {
+  const has = (name) => existsSync(join(root, name));
+  const test = detectTestCommand(root, profiles);
+  const withTest = (label) => test === void 0 ? { label } : { label, test };
+  if (has("package.json")) {
+    let deps = {};
+    try {
+      const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+      deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    } catch {
+    }
+    const language = has("tsconfig.json") || "typescript" in deps ? "TypeScript" : "JavaScript";
+    const runner = ["vitest", "jest", "mocha"].find((r) => r in deps);
+    const manager = has("pnpm-lock.yaml") ? "pnpm" : has("yarn.lock") ? "yarn" : has("bun.lockb") ? "bun" : "npm";
+    const app = "react-native" in deps ? " (React Native)" : "expo" in deps ? " (Expo)" : "";
+    return withTest(
+      `${language}${app}${runner === void 0 ? "" : ` with ${runner}`} (${manager})`
+    );
+  }
+  const profile = profiles[0];
+  if (profile !== void 0) return withTest(profile.label);
+  if (has("go.mod")) return withTest("Go");
+  if (has("Cargo.toml")) return withTest("Rust");
+  return void 0;
+}
+function tourPrompts(stack) {
+  return [
+    "Explain how this repository is laid out, in 10 lines or fewer.",
+    stack.test === void 0 ? "Find the riskiest function in this codebase and say why, in 5 lines." : `Run the tests (${stack.test}) and explain any failure.`,
+    "Find one function that has no test, and write a test for it."
+  ];
+}
+function tourText(stack, prompts) {
+  return [
+    `This looks like ${stack.label}. Some first tasks:`,
+    ...prompts.map((p, i) => `  ${i + 1}. ${p}`),
+    "Type a number, or your own task."
+  ].join("\n");
+}
+var rootKey = (root) => createHash("sha256").update(root).digest("hex").slice(0, 16);
+var MAX_TOURED = 200;
+async function firstRunTour(root, home, profiles) {
+  if (folderKind(root) !== "code") return void 0;
+  const stack = detectStack(root, profiles);
+  if (stack === void 0) return void 0;
+  const file = join(home, ".garuda", "ui.json");
+  let data = {};
+  try {
+    data = JSON.parse(await readFile(file, "utf8"));
+  } catch {
+  }
+  const toured = Array.isArray(data.toured) ? data.toured.filter((t) => typeof t === "string") : [];
+  const key = rootKey(root);
+  if (toured.includes(key)) return void 0;
+  try {
+    await mkdir(join(home, ".garuda"), { recursive: true, mode: 448 });
+    const next = { ...data, toured: [...toured, key].slice(-MAX_TOURED) };
+    await writeFile(file, `${JSON.stringify(next)}
+`, { mode: 384 });
+  } catch {
+  }
+  const prompts = tourPrompts(stack);
+  return { text: tourText(stack, prompts), prompts };
+}
+function tourChoice(input, prompts) {
+  const n = /^\s*([1-9])\s*$/.exec(input)?.[1];
+  return prompts !== void 0 && n !== void 0 ? prompts[Number(n) - 1] ?? input : input;
+}
+
+export {
+  detectStack,
+  tourPrompts,
+  tourText,
+  firstRunTour,
+  tourChoice
+};
+//# sourceMappingURL=chunk-Y62J7PTD.js.map