roger-roger 0.1.0

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

@@ -0,0 +1,84 @@
+// Session nicknames. Every agent session is given a short colour name — rose, jade, gold — so the
+// user can tell three agents apart at a glance and address one of them in a sentence. The colour is
+// not just a word: it becomes the swatch in front of the session's Slack messages and the colour of
+// the bar down their left edge, so a glance at the DM is enough to see who is talking.
+//
+// The pool lives in the config (`setup --names`), so the user can replace it with anything they
+// like; a name outside the table still gets a stable colour, derived from the name itself.
+
+/**
+ * name → [hex, emoji]. Short colour words that read like names, each with a token that gives it a
+ * face. The emoji is what the user sees in front of the session's messages; the hex is the bar Slack
+ * draws down their left edge.
+ */
+const COLOURS = {
+  rose: ["#D95F7C", "🌹"],
+  ruby: ["#9B111E", "💎"],
+  jade: ["#00A86B", "🐉"],
+  sage: ["#8A9A5B", "🌿"],
+  iris: ["#5A4FCF", "🪻"],
+  cyan: ["#00B7C2", "🐳"],
+  plum: ["#8E4585", "🍇"],
+  gold: ["#D4AF37", "🏆"],
+  amber: ["#FFBF00", "🍯"],
+  ash: ["#B2BEB5", "🪨"],
+  flint: ["#6F6F6F", "⚡"],
+  mint: ["#7FD4A0", "🍬"],
+  olive: ["#808000", "🫒"],
+};
+
+export const NAMES = Object.keys(COLOURS);
+
+const SWATCHES = ["🔴", "🟠", "🟡", "🟢", "🔵", "🟣", "🟤", "⚫", "⚪"];
+
+/** The hex and swatch for a nickname. Names the user invented get a stable colour of their own. */
+export function colourOf(name) {
+  const key = String(name ?? "").toLowerCase();
+  // `jade2` is still a jade: a numbered name keeps the colour and face of the one it came from.
+  const base = key.replace(/\d+$/, "");
+  if (COLOURS[base]) return { name: key, hex: COLOURS[base][0], swatch: COLOURS[base][1] };
+  let hash = 0;
+  for (const ch of key) hash = (hash * 31 + ch.charCodeAt(0)) >>> 0;
+  const hue = hash % 360;
+  return { name: key, hex: hslHex(hue, 55, 55), swatch: SWATCHES[hash % SWATCHES.length] };
+}
+
+/** `🌿 sage` — how a session is shown wherever there is room for one short token. */
+export function badge(name) {
+  const { swatch } = colourOf(name);
+  return `${swatch} ${name}`;
+}
+
+function hslHex(h, s, l) {
+  const a = (s / 100) * Math.min(l / 100, 1 - l / 100);
+  const f = (n) => {
+    const k = (n + h / 30) % 12;
+    const v = l / 100 - a * Math.max(-1, Math.min(k - 3, 9 - k, 1));
+    return Math.round(255 * v).toString(16).padStart(2, "0");
+  };
+  return `#${f(0)}${f(8)}${f(4)}`.toUpperCase();
+}
+
+/** Valid nickname: one short word, so it can be typed in front of a sentence. */
+export function isNickname(value) {
+  return typeof value === "string" && /^[a-z][a-z0-9-]{1,15}$/.test(value.toLowerCase());
+}
+
+/**
+ * A free nickname from the pool, chosen at random so consecutive sessions don't look alike. Falls
+ * back to numbering (`sage2`) only once every name in the pool is in use.
+ */
+export function pickName(taken = [], pool = NAMES, random = Math.random) {
+  const used = new Set(taken.map((n) => String(n).toLowerCase()));
+  const names = (pool.length ? pool : NAMES).map((n) => String(n).toLowerCase()).filter(isNickname);
+  const free = names.filter((n) => !used.has(n));
+  // Two of a kind side by side defeat the point, so prefer an emoji nobody is wearing.
+  const swatches = new Set([...used].map((n) => colourOf(n).swatch));
+  const distinct = free.filter((n) => !swatches.has(colourOf(n).swatch));
+  const from = distinct.length ? distinct : free;
+  if (from.length) return from[Math.floor(random() * from.length) % from.length];
+  for (let suffix = 2; ; suffix++) {
+    const candidates = names.map((n) => `${n}${suffix}`).filter((n) => !used.has(n));
+    if (candidates.length) return candidates[Math.floor(random() * candidates.length) % candidates.length];
+  }
+}

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

