@garuda-agent/garuda 0.0.1 → 0.14.1

package/dist/chunk-YQTGMCU6.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import {
+  passed,
+  testSummary
+} from "./chunk-OUCV3FCT.js";
+
+// src/jobs/text.ts
+function jobPrompt(request, plan) {
+  return [
+    "Carry out the plan below. It was made in an earlier session; you now run as a scheduled job, and nobody can answer questions or approve calls.",
+    "- Work as a staff engineer: small, focused changes that follow the plan and the project's conventions, with tests that prove each change. A principal engineer reviews your diff before the user merges it.",
+    "- Calls outside the job's approved list are denied. Do not retry a denied call: continue without it, and list it at the end.",
+    "- Do not commit, push or change branches: Garuda commits your changes to the job's branch when you finish.",
+    "- Run the project's tests when the plan says how. End with a short report: what you changed, the test result, and what is left for the user.",
+    "",
+    "<request>",
+    request.trim(),
+    "</request>",
+    "",
+    "<plan>",
+    plan.trim(),
+    "</plan>"
+  ].join("\n");
+}
+var cost = (usd) => usd === void 0 ? "unknown" : `$${usd.toFixed(4)}`;
+function jobReport(job) {
+  const r = job.result;
+  const lines = [`# Garuda job ${job.id}: ${job.title}`, ""];
+  lines.push(
+    `- Status: ${job.status}${r === void 0 ? "" : ` (${r.stopReason})`}`,
+    `- Branch: ${job.branch} (worktree ${job.worktree})`,
+    `- Base: ${job.base.slice(0, 12)}`,
+    `- Approved: ${job.allow.length === 0 ? "nothing beyond the sandbox" : job.allow.join(", ")}`
+  );
+  if (job.batch === true) {
+    lines.push(
+      `- Batch API: yes, finish by ${job.finishBy ?? "07:00"}, step limit ${job.stepLimitMinutes ?? 20} min`
+    );
+  }
+  if (job.startedAt !== void 0) lines.push(`- Started: ${job.startedAt}`);
+  if (r === void 0) return lines.join("\n");
+  lines.push(
+    `- Steps: ${r.steps} \xB7 tokens: ${Math.round(r.tokens / 100) / 10}k \xB7 cost: ${cost(r.costUsd)} \xB7 time: ${Math.round(r.durationMs / 1e3)} s`
+  );
+  if (r.sessionId !== void 0) lines.push(`- Session: ${r.sessionId}`);
+  if (r.modelCalls !== void 0) {
+    const m = r.modelCalls;
+    lines.push(
+      `- Model calls: ${m.batch} through the Batch API, ${m.normal} normal${m.slow ? ` (${m.slow} after a batch waited too long)` : ""}${m.switchedAt === void 0 ? "" : `; the rest normal from ${m.switchedAt}`}`
+    );
+  }
+  if (r.error !== void 0) lines.push(`- Error: ${r.error}`);
+  if (r.proof !== void 0) lines.push("", ...proofLines(job, r.proof));
+  lines.push("", "## Files");
+  if (r.files.length === 0) lines.push("", "No file changed.");
+  else {
+    lines.push("");
+    for (const f of r.files) {
+      const counts = f.added === void 0 ? " (binary)" : ` (+${f.added} \u2212${f.removed ?? 0})`;
+      lines.push(`- ${f.status} ${f.path}${counts}`);
+    }
+  }
+  if (r.denied.length > 0) {
+    lines.push(
+      "",
+      "## Denied calls",
+      "",
+      "The job's list did not cover these; do them yourself or add rules and run again:",
+      ""
+    );
+    for (const d of r.denied) lines.push(`- ${d.tool}: ${d.target}`);
+  }
+  if (r.answer.trim() !== "") lines.push("", "## The agent's report", "", r.answer.trim());
+  lines.push(
+    "",
+    "## Next",
+    "",
+    r.commit === void 0 ? "Nothing to merge." : `Review: \`git diff ${job.base.slice(0, 12)} ${job.branch}\` \xB7 merge: \`git merge ${job.branch}\` \xB7 clean up: \`git worktree remove ${job.worktree}\``
+  );
+  return lines.join("\n");
+}
+function proofLines(job, proof) {
+  const out = [
+    "## Verdict",
+    "",
+    proof.verdict === "ready" ? "**Ready to merge**: the tests pass, nothing stops it, and the review found no blocker." : "**Needs a look**: see the flags and the review below before you merge.",
+    "",
+    "## Tests",
+    "",
+    job.test === void 0 ? 'No test command (set "test" in the job file).' : `\`${job.test}\`: before the job ${testSummary(proof.before)}; after it ${testSummary(proof.after)}.`
+  ];
+  if (proof.after !== void 0 && !passed(proof.after)) {
+    out.push("", "```text", proof.after.tail, "```");
+  }
+  out.push("", "## Risk flags", "");
+  if (proof.flags.length === 0) out.push("None.");
+  for (const f of proof.flags) out.push(`- ${f.level === "stop" ? "STOP" : "look"}: ${f.text}`);
+  if (proof.review !== void 0) {
+    const cost2 = proof.review.costUsd === void 0 ? "" : ` (${`$${proof.review.costUsd.toFixed(4)}`})`;
+    out.push("", `## Review by a principal engineer${cost2}`, "", proof.review.text);
+  } else if (proof.reviewError !== void 0) {
+    out.push("", "## Review", "", `The review failed: ${proof.reviewError}`);
+  }
+  return out;
+}
+
+export {
+  jobPrompt,
+  jobReport
+};
+//# sourceMappingURL=chunk-YQTGMCU6.js.map

