roger-roger 0.1.0

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

@@ -0,0 +1,465 @@
+// A small terminal UI for `install`: a select, a multi-select, a confirm, a text field, a step with a
+// spinner, and notes. Raw mode and ANSI escapes, nothing else, so the skill keeps its
+// no-dependencies promise. Every prompt reads from `input` and draws on `output`, so a test can
+// drive one with a fake stream and read back exactly what it drew.
+//
+// The look is deliberate: one column of rail characters down the left (◆ for the question being
+// asked, ◇ for one answered, │ between, └ at the foot), so the whole setup reads as one page rather
+// than a stack of prompts.
+
+import { EOL } from "node:os";
+
+export class Cancelled extends Error {
+  constructor() {
+    super("cancelled");
+    this.name = "Cancelled";
+  }
+}
+
+// ---------------------------------------------------------------- colours and characters
+
+/** Colour on or off: the user's say (NO_COLOR, FORCE_COLOR) first, then whether this is a terminal. */
+export function coloursOn(output = process.stdout, env = process.env) {
+  if (env.NO_COLOR !== undefined && env.NO_COLOR !== "") return false;
+  if (env.FORCE_COLOR !== undefined) return env.FORCE_COLOR !== "0";
+  return Boolean(output.isTTY) && env.TERM !== "dumb";
+}
+
+export function makeStyle(on) {
+  const wrap = (open, close) => (s) => (on ? `\x1b[${open}m${s}\x1b[${close}m` : String(s));
+  return {
+    on,
+    bold: wrap(1, 22),
+    dim: wrap(2, 22),
+    italic: wrap(3, 23),
+    underline: wrap(4, 24),
+    inverse: wrap(7, 27),
+    red: wrap(31, 39),
+    green: wrap(32, 39),
+    yellow: wrap(33, 39),
+    blue: wrap(34, 39),
+    magenta: wrap(35, 39),
+    cyan: wrap(36, 39),
+    gray: wrap(90, 39),
+  };
+}
+
+export const strip = (s) => String(s).replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
+
+/** Visible width, near enough: escapes don't count, and wide characters (emoji, CJK) count double. */
+export function width(s) {
+  let n = 0;
+  for (const ch of strip(s)) {
+    const code = ch.codePointAt(0);
+    if (code < 32 || (code >= 0x300 && code <= 0x36f) || code === 0xfe0f || code === 0x200d) continue;
+    const wide =
+      (code >= 0x1100 && code <= 0x115f) ||
+      (code >= 0x2e80 && code <= 0xa4cf) ||
+      (code >= 0xac00 && code <= 0xd7a3) ||
+      (code >= 0xf900 && code <= 0xfaff) ||
+      (code >= 0xfe30 && code <= 0xfe4f) ||
+      (code >= 0xff00 && code <= 0xff60) ||
+      (code >= 0xffe0 && code <= 0xffe6) ||
+      (code >= 0x1f300 && code <= 0x1faff) ||
+      (code >= 0x20000 && code <= 0x3fffd);
+    n += wide ? 2 : 1;
+  }
+  return n;
+}
+
+/** Cut a plain string to `max` columns, with an ellipsis if anything was cut. */
+export function fit(text, max) {
+  const s = String(text);
+  if (max <= 0) return "";
+  if (width(s) <= max) return s;
+  let out = "";
+  for (const ch of s) {
+    if (width(out + ch) > max - 1) break;
+    out += ch;
+  }
+  return out + "…";
+}
+
+export const RAIL = { ask: "◆", done: "◇", bar: "│", end: "└", fail: "■", radioOn: "●", radioOff: "○", boxOn: "◼", boxOff: "◻" };
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+// ---------------------------------------------------------------- keys
+
+/** One chunk from a raw-mode terminal → which key it was. Pasted text arrives as one `char` holding all of it. */
+export function parseKey(data) {
+  const s = data.toString("utf8");
+  if (s === "\r" || s === "\n" || s === "\r\n") return { name: "enter" };
+  if (s === "\x03") return { name: "ctrl-c" };
+  if (s === "\x04") return { name: "ctrl-d" };
+  if (s === "\x1b") return { name: "escape" };
+  if (s === "\x7f" || s === "\b") return { name: "backspace" };
+  if (s === "\t") return { name: "tab" };
+  if (s === " ") return { name: "space" };
+  if (s === "\x1b[A" || s === "\x1bOA") return { name: "up" };
+  if (s === "\x1b[B" || s === "\x1bOB") return { name: "down" };
+  if (s === "\x1b[C" || s === "\x1bOC") return { name: "right" };
+  if (s === "\x1b[D" || s === "\x1bOD") return { name: "left" };
+  if (s === "\x1b[H" || s === "\x1b[1~" || s === "\x1bOH") return { name: "home" };
+  if (s === "\x1b[F" || s === "\x1b[4~" || s === "\x1bOF") return { name: "end" };
+  if (s === "\x1b[3~") return { name: "delete" };
+  if (s.startsWith("\x1b")) return { name: "unknown", raw: s };
+  // Control characters in a paste are dropped; a newline in one ends the line, as Enter would.
+  const text = s.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
+  if (/[\r\n]/.test(text)) return { name: "char", ch: text.split(/[\r\n]/)[0], enter: true };
+  return { name: "char", ch: text };
+}
+
+/** Keys from `input`, one at a time, for as long as the prompt wants them. */
+function keyReader(input) {
+  const queue = [];
+  const waiters = [];
+  const onData = (d) => {
+    const key = parseKey(d);
+    const waiter = waiters.shift();
+    if (waiter) waiter(key);
+    else queue.push(key);
+  };
+  const onEnd = () => onData(Buffer.from("\x04"));
+  input.on("data", onData);
+  input.on("end", onEnd);
+  return {
+    next: () => new Promise((resolve) => (queue.length ? resolve(queue.shift()) : waiters.push(resolve))),
+    close: () => {
+      input.off("data", onData);
+      input.off("end", onEnd);
+    },
+  };
+}
+
+// ---------------------------------------------------------------- the UI
+
+/**
+ * A UI bound to one input and one output. `interactive` is false when either is not a terminal;
+ * the prompts then throw, and the caller is expected to have taken the non-interactive path.
+ */
+export function createUI({ input = process.stdin, output = process.stdout, env = process.env, colours = coloursOn(output, env) } = {}) {
+  const c = makeStyle(colours);
+  const tty = Boolean(input.isTTY && output.isTTY);
+  const columns = () => Math.max(40, output.columns || 80);
+  const write = (s) => output.write(s);
+  const nl = EOL;
+
+  const rail = {
+    ask: c.cyan(RAIL.ask),
+    done: c.green(RAIL.done),
+    fail: c.red(RAIL.fail),
+    bar: c.gray(RAIL.bar),
+    end: c.gray(RAIL.end),
+  };
+  const line = (text = "") => `${rail.bar}  ${text}`;
+  const cancelKey = (key) => key.name === "ctrl-c" || key.name === "escape" || key.name === "ctrl-d";
+  const isEnter = (key) => key.name === "enter" || (key.name === "char" && key.enter);
+
+  // Raw mode is on only while a prompt is reading, so a spinner or a subprocess in between sees the
+  // terminal as the user left it.
+  function rawOn() {
+    if (typeof input.setRawMode === "function") input.setRawMode(true);
+    input.resume();
+  }
+  function rawOff() {
+    if (typeof input.setRawMode === "function") input.setRawMode(false);
+    input.pause();
+  }
+
+  /** A styled line cut to the terminal width, without cutting inside an escape sequence. */
+  function fitStyled(styled, max) {
+    if (width(styled) <= max) return styled;
+    let out = "";
+    let seen = 0;
+    const re = /(\x1b\[[0-9;?]*[A-Za-z])|([\s\S])/g;
+    for (let m; (m = re.exec(styled)); ) {
+      if (m[1]) {
+        out += m[1];
+        continue;
+      }
+      if (seen + width(m[2]) > max - 1) break;
+      out += m[2];
+      seen += width(m[2]);
+    }
+    return out + "…" + (c.on ? "\x1b[0m" : "");
+  }
+
+  /** Redraw a block of lines in place: up over what was drawn last time, clear, draw again. */
+  function painter() {
+    let drawn = 0;
+    return {
+      draw(lines) {
+        let s = "";
+        if (drawn) s += `\x1b[${drawn}A`;
+        s += "\x1b[0J";
+        const max = columns() - 1;
+        s += lines.map((l) => fitStyled(l, max)).join(nl) + nl;
+        write(s);
+        drawn = lines.length;
+      },
+      clear() {
+        if (drawn) write(`\x1b[${drawn}A\x1b[0J`);
+        drawn = 0;
+      },
+    };
+  }
+
+  /** The loop every prompt shares: raw mode on, keys in, redraw, and the terminal put back after. */
+  async function prompt(draw, onKey) {
+    if (!tty) throw new Error("this needs a terminal; pass --yes for a setup without questions");
+    const paint = painter();
+    write("\x1b[?25l");
+    rawOn();
+    const keys = keyReader(input);
+    try {
+      paint.draw(draw());
+      for (;;) {
+        const key = await keys.next();
+        if (cancelKey(key)) throw new Cancelled();
+        const result = await onKey(key, () => paint.draw(draw()));
+        if (result === true) break;
+        paint.draw(draw());
+      }
+    } finally {
+      keys.close();
+      rawOff();
+      paint.clear();
+      write("\x1b[?25h");
+    }
+  }
+
+  /** The line a finished prompt leaves behind: the question, and the answer under it. */
+  const answered = (message, answer) => write(`${rail.done}  ${message}` + nl + line(c.dim(answer)) + nl + line() + nl);
+
+  const ui = {
+    style: c,
+    interactive: tty,
+    rail,
+    columns,
+    write,
+
+    /** The opening: a name and a line under it. */
+    intro(title, subtitle = "") {
+      write(nl + `${rail.bar}  ${c.bold(title)}` + (subtitle ? nl + line(c.dim(subtitle)) : "") + nl + line() + nl);
+    },
+
+    /** A plain line on the rail. */
+    log(text = "") {
+      write(line(text) + nl);
+    },
+
+    /** A step that needed no question, closed in one line. `detail` may be several lines. */
+    done(title, detail = "") {
+      const details = [].concat(detail).filter(Boolean);
+      write(`${rail.done}  ${title}` + details.map((d) => nl + line(c.dim(d))).join("") + nl + line() + nl);
+    },
+
+    failed(title, detail = "") {
+      write(`${rail.fail}  ${c.red(title)}` + (detail ? nl + line(c.dim(detail)) : "") + nl + line() + nl);
+    },
+
+    /** A boxed note: something to read, or to copy. */
+    note(title, lines = []) {
+      const inner = Math.min(columns() - 8, Math.max(width(title), ...lines.map(width)) + 2);
+      const pad = (s) => fit(s, inner) + " ".repeat(Math.max(0, inner - width(fit(s, inner))));
+      const edge = c.gray("│");
+      write(line(c.gray(`┌${"─".repeat(inner + 2)}┐`)) + nl);
+      write(line(`${edge} ${c.bold(pad(title))} ${edge}`) + nl);
+      if (lines.length) write(line(`${edge} ${pad("")} ${edge}`) + nl);
+      for (const l of lines) write(line(`${edge} ${pad(l)} ${edge}`) + nl);
+      write(line(c.gray(`└${"─".repeat(inner + 2)}┘`)) + nl + line() + nl);
+    },
+
+    /** The closing: the foot of the rail and a few lines after it. */
+    outro(lines = []) {
+      write(`${rail.end}  ${lines[0] ?? ""}` + nl);
+      for (const l of lines.slice(1)) write(`   ${l}` + nl);
+      write(nl);
+    },
+
+    /**
+     * A step that takes a while. `done`/`fail`/`skip` replace the spinner line with the outcome.
+     * Without a terminal the label is printed once and the outcome after it.
+     */
+    task(label) {
+      let frame = 0;
+      let timer = null;
+      const paint = painter();
+      const draw = () => paint.draw([`${c.cyan(FRAMES[frame++ % FRAMES.length])}  ${label}`]);
+      if (tty) {
+        write("\x1b[?25l");
+        draw();
+        timer = setInterval(draw, 80);
+      } else {
+        write(`…  ${label}` + nl);
+      }
+      const finish = (mark, text, detail) => {
+        if (timer) clearInterval(timer);
+        timer = null;
+        if (tty) {
+          paint.clear();
+          write("\x1b[?25h");
+        }
+        write(`${mark}  ${text}` + (detail ? nl + line(c.dim(detail)) : "") + nl + line() + nl);
+      };
+      return {
+        update(text) {
+          label = text;
+          if (!tty) write(`…  ${label}` + nl);
+        },
+        done: (text = label, detail = "") => finish(rail.done, text, detail),
+        fail: (text = label, detail = "") => finish(rail.fail, c.red(text), detail),
+        skip: (text = label, detail = "") => finish(c.gray(RAIL.done), c.dim(text), detail),
+      };
+    },
+
+    /** Run `fn` under a spinner. `done(result)` and `fail(error)` word the outcome line. */
+    async run(label, fn, { done = () => label, fail = (e) => `${label}: ${e.message}` } = {}) {
+      const t = ui.task(label);
+      try {
+        const result = await fn(t);
+        const text = done(result);
+        if (typeof text === "object" && text) t.done(text.text ?? label, text.detail ?? "");
+        else t.done(text || label);
+        return result;
+      } catch (e) {
+        t.fail(fail(e));
+        throw e;
+      }
+    },
+
+    /**
+     * Pick one of `choices` ({ value, label, hint?, preview? }). Arrow keys move, Enter picks; Space
+     * runs the highlighted choice's `preview` if it has one (a sound, a voice), and says so meanwhile.
+     */
+    async select({ message, choices, initial, previewHint = "space to hear it" }) {
+      let index = Math.max(0, choices.findIndex((ch) => ch.value === initial));
+      const hasPreview = choices.some((ch) => typeof ch.preview === "function");
+      let status = "";
+      let previewing = false;
+      const labelWidth = Math.max(...choices.map((ch) => width(ch.label)));
+      const draw = () => {
+        const lines = [`${rail.ask}  ${c.bold(message)}`];
+        choices.forEach((ch, i) => {
+          const on = i === index;
+          const mark = on ? c.cyan(RAIL.radioOn) : c.gray(RAIL.radioOff);
+          const pad = " ".repeat(labelWidth - width(ch.label) + 2);
+          lines.push(line(`${mark} ${on ? c.bold(ch.label) : ch.label}${ch.hint ? pad + c.dim(ch.hint) : ""}`));
+        });
+        const keys = ["↑↓ move", "enter choose", ...(hasPreview ? [previewHint] : [])].join(" · ");
+        lines.push(`${rail.end}  ${status ? c.cyan(status) : c.dim(keys)}`);
+        return lines;
+      };
+      await prompt(draw, (key, redraw) => {
+        if (key.name === "up" || (key.name === "char" && key.ch === "k")) index = (index + choices.length - 1) % choices.length;
+        else if (key.name === "down" || key.name === "tab" || (key.name === "char" && key.ch === "j")) index = (index + 1) % choices.length;
+        else if (key.name === "home") index = 0;
+        else if (key.name === "end") index = choices.length - 1;
+        else if (key.name === "char" && /^[1-9]$/.test(key.ch) && Number(key.ch) <= choices.length) index = Number(key.ch) - 1;
+        else if (isEnter(key)) return true;
+        else if (key.name === "space" && choices[index].preview && !previewing) {
+          previewing = true;
+          const chosen = choices[index];
+          status = chosen.previewing ?? `playing ${chosen.label}…`;
+          Promise.resolve()
+            .then(() => chosen.preview())
+            .then(() => (status = ""), (e) => (status = `couldn't play: ${e.message}`))
+            .finally(() => {
+              previewing = false;
+              redraw();
+            });
+        }
+        return false;
+      });
+      const chosen = choices[index];
+      answered(message, chosen.label);
+      return chosen.value;
+    },
+
+    /** Tick any number of `choices` ({ value, label, hint?, checked? }). Space toggles, Enter confirms. */
+    async multiselect({ message, choices, min = 0 }) {
+      let index = 0;
+      const checked = choices.map((ch) => Boolean(ch.checked));
+      let warning = "";
+      const labelWidth = Math.max(...choices.map((ch) => width(ch.label)));
+      const draw = () => {
+        const lines = [`${rail.ask}  ${c.bold(message)}`];
+        choices.forEach((ch, i) => {
+          const on = i === index;
+          const mark = checked[i] ? c.green(RAIL.boxOn) : c.gray(RAIL.boxOff);
+          const label = on ? c.bold(ch.label) : checked[i] ? ch.label : c.dim(ch.label);
+          const pad = " ".repeat(labelWidth - width(ch.label) + 2);
+          lines.push(line(`${mark} ${label}${ch.hint ? pad + c.dim(ch.hint) : ""}`));
+        });
+        lines.push(`${rail.end}  ${warning ? c.yellow(warning) : c.dim("↑↓ move · space toggle · a all · enter continue")}`);
+        return lines;
+      };
+      await prompt(draw, (key) => {
+        warning = "";
+        if (key.name === "up" || (key.name === "char" && key.ch === "k")) index = (index + choices.length - 1) % choices.length;
+        else if (key.name === "down" || key.name === "tab" || (key.name === "char" && key.ch === "j")) index = (index + 1) % choices.length;
+        else if (key.name === "space") checked[index] = !checked[index];
+        else if (key.name === "char" && key.ch === "a") checked.fill(!checked.every(Boolean));
+        else if (key.name === "char" && /^[1-9]$/.test(key.ch) && Number(key.ch) <= choices.length) checked[Number(key.ch) - 1] = !checked[Number(key.ch) - 1];
+        else if (isEnter(key)) {
+          if (checked.filter(Boolean).length >= min) return true;
+          warning = min === 1 ? "pick at least one" : `pick at least ${min}`;
+        }
+        return false;
+      });
+      const picked = choices.filter((_, i) => checked[i]);
+      answered(message, picked.length ? picked.map((ch) => ch.label).join(", ") : "none");
+      return picked.map((ch) => ch.value);
+    },
+
+    /** Yes or no. Arrows or y/n move, Enter confirms. */
+    async confirm({ message, initial = true, yes = "Yes", no = "No", hint = "" }) {
+      let value = Boolean(initial);
+      const pick = (on, label) => (on ? `${c.cyan(RAIL.radioOn)} ${c.bold(label)}` : `${c.gray(RAIL.radioOff)} ${c.dim(label)}`);
+      const draw = () => [
+        `${rail.ask}  ${c.bold(message)}` + (hint ? `  ${c.dim(hint)}` : ""),
+        line(`${pick(value, yes)}   ${pick(!value, no)}`),
+        `${rail.end}  ${c.dim("←→ or y/n · enter confirm")}`,
+      ];
+      await prompt(draw, (key) => {
+        if (["left", "right", "up", "down", "tab", "space"].includes(key.name)) value = !value;
+        else if (key.name === "char" && /^y$/i.test(key.ch)) value = true;
+        else if (key.name === "char" && /^n$/i.test(key.ch)) value = false;
+        else if (isEnter(key)) return true;
+        return false;
+      });
+      answered(message, value ? yes : no);
+      return value;
+    },
+
+    /**
+     * A line of text. `mask` hides what is typed (a key); `validate` returns a message to show
+     * instead of accepting; `placeholder` shows while empty, and an empty Enter returns "".
+     */
+    async text({ message, placeholder = "", initial = "", mask = false, hint = "", validate = () => "" }) {
+      let value = String(initial);
+      let warning = "";
+      const draw = () => [
+        `${rail.ask}  ${c.bold(message)}` + (hint ? `  ${c.dim(hint)}` : ""),
+        line(`${value ? (mask ? "•".repeat(Math.min(value.length, 32)) : value) : c.dim(placeholder)}${c.inverse(" ")}`),
+        `${rail.end}  ${warning ? c.yellow(warning) : c.dim("enter to continue")}`,
+      ];
+      await prompt(draw, (key) => {
+        warning = "";
+        if (key.name === "backspace") value = value.slice(0, -1);
+        else if (key.name === "space") value += " ";
+        else if (key.name === "char") value += key.ch;
+        if (isEnter(key)) {
+          value = value.trim();
+          const problem = validate(value);
+          if (!problem) return true;
+          warning = problem;
+        }
+        return false;
+      });
+      answered(message, value ? (mask ? "•".repeat(8) : value) : "(empty)");
+      return value;
+    },
+  };
+  return ui;
+}

package/skills/roger-roger/slack/manifest.json

@@ -0,0 +1,34 @@
+{
+  "display_information": {
+    "name": "roger-roger",
+    "description": "Lets your AI coding agent ping you, and ask you to decide, when you're away from the screen.",
+    "background_color": "#1f2329"
+  },
+  "features": {
+    "app_home": {
+      "home_tab_enabled": false,
+      "messages_tab_enabled": true,
+      "messages_tab_read_only_enabled": false
+    },
+    "bot_user": {
+      "display_name": "roger-roger",
+      "always_online": true
+    }
+  },
+  "oauth_config": {
+    "scopes": {
+      "bot": ["chat:write", "im:write", "im:history", "files:read", "files:write", "reactions:write"]
+    }
+  },
+  "settings": {
+    "event_subscriptions": {
+      "bot_events": ["message.im"]
+    },
+    "interactivity": {
+      "is_enabled": true
+    },
+    "org_deploy_enabled": false,
+    "socket_mode_enabled": true,
+    "token_rotation_enabled": false
+  }
+}