@garuda-agent/garuda 0.0.1 → 0.15.0

package/dist/nightCommand-CR6ZHYGP.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+import {
+  msUntil
+} from "./chunk-2S62ZNTC.js";
+import {
+  notificationBytes,
+  pickChannel
+} from "./chunk-N4I6YS3E.js";
+import "./chunk-HRGX53VC.js";
+import "./chunk-5DEWP3YX.js";
+import "./chunk-PZS3V6P3.js";
+import "./chunk-K3SIUOAG.js";
+import {
+  defaultAgentEnv,
+  nightSpec,
+  removeSpec
+} from "./chunk-S77XDSD4.js";
+import "./chunk-YQTGMCU6.js";
+import {
+  testSummary
+} from "./chunk-OUCV3FCT.js";
+import {
+  hostCommand,
+  shellWord
+} from "./chunk-2TAXSFWN.js";
+import {
+  createExecutor
+} from "./chunk-SI2QJYCR.js";
+import "./chunk-WMOLXTBU.js";
+import "./chunk-HUIK3WXO.js";
+import {
+  JOBS_DIR,
+  listJobs,
+  loadJob,
+  settleJob
+} from "./chunk-KKB5W47S.js";
+import "./chunk-3NJNVZTK.js";
+
+// src/cli/nightCommand.ts
+import { realpathSync } from "fs";
+
+// src/jobs/night.ts
+import { writeFile } from "fs/promises";
+import { join } from "path";
+var DEFAULT_NIGHT_PARALLEL = 3;
+var MAX_NIGHT_PARALLEL = 10;
+var JOB_PROCESS_TIMEOUT_MS = 24 * 36e5;
+async function nightQueue(root) {
+  const jobs = await listJobs(root);
+  return jobs.filter((j) => j.status === "scheduled" && j.queue === true && j.launchd === void 0).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function processRunner(executor, env) {
+  const program = env.script === "" || env.script === env.node ? shellWord(env.node) : `${shellWord(env.node)} ${shellWord(env.script)}`;
+  return async (job) => {
+    const log = join(job.root, JOBS_DIR, `${job.id}.log`);
+    const result = await executor.run(
+      `${program} run ${shellWord(job.id)} >> ${shellWord(log)} 2>&1`,
+      {
+        root: job.root,
+        sandbox: false,
+        writePaths: [],
+        denyWritePaths: [],
+        denyReadPaths: [],
+        network: true,
+        envAllowlist: [],
+        timeoutMs: JOB_PROCESS_TIMEOUT_MS,
+        maxOutputBytes: 1e4
+      },
+      { env: processEnv() }
+    );
+    return result.exitCode;
+  };
+}
+function processEnv() {
+  const out = {};
+  for (const [k, v] of Object.entries(process.env)) if (typeof v === "string") out[k] = v;
+  return out;
+}
+async function runQueue(jobs, run, parallel, report = {}) {
+  let next = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const job = jobs[next++];
+      if (job === void 0) return;
+      report.onStart?.(job);
+      let code = null;
+      try {
+        code = await run(job);
+      } catch {
+        code = null;
+      }
+      await report.settle?.(job, code).catch(() => {
+      });
+      report.onEnd?.(job, code);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(parallel, jobs.length)) }, worker));
+}
+function nightDigest(jobs, started, ended) {
+  const ready = jobs.filter((j) => j.result?.proof?.verdict === "ready");
+  const cost = jobs.reduce(
+    (sum, j) => sum + (j.result?.costUsd ?? 0) + (j.result?.proof?.review?.costUsd ?? 0),
+    0
+  );
+  const lines = [
+    `# Garuda night shift: ${local(started)}`,
+    "",
+    `${jobs.length} job(s): ${ready.length} ready to merge, ${jobs.length - ready.length} need a look. Time ${Math.round((ended.getTime() - started.getTime()) / 6e4)} min \xB7 cost $${cost.toFixed(4)}.`,
+    "",
+    "| Job | Verdict | Tests after | Files | Cost | Branch |",
+    "| --- | --- | --- | --- | --- | --- |"
+  ];
+  for (const j of jobs) {
+    const r = j.result;
+    const verdict = r?.proof === void 0 ? j.status : r.proof.verdict === "ready" ? "ready to merge" : "needs a look";
+    const jobCost = r === void 0 ? "\u2013" : `$${((r.costUsd ?? 0) + (r.proof?.review?.costUsd ?? 0)).toFixed(4)}`;
+    lines.push(
+      `| ${j.id}: ${cell(j.title)} | ${verdict} | ${j.test === void 0 ? "no tests" : testSummary(r?.proof?.after)} | ${r?.files.length ?? 0} | ${jobCost} | ${j.branch} |`
+    );
+  }
+  const looks = jobs.filter((j) => j.result?.proof?.verdict !== "ready");
+  if (looks.length > 0) {
+    lines.push("", "## Needs a look", "");
+    for (const j of looks) {
+      const flags = j.result?.proof?.flags.map((f) => f.text) ?? [];
+      const summary = /^SUMMARY:\s*(.+)$/m.exec(j.result?.proof?.review?.text ?? "")?.[1];
+      const why = [...flags, ...summary === void 0 ? [] : [`Review: ${summary}`]];
+      lines.push(`- ${j.id}: ${why.length === 0 ? `status ${j.status}` : why.join(" ")}`);
+    }
+  }
+  lines.push(
+    "",
+    "## Next",
+    "",
+    "Each job's report: `/jobs <id>` or `.garuda/jobs/<id>.md`. Merge a ready branch with `git merge <branch>`."
+  );
+  return lines.join("\n");
+}
+async function writeDigest(root, text, started) {
+  const file = join(root, JOBS_DIR, `night-${stamp(started)}.md`);
+  await writeFile(file, `${text}
+`, { mode: 384 });
+  return file;
+}
+var cell = (text) => text.replace(/\|/g, "\\|").replace(/\n/g, " ");
+var pad = (n) => String(n).padStart(2, "0");
+function local(d) {
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function stamp(d) {
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}`;
+}
+
+// src/cli/nightCommand.ts
+async function nightCommand(options, renderer, runner, root = realpathSync(process.cwd()), agent = {}) {
+  const code = await runNight(options, renderer, runner, root, agent);
+  if (options.fromLaunchd === true) {
+    await removeSpec(
+      agent.executor ?? createExecutor("host").executor,
+      nightSpec(root),
+      agent.env ?? defaultAgentEnv()
+    );
+  }
+  return code;
+}
+async function runNight(options, renderer, runner, root, agent) {
+  const parallel = options.parallel === void 0 ? DEFAULT_NIGHT_PARALLEL : Number(options.parallel);
+  if (!Number.isInteger(parallel) || parallel < 1 || parallel > MAX_NIGHT_PARALLEL) {
+    renderer.error(`--parallel takes 1 to ${MAX_NIGHT_PARALLEL}.`);
+    return 1;
+  }
+  if (options.at !== void 0) {
+    const m = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(options.at);
+    if (m === null) {
+      renderer.error(`"${options.at}" is not a time. Use HH:MM, for example 01:00.`);
+      return 1;
+    }
+    const ms = msUntil(Number(m[1]), Number(m[2]));
+    renderer.info(
+      `The night shift starts at ${options.at} (in ${Math.floor(ms / 36e5)} h ${Math.round(ms % 36e5 / 6e4)} min). Keep this terminal open and the Mac awake and on power. Ctrl-C cancels.`
+    );
+    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. The queue is unchanged.");
+      return 130;
+    }
+  }
+  const queue = await nightQueue(root);
+  if (queue.length === 0) {
+    renderer.info("The night queue is empty. Make a plan (/plan), then /schedule adds it.");
+    return 0;
+  }
+  const started = /* @__PURE__ */ new Date();
+  renderer.info(
+    `Night shift: ${queue.length} job(s), up to ${parallel} at a time. Each job logs to .garuda/jobs/<id>.log.`
+  );
+  const run = runner ?? processRunner(createExecutor("host").executor, defaultAgentEnv());
+  await runQueue(queue, run, parallel, {
+    onStart: (job) => renderer.info(`\u25B6 ${job.id}: ${job.title}`),
+    onEnd: (job, code) => renderer.info(`\u25A0 ${job.id} ended (exit code ${code ?? "none"})`),
+    // A job process that was killed leaves its job "running": mark it failed (0.14.1, review).
+    settle: (job, code) => settleJob(root, job.id, code)
+  });
+  const jobs = await Promise.all(queue.map((j) => loadJob(root, j.id).catch(() => j)));
+  const digest = nightDigest(jobs, started, /* @__PURE__ */ new Date());
+  const file = await writeDigest(root, digest, started);
+  renderer.info(`
+${digest}
+
+Digest: ${file}`);
+  const ready = jobs.filter((j) => j.result?.proof?.verdict === "ready").length;
+  const note = `Garuda night shift: ${jobs.length} job(s), ${ready} ready to merge`;
+  if (process.stdout.isTTY) {
+    process.stdout.write(notificationBytes(pickChannel(void 0), note));
+  } else if (options.fromLaunchd === true && (agent.platform ?? process.platform) === "darwin") {
+    await hostCommand(
+      agent.executor ?? createExecutor("host").executor,
+      root,
+      [
+        "osascript",
+        "-e",
+        "on run argv",
+        "-e",
+        'display notification (item 1 of argv) with title "Garuda"',
+        "-e",
+        "end run",
+        note
+      ],
+      { check: false }
+    );
+  }
+  return 0;
+}
+export {
+  nightCommand
+};
+//# sourceMappingURL=nightCommand-CR6ZHYGP.js.map

package/dist/oauth-W6OK6XXO.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import {
+  AUTH_FILE,
+  AuthStore,
+  CallbackError,
+  GarudaOAuthProvider,
+  SIGN_IN_TIMEOUT_MS,
+  authKey,
+  freePort,
+  waitForCallback
+} from "./chunk-3CEPHS4C.js";
+import "./chunk-PZS3V6P3.js";
+export {
+  AUTH_FILE,
+  AuthStore,
+  CallbackError,
+  GarudaOAuthProvider,
+  SIGN_IN_TIMEOUT_MS,
+  authKey,
+  freePort,
+  waitForCallback
+};
+//# sourceMappingURL=oauth-W6OK6XXO.js.map