roger-roger 0.1.0

package/skills/roger-roger/scripts/decisions.mjs

@@ -0,0 +1,158 @@
+// Pending decisions on disk (~/.roger-roger/decisions/<id>.json), plus settling one:
+// recording the outcome and rewriting its Slack message so the buttons go away.
+
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { rogerRogerHome, outcomeText, resolvedBlocks, stripTags } from "./lib.mjs";
+import { updateMessage } from "./slack.mjs";
+
+const KEEP_RESOLVED_MS = 7 * 24 * 3600 * 1000;
+
+export function decisionsDir() {
+  return path.join(rogerRogerHome(), "decisions");
+}
+
+function fileFor(id) {
+  if (!/^[a-z0-9]+$/.test(id)) throw new Error(`invalid decision id "${id}"`);
+  return path.join(decisionsDir(), `${id}.json`);
+}
+
+export function newId() {
+  return crypto.randomBytes(4).toString("hex");
+}
+
+/** Write via a temp file and rename, so a reader never sees half a decision. */
+function write(decision) {
+  fs.mkdirSync(decisionsDir(), { recursive: true });
+  const file = fileFor(decision.id);
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(decision, null, 2) + "\n", "utf8");
+  fs.renameSync(tmp, file);
+}
+
+export function create(decision) {
+  write(decision);
+  return decision;
+}
+
+export function read(id) {
+  try {
+    return JSON.parse(fs.readFileSync(fileFor(id), "utf8"));
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  }
+}
+
+/** All decisions, newest first. Resolved ones older than a week are deleted on the way. */
+export function list() {
+  let files;
+  try {
+    files = fs.readdirSync(decisionsDir()).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const now = Date.now();
+  const all = [];
+  for (const f of files) {
+    try {
+      const d = JSON.parse(fs.readFileSync(path.join(decisionsDir(), f), "utf8"));
+      if (d.status !== "pending" && now - Date.parse(d.resolvedAt ?? d.createdAt) > KEEP_RESOLVED_MS) {
+        fs.rmSync(path.join(decisionsDir(), f), { force: true });
+        continue;
+      }
+      all.push(d);
+    } catch {
+      // A file mid-write or hand-edited into garbage is skipped, not fatal.
+    }
+  }
+  return all.sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
+}
+
+/** Change a still-pending decision's bookkeeping (e.g. reminders sent). Returns it, or null if settled. */
+export function patchPending(id, patch) {
+  const current = read(id);
+  if (!current || current.status !== "pending") return null;
+  const next = { ...current, ...patch };
+  write(next);
+  return next;
+}
+
+/** Settle a decision whose time is up: its recommended option if it has one and asked for that, else expired. */
+export function expire(decision, log, options) {
+  const r = decision.recommended;
+  if (decision.onExpire === "recommended" && decision.multi && Array.isArray(r) && r.length) {
+    const indices = r.filter((i) => decision.choices[i] !== undefined);
+    return settle(decision.id, {
+      status: "answered",
+      answer: { indices, choices: indices.map((i) => decision.choices[i]), by: null, auto: true },
+    }, log, options);
+  }
+  if (decision.onExpire === "recommended" && Number.isInteger(r) && decision.choices[r] !== undefined) {
+    return settle(decision.id, { status: "answered", answer: { index: r, choice: decision.choices[r], by: null, auto: true } }, log, options);
+  }
+  return settle(decision.id, { status: "expired" }, log, options);
+}
+
+export function isExpired(decision, now = Date.now()) {
+  return decision.status === "pending" && Date.parse(decision.expiresAt) <= now;
+}
+
+/**
+ * Move a pending decision to a final state and update its Slack message.
+ * Returns the settled decision (with `slackUpdateError` if the message could not be
+ * rewritten), or null if it was already settled: the first outcome wins.
+ */
+export async function settle(id, patch, log = () => {}, { waiting = false } = {}) {
+  const current = read(id);
+  if (!current || current.status !== "pending") return null;
+  const now = new Date().toISOString();
+  // An answer belongs to the session that asked until it has actually been handed over. While
+  // `deliveredAt` is null it waits here, and the next command from that agent — any command — picks
+  // it up. Without that, an agent that stopped waiting never learns what the user said.
+  const owed = Boolean(current.sessionId) && patch.status === "answered";
+  const settled = { ...current, ...patch, resolvedAt: now, ...(owed ? { deliveredAt: waiting ? now : null } : {}) };
+  write(settled);
+
+  try {
+    const outcome = outcomeText(settled);
+    await updateMessage(settled.channel, settled.ts, {
+      text: `${stripTags(settled.question)} (${outcome})`,
+      blocks: resolvedBlocks(settled, outcome),
+    });
+    return settled;
+  } catch (e) {
+    log(`could not update Slack message for ${id}: ${e.message}`);
+    return { ...settled, slackUpdateError: e.message };
+  }
+}
+
+/** Answers this session has not been handed yet, oldest first. */
+export function undeliveredFor(sessionId) {
+  if (!sessionId) return [];
+  return list()
+    .filter((d) => d.sessionId === sessionId && d.status === "answered" && d.deliveredAt === null)
+    .sort((a, b) => Date.parse(a.resolvedAt) - Date.parse(b.resolvedAt));
+}
+
+/**
+ * Hand an answer over, and say so in Slack so the message stops claiming nobody has read it.
+ * Returns the delivered decision, or null if there was nothing to hand over.
+ */
+export async function deliver(id, log = () => {}) {
+  const current = read(id);
+  if (!current || current.status !== "answered" || current.deliveredAt !== null) return null;
+  const delivered = { ...current, deliveredAt: new Date().toISOString() };
+  write(delivered);
+  try {
+    const outcome = outcomeText(delivered);
+    await updateMessage(delivered.channel, delivered.ts, {
+      text: `${stripTags(delivered.question)} (${outcome})`,
+      blocks: resolvedBlocks(delivered, outcome),
+    });
+  } catch (e) {
+    log(`could not update Slack message for ${id}: ${e.message}`);
+  }
+  return delivered;
+}