@@ -0,0 +1,91 @@
+// Progress messages: one Slack message per key, edited in place as work moves on, with Pause /
+// Resume / Stop buttons. State (~/.roger-roger/progress/<key>.json) remembers which message to edit,
+// what it last said, and the latest button the user pressed.
+
+import fs from "node:fs";
+import path from "node:path";
+import { rogerRogerHome } from "./lib.mjs";
+
+// After this long a key starts a fresh message rather than editing one buried far up the DM.
+const STALE_MS = 12 * 3600 * 1000;
+// How long after its last update a progress message keeps the watcher (and so its buttons) alive.
+const ACTIVE_MS = 2 * 3600 * 1000;
+
+export const CONTROLS = ["running", "pause", "stop"];
+
+function dir() {
+  return path.join(rogerRogerHome(), "progress");
+}
+
+function fileFor(key) {
+  return path.join(dir(), `${key}.json`);
+}
+
+/** Keys become file names, so keep them to a safe, readable alphabet. */
+export function progressKey(value) {
+  const key = String(value).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  if (!key) throw new Error("--key must contain letters or digits");
+  return key;
+}
+
+/** The message a key is editing, or null if there is none (or it has gone stale). */
+export function current(key, now = Date.now()) {
+  try {
+    const state = JSON.parse(fs.readFileSync(fileFor(key), "utf8"));
+    return now - Date.parse(state.updatedAt) < STALE_MS ? state : null;
+  } catch {
+    return null;
+  }
+}
+
+export function save(key, state) {
+  fs.mkdirSync(dir(), { recursive: true });
+  const tmp = `${fileFor(key)}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify({ ...state, key }, null, 2) + "\n", "utf8");
+  fs.renameSync(tmp, fileFor(key));
+}
+
+/**
+ * What an agent's check sees: the user's Pause / Stop (now acknowledged, so the message can say the
+ * agent is really holding or stopping) and notes it hasn't read yet (now marked read).
+ */
+export function acknowledge(state, now = new Date().toISOString()) {
+  const control = state?.control ?? { state: "running" };
+  const acked = control.state !== "running" && !control.ack ? { ...control, ack: now } : control;
+  const notes = state?.notes ?? [];
+  const unread = notes.filter((n) => !n.readAt);
+  return {
+    control: acked,
+    notes: notes.map((n) => (n.readAt ? n : { ...n, readAt: now })),
+    unread,
+    changed: acked !== control || unread.length > 0,
+  };
+}
+
+/**
+ * Save after a check without losing anything the user did meanwhile: a newer button press wins over
+ * the acknowledged one, and notes that arrived during the check stay unread.
+ */
+export function mergeAcknowledged(latest, seen) {
+  const control = latest?.control && latest.control.at !== seen.control.at ? latest.control : seen.control;
+  const readAt = new Map(seen.notes.filter((n) => n.readAt).map((n) => [n.at, n.readAt]));
+  const notes = (latest?.notes ?? seen.notes).map((n) => (readAt.has(n.at) && !n.readAt ? { ...n, readAt: readAt.get(n.at) } : n));
+  return { control, notes };
+}
+
+export function finish(key) {
+  fs.rmSync(fileFor(key), { force: true });
+}
+
+/** Progress messages updated recently enough that their buttons should keep working. */
+export function active(now = Date.now()) {
+  let files;
+  try {
+    files = fs.readdirSync(dir()).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  return files
+    .map((f) => current(f.slice(0, -5), now))
+    .filter((s) => s && s.headline && now - Date.parse(s.updatedAt) < ACTIVE_MS);
+}

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

@@ -0,0 +1,71 @@
+// How the CLI talks to the daemon: newline-delimited JSON over a local socket. A named pipe on
+// Windows, a unix socket elsewhere. No port is opened, so nothing on the network can reach it, and
+// the socket lives or dies with the process that bound it.
+//
+// A request is { n, cmd, args, session }. The daemon answers with { n, ok, data, code } and may send
+// { n, event, data } lines first, so a client blocked in `wait` hears about an answer the moment it
+// lands instead of polling for it.
+
+import crypto from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { rogerRogerHome } from "./lib.mjs";
+
+// macOS and Linux cap a unix socket path at ~104 bytes, and quietly fail to bind past it. A home
+// under a temp directory — a test, or a machine that puts homes somewhere deep — can reach that
+// without anyone noticing, so a long one gets a short name derived from it instead. Two homes still
+// get two daemons either way.
+const MAX_SOCKET_PATH = 100;
+
+export function unixSocketPath(home, tmpDir = os.tmpdir()) {
+  const preferred = path.join(home, "daemon.sock");
+  if (Buffer.byteLength(preferred) <= MAX_SOCKET_PATH) return preferred;
+  const tag = crypto.createHash("sha1").update(home).digest("hex").slice(0, 12);
+  return path.join(tmpDir, `roger-roger-${tag}.sock`);
+}
+
+export const PROTOCOL_VERSION = 1;
+
+/**
+ * The socket to talk on. It is derived from ROGER_ROGER_HOME, so a test (or a second account) gets its
+ * own daemon rather than joining the real one.
+ */
+export function socketPath(env = process.env) {
+  const home = rogerRogerHome(env);
+  if (process.platform !== "win32") return unixSocketPath(home);
+  const tag = crypto.createHash("sha1").update(home.toLowerCase()).digest("hex").slice(0, 12);
+  return `\\\\.\\pipe\\roger-roger-${tag}`;
+}
+
+/** Reads a socket's NDJSON and calls `onMessage` for each complete line. */
+export function lineReader(onMessage, onBad = () => {}) {
+  let buffer = "";
+  return (chunk) => {
+    buffer += chunk;
+    let nl;
+    while ((nl = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, nl).trim();
+      buffer = buffer.slice(nl + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch (e) {
+        onBad(e, line);
+        continue;
+      }
+      onMessage(message);
+    }
+  };
+}
+
+export function send(socket, message) {
+  try {
+    socket.write(JSON.stringify(message) + "\n");
+    return true;
+  } catch {
+    return false; // The other end went away; callers treat that as a closed connection.
+  }
+}
+
+export { identity } from "./agent.mjs";