@garuda-agent/garuda 0.0.1 → 0.15.0

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-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

package/dist/chunk-NXJ4XLB5.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+// src/permissions/autoApprover.ts
+var AutoApprover = class {
+  requests = [];
+  answer;
+  constructor(answer = "once") {
+    this.answer = typeof answer === "function" ? answer : () => answer;
+  }
+  async ask(request) {
+    this.requests.push(request);
+    return this.answer(request);
+  }
+};
+
+export {
+  AutoApprover
+};
+//# sourceMappingURL=chunk-NXJ4XLB5.js.map

package/dist/chunk-OUCV3FCT.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+// src/jobs/proof.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { extname, join } from "path";
+var TEST_TAIL_LINES = 30;
+var REVIEW_DIFF_CHARS = 6e4;
+function detectTestCommand(root, profiles) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+    const test = pkg.scripts?.test;
+    if (typeof test === "string" && test.trim() !== "" && !test.includes("no test specified")) {
+      if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm test";
+      if (existsSync(join(root, "yarn.lock"))) return "yarn test";
+      return "npm test";
+    }
+  } catch {
+  }
+  if (profiles[0] !== void 0) return profiles[0].test;
+  return hasNodeTests(root) ? "node --test" : void 0;
+}
+function hasNodeTests(root) {
+  const isTest = (name) => /\.test\.[cm]?js$/.test(name);
+  for (const dir of [root, join(root, "test")]) {
+    try {
+      if (readdirSync(dir).some(isTest)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function testSummary(run) {
+  if (run === void 0) return "not run";
+  if (run.timedOut) return `stopped after ${Math.round(run.durationMs / 1e3)} s (too long)`;
+  return `${run.exitCode === 0 ? "pass" : `fail (exit code ${run.exitCode})`} in ${Math.round(run.durationMs / 1e3)} s`;
+}
+var passed = (run) => run !== void 0 && !run.timedOut && run.exitCode === 0;
+var TEST_PATH = /(^|\/)(tests?|__tests__|spec)\/|\.(test|spec)\.[cm]?[jt]sx?$|(^|\/)test_[^/]*\.py$|_test\.(py|go)$|(^|\/)src\/test\//;
+var MANIFEST = /(^|\/)(package\.json|pnpm-lock\.yaml|package-lock\.json|yarn\.lock|pyproject\.toml|requirements[^/]*\.txt|poetry\.lock|uv\.lock|pom\.xml|build\.gradle(\.kts)?|go\.mod|go\.sum|Cargo\.toml|Cargo\.lock|Gemfile(\.lock)?)$/;
+var DELIVERY = /(^|\/)(\.github\/workflows\/|\.gitlab-ci\.yml$|Dockerfile$|docker-compose[^/]*\.ya?ml$|\.env)/;
+function riskFlags(input) {
+  const { result, test, before, after } = input;
+  const flags = [];
+  if (result.stopReason !== "done") {
+    flags.push({
+      level: "stop",
+      text: `The job did not finish: it stopped with "${result.stopReason}".`
+    });
+  }
+  if (result.error !== void 0) flags.push({ level: "stop", text: `Error: ${result.error}` });
+  if (test === void 0) {
+    flags.push({ level: "look", text: "No test command: nothing proves the change works." });
+  } else if (after !== void 0 && !passed(after)) {
+    flags.push({
+      level: "stop",
+      text: passed(before) ? "The tests passed before the job and fail after it." : "The tests fail after the job (they failed before it too)."
+    });
+  } else if (after !== void 0 && before !== void 0 && !passed(before)) {
+    flags.push({
+      level: "look",
+      text: "The tests failed before the job and pass after it: check that the change is why."
+    });
+  }
+  const tests = result.files.filter((f) => TEST_PATH.test(f.path));
+  const deletedTests = tests.filter((f) => f.status === "deleted");
+  if (deletedTests.length > 0) {
+    flags.push({
+      level: "look",
+      text: `Test files deleted: ${deletedTests.map((f) => f.path).join(", ")}.`
+    });
+  }
+  const changedTests = tests.filter((f) => f.status === "modified");
+  if (changedTests.length > 0) {
+    flags.push({
+      level: "look",
+      text: `Existing tests changed: ${changedTests.map((f) => f.path).join(", ")}. Check that they still test what they did.`
+    });
+  }
+  const manifests = result.files.filter((f) => MANIFEST.test(f.path));
+  if (manifests.length > 0) {
+    flags.push({
+      level: "look",
+      text: `Dependencies or build files changed: ${manifests.map((f) => f.path).join(", ")}.`
+    });
+  }
+  const delivery = result.files.filter((f) => DELIVERY.test(f.path));
+  if (delivery.length > 0) {
+    flags.push({
+      level: "look",
+      text: `CI, container or environment files changed: ${delivery.map((f) => f.path).join(", ")}.`
+    });
+  }
+  const lines = result.files.reduce((n, f) => n + (f.added ?? 0) + (f.removed ?? 0), 0);
+  if (result.files.length > 20 || lines > 500) {
+    flags.push({
+      level: "look",
+      text: `A large change: ${result.files.length} files, ${lines} lines.`
+    });
+  }
+  if (result.denied.length > 0) {
+    flags.push({
+      level: "look",
+      text: `${result.denied.length} call(s) were denied: the job may be incomplete.`
+    });
+  }
+  return flags;
+}
+var LANGUAGES = {
+  ts: "TypeScript",
+  tsx: "TypeScript",
+  mts: "TypeScript",
+  cts: "TypeScript",
+  js: "JavaScript",
+  jsx: "JavaScript",
+  mjs: "JavaScript",
+  cjs: "JavaScript",
+  py: "Python",
+  java: "Java",
+  kt: "Kotlin",
+  go: "Go",
+  rs: "Rust",
+  rb: "Ruby",
+  cs: "C#",
+  swift: "Swift",
+  php: "PHP",
+  scala: "Scala",
+  sql: "SQL"
+};
+function stackOf(files, profiles) {
+  const out = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    const language = LANGUAGES[extname(f.path).slice(1).toLowerCase()];
+    if (language !== void 0) out.add(language);
+  }
+  for (const p of profiles) out.add(p.label);
+  return [...out];
+}
+function reviewerSystem(stack) {
+  const expert = stack.length === 0 ? "this codebase" : `${stack.join(", ")} and this codebase`;
+  return [
+    `You are a principal engineer and a domain expert in ${expert}. A staff engineer made the change below`,
+    "as an unattended job, from a plan that the user approved. You review it before the user merges it.",
+    "Check, in this order: correctness and edge cases; that the change does what the plan says, no more and",
+    "no less; that tests prove it (new behaviour tested, no test weakened); security and data risks; the",
+    "project's conventions. Judge only what the diff and the facts show. Do not invent problems; say what",
+    "you cannot see.",
+    "",
+    "Answer in exactly this form:",
+    "VERDICT: ready | needs a look",
+    "SUMMARY: one sentence",
+    "FINDINGS:",
+    "- [high|medium|low] path:line: the problem and the fix",
+    '(or "- none")'
+  ].join("\n");
+}
+function reviewPrompt(input) {
+  const diff = input.diff.length <= REVIEW_DIFF_CHARS ? input.diff : `${input.diff.slice(0, REVIEW_DIFF_CHARS)}
+[\u2026 the diff is cut here; ${input.diff.length - REVIEW_DIFF_CHARS} more characters]`;
+  return [
+    "<job>",
+    input.prompt.trim(),
+    "</job>",
+    "",
+    "<facts>",
+    `Files: ${input.files.map((f) => `${f.status} ${f.path} (+${f.added ?? "?"} \u2212${f.removed ?? "?"})`).join("; ") || "none"}`,
+    `Tests (${input.test ?? "no test command"}): before the job ${testSummary(input.before)}; after it ${testSummary(input.after)}`,
+    ...input.after !== void 0 && !passed(input.after) ? [`Test output after the job:
+${input.after.tail}`] : [],
+    `Risk flags: ${input.flags.length === 0 ? "none" : input.flags.map((f) => f.text).join(" ")}`,
+    "</facts>",
+    "",
+    "<diff>",
+    diff,
+    "</diff>"
+  ].join("\n");
+}
+function parseReview(text) {
+  const m = /^\s*VERDICT:\s*(ready|needs a look)\b/im.exec(text);
+  return { verdict: m?.[1]?.toLowerCase() === "ready" ? "ready" : "needs-look", text: text.trim() };
+}
+function jobVerdict(flags, review) {
+  if (flags.some((f) => f.level === "stop")) return "needs-look";
+  return review ?? (flags.length === 0 ? "ready" : "needs-look");
+}
+function tail(text, lines = TEST_TAIL_LINES) {
+  const all = text.trimEnd().split("\n");
+  return all.length <= lines ? all.join("\n") : `[\u2026 ${all.length - lines} lines]
+${all.slice(-lines).join("\n")}`;
+}
+
+export {
+  detectTestCommand,
+  testSummary,
+  passed,
+  TEST_PATH,
+  MANIFEST,
+  riskFlags,
+  stackOf,
+  reviewerSystem,
+  reviewPrompt,
+  parseReview,
+  jobVerdict,
+  tail
+};
+//# sourceMappingURL=chunk-OUCV3FCT.js.map