lazyclaw 6.3.0 → 6.4.0

package/tui/chat_mode_slash.mjs

@@ -0,0 +1,59 @@
+// tui/chat_mode_slash.mjs — /agentic and /plan slash handlers (Group 1).
+//
+// Extracted from slash_dispatcher.mjs (at its file-size ratchet ceiling) so
+// the agentic REPL / plan mode toggles can grow without forcing that file
+// over its pinned limit. slash_dispatcher imports + registers these in
+// SLASH_HANDLERS and the shared SLASH_COMMANDS catalog.
+//
+// Both mirror the /hud toggle (tui/hud.mjs::hudSlash): read cfg, flip the
+// chat.* key, persist via writeConfig when wired, and mirror onto the
+// in-memory cfg so the next turn (makeRunTurn → chatAgenticGet /
+// chatPlanModeGet) sees it live. No-arg flips the current value, or opens
+// an on/off picker in the Ink UI.
+
+import { chatAgenticGet, chatPlanModeGet, chatSet } from '../config_features.mjs';
+
+async function _chatToggleSlash(args, ctx, { key, label, pickerDesc }) {
+  const getter = key === 'agentic' ? chatAgenticGet : chatPlanModeGet;
+  const cfg = ctx.readConfig ? ctx.readConfig() : (ctx.cfg || {});
+  const cur = getter(cfg);
+  const a = String(args || '').trim().toLowerCase();
+  let next;
+  if (a === 'on') next = true;
+  else if (a === 'off') next = false;
+  else if (!a && typeof ctx.openPicker === 'function') {
+    const picked = await ctx.openPicker({
+      kind: 'menu',
+      title: `${label} mode`,
+      subtitle: `currently ${cur ? 'on' : 'off'}`,
+      items: [
+        { id: 'on', label: 'on', desc: pickerDesc },
+        { id: 'off', label: 'off', desc: 'off' },
+      ],
+    });
+    const id = picked && typeof picked === 'object' ? picked.id : picked;
+    if (id !== 'on' && id !== 'off') return `${label}: cancelled`;
+    next = id === 'on';
+  } else next = !cur;
+  chatSet(cfg, key, next);
+  if (ctx.writeConfig) ctx.writeConfig(cfg);
+  if (ctx.cfg && ctx.cfg !== cfg) chatSet(ctx.cfg, key, next);
+  return `${label} ${next ? 'on' : 'off'}`;
+}
+
+export const agenticSlash = (a, ctx) => _chatToggleSlash(a, ctx, {
+  key: 'agentic', label: 'agentic',
+  pickerDesc: 'run tools behind the approval gate (read/grep/skill by default)',
+});
+
+export const planSlash = (a, ctx) => _chatToggleSlash(a, ctx, {
+  key: 'planMode', label: 'plan',
+  pickerDesc: 'read-only: propose a plan, do not mutate',
+});
+
+// Catalog entries for the shared SLASH_COMMANDS list (consumed by /help, the
+// popup, ghost-autocomplete, and the d6 drift-guard).
+export const CHAT_MODE_SLASH_COMMANDS = [
+  { cmd: '/agentic', help: 'toggle the agentic REPL (tools behind approval): /agentic on|off' },
+  { cmd: '/plan', help: 'toggle plan mode (read-only: propose, do not mutate): /plan on|off' },
+];

package/tui/config_picker.mjs

