@garuda-agent/garuda 0.0.1 → 0.14.1

package/dist/chunk-KKB5W47S.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+import {
+  parseRule
+} from "./chunk-3NJNVZTK.js";
+
+// src/jobs/job.ts
+import { randomBytes } from "crypto";
+import { mkdirSync, renameSync, writeFileSync } from "fs";
+import { mkdir, readdir, readFile, rename, writeFile } from "fs/promises";
+import { join } from "path";
+import { z } from "zod";
+var JOBS_DIR = join(".garuda", "jobs");
+var DEFAULT_JOB_MAX_STEPS = 100;
+var JOB_STATUSES = ["scheduled", "running", "done", "stopped", "failed"];
+var fileChange = z.object({
+  status: z.enum(["added", "modified", "deleted"]),
+  path: z.string(),
+  added: z.number().optional(),
+  removed: z.number().optional()
+});
+var testRun = z.object({
+  exitCode: z.number().nullable(),
+  timedOut: z.boolean(),
+  durationMs: z.number(),
+  tail: z.string()
+});
+var resultSchema = z.object({
+  stopReason: z.string(),
+  steps: z.number(),
+  tokens: z.number(),
+  costUsd: z.number().optional(),
+  durationMs: z.number(),
+  sessionId: z.string().optional(),
+  commit: z.string().optional(),
+  files: z.array(fileChange),
+  denied: z.array(z.object({ tool: z.string(), target: z.string() })),
+  answer: z.string(),
+  error: z.string().optional(),
+  /** With the Batch API: requests per API, and when the job switched to the normal API. */
+  modelCalls: z.object({
+    batch: z.number(),
+    normal: z.number(),
+    /** Steps that waited past the step limit and ran on the normal API. */
+    slow: z.number().optional(),
+    switchedAt: z.string().optional()
+  }).optional(),
+  /** Proof of work (0.11): tests before and after, risk flags, the review and the verdict. */
+  proof: z.object({
+    verdict: z.enum(["ready", "needs-look"]),
+    before: testRun.optional(),
+    after: testRun.optional(),
+    flags: z.array(z.object({ level: z.enum(["stop", "look"]), text: z.string() })),
+    review: z.object({
+      verdict: z.enum(["ready", "needs-look"]),
+      text: z.string(),
+      costUsd: z.number().optional()
+    }).optional(),
+    reviewError: z.string().optional()
+  }).optional()
+});
+var jobSchema = z.object({
+  version: z.literal(1),
+  id: z.string().regex(/^[A-Za-z0-9_-]{1,80}$/),
+  title: z.string(),
+  createdAt: z.string(),
+  /** The project folder the job belongs to (the user's checkout). */
+  root: z.string(),
+  /** The commit the job starts from: HEAD, or a snapshot of the uncommitted changes. */
+  base: z.string().regex(/^[0-9a-f]{40,64}$/),
+  branch: z.string().regex(/^garuda\/job-[A-Za-z0-9_-]+$/),
+  worktree: z.string(),
+  /** The task: the plan and how to carry it out. */
+  prompt: z.string().min(1),
+  /** The session the plan came from. */
+  planSession: z.string().optional(),
+  model: z.string().optional(),
+  /** Permission rules for this job only, in the settings format ("edit_file(src/**)"). */
+  allow: z.array(z.string()),
+  onUnapproved: z.literal("deny-and-continue"),
+  /** "01:00" (local time) for `garuda run --at`, when the user gave one. */
+  at: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).optional(),
+  maxSteps: z.number().int().min(1).max(1e3),
+  /** The Batch API (0.7): half price, minutes per step; the normal API from 15 min before finishBy. */
+  batch: z.boolean().optional(),
+  finishBy: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).optional(),
+  /** A batch step that waits longer goes to the normal API (only that step). Default 20. */
+  stepLimitMinutes: z.number().int().min(1).max(24 * 60).optional(),
+  /**
+   * Ignored folders of the checkout (node_modules, .venv) that the worktree links to. Each is one
+   * folder name in the root (0.14.1, review: ".." made the parent folder writable for the job).
+   */
+  links: z.array(
+    z.string().regex(/^[^/\\]+$/, "a link is one folder name in the project").refine((name) => name !== "." && name !== "..", "a link is one folder name in the project")
+  ),
+  /**
+   * Proof of work (0.11): the test command, run in the sandbox before and after the job (absent:
+   * no tests), and the review of the diff (default true).
+   */
+  test: z.string().min(1).optional(),
+  review: z.boolean().optional(),
+  /**
+   * The network allowlist (0.13): presets and hosts that the job's sandboxed commands may reach,
+   * approved with the job. Other hosts are denied and reported. Absent: no network.
+   */
+  network: z.array(z.string()).optional(),
+  /** In the project's night queue (0.11): `garuda night` runs it. */
+  queue: z.boolean().optional(),
+  /** The launchd agent that starts the job (macOS), while it is installed. */
+  launchd: z.object({ label: z.string(), plist: z.string(), when: z.string() }).optional(),
+  status: z.enum(JOB_STATUSES),
+  /** Why a job failed before its turn ended (0.14.1, review). */
+  error: z.string().max(2e3).optional(),
+  startedAt: z.string().optional(),
+  endedAt: z.string().optional(),
+  result: resultSchema.optional()
+});
+function newJobId(now = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const date = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`;
+  return `${date}-${pad(now.getHours())}${pad(now.getMinutes())}-${randomBytes(2).toString("hex")}`;
+}
+function jobPath(root, id) {
+  return join(root, JOBS_DIR, `${id}.json`);
+}
+function failJobSync(job, error) {
+  job.status = "failed";
+  job.error = error.slice(0, 2e3);
+  job.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const dir = join(job.root, JOBS_DIR);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const file = jobPath(job.root, job.id);
+  const temp = `${file}.${process.pid}.tmp`;
+  writeFileSync(temp, `${JSON.stringify(job, null, 2)}
+`, { mode: 384 });
+  renameSync(temp, file);
+}
+async function settleJob(root, id, exitCode) {
+  const job = await loadJob(root, id).catch(() => void 0);
+  if (job?.status !== "running") return;
+  failJobSync(
+    job,
+    `The job process ended (exit code ${exitCode ?? "none"}) before the job finished. See ${JOBS_DIR}/${id}.log.`
+  );
+}
+async function saveJob(job) {
+  const dir = join(job.root, JOBS_DIR);
+  await mkdir(dir, { recursive: true, mode: 448 });
+  const file = jobPath(job.root, job.id);
+  const temp = `${file}.${process.pid}.tmp`;
+  await writeFile(temp, `${JSON.stringify(job, null, 2)}
+`, { mode: 384 });
+  await rename(temp, file);
+}
+async function loadJob(root, id) {
+  if (!/^[A-Za-z0-9_-]{1,80}$/.test(id)) throw new Error(`"${id}" is not a job id.`);
+  let text;
+  try {
+    text = await readFile(jobPath(root, id), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`There is no job ${id} in this project (${JOBS_DIR}).`);
+    }
+    throw error;
+  }
+  let parsed;
+  try {
+    const result = jobSchema.safeParse(JSON.parse(text));
+    if (!result.success) throw new Error(z.prettifyError(result.error));
+    parsed = result.data;
+  } catch (error) {
+    throw new Error(`${JOBS_DIR}/${id}.json: ${error.message}`);
+  }
+  if (parsed.root !== root) {
+    throw new Error(`Job ${id} belongs to ${parsed.root}, not to ${root}.`);
+  }
+  for (const rule of parsed.allow) parseRule(rule);
+  return parsed;
+}
+async function listJobs(root) {
+  let names;
+  try {
+    names = (await readdir(join(root, JOBS_DIR))).filter((n) => n.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const jobs = [];
+  for (const name of names.sort().reverse()) {
+    try {
+      jobs.push(await loadJob(root, name.slice(0, -".json".length)));
+    } catch {
+    }
+  }
+  return jobs;
+}
+function planPermissions(plan) {
+  const block = /```permissions[^\n]*\n([\s\S]*?)```/.exec(plan)?.[1];
+  const rules = [];
+  const problems = [];
+  for (const raw of (block ?? "").split("\n")) {
+    const line = raw.replace(/^\s*[-*]\s+/, "").trim();
+    if (line === "" || line.startsWith("#")) continue;
+    try {
+      parseRule(line);
+      if (!rules.includes(line)) rules.push(line);
+    } catch {
+      problems.push(line);
+    }
+  }
+  return { rules, problems };
+}
+function planTitle(prompt, plan) {
+  const line = prompt.split("\n").map((l) => l.trim()).find((l) => l !== "") ?? plan.split("\n").find((l) => l.trim() !== "") ?? "job";
+  const clean = line.replace(/^#+\s*/, "");
+  return clean.length <= 70 ? clean : `${clean.slice(0, 69)}\u2026`;
+}
+
+export {
+  JOBS_DIR,
+  DEFAULT_JOB_MAX_STEPS,
+  JOB_STATUSES,
+  newJobId,
+  jobPath,
+  failJobSync,
+  settleJob,
+  saveJob,
+  loadJob,
+  listJobs,
+  planPermissions,
+  planTitle
+};
+//# sourceMappingURL=chunk-KKB5W47S.js.map

package/dist/chunk-KWRJREUH.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+import {
+  isLoopbackHost
+} from "./chunk-ATW7BNIG.js";
+
+// src/commands/builtins.ts
+var BUILTIN_COMMANDS = [
+  "help",
+  "usage",
+  "session",
+  "sessions",
+  "models",
+  "export",
+  "compact",
+  "diff",
+  "schedule",
+  "jobs",
+  "where",
+  "defs",
+  "refs",
+  "callers",
+  "impact",
+  "map",
+  "mcp",
+  "hooks",
+  "lsp",
+  "languages",
+  "experts",
+  "audit",
+  "commands",
+  "agents",
+  "plan",
+  "build",
+  "new",
+  "init",
+  "editor",
+  "details",
+  "thinking",
+  "search",
+  "undo",
+  "redo",
+  "exit",
+  "quit"
+];
+
+// src/web/search.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { z } from "zod";
+var SEARCH_FILE = join(".garuda", "search.json");
+var SEARCH_TIMEOUT_MS = 2e4;
+var SEARCH_MAX_BYTES = 2 * 1024 * 1024;
+var DEFAULT_RESULTS = 5;
+var MAX_RESULTS = 10;
+var SEARCH_USES = ["claude", "provider", "off"];
+var DEFAULT_CLAUDE_MAX_USES = 5;
+var domains = z.array(
+  z.string().min(1).regex(/^[^\s:/][^\s:]*$/, "a bare domain, with an optional path (no scheme)")
+);
+var claudeSchema = z.strictObject({
+  /** Searches per model request, 1–20. Default 5. */
+  maxUses: z.number().int().min(1).max(20).optional(),
+  allowedDomains: domains.optional(),
+  blockedDomains: domains.optional()
+}).refine((c) => c.allowedDomains === void 0 || c.blockedDomains === void 0, {
+  message: "use allowedDomains or blockedDomains, not both"
+});
+var fileSchema = z.strictObject({
+  /** The user's choice (0.14); absent: the chat asks once and saves the answer. */
+  use: z.enum(SEARCH_USES).optional(),
+  provider: z.enum(["brave", "tavily", "searxng"]).optional(),
+  /** Claude's own web search (0.6). */
+  claude: claudeSchema.optional(),
+  /** SearXNG only: the server's base URL. */
+  url: z.string().optional(),
+  /** The environment variable with the key. Default: BRAVE_API_KEY or TAVILY_API_KEY. */
+  apiKeyEnv: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).optional(),
+  /** Results per search, 1–10. Default 5. */
+  maxResults: z.number().int().min(1).max(MAX_RESULTS).optional()
+});
+var LABELS = {
+  brave: "Brave Search",
+  tavily: "Tavily",
+  searxng: "SearXNG"
+};
+function providerLabel(config) {
+  return `${LABELS[config.provider]} (${config.endpoint.host})`;
+}
+async function loadSearchConfig(home = homedir(), env = process.env) {
+  const file = join(home, SEARCH_FILE);
+  let text;
+  try {
+    text = await readFile(file, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      return { problem: `${file}: ${error.message}` };
+    }
+  }
+  if (text === void 0) return fromEnv(env, DEFAULT_RESULTS);
+  let parsed;
+  try {
+    const result = fileSchema.safeParse(JSON.parse(text));
+    if (!result.success) return { problem: `${file}: ${z.prettifyError(result.error)}` };
+    parsed = result.data;
+  } catch (error) {
+    return { problem: `${file}: invalid JSON: ${error.message}` };
+  }
+  const max = parsed.maxResults ?? DEFAULT_RESULTS;
+  const use = parsed.use === void 0 ? {} : { use: parsed.use };
+  const claude = parsed.claude === void 0 ? {} : {
+    claude: {
+      maxUses: parsed.claude.maxUses ?? DEFAULT_CLAUDE_MAX_USES,
+      ...parsed.claude.allowedDomains === void 0 ? {} : { allowedDomains: parsed.claude.allowedDomains },
+      ...parsed.claude.blockedDomains === void 0 ? {} : { blockedDomains: parsed.claude.blockedDomains }
+    }
+  };
+  if (parsed.provider === void 0) {
+    if (parsed.claude === void 0 && parsed.use === void 0) {
+      return { problem: `${file}: name a "provider", or add a "claude" section.` };
+    }
+    return { ...fromEnv(env, max), ...claude, ...use };
+  }
+  const client = clientConfig(file, { ...parsed, provider: parsed.provider }, env, max);
+  return "problem" in client ? { ...client, ...claude, ...use } : { config: client.config, ...claude, ...use };
+}
+async function saveSearchUse(home, use) {
+  const file = join(home, SEARCH_FILE);
+  let data = {};
+  try {
+    data = JSON.parse(await readFile(file, "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify({ ...data, use }, null, 2)}
+`, { mode: 384 });
+  return file;
+}
+function fromEnv(env, max) {
+  if (env.BRAVE_API_KEY) return { config: brave(env.BRAVE_API_KEY, max) };
+  if (env.TAVILY_API_KEY) return { config: tavily(env.TAVILY_API_KEY, max) };
+  return {};
+}
+function clientConfig(file, parsed, env, max) {
+  if (parsed.provider === "searxng") {
+    if (parsed.url === void 0) return { problem: `${file}: "searxng" needs a "url".` };
+    const endpoint = searxngEndpoint(parsed.url);
+    if (typeof endpoint === "string") return { problem: `${file}: ${endpoint}` };
+    return { config: { provider: "searxng", endpoint, maxResults: max } };
+  }
+  const variable = parsed.apiKeyEnv ?? (parsed.provider === "brave" ? "BRAVE_API_KEY" : "TAVILY_API_KEY");
+  const key = env[variable];
+  if (!key) return { problem: `${file}: web search needs the key in ${variable}; it is not set.` };
+  return { config: parsed.provider === "brave" ? brave(key, max) : tavily(key, max) };
+}
+function brave(apiKey, maxResults) {
+  return {
+    provider: "brave",
+    endpoint: new URL("https://api.search.brave.com/res/v1/web/search"),
+    apiKey,
+    maxResults
+  };
+}
+function tavily(apiKey, maxResults) {
+  return {
+    provider: "tavily",
+    endpoint: new URL("https://api.tavily.com/search"),
+    apiKey,
+    maxResults
+  };
+}
+function searxngEndpoint(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return `"${raw}" is not a valid URL.`;
+  }
+  if (url.username !== "" || url.password !== "")
+    return "a URL with a user name or password is not allowed.";
+  const local = isLoopbackHost(url.hostname.replace(/^\[|\]$/g, ""));
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && local)) {
+    return "use https (http only for localhost).";
+  }
+  return new URL(`${url.pathname.replace(/\/+$/, "")}/search`, url);
+}
+async function search(config, query, maxResults, signal, fetchFn = fetch) {
+  const count = Math.min(Math.max(1, maxResults), MAX_RESULTS);
+  const timeout = AbortSignal.any([signal, AbortSignal.timeout(SEARCH_TIMEOUT_MS)]);
+  let request;
+  if (config.provider === "brave") {
+    const url = new URL(config.endpoint);
+    url.searchParams.set("q", query);
+    url.searchParams.set("count", String(count));
+    request = new Request(url, {
+      headers: { accept: "application/json", "x-subscription-token": config.apiKey ?? "" }
+    });
+  } else if (config.provider === "tavily") {
+    request = new Request(config.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${config.apiKey ?? ""}`
+      },
+      body: JSON.stringify({ query, max_results: count, search_depth: "basic" })
+    });
+  } else {
+    const url = new URL(config.endpoint);
+    url.searchParams.set("q", query);
+    url.searchParams.set("format", "json");
+    request = new Request(url, { headers: { accept: "application/json" } });
+  }
+  let response;
+  try {
+    response = await fetchFn(request, { signal: timeout, redirect: "error" });
+  } catch (error) {
+    if (signal.aborted) throw error;
+    throw new Error(`${LABELS[config.provider]} did not answer: ${error.message}`);
+  }
+  if (!response.ok) {
+    const hint = response.status === 401 || response.status === 403 ? " Check the API key." : response.status === 429 ? " Too many searches; wait, or check your plan." : "";
+    throw new Error(`${LABELS[config.provider]} answered ${response.status}.${hint}`);
+  }
+  const text = await readCapped(response, SEARCH_MAX_BYTES);
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new Error(
+      `${LABELS[config.provider]} did not answer with JSON.${config.provider === "searxng" ? ' Turn on the "json" format in its settings.yml (search.formats).' : ""}`
+    );
+  }
+  return parseResults(config.provider, json).slice(0, count);
+}
+function parseResults(provider, json) {
+  const obj = (v) => v !== null && typeof v === "object" ? v : {};
+  const str = (v) => typeof v === "string" ? v : "";
+  const list = provider === "brave" ? obj(obj(json).web).results : obj(json).results;
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  for (const item of list) {
+    const r = obj(item);
+    const url = str(r.url);
+    if (!/^https?:\/\//.test(url)) continue;
+    const snippet = provider === "brave" ? str(r.description) : str(r.content);
+    const age = provider === "brave" ? str(r.age) : str(r.publishedDate);
+    out.push({
+      title: str(r.title),
+      url,
+      snippet,
+      ...age === "" ? {} : { age }
+    });
+  }
+  return out;
+}
+async function readCapped(response, max) {
+  const reader = response.body?.getReader();
+  if (reader === void 0) return "";
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > max) {
+      await reader.cancel();
+      throw new Error(`The search answer is larger than ${max} bytes.`);
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+export {
+  BUILTIN_COMMANDS,
+  MAX_RESULTS,
+  providerLabel,
+  loadSearchConfig,
+  saveSearchUse,
+  search
+};
+//# sourceMappingURL=chunk-KWRJREUH.js.map

package/dist/chunk-N4I6YS3E.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+// src/cli/notify.ts
+var DEFAULT_AFTER_SECONDS = 10;
+var MAX_TEXT = 120;
+var OSC9_TERMINALS = /* @__PURE__ */ new Set(["iTerm.app", "ghostty", "WezTerm"]);
+function pickChannel(choice, env = process.env) {
+  const fromEnv = env.GARUDA_NOTIFY;
+  const wanted = fromEnv !== void 0 && fromEnv !== "" ? fromEnv : choice ?? "auto";
+  if (wanted === "off" || wanted === "bell" || wanted === "osc9") return wanted;
+  const multiplexer = env.TMUX !== void 0 || (env.TERM ?? "").startsWith("screen");
+  return !multiplexer && OSC9_TERMINALS.has(env.TERM_PROGRAM ?? "") ? "osc9" : "bell";
+}
+function notificationBytes(channel, text) {
+  if (channel === "off") return "";
+  if (channel === "bell") return "\x07";
+  const clean = Array.from(text, (ch) => {
+    const code = ch.codePointAt(0) ?? 0;
+    return code < 32 || code >= 127 && code <= 159 ? " " : ch;
+  }).join("").replace(/ {2,}/g, " ").trim();
+  const cut = clean.length <= MAX_TEXT ? clean : `${clean.slice(0, MAX_TEXT - 1)}\u2026`;
+  return `\x1B]9;${cut}\x07`;
+}
+var Notifier = class {
+  constructor(channel, write, afterSeconds = DEFAULT_AFTER_SECONDS, isFocused = () => void 0) {
+    this.channel = channel;
+    this.write = write;
+    this.afterSeconds = afterSeconds;
+    this.isFocused = isFocused;
+  }
+  channel;
+  write;
+  afterSeconds;
+  isFocused;
+  /** Questions notify only during a turn: after a command the user typed (/undo), the user is here. */
+  running = false;
+  /** An approval or a consent question waits for the user. */
+  approval(request) {
+    if (!this.running) return;
+    const target = request.target;
+    const what = request.title ?? (target.kind === "command" ? `${request.tool}: ${target.command.split("\n")[0] ?? ""}` : target.kind === "path" ? `${request.tool} ${target.path}` : request.tool);
+    this.send(`Garuda needs your approval: ${what}`);
+  }
+  turnStarted() {
+    this.running = true;
+  }
+  /** A turn ended. Short turns and turns the user stopped stay quiet. */
+  turnEnded(outcome, ms) {
+    this.running = false;
+    if (outcome === void 0 || outcome.kind === "interrupted") return;
+    if (ms < this.afterSeconds * 1e3) return;
+    const time = formatSeconds(ms);
+    if (outcome.kind === "error") this.send(`Garuda: the task failed after ${time}.`);
+    else if (outcome.result.stopReason === "done") this.send(`Garuda: the task is done (${time}).`);
+    else this.send(`Garuda: the task stopped (${outcome.result.stopReason}) after ${time}.`);
+  }
+  send(text) {
+    if (this.isFocused() === true) return;
+    const bytes = notificationBytes(this.channel, text);
+    if (bytes !== "") this.write(bytes);
+  }
+};
+function formatSeconds(ms) {
+  const s = Math.round(ms / 1e3);
+  return s < 60 ? `${s} s` : `${Math.floor(s / 60)} min ${s % 60} s`;
+}
+
+export {
+  pickChannel,
+  notificationBytes,
+  Notifier
+};
+//# sourceMappingURL=chunk-N4I6YS3E.js.map