package/dist/chunk-ZAE25JM2.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import {
+  checkAddress,
+  isIpLiteral,
+  isLoopbackHost
+} from "./chunk-ATW7BNIG.js";
+
+// src/mcp/config.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { z } from "zod";
+var MCP_FILE = join(".garuda", "mcp.json");
+var SERVER_NAME = /^[a-z0-9][a-z0-9_]{0,31}$/;
+var stdioSchema = z.strictObject({
+  command: z.string().min(1),
+  args: z.array(z.string()).default([]),
+  env: z.record(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), z.string()).default({}),
+  /** The server may use the network. Default: no network (it runs in the OS sandbox). */
+  network: z.boolean().default(false),
+  /** Extra writable paths. `~/` is the home folder; relative paths start at the root. */
+  writePaths: z.array(z.string()).default([]),
+  /** Time limit for one tool call. */
+  timeoutMs: z.number().int().min(1e3).max(6e5).default(6e4),
+  enabled: z.boolean().default(true)
+});
+var httpSchema = z.strictObject({
+  type: z.literal("http").optional(),
+  url: z.string().min(1),
+  /** Time limit for one tool call. */
+  timeoutMs: z.number().int().min(1e3).max(6e5).default(6e4),
+  enabled: z.boolean().default(true)
+});
+var serverSchema = z.union([httpSchema, stdioSchema]);
+var fileSchema = z.strictObject({
+  servers: z.record(z.string(), serverSchema).default({})
+});
+function isHttp(def) {
+  return "url" in def;
+}
+async function loadMcpConfig({ home, root } = { home: homedir(), root: process.cwd() }) {
+  const problems = [];
+  const read = async (source, file) => {
+    let text;
+    try {
+      text = await readFile(file, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return [];
+      problems.push(`${file}: ${error.message}`);
+      return [];
+    }
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch (error) {
+      problems.push(`${file}: invalid JSON: ${error.message}`);
+      return [];
+    }
+    const parsed = fileSchema.safeParse(json);
+    if (!parsed.success) {
+      problems.push(`${file}: ${z.prettifyError(parsed.error)}`);
+      return [];
+    }
+    const out = [];
+    for (const [name, def] of Object.entries(parsed.data.servers)) {
+      if (!SERVER_NAME.test(name)) {
+        problems.push(
+          `${file}: server name "${name}" is not valid. Use lowercase letters, digits and _ (up to 32).`
+        );
+        continue;
+      }
+      if (isHttp(def)) {
+        const problem = checkServerUrl(def.url, source);
+        if (problem !== void 0) {
+          problems.push(`${file}: server "${name}": ${problem}`);
+          continue;
+        }
+      }
+      out.push({ name, source, file, def });
+    }
+    return out;
+  };
+  const user = await read("user", join(home, MCP_FILE));
+  const project = home === root ? [] : await read("project", join(root, MCP_FILE));
+  const userNames = new Set(user.map((s) => s.name));
+  for (const s of project) {
+    if (userNames.has(s.name)) {
+      problems.push(
+        `${s.file}: server "${s.name}" is ignored: a server with this name is in your own ${join("~", MCP_FILE)}.`
+      );
+    }
+  }
+  return { servers: [...user, ...project.filter((s) => !userNames.has(s.name))], problems };
+}
+function checkServerUrl(raw, source) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return `"${raw.slice(0, 200)}" is not a valid URL.`;
+  }
+  if (url.username !== "" || url.password !== "")
+    return "a URL with a user name or password is not allowed.";
+  if (url.hash !== "") return "a URL with a #fragment is not allowed.";
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  const loopback = isLoopbackHost(host);
+  if (url.protocol === "http:") {
+    if (!loopback || source === "project")
+      return "use https (http only for localhost, in your own ~/.garuda/mcp.json).";
+  } else if (url.protocol !== "https:") {
+    return `only https URLs are allowed, not ${url.protocol}`;
+  }
+  if (source === "project" && (loopback || isIpLiteral(host) && !checkAddress(host, false).ok)) {
+    return "a project server must be on a public address.";
+  }
+  return void 0;
+}
+function defHash(def) {
+  if (isHttp(def)) {
+    return createHash("sha256").update(JSON.stringify({ type: "http", url: def.url })).digest("hex");
+  }
+  const canonical = JSON.stringify({
+    command: def.command,
+    args: def.args,
+    env: Object.fromEntries(Object.entries(def.env).sort(([a], [b]) => a.localeCompare(b))),
+    network: def.network,
+    writePaths: def.writePaths
+  });
+  return createHash("sha256").update(canonical).digest("hex");
+}
+function expandEnv(env, source = process.env) {
+  const missing = [];
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    out[key] = value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, name) => {
+      const v = source[name];
+      if (v === void 0) missing.push(name);
+      return v ?? "";
+    });
+  }
+  return { env: out, missing };
+}
+function commandLine(def) {
+  const quote = (s) => /^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replaceAll("'", `'\\''`)}'`;
+  return [def.command, ...def.args].map(quote).join(" ");
+}
+
+export {
+  SERVER_NAME,
+  isHttp,
+  loadMcpConfig,
+  checkServerUrl,
+  defHash,
+  expandEnv,
+  commandLine
+};
+//# sourceMappingURL=chunk-ZAE25JM2.js.map

package/dist/chunk-ZGZ2ZADL.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_ENV_ALLOWLIST
+} from "./chunk-D5O5CIWK.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-ZGZ2ZADL.js.map