@@ -17,6 +17,7 @@ const CONFIG_ITEMS = [
   { id: 'provider',     label: 'provider',            desc: 'switch the chat provider (family → vendor picker)' },
   { id: 'model',        label: 'model',               desc: 'switch the model (live list when the provider supports it)' },
   { id: 'context',      label: 'context window',      desc: 'history turns / token budget sent per turn' },
+  { id: 'hud',          label: 'HUD status bar',      desc: 'show/hide the usage · models · cost row above the input' },
   { id: 'trainer',      label: 'trainer',             desc: 'learning-loop provider/model (auto = $0 on claude-cli)' },
   { id: 'orchestrator', label: 'orchestrator',        desc: 'multi-agent on/off, planner, workers' },
   { id: 'channel',      label: 'channel credentials', desc: 'Slack/Telegram/Matrix tokens — leaves chat for the prompts, then returns' },

package/tui/editor.mjs

@@ -30,25 +30,39 @@
 // on long Korean buffers.
 import React, { useState, useEffect, useRef } from 'react';
 import { Box, Text, useInput } from 'ink';
-import stringWidth from 'string-width';
 import { theme } from './theme.mjs';
+import {
+  nextCodepointIndex,
+  INTERRUPT_WINDOW_MS,
+  PROMPT_PREFIX,
+  PROMPT_WIDTH,
+  CONTINUATION_GUTTER,
+  CONTINUATION_WIDTH,
+  displayWidth,
+  wrapToBudget,
+  cursorDisplayCol,
+  makeEditorState,
+  applyKey,
+  fillSlashCommand,
+  fillArgToken,
+} from './editor_keys.mjs';
 
-// The accent prompt (`› `) prepended to the first rendered line. Its
-// display width matters for any caller that wants to know the usable
-// inner width of the editor box. Defined once so the value stays in
-// sync if the prompt glyph ever changes.
-export const PROMPT_PREFIX = '› ';
-export const PROMPT_WIDTH = stringWidth(PROMPT_PREFIX);
-export const CONTINUATION_GUTTER = '  ';
-export const CONTINUATION_WIDTH = stringWidth(CONTINUATION_GUTTER);
-
-// Public helper: display width of a buffer (or any substring of it),
-// counting wide chars (CJK, fullwidth, most emoji) as 2 cells and
-// ignoring ANSI escapes. Use this — never `.length` — for column math.
-export function displayWidth(text) {
-  if (!text) return 0;
-  return stringWidth(String(text));
-}
+// Re-export the pure state machine + measurement helpers (moved to
+// editor_keys.mjs to keep this file under the 500-line gate) so every
+// existing import path (`from '../tui/editor.mjs'`) keeps working.
+export {
+  INTERRUPT_WINDOW_MS,
+  PROMPT_PREFIX,
+  PROMPT_WIDTH,
+  CONTINUATION_GUTTER,
+  CONTINUATION_WIDTH,
+  displayWidth,
+  wrapToBudget,
+  cursorDisplayCol,
+  makeEditorState,
+  applyKey,
+  fillSlashCommand,
+};
 
 // ─── IME cursor anchor (v5.4.4) ─────────────────────────────────────
 //
@@ -92,126 +106,21 @@ function _installAnchorShim() {
   _anchorState.shimmed = true;
 }
 
-// Cell-aware soft-wrap. Returns an array of visual rows whose width
-// respects the budget (first row uses `firstBudget`, subsequent rows
-// use `contBudget`). Hoisted to module level (was inner-fn) so the
-// cursor-anchor useEffect in <Editor/> can reuse it.
-export function wrapToBudget(text, firstBudget, contBudget) {
-  if (!text) return [''];
-  const out = [];
-  let line = '';
-  let lineW = 0;
-  let budget = firstBudget;
-  for (const ch of text) {
-    const w = stringWidth(ch);
-    if (lineW + w > budget) {
-      out.push(line);
-      line = ch;
-      lineW = w;
-      budget = contBudget;
-    } else {
-      line += ch;
-      lineW += w;
-    }
-  }
-  out.push(line);
-  return out;
-}
-
-// Display column of the caret given a state. Counts wide chars as 2.
-// On the first rendered line this is offset by PROMPT_WIDTH; on
-// continuation lines (after a Shift+Enter) it is offset by
-// CONTINUATION_WIDTH. Callers that only need the in-buffer column can
-// pass `{ withPrefix: false }`.
-export function cursorDisplayCol(state, { withPrefix = true } = {}) {
-  const before = String(state.buffer || '').slice(0, state.cursor || 0);
-  const newlineIdx = before.lastIndexOf('\n');
-  const lineSlice = newlineIdx === -1 ? before : before.slice(newlineIdx + 1);
-  const inLine = stringWidth(lineSlice);
-  if (!withPrefix) return inLine;
-  const prefix = newlineIdx === -1 ? PROMPT_WIDTH : CONTINUATION_WIDTH;
-  return prefix + inLine;
-}
-
-export function makeEditorState({ history = [] } = {}) {
-  return {
-    buffer: '',
-    cursor: 0,
-    historyIdx: history.length,
-    history,
-    lastSubmit: null,
-    lastWasPaste: false,
-  };
-}
-
-export function applyKey(state, evt) {
-  const { input = '', key = {}, paste = false } = evt;
-  const next = { ...state, lastSubmit: null, lastWasPaste: false };
-
-  if (key.return && key.shift) {
-    next.buffer = state.buffer + '\n';
-    next.cursor = next.buffer.length;
-    return next;
-  }
-  if (key.return) {
-    next.lastSubmit = state.buffer;
-    next.buffer = '';
-    next.cursor = 0;
-    next.historyIdx = state.history.length;
-    return next;
-  }
-  if (key.upArrow) {
-    const idx = Math.max(0, state.historyIdx - 1);
-    if (state.history[idx] !== undefined) {
-      next.historyIdx = idx;
-      next.buffer = state.history[idx];
-      next.cursor = next.buffer.length;
-    }
-    return next;
-  }
-  if (key.downArrow) {
-    const idx = Math.min(state.history.length, state.historyIdx + 1);
-    next.historyIdx = idx;
-    next.buffer = state.history[idx] !== undefined ? state.history[idx] : '';
-    next.cursor = next.buffer.length;
-    return next;
-  }
-  if (key.backspace || key.delete) {
-    next.buffer = state.buffer.slice(0, -1);
-    next.cursor = next.buffer.length;
-    return next;
-  }
-  if (input) {
-    next.buffer = state.buffer + input;
-    next.cursor = next.buffer.length;
-    next.lastWasPaste = paste || input.length >= 16;
-    return next;
-  }
-  return next;
-}
-
-// Pure helper used by the slash-popup branch in <Editor/>. Replaces the
-// editor buffer with `${cmd} ` (note trailing space so the user can keep
-// typing args without an extra keystroke). Does NOT submit.
-export function fillSlashCommand(state, cmd) {
-  const filled = cmd.endsWith(' ') ? cmd : cmd + ' ';
-  return {
-    ...state,
-    buffer: filled,
-    cursor: filled.length,
-    lastSubmit: null,
-    lastWasPaste: false,
-  };
-}
-
 export function Editor({
   history,
   onSubmit,
   onEscape,
   onBufferChange,
+  // v6.4 2-stage Ctrl+C (optional — pre-v6.4 callers pass none). First press
+  // fires onInterrupt (cancel in-flight turn / clear buffer); a second press
+  // within INTERRUPT_WINDOW_MS fires onExit. Only reachable when Ink is
+  // rendered with exitOnCtrlC:false (otherwise Ink intercepts Ctrl+C first).
+  onInterrupt,           // () => void
+  onExit,                // () => void
   // v5.4 slash-popup wiring (all optional — pre-v5.4 callers pass none):
   slashSuggestions,      // Array<{cmd,help}> | null
   slashSelectedIndex,    // number
+  slashFillMode,         // 'command' (default) | 'arg' — arg fills the token via fillArgToken
   onSlashMove,           // (delta: -1 | +1) => void
   onSlashDismiss,        // () => void
   // v5.4.3 modal-picker wiring (all optional — pre-v5.4.3 callers pass none).
@@ -230,6 +139,14 @@ export function Editor({
   // pre-edit overlay at the actual typing position. Opt-out via the
   // LAZYCLAW_NO_CURSOR_ANCHOR env var (handled internally).
   altEnabled,
+  // v6.x slash-argument completion (all optional). When the buffer is a
+  // command + a completable value, the host sets argCompletable; Tab then
+  // calls onArgComplete(buffer) so the host opens the modal picker. The host
+  // pushes the chosen value back via argInject={value,nonce}, which the
+  // Editor applies with fillArgToken (only token under the cursor changes).
+  argCompletable,        // boolean
+  onArgComplete,         // (buffer: string) => void
+  argInject,             // { value: string, nonce: number } | null
 }) {
   const [state, setState] = useState(() => makeEditorState({ history }));
   const slashOpen = Array.isArray(slashSuggestions) && slashSuggestions.length > 0;
@@ -249,8 +166,48 @@ export function Editor({
     setState(next);
   };
 
+  // v6.4 — this-session input history. The parent (repl) grows `history` as
+  // each prompt is submitted, but makeEditorState only snapshots it at mount,
+  // so without this sync the editor's Up/Down never saw this-session prompts
+  // (the audit gap). When the prop array CHANGES, mirror it into state and
+  // reset historyIdx to the tip so the next Up recalls the newest submission.
+  // The buffer/cursor are left untouched (don't disturb an in-progress draft).
+  const historyKey = Array.isArray(history) ? history.join('') : '';
+  const prevHistoryKeyRef = useRef(null);
+  if (prevHistoryKeyRef.current === null) prevHistoryKeyRef.current = historyKey;
+  useEffect(() => {
+    if (prevHistoryKeyRef.current === historyKey) return;
+    prevHistoryKeyRef.current = historyKey;
+    const list = Array.isArray(history) ? history : [];
+    commit({ ...stateRef.current, history: list, historyIdx: list.length });
+  }, [historyKey]);
+
+  // v6.4 — 2-stage Ctrl+C. Tracks the timestamp of the last Ctrl+C so a
+  // second press within the window exits; the first only interrupts.
+  const lastCtrlCRef = useRef(0);
+
   useInput((input, key) => {
     const current = stateRef.current;
+    // ─── 2-stage Ctrl+C (highest priority — v6.4) ───────────────────────
+    // Only reached when Ink is rendered with exitOnCtrlC:false; otherwise
+    // Ink swallows Ctrl+C and exits before useInput sees it. First press
+    // cancels the in-flight turn + clears the buffer (consistent with Esc);
+    // a second press within INTERRUPT_WINDOW_MS exits.
+    if (key.ctrl && (input === 'c' || input === 'C')) {
+      const now = Date.now();
+      if (now - lastCtrlCRef.current <= INTERRUPT_WINDOW_MS) {
+        lastCtrlCRef.current = 0;
+        if (onExit) onExit();
+        return;
+      }
+      lastCtrlCRef.current = now;
+      // Clear the draft + cancel in-flight work.
+      const cleared = { ...current, buffer: '', cursor: 0, lastSubmit: null, lastWasPaste: false };
+      commit(cleared);
+      if (onBufferChange) { try { onBufferChange(''); } catch {} }
+      if (onInterrupt) onInterrupt();
+      return;
+    }
     // ─── Modal-picker keyboard contract (highest priority — v5.4.3) ──
     // When a host-owned picker is up, EVERY key is consumed by the
     // picker. The chat buffer is never mutated and onSubmit is never
@@ -313,25 +270,50 @@ export function Editor({
       if (key.tab || key.return) {
         const safeIdx = Math.max(0, Math.min(slashSuggestions.length - 1, slashSelectedIndex || 0));
         const picked = slashSuggestions[safeIdx];
-        const bufTrim = current.buffer.replace(/\s+$/, '');
-        const alreadyExact = !!picked && (current.buffer === picked.cmd || bufTrim === picked.cmd);
-        if (alreadyExact) {
-          if (key.tab) return; // no completion to make
-          // key.return on exact match → fall through to applyKey/submit.
+        if (slashFillMode === 'arg') {
+          // Arg popup: picked.cmd holds the candidate VALUE. Fill it into the
+          // token in place. When the token already equals the candidate, Enter
+          // falls through to submit (Tab no-ops).
+          const start = Math.max(current.buffer.lastIndexOf(' '), current.buffer.lastIndexOf(',')) + 1;
+          const exact = !!picked && current.buffer.slice(start) === picked.cmd;
+          if (exact && key.return) {
+            // token complete → fall through to applyKey/submit
+          } else {
+            if (!exact && picked) {
+              const next = fillArgToken(current, picked.cmd);
+              commit(next);
+              if (onBufferChange) { try { onBufferChange(next.buffer); } catch {} }
+            }
+            return;
+          }
         } else {
-          if (picked) {
-            const next = fillSlashCommand(current, picked.cmd);
-            commit(next);
-            if (onBufferChange) {
-              try { onBufferChange(next.buffer); } catch {}
+          const bufTrim = current.buffer.replace(/\s+$/, '');
+          const alreadyExact = !!picked && (current.buffer === picked.cmd || bufTrim === picked.cmd);
+          if (alreadyExact) {
+            if (key.tab) return; // no completion to make
+            // key.return on exact match → fall through to applyKey/submit.
+          } else {
+            if (picked) {
+              const next = fillSlashCommand(current, picked.cmd);
+              commit(next);
+              if (onBufferChange) {
+                try { onBufferChange(next.buffer); } catch {}
+              }
             }
+            return;
           }
-          return;
         }
       }
       // Anything else (printable, backspace) falls through to applyKey.
     }
 
+    // Arg completion: Tab while typing a command's value (slash popup closed,
+    // no modal) hands the buffer to the host, which opens the picker and pushes
+    // the choice back via argInject. Without a completer, Tab falls through.
+    if (!slashOpen && key.tab && argCompletable && onArgComplete) {
+      onArgComplete(stateRef.current.buffer);
+      return;
+    }
     // Esc: forward to host (ReplApp uses this to abort an in-flight turn).
     // Do not mutate the buffer — the user may want to keep typing.
     if (key.escape) { if (onEscape) onEscape(); return; }
@@ -345,6 +327,19 @@ export function Editor({
     if (state.lastSubmit !== null && onSubmit) onSubmit(state.lastSubmit);
   }, [state.lastSubmit]);
 
+  // Apply a host-pushed arg-completion value into the buffer (the picker the
+  // host opened resolved to `value`). Guarded by a monotonic nonce so the same
+  // value can be injected twice and re-renders don't re-apply a stale value.
+  const injectNonceRef = useRef(0);
+  useEffect(() => {
+    if (argInject && argInject.nonce !== injectNonceRef.current && typeof argInject.value === 'string') {
+      injectNonceRef.current = argInject.nonce;
+      const nextState = fillArgToken(stateRef.current, argInject.value);
+      commit(nextState);
+      if (onBufferChange) { try { onBufferChange(nextState.buffer); } catch {} }
+    }
+  }, [argInject]);
+
   // v5.4.3 — IME cursor anchor.
   //
   // After every Ink render commit, move the terminal cursor BACK inside
@@ -393,7 +388,7 @@ export function Editor({
     const lastWrapped = wrapToBudget(lastBefore, fb, cb);
     rowInEditor += lastWrapped.length - 1;
     const lastSegment = lastWrapped[lastWrapped.length - 1] || '';
-    const colInLine = stringWidth(lastSegment);
+    const colInLine = displayWidth(lastSegment);
 
     // After Ink writes `<frame>\n`, cursor sits on the line below the
     // editor's bottom border at column 0. Editor geometry: 1 top border
@@ -440,27 +435,59 @@ export function Editor({
   // Box overhead: 1 border + 1 padX on each side = 4 cells; first row
   // also reserves PROMPT_WIDTH; continuation rows reserve CONTINUATION_WIDTH.
   const innerCells = Math.max(8, TERM - 4); // 2 border + 2 padX
+  // Caret position in BUFFER code units (split by logical line). caretLine is
+  // the index into `lines`; caretCol is the code-unit offset within that line.
+  const beforeCaret = state.buffer.slice(0, state.cursor || 0);
+  const beforeLines = beforeCaret.split('\n');
+  const caretLine = beforeLines.length - 1;
+  const caretCol = beforeLines[beforeLines.length - 1].length;
   const renderedLines = [];
+  // While wrapping each logical line, find which rendered row the caret sits
+  // on and its code-unit offset within that row's text (so the inverse-video
+  // caret can be drawn AT the cursor, not always at the end).
+  let caretRow = -1;
+  let caretRowOffset = 0;
   for (let li = 0; li < lines.length; li++) {
     const wrapped = wrapToBudget(lines[li], innerCells - PROMPT_WIDTH, innerCells - CONTINUATION_WIDTH);
+    let consumed = 0; // code units of this logical line placed into prior rows
     for (let wi = 0; wi < wrapped.length; wi++) {
       const isFirstLogical = li === 0 && wi === 0;
+      const seg = wrapped[wi];
+      if (li === caretLine && caretRow === -1) {
+        const isLastSeg = wi === wrapped.length - 1;
+        // The caret belongs to this row if its column falls within the row's
+        // span, or it's the last segment (end-of-line caret rests here).
+        if (caretCol <= consumed + seg.length || isLastSeg) {
+          caretRow = renderedLines.length;
+          caretRowOffset = Math.max(0, caretCol - consumed);
+        }
+      }
       renderedLines.push({
         prefix: isFirstLogical ? theme.accent(PROMPT_PREFIX) : CONTINUATION_GUTTER,
-        text: wrapped[wi],
+        text: seg,
       });
+      consumed += seg.length;
     }
   }
-  // Always-visible caret: an inverse-video cell drawn AT the cursor (the
-  // editor has no mid-line cursor movement, so the cursor is always at the
-  // end of the buffer — including column 0 of an empty box). The real
-  // terminal cursor is anchored to the same cell for IME pre-edit; this
-  // glyph keeps the position visible even between anchor writes (e.g.
-  // while another component renders). Hidden while a modal picker owns
-  // the keyboard so it can't masquerade as an active prompt.
+  // Always-visible caret: an inverse-video cell drawn AT the cursor. Mid-line,
+  // it highlights the character under the cursor (block caret); at end-of-row
+  // it appends an inverse space. The real terminal cursor is anchored to the
+  // same cell for IME pre-edit; this glyph keeps the position visible even
+  // between anchor writes (e.g. while another component renders). Hidden while
+  // a modal picker owns the keyboard so it can't masquerade as an active prompt.
   if (!modalOpen && renderedLines.length > 0) {
-    const last = renderedLines[renderedLines.length - 1];
-    last.text = `${last.text}\x1b[7m \x1b[27m`;
+    if (caretRow === -1) caretRow = renderedLines.length - 1;
+    const row = renderedLines[caretRow];
+    const off = Math.min(caretRowOffset, row.text.length);
+    const head = row.text.slice(0, off);
+    const rest = row.text.slice(off);
+    if (rest.length > 0) {
+      // Highlight the character at the cursor (codepoint-safe slice).
+      const at = nextCodepointIndex(rest, 0);
+      row.text = `${head}\x1b[7m${rest.slice(0, at)}\x1b[27m${rest.slice(at)}`;
+    } else {
+      row.text = `${head}\x1b[7m \x1b[27m`;
+    }
   }
   return React.createElement(
     Box,