@rind-ai/cli 0.4.1

package/bin/rind.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runFrontendCli } from "../lib/frontend-cli.js";
+
+await runFrontendCli(process.argv.slice(2));

package/lib/assistant-renderer.js

@@ -0,0 +1,265 @@
+import { graphemes, textWidth } from "./text-width.js";
+
+const INLINE_TOKEN_RE = /(\[[^\]]+\]\([^)]+\)|`[^`]+`|\*\*[^*]+\*\*)/g;
+const PLAIN_TEXT_RE = /[`*#>|\[]/;
+const CONTENT_PREFIX = "  ";
+const ANSI_SEQUENCE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+
+export class AssistantRenderer {
+  constructor(write, options = {}) {
+    this.write = write;
+    this.color = options.color ?? (Boolean(process.stdout.isTTY) && !process.env.NO_COLOR);
+    this.pending = "";
+    this.inCodeBlock = false;
+    this.lineOpen = false;
+    this.atLineStart = true;
+    this.visibleColumn = 0;
+    this.columns = options.columns;
+  }
+
+  append(text) {
+    this.pending += String(text || "");
+    while (true) {
+      const newlineIndex = this.pending.indexOf("\n");
+      if (newlineIndex === -1) {
+        break;
+      }
+      const line = this.pending.slice(0, newlineIndex);
+      this.pending = this.pending.slice(newlineIndex + 1);
+      this.renderLine(line, true);
+    }
+    this.flushPlainPending();
+  }
+
+  finish() {
+    if (this.pending) {
+      this.renderLine(this.pending, false);
+      this.pending = "";
+    }
+    if (this.lineOpen) {
+      this.writeText("\n");
+      this.lineOpen = false;
+    }
+  }
+
+  flushPlainPending() {
+    if (!this.pending || this.inCodeBlock || !isPlainLine(this.pending)) {
+      return;
+    }
+    this.writePlain(this.pending, false);
+    this.pending = "";
+  }
+
+  renderLine(line, newline) {
+    if (isTableLine(line, this.inCodeBlock)) {
+      this.renderTableLine(line, newline);
+      return;
+    }
+    if (line.trim().startsWith("```")) {
+      this.renderCodeFence(line, newline);
+      return;
+    }
+    if (this.inCodeBlock) {
+      this.writeStyled(styled(line, this.color, "codeBlock"), newline);
+      return;
+    }
+    if (isPlainLine(line)) {
+      this.writePlain(line, newline);
+      return;
+    }
+    this.writeStyled(renderMarkdownishLine(line, this.color), newline);
+  }
+
+  renderTableLine(line, newline) {
+    const cells = parseTableRow(line);
+    if (!cells.length || cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim()))) {
+      return;
+    }
+    const rendered = cells.map((cell, index) =>
+      renderInline(cell, this.color, index === 0 ? "tableHeader" : "")
+    );
+    this.writeStyled(rendered.join(dim(" | ", this.color)), newline);
+  }
+
+  renderCodeFence(line, newline) {
+    const opening = !this.inCodeBlock;
+    this.inCodeBlock = opening;
+    const label = opening ? line.trim().slice(3).trim().slice(0, 32) : "";
+    this.writeStyled(dim(opening ? codeOpenLabel(label) : "└ end", this.color), newline);
+  }
+
+  writePlain(text, newline) {
+    this.writeText(text + (newline ? "\n" : ""));
+    this.lineOpen = Boolean(text) && !newline;
+  }
+
+  writeStyled(text, newline) {
+    this.writeText(text + (newline ? "\n" : ""));
+    this.lineOpen = Boolean(text) && !newline;
+  }
+
+  writeText(text) {
+    const parts = String(text || "").split(/(\r\n|\r|\n)/);
+    const maxWidth = Math.max(1, Math.floor(Number(this.columns ?? process.stdout.columns ?? 80) || 80));
+    const prefixWidth = textWidth(CONTENT_PREFIX);
+    let output = "";
+    for (const part of parts) {
+      if (!part) {
+        continue;
+      }
+      if (part === "\r\n" || part === "\r" || part === "\n") {
+        if (this.atLineStart) {
+          output += CONTENT_PREFIX;
+        }
+        output += part;
+        this.atLineStart = true;
+        this.visibleColumn = 0;
+        continue;
+      }
+      for (const segment of ansiSegments(part)) {
+        if (segment.ansi) {
+          if (this.atLineStart) {
+            output += CONTENT_PREFIX;
+            this.atLineStart = false;
+            this.visibleColumn = prefixWidth;
+          }
+          output += segment.text;
+          continue;
+        }
+        for (const grapheme of graphemes(segment.text)) {
+          const segmentWidth = textWidth(grapheme);
+          if (this.atLineStart) {
+            output += CONTENT_PREFIX;
+            this.atLineStart = false;
+            this.visibleColumn = prefixWidth;
+          }
+          if (
+            segmentWidth > 0
+            && this.visibleColumn > prefixWidth
+            && this.visibleColumn + segmentWidth > maxWidth
+          ) {
+            output += `\n${CONTENT_PREFIX}`;
+            this.visibleColumn = prefixWidth;
+          }
+          output += grapheme;
+          this.visibleColumn += segmentWidth;
+        }
+      }
+    }
+    if (output) {
+      this.write(output);
+    }
+  }
+}
+
+function ansiSegments(value) {
+  const segments = [];
+  let position = 0;
+  for (const match of value.matchAll(ANSI_SEQUENCE)) {
+    if (match.index > position) {
+      segments.push({ text: value.slice(position, match.index), ansi: false });
+    }
+    segments.push({ text: match[0], ansi: true });
+    position = match.index + match[0].length;
+  }
+  if (position < value.length) {
+    segments.push({ text: value.slice(position), ansi: false });
+  }
+  return segments;
+}
+
+function renderMarkdownishLine(line, color) {
+  const heading = line.match(/^(#{1,6})\s+(.+?)\s*$/);
+  if (heading) {
+    return renderInline(heading[2], color, "heading");
+  }
+
+  const quote = line.match(/^(\s*)>\s?(.*)$/);
+  if (quote) {
+    return `${quote[1]}${dim("│ ", color)}${renderInline(quote[2], color)}`;
+  }
+
+  const list = line.match(/^(\s*)([-*+]|\d+\.)\s+(.*)$/);
+  if (list) {
+    const marker = /^\d+\.$/.test(list[2]) ? list[2] : "•";
+    return `${list[1]}${dim(`${marker} `, color)}${renderInline(list[3], color)}`;
+  }
+
+  return renderInline(line, color);
+}
+
+function renderInline(text, color, baseStyle = "") {
+  const source = String(text || "");
+  let output = "";
+  let index = 0;
+  for (const match of source.matchAll(INLINE_TOKEN_RE)) {
+    output += styled(source.slice(index, match.index), color, baseStyle);
+    output += renderInlineToken(match[0], color, baseStyle);
+    index = match.index + match[0].length;
+  }
+  return output + styled(source.slice(index), color, baseStyle);
+}
+
+function renderInlineToken(token, color, baseStyle) {
+  const link = token.match(/^\[([^\]]+)\]\(([^)]+)\)$/);
+  if (link) {
+    return `${renderInline(link[1], color, baseStyle)} ${dim(`(${link[2]})`, color)}`;
+  }
+  if (token.startsWith("`") && token.endsWith("`")) {
+    return styled(token.slice(1, -1), color, "inlineCode");
+  }
+  if (token.startsWith("**") && token.endsWith("**")) {
+    return styled(token.slice(2, -2), color, baseStyle || "emphasis");
+  }
+  return token;
+}
+
+function isPlainLine(line) {
+  if (!line) {
+    return true;
+  }
+  if (PLAIN_TEXT_RE.test(line)) {
+    return false;
+  }
+  const stripped = line.trimStart();
+  return !stripped.match(/^([-*+]|\d+\.)\s+/);
+}
+
+function isTableLine(line, inCodeBlock) {
+  const stripped = line.trim();
+  return !inCodeBlock && stripped.includes("|") && stripped.split("|").length > 2;
+}
+
+function parseTableRow(line) {
+  let stripped = line.trim();
+  if (stripped.startsWith("|")) {
+    stripped = stripped.slice(1);
+  }
+  if (stripped.endsWith("|")) {
+    stripped = stripped.slice(0, -1);
+  }
+  return stripped.split("|").map((cell) => cell.trim());
+}
+
+function codeOpenLabel(label) {
+  return label ? `┌ code ${label}` : "┌ code";
+}
+
+function styled(text, color, style) {
+  if (!text || !color || !style) {
+    return text;
+  }
+  const codes = {
+    codeBlock: "38;5;110",
+    emphasis: "1;38;5;221",
+    heading: "1;38;5;81",
+    inlineCode: "38;5;215",
+    tableHeader: "1;38;5;81",
+  };
+  const code = codes[style] || codes.emphasis;
+  return `\x1b[${code}m${text}\x1b[0m`;
+}
+
+function dim(text, color) {
+  return color ? `\x1b[2m${text}\x1b[0m` : text;
+}

