@garuda-agent/garuda 0.0.1 → 0.15.0

package/dist/chunk-2S62ZNTC.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+import {
+  notificationBytes,
+  pickChannel
+} from "./chunk-N4I6YS3E.js";
+import {
+  gateProjectSettings,
+  totalTokens
+} from "./chunk-HRGX53VC.js";
+import {
+  TrustStore
+} from "./chunk-5DEWP3YX.js";
+import {
+  cleanArgs,
+  commitJob,
+  jobChanges,
+  prepareWorktree
+} from "./chunk-K3SIUOAG.js";
+import {
+  defaultAgentEnv,
+  removeAgent
+} from "./chunk-S77XDSD4.js";
+import {
+  jobReport
+} from "./chunk-YQTGMCU6.js";
+import {
+  jobVerdict,
+  parseReview,
+  reviewPrompt,
+  reviewerSystem,
+  riskFlags,
+  stackOf,
+  testSummary
+} from "./chunk-OUCV3FCT.js";
+import {
+  JobGitError,
+  git,
+  hostCommand
+} from "./chunk-2TAXSFWN.js";
+import {
+  createExecutor,
+  loadSettings
+} from "./chunk-SI2QJYCR.js";
+import {
+  JOBS_DIR,
+  loadJob,
+  saveJob
+} from "./chunk-KKB5W47S.js";
+import {
+  parseRule
+} from "./chunk-3NJNVZTK.js";
+
+// src/cli/jobCommand.ts
+import { writeFile } from "fs/promises";
+import { join } from "path";
+var JOB_TEST_TIMEOUT_MS = 10 * 6e4;
+async function testsBefore(prepared, runtime, renderer, git2 = createExecutor("host").executor) {
+  const { job } = prepared;
+  if (job.test === void 0) return;
+  renderer.info(`Tests before the job: ${job.test}`);
+  prepared.testsBefore = await runtime.runCheck(
+    job.test,
+    JOB_TEST_TIMEOUT_MS,
+    new AbortController().signal
+  );
+  renderer.info(`Tests before the job: ${testSummary(prepared.testsBefore)}`);
+  await git(git2, job.worktree, ["checkout", "--", "."], { check: false });
+  await git(git2, job.worktree, cleanArgs(job.links), { check: false });
+}
+async function proveJob(prepared, result, runtime, renderer, git2) {
+  const { job } = prepared;
+  const signal = new AbortController().signal;
+  let after;
+  if (job.test !== void 0) {
+    after = await runtime.runCheck(job.test, JOB_TEST_TIMEOUT_MS, signal);
+    renderer.info(`Tests after the job: ${testSummary(after)}`);
+  }
+  const before = prepared.testsBefore;
+  const flags = riskFlags({
+    result,
+    ...job.test === void 0 ? {} : { test: job.test },
+    ...before === void 0 ? {} : { before },
+    ...after === void 0 ? {} : { after }
+  });
+  if (result.commit === void 0) flags.push({ level: "look", text: "No file changed." });
+  const proof = {
+    verdict: "needs-look",
+    ...before === void 0 ? {} : { before },
+    ...after === void 0 ? {} : { after },
+    flags
+  };
+  if (job.review !== false && result.commit !== void 0) {
+    renderer.info("Reviewing the diff (a principal engineer's review)\u2026");
+    try {
+      const diff = (await git(git2, job.root, ["diff", "--no-renames", job.base, job.branch], {
+        check: false
+      })).stdout;
+      const answer = await runtime.askModel(
+        reviewerSystem(stackOf(result.files, runtime.profiles)),
+        reviewPrompt({
+          prompt: job.prompt,
+          files: result.files,
+          ...job.test === void 0 ? {} : { test: job.test },
+          ...before === void 0 ? {} : { before },
+          ...after === void 0 ? {} : { after },
+          flags,
+          diff
+        }),
+        signal
+      );
+      const parsed = parseReview(answer.text);
+      proof.review = {
+        ...parsed,
+        ...answer.costUsd === void 0 ? {} : { costUsd: answer.costUsd }
+      };
+    } catch (error) {
+      proof.reviewError = error.message;
+    }
+  }
+  proof.verdict = jobVerdict(flags, proof.review?.verdict);
+  return proof;
+}
+async function prepareJob(mainRoot, id, at, renderer, git2 = createExecutor("host").executor, launchd = {}, trustHome) {
+  const prepared = await prepare(mainRoot, id, at, renderer, git2, trustHome);
+  if (typeof prepared === "number" && launchd.fromLaunchd === true) {
+    const job = await loadJob(mainRoot, id).catch(() => void 0);
+    if (job !== void 0) await removeAgent(git2, job, launchd.env ?? defaultAgentEnv());
+  }
+  return prepared;
+}
+async function prepare(mainRoot, id, at, renderer, git2, trustHome) {
+  let job;
+  try {
+    job = await loadJob(mainRoot, id);
+  } catch (error) {
+    renderer.error(error.message);
+    return 1;
+  }
+  if (job.status === "running") {
+    renderer.error(
+      `Job ${id} is marked as running. If no other garuda runs it, set "status" to "stopped" in ${JOBS_DIR}/${id}.json and try again.`
+    );
+    return 1;
+  }
+  if (job.status === "done") {
+    renderer.error(`Job ${id} is done. Its report: ${join(JOBS_DIR, `${id}.md`)}`);
+    return 1;
+  }
+  if (at !== void 0) {
+    const waited = await waitUntil(at, renderer, job);
+    if (waited !== 0) return waited;
+  }
+  try {
+    await prepareWorktree(git2, job);
+  } catch (error) {
+    if (!(error instanceof JobGitError)) throw error;
+    renderer.error(`The job's worktree failed: ${error.message}`);
+    return 1;
+  }
+  const gate = await gateProjectSettings({
+    root: job.root,
+    settings: await loadSettings(job.worktree),
+    trust: trustHome === void 0 ? void 0 : await TrustStore.open(trustHome)
+  });
+  if (gate.notice !== void 0) renderer.info(gate.notice);
+  const project = gate.settings;
+  const links = job.links.map((name) => join(job.root, name));
+  const { network: _projectNetwork, ...projectRest } = project;
+  const settings = {
+    ...projectRest,
+    ...job.network === void 0 ? {} : { network: { allow: job.network } },
+    allow: [...project.allow, ...job.allow.map((rule) => parseRule(rule))],
+    maxSteps: job.maxSteps,
+    sandbox: {
+      ...project.sandbox,
+      // Linked folders (node_modules …) live in the checkout: tools may write their caches there.
+      writePaths: [...project.sandbox?.writePaths ?? [], ...links]
+    }
+  };
+  job.status = "running";
+  job.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveJob(job);
+  renderer.info(
+    `Job ${job.id}: ${job.title}
+Branch ${job.branch} \xB7 worktree ${job.worktree}
+Approved: ${job.allow.length === 0 ? "nothing beyond the sandbox" : job.allow.join(", ")}`
+  );
+  return { job, root: job.worktree, settings, denied: [], startedAt: Date.now() };
+}
+async function waitUntil(at, renderer, job) {
+  const match = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(at);
+  if (match === null) {
+    renderer.error(`"${at}" is not a time. Use HH:MM, for example 01:00.`);
+    return 1;
+  }
+  const ms = msUntil(Number(match[1]), Number(match[2]));
+  const hours = Math.floor(ms / 36e5);
+  const minutes = Math.round(ms % 36e5 / 6e4);
+  renderer.info(
+    `Job ${job.id} waits until ${at} (in ${hours} h ${minutes} min). Keep this terminal open and the Mac awake and on power. Ctrl-C cancels the wait.`
+  );
+  const cancelled = await new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      process.off("SIGINT", cancel);
+      resolve(false);
+    }, ms);
+    const cancel = () => {
+      clearTimeout(timer);
+      resolve(true);
+    };
+    process.once("SIGINT", cancel);
+  });
+  if (cancelled) {
+    renderer.warn(`The wait was cancelled. Job ${job.id} is still scheduled.`);
+    return 130;
+  }
+  return 0;
+}
+function msUntil(hour, minute, now = /* @__PURE__ */ new Date()) {
+  const next = new Date(now);
+  next.setHours(hour, minute, 0, 0);
+  if (next.getTime() <= now.getTime()) next.setDate(next.getDate() + 1);
+  return next.getTime() - now.getTime();
+}
+async function finishJob(prepared, outcome, runtime, renderer, git2 = createExecutor("host").executor, launchd = {}) {
+  const { job } = prepared;
+  const hadAgent = job.launchd !== void 0 || launchd.fromLaunchd === true;
+  delete job.launchd;
+  const result = {
+    stopReason: outcome.kind === "done" ? outcome.result.stopReason : outcome.kind,
+    steps: outcome.kind === "done" ? outcome.result.steps : 0,
+    tokens: runtime.session === void 0 ? 0 : totalTokens(runtime.session.usage),
+    ...runtime.session?.costUsd === void 0 ? {} : { costUsd: runtime.session.costUsd },
+    durationMs: Date.now() - prepared.startedAt,
+    ...runtime.session === void 0 ? {} : { sessionId: runtime.session.id },
+    files: [],
+    denied: prepared.denied,
+    answer: lastAnswer(runtime),
+    ...prepared.deadline === void 0 ? {} : {
+      modelCalls: {
+        batch: prepared.deadline.calls.primary,
+        normal: prepared.deadline.calls.fallback,
+        slow: prepared.deadline.calls.slow,
+        ...prepared.deadline.calls.switchedAt === void 0 ? {} : { switchedAt: prepared.deadline.calls.switchedAt.toISOString() }
+      }
+    },
+    ...outcome.kind === "error" ? { error: outcome.message } : {}
+  };
+  try {
+    const commit = await commitJob(
+      git2,
+      job,
+      `Garuda job ${job.id}: ${job.title}${outcome.kind === "done" && outcome.result.stopReason === "done" ? "" : ` (${result.stopReason})`}`
+    );
+    if (commit !== void 0) result.commit = commit;
+    result.files = await jobChanges(git2, job);
+  } catch (error) {
+    if (!(error instanceof JobGitError)) throw error;
+    result.error = [result.error, `commit: ${error.message}`].filter(Boolean).join("; ");
+  }
+  if (outcome.kind !== "interrupted") {
+    result.proof = await proveJob(prepared, result, runtime, renderer, git2);
+  }
+  job.status = outcome.kind === "error" ? "failed" : outcome.kind === "interrupted" ? "stopped" : "done";
+  job.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+  job.result = result;
+  await saveJob(job);
+  const report = jobReport(job);
+  const file = join(job.root, JOBS_DIR, `${job.id}.md`);
+  await writeFile(file, `${report}
+`, { mode: 384 });
+  renderer.info(`
+${report}
+
+Report: ${file}`);
+  const verdict = result.proof === void 0 ? "" : result.proof.verdict === "ready" ? ", ready to merge" : ", needs a look";
+  const note = `Garuda: job ${job.id} ${job.status}${verdict} (${result.files.length} file(s) changed)`;
+  if (process.stdout.isTTY) {
+    process.stdout.write(
+      notificationBytes(pickChannel(runtime.notificationSettings?.channel), note)
+    );
+  } else if (launchd.fromLaunchd === true && process.platform === "darwin") {
+    await hostCommand(
+      git2,
+      job.root,
+      [
+        "osascript",
+        "-e",
+        "on run argv",
+        "-e",
+        'display notification (item 1 of argv) with title "Garuda"',
+        "-e",
+        "end run",
+        note
+      ],
+      { check: false }
+    );
+  }
+  if (hadAgent) await removeAgent(git2, job, launchd.env ?? defaultAgentEnv());
+}
+function lastAnswer(runtime) {
+  const messages = runtime.session?.messages ?? [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m?.role !== "assistant") continue;
+    const text = m.content.map((b) => b.type === "text" ? b.text : "").join("").trim();
+    if (text !== "") return text.length <= 8e3 ? text : `${text.slice(0, 8e3)}
+\u2026 [cut]`;
+  }
+  return "";
+}
+
+export {
+  JOB_TEST_TIMEOUT_MS,
+  testsBefore,
+  prepareJob,
+  msUntil,
+  finishJob
+};
+//# sourceMappingURL=chunk-2S62ZNTC.js.map

