@rind-ai/cli 0.6.1 → 0.7.0

package/lib/cli-output-controller.js

@@ -18,17 +18,13 @@ import { ToolBlock } from "./components/tool-block.js";
 import { argsFromResult } from "./tool-display.js";
 
 export function createCliOutputController({ state, terminalUi, transcript }) {
-  const streamBuffer = createLegacyStreamBuffer();
   const legacyRenderer = new AssistantRenderer((text) => writeOutput(text));
   let assistantMessage = null;
   let blockCount = 0;
   const toolBlocks = new Map();
   const legacyBegunTools = new Set();
   let questionBlock = null;
-
-  function suspendPrompt(action, options = {}) {
-    return action();
-  }
+  let turnContext = "";
 
   function redraw(force = false) {
     if (!terminalUi || state.runtime.status === "closing") {
@@ -39,19 +35,29 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
 
   function inputState() {
     const running = state.turn.active || state.display.activeCompact;
+    const inputSession = state.input.session;
     return {
       running,
-      label: state.display.activeCompact
+      label: state.display.activityLabel || (state.display.activeCompact
         ? "Compacting"
-        : state.display.goalChasing
-          ? "Goal-Chasing"
-          : "Working",
+        : "Working"),
       frame: state.display.activityFrame,
       elapsedMs: running ? Date.now() - state.display.activityStartedAt : 0,
       pendingInputs: state.input.pending,
+      inputMode: inputSession?.mode || "prompt",
+      menuOpen: Boolean(inputSession?.menuState?.matches?.()?.length),
     };
   }
 
+  function setActivityLabel(label = "") {
+    const next = String(label || "");
+    if (state.display.activityLabel === next) {
+      return;
+    }
+    state.display.activityLabel = next;
+    redraw();
+  }
+
   function mainPromptText(frameWidth) {
     return promptText(state.session.info, state.display.stats, inputState(), frameWidth);
   }
@@ -80,10 +86,9 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
   }
 
   function clearActivityTimer() {
-    if (!state.display.activityTimer) {
-      return;
+    if (state.display.activityTimer) {
+      clearInterval(state.display.activityTimer);
     }
-    clearInterval(state.display.activityTimer);
     state.display.activityTimer = null;
     state.display.activityFrame = 0;
     state.display.activityStartedAt = 0;
@@ -114,7 +119,6 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
   function log(text) {
     const build = typeof text === "function" ? text : () => String(text ?? "");
     if (!terminalUi) {
-      flushAssistantText(streamBuffer.flush());
       const value = String(build() ?? "");
       if (!value.trim()) {
         return;
@@ -129,7 +133,7 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
 
   function writeOutput(text) {
     if (!terminalUi) {
-      flushAssistantText(streamBuffer.push(text));
+      flushAssistantText(text);
     }
   }
 
@@ -141,14 +145,13 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
     process.stdout.write(output);
   }
 
-  function writeUserInput(text) {
+  function writeUserInput(text, source = "") {
     const value = String(text ?? "");
     if (!value.trim()) {
       return;
     }
     if (!terminalUi) {
-      flushAssistantText(streamBuffer.flush());
-      const line = userInputText(value);
+      const line = userInputText(value, undefined, source);
       if (!line) {
         return;
       }
@@ -158,7 +161,7 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
     }
     const leading = blockCount > 0;
     appendBlock(new DynamicBlock((width) => {
-      const rendered = userInputText(value, width);
+      const rendered = userInputText(value, width, source);
       const lines = rendered ? rendered.split("\n") : [];
       if (leading && lines.length) {
         lines.unshift("");
@@ -179,8 +182,6 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
     appendBlock(new TextBlock(outputBlockText(value), { leading: blockCount > 0 }));
   }
 
-  function closeOpenAssistantOutputLine() {}
-
   function ensureAssistantBlocks() {
     if (!assistantMessage) {
       const leading = blockCount > 0;
@@ -203,7 +204,6 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
       return;
     }
     legacyRenderer.finish();
-    flushAssistantText(streamBuffer.flush());
     state.display.assistantHeaderShown = false;
   }
 
@@ -245,13 +245,6 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
     redraw();
   }
 
-  function clearAssistantLineForInput() {
-    if (!terminalUi && state.display.assistantOutputLineOpen) {
-      process.stdout.write("\n");
-      state.display.assistantOutputLineOpen = false;
-    }
-  }
-
   function showStartup(info) {
     if (!terminalUi) {
       return;
@@ -280,7 +273,8 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
     if (!callId) {
       return;
     }
-    const existing = toolBlocks.get(callId);
+    const key = toolBlockKey(callId);
+    const existing = toolBlocks.get(key);
     if (existing) {
       existing.enrichArgs(event);
       return;
@@ -290,7 +284,7 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
       onRequestRender: () => redraw(),
       leading: blockCount > 0,
     });
-    toolBlocks.set(callId, block);
+    toolBlocks.set(key, block);
     appendBlock(block);
   }
 
@@ -298,7 +292,7 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
     if (!terminalUi) {
       return;
     }
-    toolBlocks.get(String(callId || ""))?.setProgress(message);
+    toolBlocks.get(toolBlockKey(callId))?.setProgress(message);
   }
 
   function finishTool(event, fileChange) {
@@ -307,7 +301,8 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
       return;
     }
     const callId = String(event?.tool_call_id || "");
-    let block = toolBlocks.get(callId);
+    const key = toolBlockKey(callId);
+    let block = toolBlocks.get(key);
     if (!block) {
       if (!callId) {
         return;
@@ -317,7 +312,7 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
         onRequestRender: () => redraw(),
         leading: blockCount > 0,
       });
-      toolBlocks.set(callId, block);
+      toolBlocks.set(key, block);
       appendBlock(block);
     }
     block.enrichArgs({ arguments: argsFromResult(event?.tool_name, event?.result) });
@@ -334,21 +329,30 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
     redraw();
   }
 
-  function renderHistory(messages) {
-    const pendingTools = new Map();
-    const flushPendingTools = () => {
-      for (const [toolCallId, tool] of pendingTools.entries()) {
-        beginTool({
-          tool_call_id: toolCallId,
-          tool_name: tool.name,
-          args_preview: tool.arguments,
-        });
-        finishTool({
-          tool_call_id: toolCallId,
-          tool_name: tool.name,
-          status: "completed",
-          result: "",
-        });
+  function setTurnContext(turnId = "") {
+    turnContext = String(turnId || "");
+  }
+
+  function toolBlockKey(callId) {
+    const value = String(callId || "");
+    return value ? `${turnContext}:${value}` : "";
+  }
+
+  function renderHistory(messages) {
+    const pendingTools = new Map();
+    const flushPendingTools = () => {
+      for (const [toolCallId, tool] of pendingTools.entries()) {
+        beginTool({
+          tool_call_id: toolCallId,
+          tool_name: tool.name,
+          args_preview: tool.arguments,
+        });
+        finishTool({
+          tool_call_id: toolCallId,
+          tool_name: tool.name,
+          status: "completed",
+          result: "",
+        });
       }
       pendingTools.clear();
     };
@@ -360,39 +364,39 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
         writeUserInput(messageText(message?.content));
         continue;
       }
-      if (role === "assistant") {
-        flushPendingTools();
+      if (role === "assistant") {
+        flushPendingTools();
         const content = messageText(message?.content);
         if (content) {
           assistantAppend(content);
           closeAssistant();
         }
-        for (const call of Array.isArray(message?.tool_calls) ? message.tool_calls : []) {
-          const toolCallId = String(call?.id || "");
-          const toolName = String(call?.function?.name || "tool");
-          if (toolCallId) {
-            pendingTools.set(toolCallId, {
-              name: toolName,
-              arguments: String(call?.function?.arguments || ""),
-            });
-          }
-        }
-        continue;
-      }
-      if (role === "tool") {
-        const toolCallId = String(message?.tool_call_id || "");
-        const tool = pendingTools.get(toolCallId) || { name: "tool", arguments: "" };
-        pendingTools.delete(toolCallId);
-        beginTool({
-          tool_call_id: toolCallId,
-          tool_name: tool.name,
-          args_preview: tool.arguments,
-        });
-        finishTool({
-          tool_call_id: toolCallId,
-          tool_name: tool.name,
-          status: "completed",
-          result: messageText(message?.content),
+        for (const call of Array.isArray(message?.tool_calls) ? message.tool_calls : []) {
+          const toolCallId = String(call?.id || "");
+          const toolName = String(call?.function?.name || "tool");
+          if (toolCallId) {
+            pendingTools.set(toolCallId, {
+              name: toolName,
+              arguments: String(call?.function?.arguments || ""),
+            });
+          }
+        }
+        continue;
+      }
+      if (role === "tool") {
+        const toolCallId = String(message?.tool_call_id || "");
+        const tool = pendingTools.get(toolCallId) || { name: "tool", arguments: "" };
+        pendingTools.delete(toolCallId);
+        beginTool({
+          tool_call_id: toolCallId,
+          tool_name: tool.name,
+          args_preview: tool.arguments,
+        });
+        finishTool({
+          tool_call_id: toolCallId,
+          tool_name: tool.name,
+          status: "completed",
+          result: messageText(message?.content),
         });
       }
     }
@@ -403,16 +407,15 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
 
   return {
     terminalUi: Boolean(terminalUi),
-    suspendPrompt,
     redraw,
     refreshInputState,
     clearActivityTimer,
+    setActivityLabel,
     mainPromptText,
     log,
     writeUserInput,
     writeError,
     closeAssistant,
-    clearAssistantLineForInput,
     assistantAppend,
     beginTool,
     updateToolProgress,
@@ -420,28 +423,13 @@ export function createCliOutputController({ state, terminalUi, transcript }) {
     beginQuestion,
     finishQuestion,
     setToolsExpanded,
+    setTurnContext,
     renderHistory,
     showStartup,
     replayAll: () => terminalUi?.replayAll?.(),
   };
 }
 
-function createLegacyStreamBuffer() {
-  let pending = "";
-  return {
-    push(text) {
-      pending += String(text || "");
-      const flushed = pending;
-      pending = "";
-      return flushed;
-    },
-    flush() {
-      const flushed = pending;
-      pending = "";
-      return flushed;
-    },
-  };
-}
 
 function messageText(content) {
   if (typeof content === "string") {

package/lib/cli-runtime-controller.js

@@ -1,5 +1,5 @@
 import { REASONING_EFFORTS } from "./runtime-protocol.js";
-import { modelListErrorText, commandResultText, goalCommandText, sessionSwitchedText } from "./rendering.js";
+import { commandResultText, contextBoardText, goalCommandText, modelListErrorText, sessionSwitchedText, usageBoardText } from "./rendering.js";
 
 export function createCliRuntimeController({
   client,
@@ -9,14 +9,16 @@ export function createCliRuntimeController({
   requireInitialization,
   state,
   getCommands,
-  getTurnController,
   getTaskMonitor,
   getCompactContextState,
   askModelMenu,
   askEffortMenu = null,
   askSessionMenu,
+  askForkPointMenu,
+  askContextBoard = null,
   restoreLiveTurn,
   renderHistory = () => {},
+  onSessionRestored = () => {},
   clearPendingInputs,
   closeAssistant,
   refreshInputState,
@@ -74,7 +76,6 @@ export function createCliRuntimeController({
   }
 
   async function runGoalCommand(command) {
-    const turnController = getTurnController();
     if (command.action === "set" && state.turn.active) {
       log(() => commandResultText("Goal not started", "pause or finish the active turn first"));
       return;
@@ -84,7 +85,6 @@ export function createCliRuntimeController({
         const result = await request(methods.goalSet, { objective: command.objective });
         updateGoalState(result?.goal);
         log(() => goalCommandText(result?.goal, "set"));
-        turnController.submit(command.objective);
         return;
       }
       if (command.action === "clear") {
@@ -97,9 +97,6 @@ export function createCliRuntimeController({
         const result = await request(methods.goalStatus, { status: command.action === "resume" ? "active" : "paused" });
         updateGoalState(result?.goal);
         log(() => goalCommandText(result?.goal, command.action));
-        if (command.action === "resume" && !state.turn.active) {
-          turnController.submit("", { goal_continuation: true });
-        }
         return;
       }
       const result = await request(methods.goalGet);
@@ -179,6 +176,7 @@ export function createCliRuntimeController({
     getCompactContextState().clear();
     refreshInputState();
     redraw();
+    await onSessionRestored();
     void getTaskMonitor()?.refresh().catch(() => {});
     return true;
   }
@@ -219,12 +217,137 @@ export function createCliRuntimeController({
     }
   }
 
+  async function runForkSelector() {
+    if (state.turn.active || state.display.activeCompact) {
+      log("Cannot fork while a turn is running. Wait for it to finish or stop it first.");
+      return;
+    }
+    if (String(state.session.info.session_type || "") === "delegated_task") {
+      log("Delegated task sessions cannot be forked.");
+      return;
+    }
+    let replay;
+    try {
+      replay = await request(methods.sessionReplay);
+    } catch (error) {
+      log(`Command failed: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+    const messages = Array.isArray(replay?.messages) ? replay.messages : [];
+    const userMessages = messages.filter(isForkableUserMessage).slice(-FORK_MENU_MESSAGE_LIMIT);
+    if (!userMessages.length) {
+      log("Nothing to fork: this session has no messages yet.");
+      return;
+    }
+    const items = [
+      { id: "", label: FORK_END_LABEL },
+      ...userMessages.slice().reverse().map((message) => ({
+        id: String(message.id || ""),
+        label: forkPointLabel(message),
+        text: String(message.content || ""),
+      })),
+    ];
+    const selected = await askForkPointMenu(items);
+    if (!selected || state.runtime.status === "closing") {
+      return;
+    }
+    let fork;
+    try {
+      fork = await request(methods.sessionFork, selected.id ? { before_message_id: selected.id } : {});
+    } catch (error) {
+      log(`Fork failed: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+    const newId = String(fork?.session_id || "");
+    if (!newId) {
+      log("Fork failed: the runtime returned no session id.");
+      return;
+    }
+    try {
+      const switched = await restoreSession(newId, {
+        switchSession: true,
+        announce: (info) => log(() => sessionSwitchedText(info)),
+      });
+      if (!switched) {
+        return;
+      }
+    } catch (error) {
+      log(`Forked to ${newId}, but switching failed: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+    const kept = selected.id
+      ? Math.max(0, messages.findIndex((message) => String(message.id || "") === selected.id))
+      : messages.length;
+    log(`Forked ${newId} ← ${fork.forked_from} (${kept === messages.length ? `kept all ${kept}` : `kept the first ${kept} of ${messages.length}`} messages).`);
+    if (selected.text) {
+      state.input.prefill = selected.text;
+    }
+  }
+
+  async function runContextBoard() {
+    if (state.turn.active || state.display.activeCompact) {
+      log("Cannot open the context board while a turn is running. Wait for it to finish or stop it first.");
+      return;
+    }
+    let data;
+    try {
+      data = await fetchContextBoardData();
+    } catch (error) {
+      log(`Context board failed: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+    if (!askContextBoard) {
+      printContextPages(data);
+      return;
+    }
+    await askContextBoard({
+      render: (pageIndex, width) => contextPageText(data, pageIndex, width),
+    });
+  }
+
+  async function printContextReport() {
+    let data;
+    try {
+      data = await fetchContextBoardData();
+    } catch (error) {
+      log(`Context report failed: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+    printContextPages(data);
+  }
+
+  async function fetchContextBoardData() {
+    const breakdownResult = await request(methods.contextInspect);
+    const summaryResult = await request(methods.usageSummary, { days: CONTEXT_BOARD_DAYS });
+    return {
+      breakdown: breakdownResult?.breakdown && typeof breakdownResult.breakdown === "object" ? breakdownResult.breakdown : null,
+      latestUsage: breakdownResult?.latest_usage && typeof breakdownResult.latest_usage === "object" ? breakdownResult.latest_usage : null,
+      summary: summaryResult && typeof summaryResult === "object" ? summaryResult : null,
+    };
+  }
+
+  function contextPageText(data, pageIndex, width, { plain = false } = {}) {
+    return pageIndex === 0
+      ? contextBoardText({ breakdown: data.breakdown, latest_usage: data.latestUsage, index: 1, count: 2, plain }, width)
+      : usageBoardText({ summary: data.summary, index: 2, count: 2, plain }, width);
+  }
+
+  function printContextPages(data) {
+    for (const pageIndex of [0, 1]) {
+      const text = contextPageText(data, pageIndex, process.stdout.columns || 0, { plain: true });
+      if (text.trim()) {
+        log(text);
+      }
+    }
+  }
+
   function startCompactCommand() {
     if (state.display.activeCompact) {
       log("Compact is already running.");
       return;
     }
     state.display.activeCompact = true;
+    state.display.activityLabel = "Compacting";
     state.turn.interruptRequested = false;
     refreshInputState();
     void runCompactCommand().catch((error) => {
@@ -240,6 +363,7 @@ export function createCliRuntimeController({
       await getCommands().applyResult(result);
     } finally {
       state.display.activeCompact = false;
+      state.display.activityLabel = "";
       state.turn.interruptRequested = false;
       refreshInputState();
     }
@@ -309,12 +433,17 @@ export function createCliRuntimeController({
     runGoalCommand,
     refreshGoalState,
     runSessionsSelector,
+    runForkSelector,
+    runContextBoard,
+    printContextReport,
     startCompactCommand,
     runModelSelector,
     runEffortCommand,
   };
 }
 
+const CONTEXT_BOARD_DAYS = 7;
+
 function mergeSlashCommands(...groups) {
   const byName = new Map();
   for (const group of groups) {
@@ -327,6 +456,24 @@ function mergeSlashCommands(...groups) {
   return [...byName.values()].sort((left, right) => left.name.localeCompare(right.name));
 }
 
+const FORK_MENU_MESSAGE_LIMIT = 50;
+const FORK_END_LABEL = "Fork at current end (keep full history)";
+const FORK_CONTEXT_KINDS = new Set(["skill_snapshot", "skill_catalog", "goal_checkpoint"]);
+
+function isForkableUserMessage(message) {
+  if (message?.role !== "user" || !String(message?.content || "").trim()) {
+    return false;
+  }
+  const kind = message?.meta?.kind;
+  return !kind || !FORK_CONTEXT_KINDS.has(kind);
+}
+
+function forkPointLabel(message) {
+  const rawTime = String(message.ts || "").slice(11, 16);
+  const time = /^\d{2}:\d{2}$/.test(rawTime) ? rawTime : "";
+  return [time, singleLineText(message.content).slice(0, 60)].filter(Boolean).join(" · ");
+}
+
 function sessionMenuOption(session) {
   const values = [singleLineText(session?.id), singleLineText(session?.title), singleLineText(session?.updated_at)];
   if (session?.current) values.push("current");
@@ -341,7 +488,7 @@ function modelSetResultText(result, model) {
   if (defaultModel) lines.push(`- default model: ${defaultModel} (unchanged)`);
   lines.push(result?.active_updated || result?.runtime || result?.session
     ? "- active session: updated"
-    : "- active session: unchanged; start a new session to use this model");
+    : "- active turn: unchanged; the new model applies to the next turn");
   return commandResultText(lines[0], lines.slice(1).join(" · "));
 }
 

package/lib/cli-state.js

@@ -25,13 +25,13 @@ export function createCliState() {
     },
     display: {
       activeCompact: false,
-      goalChasing: false,
+      activityLabel: "",
       stats: {},
       lastEventSequence: 0,
+      lastTurnId: "",
       activityFrame: 0,
       activityTimer: null,
       activityStartedAt: 0,
-      assistantOutputLineOpen: false,
       assistantHeaderShown: false,
       outputStarted: false,
       toolDetailsExpanded: false,

package/lib/command-controller.js

@@ -66,6 +66,28 @@ export function createCommandController({
       await input.runSessionsSelector?.();
       return;
     }
+    if (isBareForkCommand(text)) {
+      if (input.isTerminal && input.runForkSelector) {
+        await input.runForkSelector();
+      } else {
+        output.log?.("/fork requires an interactive terminal.");
+      }
+      return;
+    }
+    if (isContextCommand(text)) {
+      const argument = contextArgument(text);
+      if (argument) {
+        output.log?.("Custom ranges are not supported yet; showing the last 7 days.");
+      }
+      if (input.isTerminal && input.runContextBoard) {
+        await input.runContextBoard();
+      } else if (input.printContextReport) {
+        await input.printContextReport();
+      } else {
+        output.log?.("/context requires a connected runtime.");
+      }
+      return;
+    }
     const result = await request(runtimeMethods.commandExecute, { input: text });
     await applyResult(result);
   }
@@ -154,6 +176,18 @@ function isBareSessionsCommand(value) {
   return String(value || "").trim().toLowerCase() === "/sessions";
 }
 
+function isBareForkCommand(value) {
+  return String(value || "").trim().toLowerCase() === "/fork";
+}
+
+function isContextCommand(value) {
+  return /^\/context\b/i.test(String(value || "").trim());
+}
+
+function contextArgument(value) {
+  return String(value || "").trim().replace(/^\/context\b/i, "").trim();
+}
+
 function isCompactCommand(value) {
   return String(value || "").trim().toLowerCase() === "/compact";
 }