@rind-ai/cli 0.4.1

package/lib/command-controller.js

@@ -0,0 +1,126 @@
+import {
+  isReadonlySlashCommand,
+  parseGoalCommand,
+  steeringCommandText,
+} from "./slash-command-mode.js";
+import {
+  helpText,
+  slashResultText,
+} from "./rendering.js";
+
+export function createCommandController({
+  request,
+  turn,
+  input = {},
+  state = {},
+  output = {},
+}) {
+  async function handle(text) {
+    if (text === "?") {
+      output.log?.(helpText(state.slashCommands || []));
+      return true;
+    }
+    if (!String(text || "").startsWith("/")) {
+      return false;
+    }
+    const goal = parseGoalCommand(text);
+    if (goal) {
+      await input.runGoalCommand?.(goal);
+      return true;
+    }
+    const steering = steeringCommandText(text);
+    if (steering !== null) {
+      turn.submitSteering(steering, text);
+      return true;
+    }
+    await runSlashCommand(text);
+    return true;
+  }
+
+  async function runSlashCommand(text) {
+    if (isBareModelCommand(text) && input.isTerminal) {
+      await input.runModelSelector?.();
+      return;
+    }
+    if (isCompactCommand(text) && input.isTerminal) {
+      input.startCompactCommand?.();
+      return;
+    }
+    if (isBareSessionsCommand(text) && input.isTerminal) {
+      await input.runSessionsSelector?.();
+      return;
+    }
+    if (isReadonlySlashCommand(text) && input.isTerminal) {
+      input.startReadonlySlashCommand?.(text);
+      return;
+    }
+    const result = await request("slash.execute", { input: text });
+    await applyResult(result);
+  }
+
+  async function applyResult(result = {}) {
+    if (result.clear_screen) {
+      output.clearScreen?.();
+    }
+    const text = slashResultText(result, state.slashCommands || []);
+    if (text) {
+      output.log?.(text);
+    }
+    if (result.context_usage_reset) {
+      output.resetContextUsage?.();
+    }
+    if (result.input_prefill) {
+      output.setInputPrefill?.(result.input_prefill);
+    }
+    if (result.run_turn_input) {
+      turn.submit(result.run_turn_input, {
+        transient_system_messages: result.transient_system_messages,
+      });
+    }
+    if (result.should_exit) {
+      await output.shutdown?.();
+      output.exit?.();
+    }
+  }
+
+  function normalizeCommands(commands) {
+    if (!Array.isArray(commands)) {
+      return [];
+    }
+    const items = [];
+    for (const command of commands) {
+      const name = singleWord(command?.name);
+      if (!name) {
+        continue;
+      }
+      const description = String(command.description || "").trim();
+      items.push({ name, description });
+      for (const alias of command.aliases || []) {
+        const aliasName = singleWord(alias);
+        if (aliasName) {
+          items.push({ name: aliasName, description: `alias for /${name}` });
+        }
+      }
+    }
+    return items.sort((left, right) => left.name.localeCompare(right.name));
+  }
+
+  return { handle, normalizeCommands, applyResult };
+}
+
+function singleWord(value) {
+  const text = String(value || "").trim().toLowerCase();
+  return text && !/\s/.test(text) ? text : "";
+}
+
+function isBareModelCommand(value) {
+  return String(value || "").trim().toLowerCase() === "/model";
+}
+
+function isBareSessionsCommand(value) {
+  return String(value || "").trim().toLowerCase() === "/sessions";
+}
+
+function isCompactCommand(value) {
+  return String(value || "").trim().toLowerCase() === "/compact";
+}

package/lib/compact-context-state.js

@@ -0,0 +1,22 @@
+export function createCompactContextState() {
+  let awaitingPostCompactContext = false;
+  return {
+    handleContextBuilt(event = {}) {
+      const decisions = event.decisions && typeof event.decisions === "object" ? event.decisions : {};
+      if (awaitingPostCompactContext) {
+        awaitingPostCompactContext = false;
+        return true;
+      }
+      if (decisions.auto_compact_token_limit_reached || decisions.compact_required) {
+        awaitingPostCompactContext = true;
+      }
+      return false;
+    },
+    clear() {
+      awaitingPostCompactContext = false;
+    },
+    pending() {
+      return awaitingPostCompactContext;
+    },
+  };
+}

package/lib/composer-terminal.js