package/dist/chunk-2TAXSFWN.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_ENV_ALLOWLIST
+} from "./chunk-SI2QJYCR.js";
+
+// src/jobs/git.ts
+var GIT_TIMEOUT_MS = 12e4;
+var JobGitError = class extends Error {
+};
+function shellWord(text) {
+  return /^[A-Za-z0-9_./:@=+-]+$/.test(text) ? text : `'${text.replace(/'/g, "'\\''")}'`;
+}
+function git(executor, cwd, args, options = {}) {
+  return hostCommand(executor, cwd, ["git", "-c", "core.hooksPath=/dev/null", ...args], options);
+}
+async function hostCommand(executor, cwd, argv, options = {}) {
+  const policy = {
+    root: cwd,
+    sandbox: false,
+    writePaths: [],
+    denyWritePaths: [],
+    denyReadPaths: [],
+    network: false,
+    envAllowlist: [...DEFAULT_ENV_ALLOWLIST],
+    timeoutMs: GIT_TIMEOUT_MS,
+    maxOutputBytes: 5e6
+  };
+  const command = argv.map(shellWord).join(" ");
+  const result = await executor.run(command, policy, {
+    ...options.signal === void 0 ? {} : { signal: options.signal },
+    env: { GIT_TERMINAL_PROMPT: "0" }
+  });
+  if (result.aborted) throw options.signal?.reason ?? new Error("stopped");
+  const out = { exitCode: result.exitCode, stdout: result.stdout.text, stderr: result.stderr.text };
+  if (options.check !== false && result.exitCode !== 0) {
+    const why = (out.stderr || out.stdout).trim().split("\n").slice(-3).join(" ");
+    const name = argv[0] === "git" ? `git ${argv.find((a, i) => i > 2 && !a.startsWith("-")) ?? ""}`.trim() : argv[0] ?? "command";
+    throw new JobGitError(result.timedOut ? `${name} took too long.` : `${name} failed: ${why}`);
+  }
+  return out;
+}
+
+export {
+  JobGitError,
+  shellWord,
+  git,
+  hostCommand
+};
+//# sourceMappingURL=chunk-2TAXSFWN.js.map