@rind-ai/cli 0.6.1 → 0.7.0

package/lib/line-editor.js

@@ -4,11 +4,11 @@ const HISTORY_LIMIT = 100;
 const UNDO_LIMIT = 100;
 const INPUT_PREFIX_WIDTH = 4;
 
-export function createLineEditor(initialValue = "") {
+export function createLineEditor(initialValue = "", options = {}) {
   let lines = splitLines(initialValue);
   let cursorLine = lines.length - 1;
   let cursorColumn = graphemes(lines[cursorLine]).length;
-  const history = [];
+  const history = normalizeHistory(options.history);
   let historyIndex = -1;
   let historyDraft = null;
   const undoStack = [];
@@ -142,13 +142,17 @@ export function createLineEditor(initialValue = "") {
       const text = String(value || "").trim();
       if (!text || history[0] === text) {
         resetHistory();
-        return;
+        return false;
       }
       history.unshift(text);
       if (history.length > HISTORY_LIMIT) {
         history.length = HISTORY_LIMIT;
       }
       resetHistory();
+      return true;
+    },
+    getHistory() {
+      return history.slice();
     },
   };
   return editor;
@@ -537,5 +541,26 @@ export function createLineEditor(initialValue = "") {
 }
 
 function isPrintable(chunk, key) {
-  return Boolean(chunk && !key.ctrl && !key.alt && String(chunk) >= " ");
+  if (!chunk || key.ctrl || key.alt || key.shift) {
+    return false;
+  }
+  return [...String(chunk)].every((character) => {
+    const code = character.codePointAt(0);
+    return code >= 0x20 && code !== 0x7f && !(code >= 0x80 && code <= 0x9f);
+  });
+}
+
+function normalizeHistory(values) {
+  const history = [];
+  for (const value of Array.isArray(values) ? values : []) {
+    const text = String(value || "").trim();
+    if (!text || history.includes(text)) {
+      continue;
+    }
+    history.push(text);
+    if (history.length >= HISTORY_LIMIT) {
+      break;
+    }
+  }
+  return history;
 }

package/lib/local-slash-commands.js

@@ -6,8 +6,10 @@ import { currentTheme, setTheme, themeNames, themeOptions } from "./theme.js";
 export const LOCAL_SLASH_COMMANDS = Object.freeze([
   { name: "compact", description: "Compact current session context", usage: "/compact" },
   { name: "config", description: "Show config guidance", usage: "/config" },
+  { name: "context", description: "Show context composition and token usage", usage: "/context" },
   { name: "doctor", description: "Run local setup diagnostics", usage: "/doctor" },
   { name: "effort", description: "Show or change reasoning effort", usage: "/effort [low | medium | high | xhigh | max]" },
+  { name: "fork", description: "Fork the current session", usage: "/fork" },
   { name: "goal", description: "View or control the active goal", usage: "/goal [pause | resume | clear | objective]" },
   { name: "help", description: "Show commands", usage: "/help [command]" },
   { name: "init", description: "Draft RIND.md", usage: "/init [project|user]" },

package/lib/markdown-lines.js

@@ -1,5 +1,8 @@
+import { textWidth, wrapTextWithAnsi } from "./text-width.js";
+
 const INLINE_TOKEN_RE = /(\[[^\]]+\]\([^)]+\)|`[^`]+`|\*\*[^*]+\*\*)/g;
 const PLAIN_TEXT_RE = /[`*#>|\[]/;
+const TABLE_SEPARATOR_CELL_RE = /^:?-{3,}:?$/;
 
 export function renderMarkdownishLine(line, color) {
   const heading = line.match(/^(#{1,6})\s+(.+?)\s*$/);
@@ -63,6 +66,14 @@ export function isTableLine(line, inCodeBlock) {
   return !inCodeBlock && stripped.includes("|") && stripped.split("|").length > 2;
 }
 
+export function isTableSeparator(line, inCodeBlock = false) {
+  if (!isTableLine(line, inCodeBlock)) {
+    return false;
+  }
+  const cells = parseTableRow(line);
+  return cells.length > 0 && cells.every((cell) => TABLE_SEPARATOR_CELL_RE.test(cell));
+}
+
 export function parseTableRow(line) {
   let stripped = line.trim();
   if (stripped.startsWith("|")) {
@@ -74,6 +85,137 @@ export function parseTableRow(line) {
   return stripped.split("|").map((cell) => cell.trim());
 }
 
+export function createTableState() {
+  return { candidate: [], rows: null };
+}
+
+export function consumeTableLine(state, line, inCodeBlock = false) {
+  if (state.rows) {
+    if (isTableLine(line, inCodeBlock)) {
+      state.rows.push(parseTableRow(line));
+      return { type: "append" };
+    }
+    const rows = state.rows;
+    state.rows = null;
+    return { type: "flush", rows, line };
+  }
+  if (state.candidate.length) {
+    if (isTableSeparator(line, inCodeBlock)) {
+      const header = state.candidate.at(-1);
+      const lines = state.candidate.slice(0, -1);
+      state.rows = [parseTableRow(header)];
+      state.candidate = [];
+      return { type: "start", lines };
+    }
+    const lines = state.candidate;
+    state.candidate = [];
+    return { type: "flush_candidate", lines, line };
+  }
+  if (isTableLine(line, inCodeBlock)) {
+    state.candidate.push(line);
+    return { type: "hold" };
+  }
+  return { type: "line", line };
+}
+
+export function finishTableState(state) {
+  if (state.rows) {
+    const rows = state.rows;
+    state.rows = null;
+    return { type: "flush", rows };
+  }
+  if (state.candidate.length) {
+    const lines = state.candidate;
+    state.candidate = [];
+    return { type: "flush_candidate", lines };
+  }
+  return null;
+}
+
+export function renderTableBlock(rows, color, width) {
+  if (!Array.isArray(rows) || rows.length === 0) {
+    return "";
+  }
+  const columnCount = Math.max(...rows.map((row) => Array.isArray(row) ? row.length : 0), 0);
+  if (!columnCount) {
+    return "";
+  }
+  const normalizedRows = rows.map((row) => Array.from({ length: columnCount }, (_, index) => String(row?.[index] || "")));
+  const header = normalizedRows[0];
+  const bodyRows = normalizedRows.slice(1).filter((row) => !row.every((cell) => TABLE_SEPARATOR_CELL_RE.test(cell)));
+  const displayRows = [header, ...bodyRows];
+  const availableWidth = Math.max(1, Number(width) || 1);
+  const borderOverhead = 3 * columnCount + 1;
+  const availableCells = availableWidth - borderOverhead;
+  if (availableCells < columnCount) {
+    return normalizedRows.map((row) => row.map((cell) => renderInline(cell, color)).join(dim(" | ", color))).join("\n");
+  }
+
+  const naturalWidths = Array(columnCount).fill(1);
+  const minimumWidths = Array(columnCount).fill(1);
+  displayRows.forEach((row, rowIndex) => {
+    row.forEach((cell, columnIndex) => {
+      const plain = renderInline(cell, false);
+      naturalWidths[columnIndex] = Math.max(naturalWidths[columnIndex], textWidth(plain));
+      minimumWidths[columnIndex] = Math.max(minimumWidths[columnIndex], longestWordWidth(plain, 30));
+      if (rowIndex === 0) {
+        minimumWidths[columnIndex] = Math.max(minimumWidths[columnIndex], 1);
+      }
+    });
+  });
+
+  const minimumTotal = minimumWidths.reduce((sum, value) => sum + value, 0);
+  if (minimumTotal > availableCells) {
+    minimumWidths.fill(1);
+  }
+  const columnWidths = minimumWidths.slice();
+  let remaining = availableCells - columnWidths.reduce((sum, value) => sum + value, 0);
+  while (remaining > 0) {
+    let grew = false;
+    for (let index = 0; index < columnCount && remaining > 0; index += 1) {
+      if (columnWidths[index] < naturalWidths[index]) {
+        columnWidths[index] += 1;
+        remaining -= 1;
+        grew = true;
+      }
+    }
+    if (!grew) {
+      break;
+    }
+  }
+
+  const border = (left, joiner, right) => `${left}─${columnWidths.map((value) => "─".repeat(value)).join(`─${joiner}─`)}─${right}`;
+  const lines = [border("┌", "┬", "┐")];
+  displayRows.forEach((row, rowIndex) => {
+    const cells = row.map((cell, columnIndex) => {
+      const rendered = renderInline(cell, color, rowIndex === 0 ? "tableHeader" : "");
+      return wrapTextWithAnsi(rendered, columnWidths[columnIndex], columnWidths[columnIndex]);
+    });
+    const height = Math.max(...cells.map((cell) => cell.length));
+    for (let lineIndex = 0; lineIndex < height; lineIndex += 1) {
+      const renderedCells = cells.map((cell, columnIndex) => {
+        const value = cell[lineIndex] || "";
+        return `${value}${" ".repeat(Math.max(0, columnWidths[columnIndex] - textWidth(value)))}`;
+      });
+      lines.push(`│ ${renderedCells.join(" │ ")} │`);
+    }
+    if (rowIndex === 0) {
+      lines.push(border("├", "┼", "┤"));
+    } else if (rowIndex < displayRows.length - 1) {
+      lines.push(border("├", "┼", "┤"));
+    }
+  });
+  lines.push(border("└", "┴", "┘"));
+  return lines.join("\n");
+}
+
+function longestWordWidth(value, limit) {
+  return Math.min(
+    limit,
+    Math.max(...String(value || "").split(/\s+/).map((word) => textWidth(word)), 1),
+  );
+}
+
 export function codeOpenLabel(label) {
   return label ? `┌ code ${label}` : "┌ code";
 }

package/lib/one-shot-progress.js

@@ -1,145 +1,145 @@
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const SPINNER_INTERVAL_MS = 120;
-const NAME_COLUMN_MAX = 26;
-
-export function formatDuration(ms) {
-  const value = Math.max(0, Number(ms) || 0);
-  if (value < 1000) return `${Math.round(value)}ms`;
-  if (value < 60_000) return `${(value / 1000).toFixed(1)}s`;
-  return `${Math.floor(value / 60_000)}m ${Math.round((value % 60_000) / 1000)}s`;
-}
-
-export function createOneShotProgress({ stderr, stream = null } = {}) {
-  const tty = stream ?? { isTTY: false };
-  const isTTY = Boolean(tty.isTTY);
-  const useColor = isTTY && process.env.NO_COLOR === undefined;
-  const c = useColor
-    ? { dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", reset: "\x1b[0m" }
-    : { dim: "", red: "", green: "", reset: "" };
-
-  const tools = new Map();
-  let toolCounter = 0;
-  let printedToolLines = 0;
-  let lastPendingToolId = null;
-  let spinnerTimer = null;
-  let spinnerFrame = 0;
-  let spinnerLabel = "";
-  let active = false;
-
-  function emit(text) {
-    stopSpinner();
-    stderr(text);
-  }
-
-  function startSpinner(label) {
-    spinnerLabel = label;
-    if (!isTTY || spinnerTimer) return;
-    spinnerFrame = 0;
-    renderSpinner();
-    spinnerTimer = setInterval(() => {
-      spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES.length;
-      renderSpinner();
-    }, SPINNER_INTERVAL_MS);
-    spinnerTimer.unref?.();
-  }
-
-  function renderSpinner() {
-    stderr(`\r${c.dim}${SPINNER_FRAMES[spinnerFrame]} ${spinnerLabel}${c.reset}\x1b[K`);
-  }
-
-  function stopSpinner() {
-    if (!spinnerTimer) return;
-    clearInterval(spinnerTimer);
-    spinnerTimer = null;
-    if (isTTY) stderr("\r\x1b[K");
-  }
-
-  function resumeSpinner() {
-    if (active && isTTY && spinnerLabel) startSpinner(spinnerLabel);
-  }
-
-  function toolLine(entry) {
-    const index = String(entry.index).padStart(2, " ");
-    const truncated = entry.name.length > NAME_COLUMN_MAX
-      ? `${entry.name.slice(0, NAME_COLUMN_MAX - 1)}…`
-      : entry.name;
-    if (entry.finishedAt === null) {
-      const pendingMark = isTTY ? `  ${c.dim}…${c.reset}` : "";
-      return `  ${c.dim}${index}${c.reset}  ${truncated}${pendingMark}`;
-    }
-    const duration = c.dim + formatDuration(entry.durationMs) + c.reset;
-    const mark = entry.ok ? "" : ` ${c.red}✗${c.reset}`;
-    return `  ${c.dim}${index}${c.reset}  ${truncated}  ${duration}${mark}`;
-  }
-
-  return {
-    begin() {
-      active = true;
-      startSpinner("starting runtime");
-    },
-
-    hasTool(toolCallId) {
-      return tools.has(toolCallId);
-    },
-
-    get toolCount() {
-      return tools.size;
-    },
-
-    session({ sessionId, model, baseUrl }) {
-      const parts = [`session ${sessionId}`];
-      if (model) parts.push(`model ${model}`);
-      if (baseUrl) parts.push(`api ${baseUrl}`);
-      emit(`${c.dim}·${c.reset} ${parts.join(`${c.dim} · ${c.reset}`)}\n`);
-      startSpinner("working");
-    },
-
-    note(text) {
-      emit(`${c.dim}· ${text}${c.reset}\n`);
-      resumeSpinner();
-    },
-
-    toolStarted(toolCallId, toolName) {
-      const name = toolName || "tool";
-      toolCounter += 1;
-      const entry = { index: toolCounter, name, finishedAt: null, durationMs: 0, ok: true };
-      tools.set(toolCallId, entry);
-      emit(`${toolLine(entry)}\n`);
-      printedToolLines += 1;
-      lastPendingToolId = toolCallId;
-      resumeSpinner();
-    },
-
-    toolFinished(toolCallId, { ok, durationMs }) {
-      const entry = tools.get(toolCallId);
-      if (!entry || entry.finishedAt !== null) return;
-      entry.finishedAt = Date.now();
-      entry.durationMs = Number(durationMs) || 0;
-      entry.ok = Boolean(ok);
-      const canRewrite = isTTY && toolCallId === lastPendingToolId;
-      if (canRewrite) {
-        stopSpinner();
-        stderr(`\x1b[1A\r\x1b[K${toolLine(entry)}\n`);
-        lastPendingToolId = null;
-        resumeSpinner();
-        return;
-      }
-      if (!entry.ok) {
-        emit(`  ${c.red}↳ ${entry.name} failed${c.reset} ${c.dim}${formatDuration(entry.durationMs)}${c.reset}\n`);
-        resumeSpinner();
-      }
-      if (toolCallId === lastPendingToolId) lastPendingToolId = null;
-    },
-
-    done(elapsedMs) {
-      active = false;
-      if (printedToolLines > 0) emit("\n");
-      emit(`${c.green}✓${c.reset} done in ${formatDuration(elapsedMs)}\n`);
-    },
-
-    fail(message) {
-      active = false;
-      emit(`${c.red}✗ ${message}${c.reset}\n`);
-    },
-  };
-}
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL_MS = 120;
+const NAME_COLUMN_MAX = 26;
+
+export function formatDuration(ms) {
+  const value = Math.max(0, Number(ms) || 0);
+  if (value < 1000) return `${Math.round(value)}ms`;
+  if (value < 60_000) return `${(value / 1000).toFixed(1)}s`;
+  return `${Math.floor(value / 60_000)}m ${Math.round((value % 60_000) / 1000)}s`;
+}
+
+export function createOneShotProgress({ stderr, stream = null } = {}) {
+  const tty = stream ?? { isTTY: false };
+  const isTTY = Boolean(tty.isTTY);
+  const useColor = isTTY && process.env.NO_COLOR === undefined;
+  const c = useColor
+    ? { dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", reset: "\x1b[0m" }
+    : { dim: "", red: "", green: "", reset: "" };
+
+  const tools = new Map();
+  let toolCounter = 0;
+  let printedToolLines = 0;
+  let lastPendingToolId = null;
+  let spinnerTimer = null;
+  let spinnerFrame = 0;
+  let spinnerLabel = "";
+  let active = false;
+
+  function emit(text) {
+    stopSpinner();
+    stderr(text);
+  }
+
+  function startSpinner(label) {
+    spinnerLabel = label;
+    if (!isTTY || spinnerTimer) return;
+    spinnerFrame = 0;
+    renderSpinner();
+    spinnerTimer = setInterval(() => {
+      spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES.length;
+      renderSpinner();
+    }, SPINNER_INTERVAL_MS);
+    spinnerTimer.unref?.();
+  }
+
+  function renderSpinner() {
+    stderr(`\r${c.dim}${SPINNER_FRAMES[spinnerFrame]} ${spinnerLabel}${c.reset}\x1b[K`);
+  }
+
+  function stopSpinner() {
+    if (!spinnerTimer) return;
+    clearInterval(spinnerTimer);
+    spinnerTimer = null;
+    if (isTTY) stderr("\r\x1b[K");
+  }
+
+  function resumeSpinner() {
+    if (active && isTTY && spinnerLabel) startSpinner(spinnerLabel);
+  }
+
+  function toolLine(entry) {
+    const index = String(entry.index).padStart(2, " ");
+    const truncated = entry.name.length > NAME_COLUMN_MAX
+      ? `${entry.name.slice(0, NAME_COLUMN_MAX - 1)}…`
+      : entry.name;
+    if (entry.finishedAt === null) {
+      const pendingMark = isTTY ? `  ${c.dim}…${c.reset}` : "";
+      return `  ${c.dim}${index}${c.reset}  ${truncated}${pendingMark}`;
+    }
+    const duration = c.dim + formatDuration(entry.durationMs) + c.reset;
+    const mark = entry.ok ? "" : ` ${c.red}✗${c.reset}`;
+    return `  ${c.dim}${index}${c.reset}  ${truncated}  ${duration}${mark}`;
+  }
+
+  return {
+    begin() {
+      active = true;
+      startSpinner("starting runtime");
+    },
+
+    hasTool(toolCallId) {
+      return tools.has(toolCallId);
+    },
+
+    get toolCount() {
+      return tools.size;
+    },
+
+    session({ sessionId, model, baseUrl }) {
+      const parts = [`session ${sessionId}`];
+      if (model) parts.push(`model ${model}`);
+      if (baseUrl) parts.push(`api ${baseUrl}`);
+      emit(`${c.dim}·${c.reset} ${parts.join(`${c.dim} · ${c.reset}`)}\n`);
+      startSpinner("working");
+    },
+
+    note(text) {
+      emit(`${c.dim}· ${text}${c.reset}\n`);
+      resumeSpinner();
+    },
+
+    toolStarted(toolCallId, toolName) {
+      const name = toolName || "tool";
+      toolCounter += 1;
+      const entry = { index: toolCounter, name, finishedAt: null, durationMs: 0, ok: true };
+      tools.set(toolCallId, entry);
+      emit(`${toolLine(entry)}\n`);
+      printedToolLines += 1;
+      lastPendingToolId = toolCallId;
+      resumeSpinner();
+    },
+
+    toolFinished(toolCallId, { ok, durationMs }) {
+      const entry = tools.get(toolCallId);
+      if (!entry || entry.finishedAt !== null) return;
+      entry.finishedAt = Date.now();
+      entry.durationMs = Number(durationMs) || 0;
+      entry.ok = Boolean(ok);
+      const canRewrite = isTTY && toolCallId === lastPendingToolId;
+      if (canRewrite) {
+        stopSpinner();
+        stderr(`\x1b[1A\r\x1b[K${toolLine(entry)}\n`);
+        lastPendingToolId = null;
+        resumeSpinner();
+        return;
+      }
+      if (!entry.ok) {
+        emit(`  ${c.red}↳ ${entry.name} failed${c.reset} ${c.dim}${formatDuration(entry.durationMs)}${c.reset}\n`);
+        resumeSpinner();
+      }
+      if (toolCallId === lastPendingToolId) lastPendingToolId = null;
+    },
+
+    done(elapsedMs) {
+      active = false;
+      if (printedToolLines > 0) emit("\n");
+      emit(`${c.green}✓${c.reset} done in ${formatDuration(elapsedMs)}\n`);
+    },
+
+    fail(message) {
+      active = false;
+      emit(`${c.red}✗ ${message}${c.reset}\n`);
+    },
+  };
+}

package/lib/one-shot.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { createRuntimeClient } from "./runtime-client.js";
 import { requireRuntimeInitialization, runtimeMethods } from "./runtime-protocol.js";
 import { createOneShotProgress } from "./one-shot-progress.js";
+import { sendHelp } from "./send.js";
 
 export const oneShotHelp = [
   "Usage: rind run --prompt <text> [--dir <absolute-path>] [--session <id>]",
@@ -20,6 +21,8 @@ export const cliHelp = [
   "Start the interactive CLI.",
   "",
   oneShotHelp,
+  "",
+  sendHelp,
 ].join("\n");
 
 export function parseOneShotArgs(args) {
@@ -143,9 +146,6 @@ export async function runOneShot({ args, python, repoRoot, runtimePath, cwd = pr
         if (message?.turn_id) turnId = String(message.turn_id);
         if (type === "assistant_delta") assistant += String(event.text || "");
         if (type === "assistant_message_completed") completed = String(event.content || "");
-        if (type === "goal_continued") {
-          progress.note(`goal check · round ${Number(event.round) || 0}`);
-        }
         const toolCallId = String(event?.tool_call_id || "");
         const trackedId = toolCallId || (type === "tool_requested" ? `anon:${(anonymousToolCounter += 1)}` : "");
         if (trackedId && (type === "tool_requested" || type === "tool_input_started") && !progress.hasTool(trackedId)) {

package/lib/prompt-history-store.js

@@ -0,0 +1,54 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+const HISTORY_LIMIT = 100;
+
+export function promptHistoryPath(rindHome = process.env.RIND_HOME || path.join(homedir(), ".rind")) {
+  return path.join(String(rindHome), "cli-history.jsonl");
+}
+
+export function loadPromptHistory(rindHome) {
+  try {
+    const lines = readFileSync(promptHistoryPath(rindHome), "utf8").split(/\r?\n/);
+    const history = [];
+    for (let index = lines.length - 1; index >= 0 && history.length < HISTORY_LIMIT; index -= 1) {
+      try {
+        const value = JSON.parse(lines[index]);
+        const text = typeof value === "string" ? value.trim() : "";
+        if (text && !history.includes(text)) {
+          history.push(text);
+        }
+      } catch {
+        continue;
+      }
+    }
+    return history;
+  } catch {
+    return [];
+  }
+}
+
+export function savePromptHistory(history, rindHome) {
+  const values = [];
+  for (const value of Array.isArray(history) ? history : []) {
+    const text = String(value || "").trim();
+    if (!text || values.includes(text)) {
+      continue;
+    }
+    values.push(text);
+    if (values.length >= HISTORY_LIMIT) {
+      break;
+    }
+  }
+  const file = promptHistoryPath(rindHome);
+  try {
+    mkdirSync(path.dirname(file), { recursive: true });
+    const temp = `${file}.${process.pid}.tmp`;
+    writeFileSync(temp, `${values.reverse().map((value) => JSON.stringify(value)).join("\n")}\n`, "utf8");
+    renameSync(temp, file);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/lib/question-menu-state.js

@@ -26,7 +26,17 @@ export function createQuestionMenuState(options) {
       editing = true;
       return true;
     },
+    leaveEditing() {
+      if (!editing) {
+        return false;
+      }
+      editing = false;
+      return true;
+    },
     handleNavigation(key = {}) {
+      if (editing) {
+        return false;
+      }
       const vimNavigation = !editing && (key.text === "j" || key.text === "k");
       if (key.name !== "up" && key.name !== "down" && !vimNavigation) {
         return false;