@rind-ai/cli 0.4.1 → 0.6.0

package/lib/command-controller.js

@@ -1,126 +1,159 @@
-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";
-}
+import { parseGoalCommand } from "./slash-command-mode.js";
+import {
+  helpText,
+  slashResultText,
+} from "./rendering.js";
+import { LOCAL_SLASH_COMMANDS } from "./local-slash-commands.js";
+import { runtimeMethods } from "./runtime-protocol.js";
+
+const LOCAL_COMMANDS = Object.freeze([
+  { name: "exit", description: "Exit Rind", aliases: ["quit"] },
+]);
+
+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;
+    }
+    if (isBareThemeCommand(text) && input.isTerminal && input.runThemeSelector) {
+      await input.runThemeSelector();
+      return true;
+    }
+    const localResult = await input.runLocalCommand?.(text);
+    if (localResult) {
+      await applyResult(localResult);
+      return true;
+    }
+    const goal = parseGoalCommand(text);
+    if (goal) {
+      await input.runGoalCommand?.(goal);
+      return true;
+    }
+    if (isLocalCommand(text, "exit") || isLocalCommand(text, "quit")) {
+      output.log?.("Goodbye.");
+      await output.shutdown?.();
+      output.exit?.();
+      return true;
+    }
+    await runSlashCommand(text);
+    return true;
+  }
+
+  async function runSlashCommand(text) {
+    if (isBareModelCommand(text) && input.isTerminal && input.runModelSelector) {
+      await input.runModelSelector();
+      return;
+    }
+    if (isEffortCommand(text)) {
+      await input.runEffortCommand?.(effortArgument(text));
+      return;
+    }
+    if (isCompactCommand(text) && input.isTerminal) {
+      input.startCompactCommand?.();
+      return;
+    }
+    if (isBareSessionsCommand(text) && input.isTerminal) {
+      await input.runSessionsSelector?.();
+      return;
+    }
+    const result = await request(runtimeMethods.commandExecute, { input: text });
+    await applyResult(result);
+  }
+
+  async function applyResult(result = {}) {
+    const text = () => slashResultText(result, state.slashCommands || []);
+    output.log?.(text);
+    if (result.display?.type === "team_blueprints" && input.askTeamBlueprint) {
+      const blueprints = Array.isArray(result.display.blueprints) ? result.display.blueprints : [];
+      const selected = await input.askTeamBlueprint(blueprints);
+      if (selected?.id) {
+        await runSlashCommand(`/team blueprint ${selected.id}`);
+      }
+      return;
+    }
+    if (result.prompt_prefill) {
+      output.setInputPrefill?.(result.prompt_prefill);
+    }
+    const nextPromptInput = result.next_prompt?.input;
+    if (typeof nextPromptInput === "string" && nextPromptInput.trim()) {
+      turn.submit(nextPromptInput, {
+        transient_system_messages: result.next_prompt.transient_system_messages,
+      });
+    }
+  }
+
+  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,
+    localCommands: () => [
+      ...LOCAL_COMMANDS,
+      ...LOCAL_SLASH_COMMANDS,
+    ].flatMap((command) => normalizeCommands([command])),
+    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 isEffortCommand(value) {
+  return String(value || "").trim().toLowerCase().startsWith("/effort");
+}
+
+function effortArgument(value) {
+  return String(value || "").trim().replace(/^\/effort\s*/i, "").trim();
+}
+
+function isBareThemeCommand(value) {
+  return String(value || "").trim().toLowerCase() === "/theme";
+}
+
+function isLocalCommand(value, name) {
+  return String(value || "").trim().toLowerCase() === `/${name}`;
+}
+
+function isBareSessionsCommand(value) {
+  return String(value || "").trim().toLowerCase() === "/sessions";
+}
+
+function isCompactCommand(value) {
+  return String(value || "").trim().toLowerCase() === "/compact";
+}

package/lib/compact-context-state.js

@@ -1,22 +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;
-    },
-  };
-}
+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/components/assistant-message.js