@@ -0,0 +1,203 @@
+import { graphemes, stripAnsi, textWidth, wrapTextCells } from "./text-width.js";
+
+const DEFAULT_COLUMNS = 80;
+const INPUT_MARKER = "\n  ▷ ";
+const ANSI_SEQUENCE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+const SGR_SEQUENCE = /^\x1b\[([0-9;]*)m$/;
+
+export function prepareComposerFrame(frame = {}, columns = DEFAULT_COLUMNS) {
+  const width = terminalColumns(columns);
+  const block = splitPromptBlock(frame.prompt);
+  const input = String(frame.inputText || "");
+  const display = input || String(frame.placeholder || "");
+  const position = cursorPosition(frame, input);
+  const leadingLines = wrapRenderedLines(block.leading, width);
+  const inputLines = wrapInputLines(block.prefix, display, width);
+  const cursor = visualCursor(block.prefix, input, position, width, inputLines);
+  const menuLines = wrapRenderedLines(frame.menuText, width);
+  const trailingLines = wrapRenderedLines(block.trailing, width);
+  const lines = [...leadingLines, ...inputLines, ...menuLines, ...trailingLines];
+  const cursorRow = leadingLines.length + cursor.row;
+  const selectedMenuRow = menuLines.findIndex((line) => stripAnsi(line).startsWith("  › "));
+
+  return {
+    lines,
+    cursorRow,
+    cursorColumn: cursor.column,
+    focusRow: selectedMenuRow === -1
+      ? cursorRow
+      : leadingLines.length + inputLines.length + selectedMenuRow,
+  };
+}
+
+function wrapInputLines(prefix, text, columns) {
+  const logicalLines = String(text || "").split("\n");
+  const prefixWidth = textWidth(prefix);
+  const continuationPrefix = " ".repeat(prefixWidth);
+  const contentWidth = Math.max(1, columns - prefixWidth);
+  const lines = [];
+  for (const [index, logicalLine] of logicalLines.entries()) {
+    const linePrefix = index === 0 ? prefix : continuationPrefix;
+    if (logicalLine.includes("\x1b")) {
+      lines.push(...wrapLine(
+        linePrefix,
+        continuationPrefix,
+        logicalLine,
+        contentWidth,
+      ));
+      continue;
+    }
+    const chunks = wrapTextCells(logicalLine, contentWidth, contentWidth);
+    lines.push(...chunks.map((chunk, chunkIndex) => (
+      `${chunkIndex === 0 ? linePrefix : continuationPrefix}${chunk.text}`
+    )));
+  }
+  return lines.length ? lines : [String(prefix || "")];
+}
+
+function visualCursor(prefix, input, position, columns, inputLines) {
+  const logicalLines = String(input).split("\n");
+  const prefixWidth = textWidth(prefix);
+  const continuationPrefix = " ".repeat(prefixWidth);
+  const contentWidth = Math.max(1, columns - prefixWidth);
+  const visualLines = [];
+  for (const [lineIndex, logicalLine] of logicalLines.entries()) {
+    const chunks = wrapTextCells(logicalLine, contentWidth, contentWidth);
+    for (const chunk of chunks) {
+      visualLines.push({
+        startColumn: chunk.startColumn,
+        length: chunk.length,
+        allowsEnd: chunk.allowsEnd,
+        line: lineIndex,
+        prefixWidth,
+      });
+    }
+    const lastChunk = chunks.at(-1);
+    if (lineIndex === logicalLines.length - 1 && !lastChunk.allowsEnd) {
+      visualLines.push({
+        startColumn: lastChunk.startColumn + lastChunk.length,
+        length: 0,
+        allowsEnd: true,
+        line: lineIndex,
+        prefixWidth,
+      });
+    }
+  }
+
+  let row = visualLines.length - 1;
+  for (const [index, visualLine] of visualLines.entries()) {
+    if (visualLine.line !== position.line) {
+      continue;
+    }
+    const offset = position.column - visualLine.startColumn;
+    if (offset >= 0 && (offset < visualLine.length || (visualLine.allowsEnd && offset === visualLine.length))) {
+      row = index;
+      break;
+    }
+  }
+  while (inputLines.length <= row) {
+    inputLines.push(continuationPrefix);
+  }
+  const visualLine = visualLines[row];
+  const text = graphemes(logicalLines[position.line])
+    .slice(visualLine.startColumn, position.column)
+    .join("");
+  return {
+    row,
+    column: visualLine.prefixWidth + textWidth(text),
+  };
+}
+
+function wrapLine(prefix, continuationPrefix, text, contentWidth) {
+  const lines = [];
+  let line = "";
+  let width = 0;
+  let activeStyle = "";
+  for (const segment of displaySegments(text)) {
+    const sgr = segment.match(SGR_SEQUENCE);
+    if (sgr) {
+      line += segment;
+      const codes = (sgr[1] || "0").split(";").map((code) => code || "0");
+      const resetIndex = codes.lastIndexOf("0");
+      activeStyle = resetIndex === codes.length - 1
+        ? ""
+        : resetIndex >= 0
+          ? segment
+          : `${activeStyle}${segment}`;
+      continue;
+    }
+    const segmentWidth = textWidth(segment);
+    if (width > 0 && width + segmentWidth > contentWidth) {
+      lines.push(`${lines.length ? continuationPrefix : prefix}${line}`);
+      line = activeStyle;
+      width = 0;
+    }
+    line += segment;
+    width += segmentWidth;
+  }
+  lines.push(`${lines.length ? continuationPrefix : prefix}${line}`);
+  return lines;
+}
+
+function displaySegments(value) {
+  const text = String(value || "");
+  const segments = [];
+  let position = 0;
+  for (const match of text.matchAll(ANSI_SEQUENCE)) {
+    segments.push(...graphemes(text.slice(position, match.index)), match[0]);
+    position = match.index + match[0].length;
+  }
+  segments.push(...graphemes(text.slice(position)));
+  return segments;
+}
+
+function cursorPosition(frame, input) {
+  const lines = String(input).split("\n");
+  const line = Math.min(lines.length - 1, Math.max(0, Math.floor(Number(frame.cursor?.line) || 0)));
+  return {
+    line,
+    column: Math.min(
+      graphemes(lines[line]).length,
+      Math.max(0, Math.floor(Number(frame.cursor?.column) || 0)),
+    ),
+  };
+}
+
+function terminalColumns(columns) {
+  const value = Number(columns);
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : DEFAULT_COLUMNS;
+}
+
+function splitPromptBlock(prompt) {
+  const text = String(prompt || "");
+  const index = text.lastIndexOf(INPUT_MARKER);
+  if (index === -1) {
+    return { leading: "", prefix: text, trailing: "" };
+  }
+  const inputStart = index + 1;
+  const trailingStart = text.indexOf("\n", inputStart);
+  if (trailingStart === -1) {
+    return {
+      leading: text.slice(0, inputStart),
+      prefix: text.slice(inputStart),
+      trailing: "",
+    };
+  }
+  return {
+    leading: text.slice(0, inputStart),
+    prefix: text.slice(inputStart, trailingStart),
+    trailing: text.slice(trailingStart + 1),
+  };
+}
+
+function wrapRenderedLines(text, columns) {
+  const value = String(text || "");
+  if (!value) {
+    return [];
+  }
+  const lines = value.split("\n");
+  if (lines.at(-1) === "") {
+    lines.pop();
+  }
+  return lines.flatMap((line) => wrapLine("", "", line, columns));
+}

package/lib/event-controller.js

@@ -0,0 +1,242 @@
+import { runtimeEventType } from "./runtime-protocol.js";
+import {
+  cancelledText,
+  contextBuiltLine,
+  errorLine,
+  goalText,
+  planUpdatedLine,
+  toolProgressLine,
+  toolRequestedLine,
+  toolResultLine,
+  toolStartedLine,
+  turnCompletedLine,
+} from "./rendering.js";
+
+export function createEventController({
+  state = {},
+  input = {},
+  output = {},
+  background = {},
+}) {
+  const announcedTools = new Set();
+  const pendingFileChanges = new Map();
+  const pendingPlanInputs = new Map();
+  let toolStats = { completed: 0, failed: 0 };
+
+  async function handle(message) {
+    if (state.runtimeClosing) {
+      return;
+    }
+    const event = message?.event;
+    const eventType = runtimeEventType(message);
+    if (!event || typeof event !== "object") {
+      if (state.debug) {
+        output.debug?.(`Ignoring runtime event without payload: ${eventType || "unknown"}`);
+      }
+      return;
+    }
+    switch (eventType) {
+      case "assistant_delta":
+        output.assistantAppend?.(event.text || "");
+        return;
+      case "context_built": {
+        if (output.handleContextBuilt?.(event)) {
+          output.resetContextUsage?.();
+        }
+        const line = contextBuiltLine(event);
+        if (line) {
+          output.closeAssistant?.();
+          output.log?.(line);
+        }
+        return;
+      }
+      case "tool_input_started":
+        output.closeAssistant?.();
+        rememberPlanInputStart(event);
+        if (isAnnounced(event)) {
+          return;
+        }
+        output.log?.(toolStartedLine(event));
+        return;
+      case "tool_input_delta":
+        appendPlanInput(event);
+        return;
+      case "tool_input_ended":
+        return;
+      case "tool_requested":
+        output.closeAssistant?.();
+        rememberPlanInputPreview(event);
+        background.recordCommand?.(event);
+        if (isAnnounced(event)) {
+          return;
+        }
+        output.log?.(toolRequestedLine(event));
+        return;
+      case "tool_call_started":
+        output.closeAssistant?.();
+        if (alreadyAnnounced(event)) {
+          return;
+        }
+        output.log?.(toolStartedLine(event));
+        return;
+      case "tool_result": {
+        output.closeAssistant?.();
+        const fileChange = pendingFileChanges.get(event.tool_call_id);
+        pendingFileChanges.delete(event.tool_call_id);
+        const planInput = takePlanInput(event);
+        background.recordResult?.(event);
+        recordToolResult(event);
+        const plan = event.tool_name === "update_plan" && event.status === "completed"
+          ? parsePlanInput(planInput)
+          : null;
+        const goal = event.tool_name === "update_goal" && event.status === "completed"
+          ? parseToolData(event.result)
+          : null;
+        if (goal?.status) {
+          output.updateGoal?.(goal);
+        }
+        output.log?.(goal?.status ? goalText(goal) : plan ? planUpdatedLine(plan) : toolResultLine(event, fileChange));
+        return;
+      }
+      case "file_change":
+        if (event.tool_call_id) {
+          pendingFileChanges.set(event.tool_call_id, event);
+        }
+        return;
+      case "tool_progress": {
+        output.closeAssistant?.();
+        const line = toolProgressLine(event);
+        if (line) {
+          output.log?.(line);
+        }
+        return;
+      }
+      case "token_stats_updated":
+        output.closeAssistant?.();
+        output.setStats?.(event.stats && typeof event.stats === "object" ? event.stats : {});
+        if (!state.activeTurn) {
+          output.redraw?.();
+        }
+        return;
+      case "user_question_requested":
+        await input.answerQuestion?.(event);
+        return;
+      case "turn_failed":
+        output.clearCompactContext?.();
+        output.closeAssistant?.();
+        output.log?.(errorLine(event.error));
+        resetTurnState();
+        return;
+      case "turn_cancelled":
+        output.clearCompactContext?.();
+        output.closeAssistant?.();
+        output.log?.(cancelledText());
+        resetTurnState();
+        return;
+      case "turn_completed":
+        output.clearCompactContext?.();
+        output.closeAssistant?.();
+        output.log?.(turnCompletedLine(event, toolStats));
+        resetTurnState();
+        return;
+      default:
+        if (state.debug) {
+          output.debug?.(`Ignoring unknown runtime event: ${eventType || "unknown"}`);
+        }
+    }
+  }
+
+  function resetTurnState() {
+    toolStats = { completed: 0, failed: 0 };
+    announcedTools.clear();
+    pendingFileChanges.clear();
+    pendingPlanInputs.clear();
+    output.resetTurnTools?.();
+  }
+
+  function isAnnounced(event) {
+    if (!event.tool_call_id) {
+      return false;
+    }
+    if (announcedTools.has(event.tool_call_id)) {
+      return true;
+    }
+    announcedTools.add(event.tool_call_id);
+    return false;
+  }
+
+  function alreadyAnnounced(event) {
+    return Boolean(event.tool_call_id && announcedTools.has(event.tool_call_id));
+  }
+
+  function recordToolResult(event) {
+    if (event.status === "failed") {
+      toolStats.failed += 1;
+      return;
+    }
+    toolStats.completed += 1;
+  }
+
+  function rememberPlanInputStart(event) {
+    if (event.tool_name === "update_plan" && event.tool_call_id) {
+      pendingPlanInputs.set(event.tool_call_id, "");
+    }
+  }
+
+  function appendPlanInput(event) {
+    if (event.tool_name !== "update_plan" || !event.tool_call_id) {
+      return;
+    }
+    const current = pendingPlanInputs.get(event.tool_call_id);
+    if (current !== undefined) {
+      pendingPlanInputs.set(event.tool_call_id, current + String(event.delta || ""));
+    }
+  }
+
+  function rememberPlanInputPreview(event) {
+    if (event.tool_name !== "update_plan" || !event.tool_call_id) {
+      return;
+    }
+    const current = pendingPlanInputs.get(event.tool_call_id);
+    if (!current) {
+      pendingPlanInputs.set(event.tool_call_id, String(event.args_preview || ""));
+    }
+  }
+
+  function takePlanInput(event) {
+    if (event.tool_name !== "update_plan" || !event.tool_call_id) {
+      return "";
+    }
+    const value = pendingPlanInputs.get(event.tool_call_id) || "";
+    pendingPlanInputs.delete(event.tool_call_id);
+    return value;
+  }
+
+  return {
+    handle,
+    closeAssistant: () => output.closeAssistant?.(),
+    resetTurnState,
+  };
+}
+
+function parsePlanInput(value) {
+  const args = parseObject(value);
+  return Array.isArray(args.plan) ? args.plan : null;
+}
+
+function parseToolData(value) {
+  const parsed = parseObject(value);
+  return parsed.data && typeof parsed.data === "object" ? parsed.data : {};
+}
+
+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 {};
+  }
+}