package/lib/assistant-stream-buffer.js

@@ -0,0 +1,25 @@
+export function createAssistantStreamBuffer() {
+  let pending = "";
+
+  return {
+    push(text, holdPartialLine = false) {
+      const output = pending + String(text || "");
+      if (!holdPartialLine || output.endsWith("\n")) {
+        pending = "";
+        return output;
+      }
+      const splitAt = output.lastIndexOf("\n");
+      if (splitAt === -1) {
+        pending = output;
+        return "";
+      }
+      pending = output.slice(splitAt + 1);
+      return output.slice(0, splitAt + 1);
+    },
+    flush() {
+      const output = pending;
+      pending = "";
+      return output;
+    },
+  };
+}

package/lib/background-controller.js

@@ -0,0 +1,307 @@
+import { backgroundMonitorText } from "./rendering.js";
+
+export function createBackgroundController({
+  request,
+  state,
+  redraw = () => {},
+  log = () => {},
+  terminalUi = false,
+}) {
+  const tasks = new Map();
+  const pendingCommands = new Map();
+  let refreshTimer = null;
+  let listInFlight = null;
+  let monitorTimer = null;
+  let monitorPollInFlight = false;
+  let monitor = null;
+  let monitorInputWasActive = false;
+
+  function refresh() {
+    if (!terminalUi || state.runtimeClosing) {
+      return Promise.resolve();
+    }
+    if (listInFlight) {
+      return listInFlight;
+    }
+    listInFlight = request("background.list")
+      .then((result) => {
+        const listed = Array.isArray(result?.tasks) ? result.tasks : [];
+        const ids = new Set();
+        for (const task of listed) {
+          const bgId = String(task?.bg_id || "").trim();
+          if (!bgId) {
+            continue;
+          }
+          ids.add(bgId);
+          tasks.set(bgId, { ...(tasks.get(bgId) || {}), ...task, bg_id: bgId });
+        }
+        for (const bgId of tasks.keys()) {
+          if (!ids.has(bgId) && tasks.get(bgId)?.status === "running") {
+            tasks.delete(bgId);
+          }
+        }
+        updateCount();
+        if (monitor) {
+          monitor.selectedIndex = clampIndex(monitor.selectedIndex);
+          redraw(true);
+        }
+      })
+      .finally(() => {
+        listInFlight = null;
+      });
+    return listInFlight;
+  }
+
+  function updateCount() {
+    const count = [...tasks.values()].filter((task) => task.status === "running").length;
+    if (Number(state.sessionInfo?.background_count) !== count) {
+      state.sessionInfo = { ...state.sessionInfo, background_count: count };
+      redraw();
+    }
+    if (count > 0) {
+      startRefresh();
+    } else {
+      stopRefresh();
+    }
+  }
+
+  function startRefresh() {
+    if (refreshTimer || state.runtimeClosing) {
+      return;
+    }
+    refreshTimer = setInterval(() => {
+      void refresh().catch(() => {});
+    }, 1000);
+    refreshTimer.unref?.();
+  }
+
+  function stopRefresh() {
+    if (!refreshTimer) {
+      return;
+    }
+    clearInterval(refreshTimer);
+    refreshTimer = null;
+  }
+
+  function clear() {
+    tasks.clear();
+    pendingCommands.clear();
+    stopRefresh();
+    updateCount();
+  }
+
+  function recordCommand(event) {
+    if (event?.tool_name !== "bash" || !event.tool_call_id) {
+      return;
+    }
+    const args = parseObject(event.args_preview);
+    if (args.command) {
+      pendingCommands.set(event.tool_call_id, String(args.command));
+    }
+  }
+
+  function recordResult(event) {
+    const parsed = parseObject(event?.result);
+    const data = parsed.data && typeof parsed.data === "object" ? parsed.data : parsed;
+    const bgId = String(data?.bg_id || "").trim();
+    if (!bgId) {
+      return;
+    }
+    const previous = tasks.get(bgId) || {};
+    const command = pendingCommands.get(event.tool_call_id) || previous.command || "";
+    tasks.set(bgId, { ...previous, ...data, bg_id: bgId, command });
+    if (event.tool_call_id) {
+      pendingCommands.delete(event.tool_call_id);
+    }
+    updateCount();
+    void pollMonitor();
+  }
+
+  function enterMonitor() {
+    if (monitor || state.runtimeClosing) {
+      return;
+    }
+    monitorInputWasActive = state.inputActive;
+    monitor = { selectedIndex: 0 };
+    state.inputActive = true;
+    redraw(true);
+    void refresh()
+      .then(() => {
+        if (!monitor) {
+          return;
+        }
+        if (!tasks.size) {
+          exitMonitor();
+          log("No background tasks.");
+          return;
+        }
+        monitor.selectedIndex = clampIndex(monitor.selectedIndex);
+        startMonitorPolling();
+        void pollMonitor();
+        redraw(true);
+      })
+      .catch((error) => {
+        if (!monitor || state.runtimeClosing) {
+          return;
+        }
+        exitMonitor();
+        log(`Background monitor failed: ${error instanceof Error ? error.message : String(error)}`);
+      });
+  }
+
+  function exitMonitor() {
+    stopMonitorPolling();
+    monitor = null;
+    state.inputActive = monitorInputWasActive;
+    redraw(true);
+  }
+
+  function startMonitorPolling() {
+    if (monitorTimer) {
+      return;
+    }
+    monitorTimer = setInterval(() => {
+      void pollMonitor();
+    }, 500);
+    monitorTimer.unref?.();
+  }
+
+  function stopMonitorPolling() {
+    if (!monitorTimer) {
+      return;
+    }
+    clearInterval(monitorTimer);
+    monitorTimer = null;
+  }
+
+  async function pollMonitor() {
+    if (!monitor || monitorPollInFlight || state.runtimeClosing) {
+      return;
+    }
+    const available = [...tasks.values()];
+    if (!available.length) {
+      return;
+    }
+    monitor.selectedIndex = clampIndex(monitor.selectedIndex);
+    const selected = available[monitor.selectedIndex];
+    if (!selected?.bg_id) {
+      return;
+    }
+    monitorPollInFlight = true;
+    try {
+      const result = await request("background.output", {
+        bg_id: selected.bg_id,
+        max_output_chars: 20000,
+      });
+      if (result?.task && typeof result.task === "object") {
+        tasks.set(selected.bg_id, {
+          ...selected,
+          ...result.task,
+          command: selected.command || "",
+        });
+        updateCount();
+        redraw();
+      }
+    } catch {
+      // Periodic list refresh reconciles expired tasks without interrupting input.
+    } finally {
+      monitorPollInFlight = false;
+    }
+  }
+
+  function moveSelection(delta) {
+    const count = tasks.size;
+    if (!monitor || !count) {
+      return;
+    }
+    const current = clampIndex(monitor.selectedIndex);
+    monitor.selectedIndex = (current + delta + count) % count;
+    void pollMonitor();
+    redraw();
+  }
+
+  function handleInput(key) {
+    const modified = key.ctrl || key.alt || key.shift;
+    if (!modified && key.name === "escape") {
+      exitMonitor();
+      return true;
+    }
+    if (key.ctrl && key.name === "b") {
+      exitMonitor();
+      return true;
+    }
+    if (modified) {
+      return true;
+    }
+    if (key.name === "up" || key.text === "k") {
+      moveSelection(-1);
+      return true;
+    }
+    if (key.name === "down" || key.text === "j") {
+      moveSelection(1);
+      return true;
+    }
+    return true;
+  }
+
+  function frame(width) {
+    const list = [...tasks.values()];
+    const selectedIndex = clampIndex(monitor?.selectedIndex);
+    const text = backgroundMonitorText(
+      list,
+      selectedIndex,
+      list[selectedIndex],
+      Math.max(20, Number(width) - 4),
+    );
+    const lines = text.split("\n");
+    const selectedRow = list.length ? 2 + selectedIndex : Math.max(0, lines.length - 1);
+    return {
+      lines,
+      cursorRow: Math.min(selectedRow, Math.max(0, lines.length - 1)),
+      cursorColumn: 0,
+      focusRow: Math.min(selectedRow, Math.max(0, lines.length - 1)),
+    };
+  }
+
+  function stop() {
+    stopRefresh();
+    stopMonitorPolling();
+    monitor = null;
+    pendingCommands.clear();
+    tasks.clear();
+  }
+
+  return {
+    refresh,
+    recordCommand,
+    recordResult,
+    enterMonitor,
+    exitMonitor,
+    handleInput,
+    clear,
+    stop,
+    frame,
+    isMonitoring: () => Boolean(monitor),
+    moveSelection,
+  };
+
+  function clampIndex(index) {
+    const count = tasks.size;
+    if (!count) {
+      return 0;
+    }
+    return Math.min(count - 1, Math.max(0, Number(index) || 0));
+  }
+}
+
+function parseObject(value) {
+  if (value && typeof value === "object") {
+    return value;
+  }
+  try {
+    const parsed = JSON.parse(String(value || ""));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}

package/lib/choice-menu-state.js

@@ -0,0 +1,46 @@
+export function createChoiceMenuState(options, recommended = "") {
+  const items = normalizeOptions(options);
+  let selected = items.indexOf(recommended);
+  if (selected < 0) {
+    selected = 0;
+  }
+  return {
+    options() {
+      return items;
+    },
+    selectedIndex() {
+      return selected;
+    },
+    selectedOption() {
+      return items[selected] || "";
+    },
+    handleKey(key = {}) {
+      if (!items.length) {
+        return false;
+      }
+      if (key.name === "up" || key.text === "k") {
+        selected = selected <= 0 ? items.length - 1 : selected - 1;
+        return true;
+      }
+      if (key.name === "down" || key.text === "j") {
+        selected = selected >= items.length - 1 ? 0 : selected + 1;
+        return true;
+      }
+      return false;
+    },
+  };
+}
+
+function normalizeOptions(options) {
+  const seen = new Set();
+  const items = [];
+  for (const option of Array.isArray(options) ? options : []) {
+    const value = String(option || "").trim();
+    if (!value || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    items.push(value);
+  }
+  return items;
+}