@@ -0,0 +1,169 @@
+import { wrapTextWithAnsi } from "../text-width.js";
+import {
+  codeOpenLabel,
+  dim,
+  isPlainLine,
+  isTableLine,
+  parseTableRow,
+  renderInline,
+  renderMarkdownishLine,
+  styled,
+} from "../markdown-lines.js";
+
+const CONTENT_PREFIX = "  ";
+
+export class AssistantMessage {
+  constructor(options = {}) {
+    this.color = Boolean(options.color);
+    this.finalized = [];
+    this.pending = "";
+    this.inCodeBlock = false;
+    this.cacheWidth = -1;
+    this.cacheItems = [];
+    this.cacheLines = null;
+  }
+
+  append(delta) {
+    this.pending += String(delta || "");
+    for (;;) {
+      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.classifyFinalize(line);
+    }
+    this.cacheLines = null;
+  }
+
+  finish() {
+    if (this.pending) {
+      const line = this.pending;
+      this.pending = "";
+      this.classifyFinalize(line);
+    }
+    this.cacheLines = null;
+  }
+
+  get isEmpty() {
+    return !this.finalized.length && !this.pending;
+  }
+
+  classifyFinalize(line) {
+    if (isTableLine(line, this.inCodeBlock)) {
+      this.finalizeTable(line);
+      return;
+    }
+    if (line.trim().startsWith("```")) {
+      this.finalizeCodeFence(line);
+      return;
+    }
+    if (this.inCodeBlock) {
+      this.pushItem({ kind: "code", raw: line });
+      return;
+    }
+    if (isPlainLine(line)) {
+      if (line) {
+        this.pushItem({ kind: "plain", raw: line });
+      } else {
+        this.finalized.push("");
+      }
+      return;
+    }
+    this.pushItem({ kind: "markdown", raw: line });
+  }
+
+  finalizeTable(line) {
+    const cells = parseTableRow(line);
+    if (!cells.length || cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim()))) {
+      return;
+    }
+    this.pushItem({ kind: "table", raw: line });
+  }
+
+  finalizeCodeFence(line) {
+    const opening = !this.inCodeBlock;
+    this.inCodeBlock = opening;
+    const label = opening ? line.trim().slice(3).trim().slice(0, 32) : "";
+    this.pushItem({ kind: "fence", label });
+  }
+
+  // Items keep the raw source; styling happens per render so theme switches
+  // recolor history without rebuilding blocks.
+  pushItem(item) {
+    this.finalized.push(item);
+  }
+
+  styleItem(item) {
+    switch (item.kind) {
+      case "table": {
+        const cells = parseTableRow(item.raw);
+        const rendered = cells.map((cell, index) =>
+          renderInline(cell, this.color, index === 0 ? "tableHeader" : "")
+        );
+        return rendered.join(dim(" | ", this.color));
+      }
+      case "fence":
+        return dim(item.label ? codeOpenLabel(item.label) : "└ end", this.color);
+      case "code":
+        return styled(item.raw, this.color, "codeBlock");
+      case "plain":
+        return item.raw;
+      default:
+        return renderMarkdownishLine(item.raw, this.color);
+    }
+  }
+
+  render(width) {
+    if (this.cacheLines && this.cacheWidth === width && !this.pending) {
+      return this.cacheLines;
+    }
+    if (this.cacheWidth !== width) {
+      this.cacheItems.length = 0;
+      this.cacheWidth = width;
+    }
+    while (this.cacheItems.length < this.finalized.length) {
+      const item = this.finalized[this.cacheItems.length];
+      const logical = typeof item === "string" ? item : this.styleItem(item);
+      this.cacheItems.push(this.wrapLogical(logical, width));
+    }
+    const lines = [];
+    for (const item of this.cacheItems) {
+      lines.push(...item);
+    }
+    if (this.pending) {
+      lines.push(...this.wrapLogical(previewPending(this.pending, this.inCodeBlock, this.color), width));
+    }
+    this.cacheLines = lines;
+    return lines;
+  }
+
+  wrapLogical(logical, width) {
+    if (!logical) {
+      return [""];
+    }
+    const contentWidth = Math.max(1, width - CONTENT_PREFIX.length);
+    return wrapTextWithAnsi(logical, contentWidth, contentWidth)
+      .map((line) => `${CONTENT_PREFIX}${line}`);
+  }
+
+  invalidate() {
+    this.cacheWidth = -1;
+    this.cacheItems.length = 0;
+    this.cacheLines = null;
+  }
+}
+
+function previewPending(text, inCodeBlock, color) {
+  if (inCodeBlock) {
+    return text;
+  }
+  if (text.trim().startsWith("```")) {
+    return "";
+  }
+  if (isPlainLine(text)) {
+    return text;
+  }
+  return renderMarkdownishLine(text, color);
+}

