@garuda-agent/garuda 0.0.1 → 0.14.1

package/dist/run-66Y6R2KU.js

@@ -0,0 +1,886 @@
+#!/usr/bin/env node
+import {
+  BUILTIN_COMMANDS,
+  loadSearchConfig,
+  providerLabel,
+  saveSearchUse
+} from "./chunk-KWRJREUH.js";
+import {
+  SERVER_NAME,
+  checkServerUrl
+} from "./chunk-ZAE25JM2.js";
+import "./chunk-ATW7BNIG.js";
+import {
+  folderKind
+} from "./chunk-42DSA4EA.js";
+
+// src/init/run.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+
+// src/init/plan.ts
+import { existsSync, readFileSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+var GITIGNORE_LINES = [".garuda/sessions/", ".garuda/index/", ".garuda/evals/"];
+function buildPlan(items, options) {
+  const { root, home } = options;
+  const lines = [];
+  const writes = [];
+  const instructions2 = items.filter((i) => i.kind === "instructions");
+  for (const scope of ["user", "project"]) {
+    const file = scope === "user" ? join(home, ".garuda", "mcp.json") : join(root, ".garuda", "mcp.json");
+    const shown = scope === "user" ? "~/.garuda/mcp.json" : ".garuda/mcp.json";
+    const servers = {};
+    for (const item of items.filter((i) => i.kind === "mcp" && i.scope === scope)) {
+      if (existsSync(file)) {
+        lines.push({ item, reason: `${shown} exists; add it there by hand` });
+      } else if (item.name in servers) {
+        lines.push({ item, reason: `a server named "${item.name}" is already in the list` });
+      } else {
+        servers[item.name] = item.def;
+        lines.push({ item, target: shown });
+      }
+    }
+    if (Object.keys(servers).length > 0) {
+      writes.push({
+        path: file,
+        shown,
+        content: `${JSON.stringify({ servers }, null, 2)}
+`,
+        mode: "new"
+      });
+    }
+  }
+  const taken = /* @__PURE__ */ new Set();
+  for (const item of items.filter((i) => i.kind === "command")) {
+    const base = item.scope === "user" ? join(home, ".garuda", "commands") : join(root, ".garuda", "commands");
+    const rel = `${item.name.split(":").join("/")}.md`;
+    const file = join(base, rel);
+    const shown = `${item.scope === "user" ? "~/" : ""}.garuda/commands/${rel}`;
+    const key = `${item.scope}:${item.name}`;
+    if (BUILTIN_COMMANDS.includes(item.name)) {
+      lines.push({ item, reason: `/${item.name} is a built-in command` });
+    } else if (existsSync(file) || taken.has(key)) {
+      lines.push({ item, reason: `${shown} exists` });
+    } else {
+      taken.add(key);
+      writes.push({ path: file, shown, content: item.text, mode: "new" });
+      lines.push({ item, target: shown });
+    }
+  }
+  const settingsFile = join(root, ".garuda", "settings.json");
+  const rules = items.filter((i) => i.kind === "rule");
+  const allow = [];
+  const deny = [];
+  for (const item of rules) {
+    if (existsSync(settingsFile)) {
+      lines.push({ item, reason: ".garuda/settings.json exists; add it there by hand" });
+      continue;
+    }
+    const list = item.list === "allow" ? allow : deny;
+    if (!list.includes(item.rule)) list.push(item.rule);
+    lines.push({ item, target: `.garuda/settings.json (${item.list})` });
+  }
+  if (!existsSync(settingsFile) && (options.defaults || allow.length + deny.length > 0)) {
+    const settings = {
+      executor: "auto",
+      permissions: { allow, deny },
+      undo: { enabled: true },
+      lsp: { enabled: false }
+    };
+    writes.push({
+      path: settingsFile,
+      shown: ".garuda/settings.json",
+      content: `${JSON.stringify(settings, null, 2)}
+`,
+      mode: "new"
+    });
+  }
+  if (options.defaults) {
+    const file = join(root, ".gitignore");
+    const current = existsSync(file) ? readFileSync(file, "utf8") : "";
+    const have = new Set(current.split(/\r?\n/).map((l) => l.trim()));
+    const missing = GITIGNORE_LINES.filter((l) => !have.has(l));
+    if (missing.length > 0) {
+      const prefix = current === "" || current.endsWith("\n") ? "" : "\n";
+      writes.push({
+        path: file,
+        shown: ".gitignore",
+        content: `${prefix}# Garuda's local state
+${missing.join("\n")}
+`,
+        mode: current === "" ? "new" : "append"
+      });
+    }
+  }
+  for (const item of items) {
+    if (item.kind === "skipped")
+      lines.push({ item, reason: item.notes[0] ?? "not supported" });
+    if (item.kind === "instructions") lines.push({ item, target: "read by the init turn" });
+  }
+  return { writes, lines, instructions: instructions2 };
+}
+function previewText(plan) {
+  const out = [];
+  const agents = [...new Set(plan.lines.map((l) => l.item.agent))];
+  for (const agent of agents) {
+    out.push(`From ${agent}:`);
+    for (const { item, target, reason } of plan.lines.filter((l) => l.item.agent === agent)) {
+      const what = item.kind === "instructions" ? describe(item) : `${describe(item)} (${item.source})`;
+      if (target !== void 0) {
+        out.push(`  + ${what} \u2192 ${target}`);
+        for (const note of item.notes) out.push(`      ! ${note}`);
+      } else {
+        out.push(`  - ${what}: ${reason}`);
+      }
+    }
+  }
+  if (plan.writes.length > 0) {
+    out.push("Files:");
+    for (const w of plan.writes) out.push(`  ${w.mode === "new" ? "new   " : "append"} ${w.shown}`);
+  }
+  return out.join("\n");
+}
+function describe(item) {
+  switch (item.kind) {
+    case "mcp":
+      return `MCP server ${item.name}`;
+    case "command":
+      return `command /${item.name}`;
+    case "rule":
+      return `${item.list} rule ${item.rule}`;
+    case "instructions":
+      return `instructions ${item.path}`;
+    case "skipped":
+      return item.what;
+  }
+}
+async function applyPlan(plan) {
+  const done = [];
+  for (const w of plan.writes) {
+    await mkdir(dirname(w.path), { recursive: true });
+    try {
+      await writeFile(w.path, w.content, { flag: w.mode === "new" ? "wx" : "a" });
+      done.push(w.shown);
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+  }
+  return done;
+}
+
+// src/init/sources.ts
+import { existsSync as existsSync2, lstatSync, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join2, relative, sep } from "path";
+
+// src/init/convert.ts
+var SECRET_NAME = /KEY|TOKEN|SECRET|PASS|CRED|AUTH/i;
+function serverName(name) {
+  const out = name.toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/^_+/, "").slice(0, 32);
+  return SERVER_NAME.test(out) ? out : void 0;
+}
+function commandPart(name) {
+  const out = name.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "");
+  return /^[a-z0-9][a-z0-9_-]*$/.test(out) ? out : void 0;
+}
+function convertEnv(env, source, notes) {
+  const out = {};
+  for (const [key, raw] of Object.entries(env ?? {})) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      notes.push(`env "${key}" is not a valid name; left out`);
+      continue;
+    }
+    const value = String(raw ?? "").replace(
+      /\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g,
+      (_, name) => `\${${name}}`
+    );
+    if (value.includes("${") || value === "") {
+      out[key] = value;
+    } else if (SECRET_NAME.test(key)) {
+      out[key] = `\${${key}}`;
+      notes.push(
+        `${key} held a value in ${source}; Garuda does not copy it: set ${key} in your environment`
+      );
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function commandFromMarkdown(text, notes) {
+  let body = text;
+  const meta = {};
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+  if (fm !== null) {
+    body = text.slice(fm[0].length);
+    for (const line of (fm[1] ?? "").split(/\r?\n/)) {
+      const m = /^([A-Za-z-]+):\s*(.*)$/.exec(line);
+      if (m === null) continue;
+      const key = m[1].toLowerCase();
+      const value = m[2].trim().replace(/^["']|["']$/g, "");
+      if (key === "description" || key === "argument-hint") meta[key] = value;
+      else notes.push(`"${key}" in the front matter is left out (Garuda has no such option)`);
+    }
+  }
+  return withMeta(meta, body, notes);
+}
+function commandFromToml(data, notes) {
+  if (typeof data.prompt !== "string" || data.prompt.trim() === "") return void 0;
+  const meta = {};
+  if (typeof data.description === "string") meta.description = data.description;
+  return withMeta(meta, data.prompt.replaceAll("{{args}}", "$ARGUMENTS"), notes);
+}
+function withMeta(meta, body, notes) {
+  if (/!`[^`]*`|!\{[^}]*\}/.test(body)) {
+    notes.push("it runs shell commands in the prompt (!`\u2026`); Garuda sends that text as it is");
+  }
+  if (/(^|\s)@\{?[\w./-]+/.test(body)) {
+    notes.push("it includes files with @\u2026; Garuda sends that text as it is");
+  }
+  const keys = Object.entries(meta).filter(([, v]) => v !== "");
+  const head = keys.length === 0 ? "" : `---
+${keys.map(([k, v]) => `${k}: ${v.replace(/\n/g, " ")}`).join("\n")}
+---
+`;
+  return `${head}${body.trim()}
+`;
+}
+function claudeRule(text) {
+  const t = text.trim();
+  if (/^mcp__[\w-]+(__[\w*-]+)?$/.test(t)) return [t];
+  const m = /^([A-Za-z]+)(?:\((.*)\))?$/.exec(t);
+  if (m === null) return void 0;
+  const tool = m[1];
+  const arg = m[2]?.trim();
+  const path = (p) => p === void 0 || p === "" ? "" : `(${p.replace(/^\.\//, "")})`;
+  switch (tool) {
+    case "Bash": {
+      if (arg === void 0 || arg === "") return ["bash"];
+      return [`bash(${arg.replace(/:\*$/, "*").replace(/ \*$/, "*")})`];
+    }
+    case "Read":
+      return [`read_file${path(arg)}`];
+    case "Edit":
+    case "Write":
+    case "MultiEdit":
+      return [`edit_file${path(arg)}`, `write_file${path(arg)}`];
+    case "WebFetch": {
+      const host = arg?.startsWith("domain:") ? arg.slice(7) : void 0;
+      return host === void 0 ? arg === void 0 ? ["web_fetch"] : void 0 : [`web_fetch(${host})`];
+    }
+    default:
+      return void 0;
+  }
+}
+function openCodeRules(permission) {
+  if (permission === null || typeof permission !== "object") return [];
+  const out = [];
+  const tools = {
+    bash: ["bash"],
+    edit: ["edit_file", "write_file"],
+    webfetch: ["web_fetch"],
+    read: ["read_file"]
+  };
+  for (const [key, value] of Object.entries(permission)) {
+    const targets = tools[key];
+    if (targets === void 0) continue;
+    const add = (action, pattern) => {
+      if (action !== "allow" && action !== "deny") return;
+      for (const tool of targets) {
+        out.push({
+          list: action,
+          rule: pattern === void 0 || pattern === "*" ? tool : `${tool}(${pattern})`
+        });
+      }
+    };
+    if (typeof value === "string") add(value);
+    else if (value !== null && typeof value === "object") {
+      for (const [pattern, action] of Object.entries(value)) {
+        add(action, key === "bash" ? pattern.replace(/ \*$/, "*") : pattern);
+      }
+    }
+  }
+  return out;
+}
+function parseJsonc(text) {
+  let out = "";
+  let inString = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (inString) {
+      out += c;
+      if (c === "\\") out += text[++i] ?? "";
+      else if (c === '"') inString = false;
+    } else if (c === '"') {
+      inString = true;
+      out += c;
+    } else if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      out += "\n";
+    } else if (c === "/" && text[i + 1] === "*") {
+      i = text.indexOf("*/", i + 2);
+      if (i === -1) break;
+      i++;
+    } else {
+      out += c;
+    }
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+
+// src/init/sources.ts
+var MAX_FILES = 200;
+var SECRET_ARG = /(token|api[-_]?key|secret|password)|^(sk-|ghp_|xox[bp]-)/i;
+function readAllSources(options) {
+  return [
+    ...claudeCode(options),
+    ...openCode(options),
+    ...codex(options),
+    ...geminiLike("Gemini CLI", options, {
+      settings: [
+        ["project", ".gemini/settings.json"],
+        ["user", ".gemini/settings.json"]
+      ],
+      commands: [
+        ["project", ".gemini/commands"],
+        ["user", ".gemini/commands"]
+      ],
+      instructions: ["GEMINI.md"]
+    }),
+    ...geminiLike("Tabnine", options, {
+      settings: [
+        ["project", ".tabnine/agent/settings.json"],
+        ["project", ".tabnine/mcp_servers.json"],
+        ["user", ".tabnine/agent/settings.json"]
+      ],
+      commands: [
+        ["project", ".tabnine/agent/commands"],
+        ["user", ".tabnine/agent/commands"]
+      ],
+      instructions: ["TABNINE.md", ".tabnine/guidelines"]
+    }),
+    ...cursor(options),
+    ...instructions("Copilot", options, [
+      ".github/copilot-instructions.md",
+      ".github/instructions"
+    ])
+  ];
+}
+function claudeCode({ root, home }) {
+  const agent = "Claude Code";
+  const out = [];
+  const mcp = readJsonFile(join2(root, ".mcp.json"), agent, out);
+  out.push(...mcpServers(agent, ".mcp.json", "project", field(mcp, "mcpServers"), "claude"));
+  const global = readJsonFile(join2(home, ".claude.json"), agent, out);
+  out.push(...mcpServers(agent, "~/.claude.json", "user", field(global, "mcpServers"), "claude"));
+  const perProject = field(field(global, "projects"), root);
+  out.push(
+    ...mcpServers(
+      agent,
+      "~/.claude.json (this project)",
+      "project",
+      field(perProject, "mcpServers"),
+      "claude"
+    )
+  );
+  out.push(...markdownCommands(agent, "project", root, ".claude/commands"));
+  out.push(...markdownCommands(agent, "user", home, ".claude/commands"));
+  for (const file of [".claude/settings.json", ".claude/settings.local.json"]) {
+    const settings = readJsonFile(join2(root, file), agent, out);
+    const permissions = field(settings, "permissions");
+    for (const list of ["allow", "deny"]) {
+      for (const text of arrayOf(field(permissions, list))) {
+        const rules = claudeRule(String(text));
+        if (rules === void 0) {
+          out.push(skipped(agent, file, `the rule ${String(text)}`, "Garuda has no such tool"));
+        } else {
+          for (const rule of rules)
+            out.push({ kind: "rule", agent, source: file, notes: [], list, rule });
+        }
+      }
+    }
+    if (field(settings, "hooks") !== void 0) {
+      out.push(skipped(agent, file, "hooks", "their format differs; see ~/.garuda/hooks.json"));
+    }
+  }
+  const userSettings = readJsonFile(join2(home, ".claude/settings.json"), agent, out);
+  if (field(userSettings, "permissions") !== void 0) {
+    out.push(
+      skipped(
+        agent,
+        "~/.claude/settings.json",
+        "your personal permission rules",
+        "Garuda has project settings only"
+      )
+    );
+  }
+  return out;
+}
+function openCode({ root, home }) {
+  const agent = "OpenCode";
+  const out = [];
+  const files = [
+    ["project", root, "opencode.json"],
+    ["project", root, "opencode.jsonc"],
+    ["user", home, ".config/opencode/opencode.json"],
+    ["user", home, ".config/opencode/opencode.jsonc"]
+  ];
+  for (const [scope, base, file] of files) {
+    const shown = scope === "user" ? `~/${file}` : file;
+    const config = readJsonFile(join2(base, file), agent, out);
+    if (config === void 0) continue;
+    for (const [name, raw] of Object.entries(objectOf(field(config, "mcp")))) {
+      const def = objectOf(raw);
+      if (def.type === "local") {
+        const cmd = arrayOf(def.command).map(String);
+        out.push(
+          ...mcpServers(agent, shown, scope, {
+            [name]: {
+              command: cmd[0],
+              args: cmd.slice(1),
+              env: def.environment,
+              enabled: def.enabled
+            }
+          })
+        );
+      } else if (def.type === "remote") {
+        out.push(
+          ...mcpServers(agent, shown, scope, {
+            [name]: { url: def.url, headers: def.headers, enabled: def.enabled }
+          })
+        );
+      }
+    }
+    for (const [name, raw] of Object.entries(objectOf(field(config, "command")))) {
+      const def = objectOf(raw);
+      const notes = [];
+      const md = `${typeof def.description === "string" ? `---
+description: ${def.description}
+---
+` : ""}${String(def.template ?? "")}`;
+      const part = commandPart(name);
+      if (part === void 0 || typeof def.template !== "string") {
+        out.push(skipped(agent, shown, `the command ${name}`, "no valid name or template"));
+        continue;
+      }
+      out.push({
+        kind: "command",
+        agent,
+        source: shown,
+        notes,
+        scope,
+        name: part,
+        text: commandFromMarkdown(md, notes)
+      });
+    }
+    if (scope === "project") {
+      for (const { list, rule } of openCodeRules(field(config, "permission"))) {
+        out.push({ kind: "rule", agent, source: shown, notes: [], list, rule });
+      }
+    } else if (field(config, "permission") !== void 0) {
+      out.push(
+        skipped(agent, shown, "your personal permission rules", "Garuda has project settings only")
+      );
+    }
+  }
+  for (const dir of [".opencode/command", ".opencode/commands"])
+    out.push(...markdownCommands(agent, "project", root, dir));
+  for (const dir of [".config/opencode/command", ".config/opencode/commands"]) {
+    out.push(...markdownCommands(agent, "user", home, dir));
+  }
+  return out;
+}
+function codex({ root, home }) {
+  const agent = "Codex";
+  const out = [];
+  for (const [scope, base, shown] of [
+    ["project", root, ".codex/config.toml"],
+    ["user", home, "~/.codex/config.toml"]
+  ]) {
+    const config = readTomlFile(join2(base, ".codex/config.toml"), agent, out);
+    for (const [name, raw] of Object.entries(objectOf(field(config, "mcp_servers")))) {
+      const def = objectOf(raw);
+      const env = { ...objectOf(def.env) };
+      for (const v of arrayOf(def.env_vars)) env[String(v)] = `\${${String(v)}}`;
+      const headers = def.http_headers ?? (def.bearer_token_env_var === void 0 ? void 0 : { Authorization: "\u2026" });
+      out.push(...mcpServers(agent, shown, scope, { [name]: { ...def, env, headers } }));
+    }
+  }
+  out.push(...markdownCommands(agent, "user", home, ".codex/prompts"));
+  return out;
+}
+function geminiLike(agent, { root, home }, paths) {
+  const out = [];
+  for (const [scope, file] of paths.settings) {
+    const base = scope === "user" ? home : root;
+    const settings = readJsonFile(join2(base, file), agent, out);
+    const shown = scope === "user" ? `~/${file}` : file;
+    out.push(...mcpServers(agent, shown, scope, field(settings, "mcpServers"), "gemini"));
+  }
+  for (const [scope, dir] of paths.commands) {
+    const base = scope === "user" ? home : root;
+    for (const file of listFiles(join2(base, dir), ".toml", scope === "user")) {
+      const shown = `${scope === "user" ? "~/" : ""}${dir}/${file}`;
+      const name = commandName(file, ".toml");
+      const data = readTomlFile(join2(base, dir, file), agent, out);
+      const notes = [];
+      const text = data === void 0 ? void 0 : commandFromToml(data, notes);
+      if (name === void 0 || text === void 0) {
+        out.push(skipped(agent, shown, "a command", "no valid name or prompt"));
+        continue;
+      }
+      out.push({ kind: "command", agent, source: shown, notes, scope, name, text });
+    }
+  }
+  out.push(...instructions(agent, { root, home }, paths.instructions));
+  return out;
+}
+function cursor({ root, home }) {
+  const agent = "Cursor";
+  const out = [];
+  const project = readJsonFile(join2(root, ".cursor/mcp.json"), agent, out);
+  out.push(...mcpServers(agent, ".cursor/mcp.json", "project", field(project, "mcpServers")));
+  const user = readJsonFile(join2(home, ".cursor/mcp.json"), agent, out);
+  out.push(...mcpServers(agent, "~/.cursor/mcp.json", "user", field(user, "mcpServers")));
+  out.push(...instructions(agent, { root, home }, [".cursorrules", ".cursor/rules"]));
+  return out;
+}
+function mcpServers(agent, source, scope, servers, dialect = "plain") {
+  const out = [];
+  for (const [rawName, raw] of Object.entries(objectOf(servers))) {
+    const def = objectOf(raw);
+    const name = serverName(rawName);
+    if (name === void 0) {
+      out.push(
+        skipped(
+          agent,
+          source,
+          `the MCP server "${rawName}"`,
+          "its name does not fit Garuda's rules"
+        )
+      );
+      continue;
+    }
+    const notes = [];
+    if (def.enabled === false || def.disabled === true) notes.push("it was off; it stays off");
+    const enabled = !(def.enabled === false || def.disabled === true);
+    const sse = dialect === "claude" && def.type === "sse" || dialect === "gemini" && def.url !== void 0 && def.httpUrl === void 0;
+    const url = dialect === "gemini" ? def.httpUrl : def.url;
+    if (sse) {
+      out.push(
+        skipped(
+          agent,
+          source,
+          `the MCP server "${rawName}"`,
+          "it uses SSE; Garuda supports Streamable HTTP only"
+        )
+      );
+      continue;
+    }
+    if (typeof url === "string") {
+      const problem = checkServerUrl(url, scope);
+      if (problem !== void 0) {
+        out.push(skipped(agent, source, `the MCP server "${rawName}"`, problem));
+        continue;
+      }
+      if (def.headers !== void 0 && Object.keys(objectOf(def.headers)).length > 0) {
+        notes.push(
+          "it sent HTTP headers (for example a token); Garuda sends none and signs in with OAuth if the server asks"
+        );
+      }
+      out.push({
+        kind: "mcp",
+        agent,
+        source,
+        notes,
+        scope,
+        name,
+        def: { url, ...enabled ? {} : { enabled: false } }
+      });
+      continue;
+    }
+    if (typeof def.command !== "string" || def.command === "") {
+      out.push(skipped(agent, source, `the MCP server "${rawName}"`, "no command and no URL"));
+      continue;
+    }
+    if (arrayOf(def.args).some((a) => SECRET_ARG.test(String(a)))) {
+      notes.push("its arguments may hold a secret; check them in the new file");
+    }
+    if (def.cwd !== void 0)
+      notes.push("its working folder (cwd) is left out; Garuda starts it in the project");
+    notes.push(
+      'it runs in the sandbox with no network; add "network": true if it needs the internet'
+    );
+    out.push({
+      kind: "mcp",
+      agent,
+      source,
+      notes,
+      scope,
+      name,
+      def: {
+        command: def.command,
+        args: arrayOf(def.args).map(String),
+        env: convertEnv(objectOf(def.env), source, notes),
+        ...enabled ? {} : { enabled: false }
+      }
+    });
+  }
+  return out;
+}
+function markdownCommands(agent, scope, base, dir) {
+  const out = [];
+  for (const file of listFiles(join2(base, dir), ".md", scope === "user")) {
+    const shown = `${scope === "user" ? "~/" : ""}${dir}/${file}`;
+    const name = commandName(file, ".md");
+    if (name === void 0) {
+      out.push(skipped(agent, shown, "a command", "its name does not fit Garuda's rules"));
+      continue;
+    }
+    const notes = [];
+    const text = commandFromMarkdown(readFileSync2(join2(base, dir, file), "utf8"), notes);
+    out.push({ kind: "command", agent, source: shown, notes, scope, name, text });
+  }
+  return out;
+}
+function instructions(agent, { root }, paths) {
+  const out = [];
+  for (const path of paths) {
+    const full = join2(root, path);
+    if (!existsSync2(full)) continue;
+    const files = statSync(full).isDirectory() ? listFiles(full, [".md", ".mdc"]).map((f) => `${path}/${f}`) : [path];
+    for (const file of files)
+      out.push({ kind: "instructions", agent, source: file, notes: [], path: file });
+  }
+  return out;
+}
+function commandName(file, ext) {
+  const parts = file.slice(0, -ext.length).split("/").map(commandPart);
+  return parts.every((p) => p !== void 0) ? parts.join(":") : void 0;
+}
+function listFiles(dir, ext, followLinks = false) {
+  const exts = Array.isArray(ext) ? ext : [ext];
+  const out = [];
+  const walk = (current) => {
+    let entries;
+    try {
+      entries = readdirSync(current).sort();
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (out.length >= MAX_FILES) return;
+      const full = join2(current, name);
+      let stat;
+      try {
+        stat = followLinks ? statSync(full) : lstatSync(full);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) walk(full);
+      else if (stat.isFile() && exts.some((e) => name.endsWith(e))) {
+        out.push(relative(dir, full).split(sep).join("/"));
+      }
+    }
+  };
+  walk(dir);
+  return out;
+}
+function readJsonFile(path, agent, out) {
+  if (!existsSync2(path)) return void 0;
+  try {
+    return objectOf(parseJsonc(readFileSync2(path, "utf8")));
+  } catch (error) {
+    out.push(
+      skipped(
+        agent,
+        path,
+        "a settings file",
+        `it does not parse: ${error.message.slice(0, 80)}`
+      )
+    );
+    return void 0;
+  }
+}
+var toml;
+function readTomlFile(path, agent, out) {
+  if (!existsSync2(path)) return void 0;
+  if (toml === void 0) {
+    out.push(skipped(agent, path, "a TOML file", "the TOML reader is not loaded"));
+    return void 0;
+  }
+  try {
+    return objectOf(toml.parse(readFileSync2(path, "utf8")));
+  } catch (error) {
+    out.push(
+      skipped(
+        agent,
+        path,
+        "a TOML file",
+        `it does not parse: ${error.message.split("\n")[0]}`
+      )
+    );
+    return void 0;
+  }
+}
+async function loadToml() {
+  toml ??= await import("smol-toml");
+}
+function skipped(agent, source, what, why) {
+  return { kind: "skipped", agent, source, notes: [why], what };
+}
+function field(value, key) {
+  return value !== null && typeof value === "object" ? value[key] : void 0;
+}
+function objectOf(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function arrayOf(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+// src/init/run.ts
+async function runInit(context) {
+  const { root, home, approver, executor, signal } = context;
+  const kind = folderKind(root);
+  const report = [];
+  await loadToml();
+  const items = readAllSources({ root, home });
+  const plan = buildPlan(items, { root, home, defaults: true });
+  if (plan.writes.length > 0 || plan.lines.some((l) => l.target === void 0)) {
+    const found = new Set(items.map((i) => i.agent));
+    const question = {
+      tool: "init",
+      target: { kind: "input", json: "{}" },
+      preview: previewText(plan),
+      isolation: executor.isolation,
+      title: found.size > 0 ? `Set up Garuda here, with what ${[...found].join(", ")} left?` : "Set up Garuda in this folder?",
+      question: "Write these files?",
+      choices: ["once", "deny"],
+      labels: { once: "Yes, write the new files", deny: "No, write nothing" }
+    };
+    if (plan.writes.length === 0) {
+      report.push(
+        "Nothing to write:",
+        ...previewText(plan).split("\n").map((l) => `  ${l}`)
+      );
+    } else if (await approver.ask(question, signal) === "once") {
+      const written = await applyPlan(plan);
+      report.push(`Wrote ${written.length} file(s): ${written.join(", ")}.`);
+      const imported = plan.lines.filter((l) => l.target !== void 0 && l.item.kind === "mcp");
+      if (imported.some((l) => l.target?.startsWith(".garuda"))) {
+        report.push(
+          "Project MCP servers ask for your consent the first time, like any project server."
+        );
+      }
+    } else {
+      report.push("Nothing written.");
+    }
+  }
+  if (!existsSync3(join3(root, ".git"))) {
+    const choice = await approver.ask(
+      {
+        tool: "init",
+        target: { kind: "command", command: "git init" },
+        preview: "This folder is not a git repository. Git keeps the history of your changes.",
+        isolation: executor.isolation,
+        title: "Run git init?",
+        question: "Run it?",
+        choices: ["once", "deny"],
+        labels: { once: "Yes, run git init", deny: "No" }
+      },
+      signal
+    );
+    if (choice === "once") {
+      const result = await executor.run(
+        "git init -q",
+        {
+          root,
+          sandbox: false,
+          writePaths: [],
+          denyWritePaths: [],
+          denyReadPaths: [],
+          network: false,
+          envAllowlist: ["PATH", "HOME"],
+          timeoutMs: 3e4,
+          maxOutputBytes: 5e3
+        },
+        { signal }
+      );
+      report.push(
+        result.exitCode === 0 ? "Ran git init." : `git init failed: ${result.stderr.text.trim()}`
+      );
+    }
+  }
+  const search = context.searchHome === void 0 ? void 0 : await searchStep(context.searchHome, approver, executor, signal);
+  if (search !== void 0) report.push(search.text);
+  return {
+    kind,
+    report,
+    prompt: initPrompt(
+      kind,
+      plan.instructions.map((i) => i.path)
+    ),
+    ...search === void 0 ? {} : { searchUse: search.use }
+  };
+}
+async function searchStep(home, approver, executor, signal) {
+  const loaded = await loadSearchConfig(home);
+  if (loaded.claude === void 0 || loaded.use !== void 0) return void 0;
+  const provider = loaded.config === void 0 ? void 0 : providerLabel(loaded.config);
+  const choice = await approver.ask(
+    {
+      tool: "init",
+      target: { kind: "input", json: "{}" },
+      preview: [
+        "Claude can search the web itself, on Anthropic's servers, when a task needs it",
+        `($10 per 1,000 searches).${provider === void 0 ? "" : ` Your other provider: ${provider}; it asks before each search.`}`,
+        'Garuda saves your choice in ~/.garuda/search.json ("use"), for every project. Change it later with /search.'
+      ].join("\n"),
+      isolation: executor.isolation,
+      title: "Web search",
+      question: "Which web search?",
+      choices: provider === void 0 ? ["once", "deny"] : ["once", "session", "deny"],
+      labels: {
+        once: "Claude's search, when a task needs it",
+        session: "My other provider only",
+        deny: "No web search"
+      }
+    },
+    signal
+  );
+  const use = choice === "once" ? "claude" : choice === "session" ? "provider" : "off";
+  const file = await saveSearchUse(home, use);
+  return { use, text: `Web search: ${use} (saved in ${file}).` };
+}
+function initPrompt(kind, otherFiles) {
+  const others = otherFiles.length === 0 ? "" : `
+These files hold instructions for other coding agents: ${otherFiles.join(", ")}. Read them and carry over what still applies.`;
+  if (kind === "code") {
+    return [
+      "Set up this project for coding agents (/init).",
+      "Read the repository with glob, grep and read_file. Do not change any code.",
+      "Then create AGENTS.md at the root, or improve it if it exists (keep what is still correct), with these sections:",
+      "## Build and test: the exact commands.",
+      "## Structure: the main folders and what they hold.",
+      "## Conventions: style, naming and patterns that the code follows.",
+      "## Notes: what an agent must know (generated files, slow tests, environment variables).",
+      `Be short and specific. Write only facts that you checked in the files. Never copy secrets.${others}`,
+      "At the end, say in two or three lines what you wrote."
+    ].join("\n");
+  }
+  const what = kind === "empty" ? "This folder is empty." : "This folder has files, but no code yet.";
+  return [
+    `${what} The user wants to start a project here (/init).`,
+    "Ask the user, in one short message, what they want to build, and which language, build tool and test tool to use.",
+    "Suggest a default for each. Do not create files in this turn.",
+    "When the user answers, create AGENTS.md with their choices (## Stack, ## Build and test, ## Conventions),",
+    `and offer to create the project skeleton.${others}`
+  ].join("\n");
+}
+export {
+  initPrompt,
+  runInit
+};
+//# sourceMappingURL=run-66Y6R2KU.js.map