@rind-ai/cli 0.6.1 → 0.7.0

package/bin/rind.js

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

package/lib/assistant-renderer.js

@@ -1,17 +1,18 @@
+import { ANSI_SEQUENCE } from "./text-width.js";
 import { graphemes, textWidth } from "./text-width.js";
 import {
   codeOpenLabel,
+  consumeTableLine,
+  createTableState,
   dim,
+  finishTableState,
   isPlainLine,
-  isTableLine,
-  parseTableRow,
-  renderInline,
+  renderTableBlock,
   renderMarkdownishLine,
   styled,
 } from "./markdown-lines.js";
 
 const CONTENT_PREFIX = "  ";
-const ANSI_SEQUENCE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
 
 export { CONTENT_PREFIX };
 
@@ -21,6 +22,7 @@ export class AssistantRenderer {
     this.color = options.color ?? (Boolean(process.stdout.isTTY) && !process.env.NO_COLOR);
     this.pending = "";
     this.inCodeBlock = false;
+    this.tableState = createTableState();
     this.lineOpen = false;
     this.atLineStart = true;
     this.visibleColumn = 0;
@@ -46,6 +48,12 @@ export class AssistantRenderer {
       this.renderLine(this.pending, false);
       this.pending = "";
     }
+    const table = finishTableState(this.tableState);
+    if (table?.type === "flush") {
+      this.writeTable(table.rows);
+    } else if (table?.type === "flush_candidate") {
+      table.lines.forEach((line) => this.renderNormalLine(line, true));
+    }
     if (this.lineOpen) {
       this.writeText("\n");
       this.lineOpen = false;
@@ -53,7 +61,7 @@ export class AssistantRenderer {
   }
 
   flushPlainPending() {
-    if (!this.pending || this.inCodeBlock || !isPlainLine(this.pending)) {
+    if (!this.pending || this.inCodeBlock || this.tableState.candidate.length || this.tableState.rows || !isPlainLine(this.pending)) {
       return;
     }
     this.writePlain(this.pending, false);
@@ -61,10 +69,29 @@ export class AssistantRenderer {
   }
 
   renderLine(line, newline) {
-    if (isTableLine(line, this.inCodeBlock)) {
-      this.renderTableLine(line, newline);
+    const result = consumeTableLine(this.tableState, line, this.inCodeBlock);
+    if (result.type === "hold" || result.type === "append") {
+      return;
+    }
+    if (result.type === "start") {
+      result.lines?.forEach((candidate) => this.renderNormalLine(candidate, true));
+      return;
+    }
+    if (result.type === "flush") {
+      this.writeTable(result.rows);
+      if (result.line === undefined) return;
+      this.renderNormalLine(result.line, newline);
+      return;
+    }
+    if (result.type === "flush_candidate") {
+      result.lines.forEach((candidate) => this.renderNormalLine(candidate, true));
+      if (result.line !== undefined) this.renderNormalLine(result.line, newline);
       return;
     }
+    this.renderNormalLine(line, newline);
+  }
+
+  renderNormalLine(line, newline) {
     if (line.trim().startsWith("```")) {
       this.renderCodeFence(line, newline);
       return;
@@ -80,15 +107,15 @@ export class AssistantRenderer {
     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" : "")
+  writeTable(rows) {
+    const table = renderTableBlock(
+      rows,
+      this.color,
+      Math.max(1, Math.floor(Number(this.columns ?? process.stdout.columns ?? 80) || 80) - CONTENT_PREFIX.length),
     );
-    this.writeStyled(rendered.join(dim(" | ", this.color)), newline);
+    if (table) {
+      this.writeStyled(table, true);
+    }
   }
 
   renderCodeFence(line, newline) {

package/lib/cli-input-actions.js

@@ -18,14 +18,17 @@ export function createCliInputActions({
   request,
   output,
   getTurnController,
+  getCommandController,
   getTaskMonitor,
   getLineInput,
   pausePrompt,
   resumePrompt,
   handleSigint,
+  promptHistory = [],
+  onPromptHistory = () => {},
 }) {
   let cancelActiveInput = null;
-  const promptEditor = createLineEditor();
+  const promptEditor = createLineEditor("", { history: promptHistory });
 
   function restoreInputText(text) {
     state.input.prefill = String(text || "");
@@ -51,7 +54,7 @@ export function createCliInputActions({
       return;
     }
     state.input.pending.splice(index, 1);
-    output.suspendPrompt(() => output.writeUserInput(input));
+    output.writeUserInput(input);
   }
 
   async function retrievePendingInput(mode, session) {
@@ -90,6 +93,28 @@ export function createCliInputActions({
     }
   }
 
+  async function promotePendingFollowUp(session) {
+    const entry = [...state.input.pending].reverse().find((item) => item.mode === "follow_up");
+    if (!entry || state.input.retrievingModes.has("follow_up")) {
+      return;
+    }
+    state.input.retrievingModes.add("follow_up");
+    try {
+      const result = await request(runtimeMethods.sessionPromoteFollowUp, { input_id: entry.inputId });
+      if (result?.accepted !== true || result?.mode !== "steering" || result?.input_id !== entry.inputId) {
+        throw new Error("Runtime did not confirm the follow-up promotion.");
+      }
+      entry.mode = "steering";
+      output.redraw();
+    } catch (error) {
+      if (state.runtime.status !== "closing") {
+        output.writeError(`${error instanceof Error ? error.message : String(error)}\n`);
+      }
+    } finally {
+      state.input.retrievingModes.delete("follow_up");
+    }
+  }
+
   function clearPendingInputs() {
     if (!state.input.pending.length) {
       return;
@@ -178,7 +203,6 @@ export function createCliInputActions({
 
   function askTtyInput(prompt, placeholder) {
     return new Promise((resolve) => {
-      output.clearAssistantLineForInput();
       const mode = placeholder && placeholder !== answerPlaceholderText() ? "prompt" : "line";
       const initialInput = state.input.prefill;
       const editor = mode === "prompt" ? promptEditor : createLineEditor(initialInput);
@@ -246,6 +270,14 @@ export function createCliInputActions({
       handleTeamBlueprintInput(session, event);
       return;
     }
+    if (session.mode === "fork") {
+      handleForkInput(session, event);
+      return;
+    }
+    if (session.mode === "context-board") {
+      handleContextBoardInput(session, event);
+      return;
+    }
     const key = event;
     const matches = session.menuState ? syncSlashMenu(session) : [];
     const menuKey = !key.ctrl && !key.alt && !key.shift && ["escape", "up", "down"].includes(key.name);
@@ -265,6 +297,10 @@ export function createCliInputActions({
       void retrievePendingInput("steering", session);
       return;
     }
+    if (session.mode === "prompt" && key.alt && !key.ctrl && !key.shift && key.name === "right" && state.input.pending.some((item) => item.mode === "follow_up")) {
+      void promotePendingFollowUp(session);
+      return;
+    }
     const result = session.editor.handleInput(key);
     if (result === "submit") {
       submitTtyInput(session);
@@ -281,7 +317,7 @@ export function createCliInputActions({
       return;
     }
     const session = state.input.session;
-    if (!session || session.mode === "model" || session.mode === "theme" || session.mode === "sessions") {
+    if (!session || session.mode === "model" || session.mode === "theme" || session.mode === "sessions" || session.mode === "fork" || session.mode === "context-board") {
       return;
     }
     if (session.mode === "question" && !session.questionState.isEditing()) {
@@ -307,7 +343,6 @@ export function createCliInputActions({
 
   function askThemeMenu() {
     return new Promise((resolve) => {
-      output.clearAssistantLineForInput();
       const themeState = createThemeMenuState();
       if (!themeState.items().length) {
         resolve("");
@@ -339,18 +374,29 @@ export function createCliInputActions({
     if (session.menuState) syncSlashMenu(session);
     const command = session.menuState?.selectedCommand();
     const value = command ? `/${command.name}` : session.editor.input();
-    if (session.mode === "prompt") session.editor.addToHistory(value);
+    if (session.mode === "prompt") recordPromptHistory(session.editor, value);
     completeTtyInput(session, value, session.mode === "prompt" && !state.turn.active, session.mode === "line" ? "\n" : "");
   }
 
   function queueTtyInput(session) {
     const value = session.editor.input();
     if (!value.trim()) return;
-    session.editor.addToHistory(value);
+    recordPromptHistory(session.editor, value);
     completeTtyInput(session, "", false);
     getTurnController().submitFollowUp(value);
   }
 
+  function recordPromptHistory(editor, value) {
+    const text = String(value || "").trim();
+    if (!text || text.startsWith("/")) {
+      editor.addToHistory("");
+      return;
+    }
+    if (editor.addToHistory(text)) {
+      onPromptHistory(editor.getHistory());
+    }
+  }
+
   function completeTtyInput(session, value, writeUser, lineText = "", displayValue = value) {
     if (state.input.session !== session) return;
     state.input.session = null;
@@ -366,7 +412,6 @@ export function createCliInputActions({
 
   function askModelMenu(models, currentModel) {
     return new Promise((resolve) => {
-      output.clearAssistantLineForInput();
       const modelState = createModelMenuState(models, currentModel);
       if (!modelState.items().length) {
         resolve("");
@@ -382,7 +427,6 @@ export function createCliInputActions({
 
   function askEffortMenu(currentEffort) {
     return new Promise((resolve) => {
-      output.clearAssistantLineForInput();
       const modelState = createModelMenuState(REASONING_EFFORTS.slice(), currentEffort);
       const session = { mode: "model", inputText: "/effort", modelState, resolve };
       state.input.session = session;
@@ -406,16 +450,17 @@ export function createCliInputActions({
 
   function askQuestionMenu(event) {
     return new Promise((resolve) => {
-      output.clearAssistantLineForInput();
       const options = (Array.isArray(event.options) ? event.options : [])
         .map((option) => ({ label: String(option?.label || "").trim(), description: String(option?.description || "").trim() }))
         .filter((option) => option.label);
       const questionState = createQuestionMenuState(options);
+      const editor = createLineEditor();
+      editor.setViewportWidth(process.stdout.columns || 80);
       state.input.session = {
         mode: "question",
         question: String(event.question || "Input required"),
         questionState,
-        editor: null,
+        editor,
         resolve,
       };
       state.input.active = true;
@@ -426,7 +471,6 @@ export function createCliInputActions({
 
   function askSessionMenu(options, sessions, currentIndex) {
     return new Promise((resolve) => {
-      output.clearAssistantLineForInput();
       const choiceState = createChoiceMenuState(options, options[currentIndex] || "");
       const session = { mode: "sessions", inputText: "/sessions", choiceState, sessions, resolve };
       state.input.session = session;
@@ -438,7 +482,6 @@ export function createCliInputActions({
 
   function askTeamBlueprint(blueprints) {
     return new Promise((resolve) => {
-      output.clearAssistantLineForInput();
       const items = (Array.isArray(blueprints) ? blueprints : []).map((item) => ({
         id: String(item?.id || ""),
         label: [item?.id, item?.name, item?.description].filter(Boolean).join(" · "),
@@ -459,9 +502,14 @@ export function createCliInputActions({
   function handleQuestionInput(session, key) {
     const modified = key.ctrl || key.alt || key.shift;
     if (session.questionState.isEditing()) {
-      if (!modified && key.name === "escape") return completeTtyInput(session, "", false);
-      if (!modified && session.questionState.handleNavigation(key)) {
-        session.editor = null;
+      if (!modified && (key.name === "up" || key.name === "down")) {
+        session.questionState.leaveEditing();
+        session.editor.setInput("");
+        if (session.questionState.handleNavigation(key)) output.redraw();
+        return;
+      }
+      if (!modified && key.name === "escape") {
+        session.questionState.leaveEditing();
         output.redraw();
         return;
       }
@@ -477,8 +525,6 @@ export function createCliInputActions({
     }
     if (!modified && (key.name === "enter" || key.name === "return" || key.name === "tab")) {
       if (session.questionState.enterEditing()) {
-        session.editor = createLineEditor();
-        session.editor.setViewportWidth(process.stdout.columns || 80);
         output.redraw();
         return;
       }
@@ -488,7 +534,6 @@ export function createCliInputActions({
     }
     if (!modified && key.name === "escape") return completeTtyInput(session, "", false);
     if (!modified && session.questionState.handleNavigation(key)) {
-      session.editor = null;
       output.redraw();
     }
   }
@@ -513,6 +558,49 @@ export function createCliInputActions({
     if (!modified && session.choiceState.handleKey(key)) output.redraw();
   }
 
+  function handleForkInput(session, key) {
+    const modified = key.ctrl || key.alt || key.shift;
+    if (!modified && (key.name === "enter" || key.name === "return")) {
+      completeTtyInput(session, session.items[session.choiceState.selectedIndex()] || null, false);
+      return;
+    }
+    if (!modified && key.name === "escape") return completeTtyInput(session, null, false);
+    if (!modified && session.choiceState.handleKey(key)) output.redraw();
+  }
+
+  function askContextBoard(board) {
+    return new Promise((resolve) => {
+      const session = { mode: "context-board", inputText: "/context", board, pageIndex: 0, resolve };
+      state.input.session = session;
+      state.input.active = true;
+      cancelActiveInput = () => completeTtyInput(session, "", false);
+      output.redraw(true);
+    });
+  }
+
+  function handleContextBoardInput(session, key) {
+    const modified = key.ctrl || key.alt || key.shift;
+    if (!modified && key.name === "escape") {
+      completeTtyInput(session, "", false);
+      return;
+    }
+    if (!modified && (key.name === "tab" || key.name === "left" || key.name === "right")) {
+      session.pageIndex = (session.pageIndex + 1) % 2;
+      output.redraw();
+    }
+  }
+
+  function askForkPointMenu(items) {
+    return new Promise((resolve) => {
+      const choiceState = createChoiceMenuState(items.map((item) => item.label), items[0].label);
+      const session = { mode: "fork", inputText: "/fork", choiceState, items, resolve };
+      state.input.session = session;
+      state.input.active = true;
+      cancelActiveInput = () => completeTtyInput(session, null, false);
+      output.redraw(true);
+    });
+  }
+
   function syncSlashMenu(session) {
     session.menuState.setInput(session.editor.input());
     return session.menuState.matches();
@@ -529,6 +617,29 @@ export function createCliInputActions({
     return typeof prompt === "function" ? prompt() : prompt;
   }
 
+  // External input (rind send) enters the same path as a typed submit: echo
+  // only when a typed enter would echo, then command-first dispatch.
+  function dispatchExternal(text) {
+    const value = String(text || "");
+    if (!value.trim()) {
+      return;
+    }
+    if (!state.turn.active && !value.startsWith("/")) {
+      output.writeUserInput(value, "send");
+    }
+    void getCommandController().handle(value)
+      .then((handled) => {
+        if (!handled) {
+          getTurnController().submit(value);
+        }
+      })
+      .catch((error) => {
+        if (state.runtime.status !== "closing") {
+          output.writeError(`${error instanceof Error ? error.message : String(error)}\n`);
+        }
+      });
+  }
+
   return {
     ask,
     answerQuestion,
@@ -538,11 +649,14 @@ export function createCliInputActions({
     clearPendingInputs,
     handleTerminalInput,
     handleTerminalPaste,
+    dispatchExternal,
     askModelMenu,
     askEffortMenu,
     askThemeMenu,
     askSessionMenu,
     askTeamBlueprint,
+    askForkPointMenu,
+    askContextBoard,
     cancel: () => cancelActiveInput?.(),
   };
 }