package/lib/components/composer-area.js

@@ -0,0 +1,25 @@
+import { prepareComposerFrame } from "../composer-terminal.js";
+import { insertCursorMarker } from "../tui/cursor.js";
+
+export class ComposerArea {
+  constructor(getFrame) {
+    this.getFrame = getFrame;
+  }
+
+  render(width) {
+    const params = this.getFrame(width);
+    if (!params) {
+      return [];
+    }
+    const frame = prepareComposerFrame(params, width);
+    const lines = frame.lines.slice();
+    if (params.showCaret === false) {
+      return lines;
+    }
+    const cursorRow = Math.min(frame.cursorRow, lines.length - 1);
+    if (cursorRow >= 0 && lines.length) {
+      lines[cursorRow] = insertCursorMarker(lines[cursorRow] ?? "", frame.cursorColumn);
+    }
+    return lines;
+  }
+}

package/lib/components/dynamic-block.js

@@ -0,0 +1,20 @@
+export class DynamicBlock {
+  constructor(build) {
+    this.build = build;
+    this.cacheWidth = -1;
+    this.cacheLines = null;
+  }
+
+  render(width) {
+    if (this.cacheWidth !== width || this.cacheLines === null) {
+      const built = this.build(width);
+      this.cacheLines = Array.isArray(built) ? built : [];
+      this.cacheWidth = width;
+    }
+    return this.cacheLines;
+  }
+
+  invalidate() {
+    this.cacheLines = null;
+  }
+}

package/lib/components/monitor-stack.js

@@ -0,0 +1,35 @@
+export class MonitorStack {
+  constructor({ composer, monitor, rows }) {
+    this.composer = composer;
+    this.monitor = monitor;
+    this.rows = rows;
+  }
+
+  render(width) {
+    const composerLines = this.composer.render(width);
+    const monitorFrame = typeof this.monitor?.frame === "function" && this.monitor.isMonitoring()
+      ? this.monitor.frame(width)
+      : null;
+    const monitorLines = Array.isArray(monitorFrame?.lines) ? monitorFrame.lines : [];
+    if (!monitorLines.length) {
+      return composerLines;
+    }
+    const totalHeight = Number(this.rows?.()) || 24;
+    if (composerLines.length + monitorLines.length <= totalHeight) {
+      return [...composerLines, ...monitorLines];
+    }
+    const available = Math.max(1, totalHeight - Math.min(composerLines.length, Math.max(1, totalHeight - 1)));
+    const focusRow = clampIndex(monitorFrame.focusRow, monitorLines.length);
+    let start = Math.min(Math.max(0, focusRow - available + 1), monitorLines.length - available);
+    start = Math.max(0, start);
+    return [...composerLines, ...monitorLines.slice(start, start + available)];
+  }
+}
+
+function clampIndex(value, length) {
+  const index = Math.floor(Number(value) || 0);
+  if (!Number.isFinite(index)) {
+    return 0;
+  }
+  return Math.max(0, Math.min(length - 1, index));
+}

package/lib/components/text-block.js

@@ -0,0 +1,47 @@
+import { wrapTextWithAnsi } from "../text-width.js";
+
+export class TextBlock {
+  constructor(text, options = {}) {
+    this.text = String(text ?? "");
+    this.leading = Boolean(options.leading);
+    this.cacheWidth = 0;
+    this.cacheLines = null;
+  }
+
+  setText(text) {
+    const next = String(text ?? "");
+    if (next === this.text) {
+      return;
+    }
+    this.text = next;
+    this.cacheLines = null;
+  }
+
+  render(width) {
+    if (this.cacheLines && this.cacheWidth === width) {
+      return this.cacheLines;
+    }
+    const source = this.text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const lines = [];
+    if (this.leading && source.trim()) {
+      lines.push("");
+    }
+    for (const logicalLine of source.split("\n")) {
+      if (!logicalLine) {
+        lines.push("");
+        continue;
+      }
+      lines.push(...wrapTextWithAnsi(logicalLine, width));
+    }
+    while (lines.length > 1 && lines.at(-1) === "") {
+      lines.pop();
+    }
+    this.cacheWidth = width;
+    this.cacheLines = lines;
+    return lines;
+  }
+
+  invalidate() {
+    this.cacheLines = null;
+  }
+}