lazyclaw 5.4.4 → 6.0.0

package/tui/provider_families.mjs

@@ -0,0 +1,41 @@
+// tui/provider_families.mjs — pure (react-free) provider bucketing for the
+// drill-in provider picker. The flat "every provider in one list" picker the
+// v5.4 Ink port shipped is overwhelming and even exposed the orchestrator
+// (which must never be a default). This restores the legacy family grouping
+// (API key / CLI-Local / Mock) as shared, unit-testable data so both the
+// readline picker (cli.mjs) and the Ink dispatcher use one bucketing rule.
+
+// Bucket every registered provider into one of three auth families.
+// orchestrator is excluded entirely (strictly opt-in; never a wizard
+// default — see cli.mjs v5.3.2 note). Returns { api:[], cli:[], mock:[] }
+// of provider-id strings.
+export function bucketProviders(registry) {
+  const info = (registry && registry.PROVIDER_INFO) || {};
+  const all = Object.keys((registry && registry.PROVIDERS) || {});
+  const out = { api: [], cli: [], mock: [] };
+  for (const name of all) {
+    if (name === 'mock') out.mock.push(name);
+    else if (name === 'orchestrator') continue;
+    else if ((info[name] || {}).requiresApiKey) out.api.push(name);
+    else out.cli.push(name);
+  }
+  return out;
+}
+
+// Full family descriptors (label/desc/plain-text tag/members) for the Ink
+// first-step picker. Tags are plain text — Ink applies its own styling.
+export function providerFamilies(registry) {
+  const b = bucketProviders(registry);
+  return {
+    api: { id: 'api', label: 'API key', desc: 'paste an sk-... key', tag: 'needs key', members: b.api },
+    cli: { id: 'cli', label: 'CLI / Local', desc: 'keyless — an existing CLI login or a local daemon', tag: 'no key', members: b.cli },
+    mock: { id: 'mock', label: 'Mock', desc: 'offline echo, only useful for testing', tag: 'test', members: b.mock },
+  };
+}
+
+// Plain-text per-row tag for a provider, from its PROVIDER_INFO meta.
+export function providerTag(meta) {
+  const m = meta || {};
+  if (m.custom) return 'custom';
+  return m.requiresApiKey ? 'api key' : 'no key';
+}

package/tui/repl.mjs

@@ -38,7 +38,7 @@ import { Splash, renderSplashToString } from './splash.mjs';
 import { Editor } from './editor.mjs';
 import { SlashPopup, filterSlashCommands } from './slash_popup.mjs';
 import { SLASH_COMMANDS } from './slash_commands.mjs';
-import { ModalPicker, filterModalItems } from './modal_picker.mjs';
+import { ModalPicker, filterModalItems, resolveModalPick } from './modal_picker.mjs';
 import { theme } from './theme.mjs';
 
 // ─── Alt-buffer mount (DEC 1049) ─────────────────────────────────────────
@@ -63,6 +63,14 @@ export const ALT_BUFFER_ENTER = '\x1b[?1049h';
 export const ALT_BUFFER_LEAVE = '\x1b[?1049l';
 export const CURSOR_VISIBLE   = '\x1b[?25h';
 
+// Rendering-mode decision. Default = Static scrollback (no flicker; splash
+// prints once + scrolls naturally). Alt-buffer fullscreen is opt-in via
+// LAZYCLAW_ALT=1; LAZYCLAW_NO_ALT=1 forces it off. TTY-only either way.
+export function computeAltEnabled(env, hasTTY) {
+  const e = env || {};
+  return !!hasTTY && !!e.LAZYCLAW_ALT && !e.LAZYCLAW_NO_ALT;
+}
+
 export function FullScreen({ enabled, children }) {
   useEffect(() => {
     if (!enabled) return undefined;
@@ -151,10 +159,10 @@ export function onStreamChunk(state, { chunk }) {
   return { ...state, liveAssistant: state.liveAssistant + chunk };
 }
 
-export function onTurnComplete(state, { reason } = {}) {
+export function onTurnComplete(state, { reason, error } = {}) {
   const promoted = state.pendingPrepend;
   const suffix = reason === 'aborted' ? ' [aborted]'
-              : reason === 'error'   ? ' [error]'
+              : reason === 'error'   ? (error ? ` [error: ${error}]` : ' [error]')
               : '';
   const text = (state.liveAssistant || '') + suffix;
   // Commit any accumulated live text to scrollback. If the turn produced
@@ -188,13 +196,21 @@ export function consumeNextTurnFirstMessage(state) {
 //   - runTurnFactory(writeFn) → runTurn(text, signal)   (sticky layout)
 //   - runTurn(text, signal)                              (legacy, stdout)
 // Legacy mode is preserved verbatim for the existing cli.mjs callsite.
-export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, onSlashCommand, statusInfo, pickerRef }) {
-  // statusInfo lets the host supply provider/model/ctx to the StatusBar
-  // independently of splashProps. Needed for the alt-buffer hand-off
-  // where splashProps is pre-printed to the primary buffer (not the
-  // alt canvas) and nulled out here to suppress the in-tree Static
-  // splash item — but the StatusBar still needs provider/model strings.
-  const _status = statusInfo || splashProps || {};
+export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, onSlashCommand, statusInfo, getStatus, pickerRef }) {
+  // statusInfo seeds the StatusBar's provider/model/ctx. getStatus (optional)
+  // returns the live values so the bar refreshes after a /provider or /model
+  // switch and after each turn (token/ctx gauge) — without it the bar would
+  // show whatever was captured at mount (stale after a slash mutates the
+  // active provider/model). v5.5.
+  const [statusState, setStatusState] = useState(() => statusInfo || splashProps || {});
+  const refreshStatus = useCallback(() => {
+    if (typeof getStatus !== 'function') return;
+    try {
+      const s = getStatus();
+      if (s) setStatusState((prev) => ({ ...prev, ...s }));
+    } catch { /* never let a status read break the turn */ }
+  }, [getStatus]);
+  const _status = statusState;
   // Splash is rendered ONCE as scrollback[0] via <Static>. Build it lazily
   // so SSR-style imports without a TTY don't crash on process.stdout.
   const splashItemRef = useRef(null);
@@ -206,12 +222,16 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
   const [state, setState] = useState(() => makeReplState({ splashItem: splashItemRef.current }));
   const { exit } = useApp();
 
-  // Alt-buffer eligibility — TTY only, opt-out via LAZYCLAW_NO_ALT=1.
-  // Captured in a ref so the value is stable across renders (it cannot
-  // change at runtime; isTTY + env are read once on mount).
+  // Rendering mode. Default is the Static scrollback (no full-frame redraw,
+  // so no typing flicker; the splash prints once to the primary buffer and
+  // scrolls naturally — it never hits the alt-canvas vanish/blank bugs). The
+  // alt-buffer fullscreen (sticky-bottom Editor) is opt-in via LAZYCLAW_ALT=1,
+  // and LAZYCLAW_NO_ALT=1 still forces it off. TTY-only either way.
+  // Captured in a ref so the value is stable across renders (isTTY + env are
+  // read once on mount; they cannot change at runtime).
   const altEnabledRef = useRef(null);
   if (altEnabledRef.current === null) {
-    altEnabledRef.current = !!(process.stdout && process.stdout.isTTY) && !process.env.LAZYCLAW_NO_ALT;
+    altEnabledRef.current = computeAltEnabled(process.env, process.stdout && process.stdout.isTTY);
   }
   const altEnabled = altEnabledRef.current;
 
@@ -265,15 +285,20 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
       const controller = new AbortController();
       setState((s) => onUserInput(s, { text: trimmed, controller }));
       try {
-        const result = await onSlashCommand(trimmed);
+        // Pass the signal so the host can abort a long slash op (e.g. /loop)
+        // when the user hits Esc (onEscape aborts state.controller).
+        const result = await onSlashCommand(trimmed, controller.signal);
         if (result === 'EXIT') { exit(); return; }
         if (typeof result === 'string' && result.length > 0) {
           setState((s) => onStreamChunk(s, { chunk: result }));
         }
         setState((s) => onTurnComplete(s, { reason: 'done' }));
+        // A slash like /provider or /model mutates the host's active
+        // provider/model — refresh the StatusBar so it isn't stale.
+        refreshStatus();
       } catch (err) {
         setState((s) => onTurnComplete(s, {
-          reason: err && err.name === 'AbortError' ? 'aborted' : 'error',
+          reason: err && err.name === 'AbortError' ? 'aborted' : 'error', error: err?.message || String(err),
         }));
       }
       return;
@@ -283,12 +308,13 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
     try {
       await runTurnRef.current(trimmed, controller.signal);
       setState((s) => onTurnComplete(s, { reason: 'done' }));
+      refreshStatus();
     } catch (err) {
       setState((s) => onTurnComplete(s, {
         reason: err && err.name === 'AbortError' ? 'aborted' : 'error',
       }));
     }
-  }, [exit, onSlashCommand]);
+  }, [exit, onSlashCommand, refreshStatus]);
 
   // Auto-submit queued mid-stream-interrupt message (spec §5.8). Read
   // state.nextTurnFirstMessage so the effect re-fires when promoted.
@@ -425,9 +451,10 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
     });
   }, [modalView.length]);
   const onModalConfirm = useCallback(() => {
-    const picked = modalView[modalIdx];
-    closeModal(picked ? picked.id : null);
-  }, [modalView, modalIdx, closeModal]);
+    // A `freeText` row resolves to { id, query } so the dispatcher can use
+    // the typed filter buffer as a custom value (e.g. an unlisted model id).
+    closeModal(resolveModalPick(modalView[modalIdx], modalQuery));
+  }, [modalView, modalIdx, modalQuery, closeModal]);
   const onModalCancel = useCallback(() => { closeModal(null); }, [closeModal]);
   const onModalQuery = useCallback((next) => {
     setModalQuery(next || '');
@@ -466,17 +493,16 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
       altEnabled
         ? React.createElement(
             Box,
-            { flexDirection: 'column', flexGrow: 1, flexShrink: 1, overflow: 'hidden' },
-            // v5.4.3 — once any user/assistant turn has been committed,
-            // drop the splash from the visible scrollback. Inside the
-            // alt-buffer canvas the splash cannot scroll off naturally
-            // (no native scrollback), so leaving it visible pushes the
-            // newest content past the StatusBar+Editor on tall outputs
-            // like /help. The splash still flashes on first mount.
-            (state.scrollback.length > 1
-              ? state.scrollback.filter((it) => it.kind !== 'splash')
-              : state.scrollback
-            ).map((item) =>
+            // v5.5 — `justifyContent: 'flex-end'` pins the newest content to
+            // the bottom of the fixed-height alt canvas; older lines (the
+            // splash / sloth + manual) overflow off the TOP and are clipped
+            // naturally, exactly like a real scrollback. This replaces the
+            // v5.4.3 hack that hard-dropped the splash after the first turn
+            // (which made the manual + character abruptly vanish the moment
+            // you ran any command). The splash now scrolls off only once
+            // there's enough content to push it past the top edge.
+            { flexDirection: 'column', flexGrow: 1, flexShrink: 1, overflow: 'hidden', justifyContent: 'flex-end' },
+            state.scrollback.map((item) =>
               React.createElement(ScrollbackItem, { key: item.id, item })
             ),
             // Live region — partial assistant stream (inside the scroll
@@ -567,10 +593,15 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
   );
 }
 
-// ScrollbackItem renders each <Static/> child. Splash renders via the
-// real <Splash/> component (preserves gradient wordmark colorization);
-// everything else is plain Text.
-export function ScrollbackItem({ item }) {
+// ScrollbackItem renders each scrollback child. Splash renders via the real
+// <Splash/> component (preserves gradient wordmark colorization); everything
+// else is plain Text.
+//
+// Wrapped in React.memo: scrollback item objects are stable across renders,
+// so when only the editor buffer changes (every keystroke) the memo skips
+// re-rendering every committed line. Without this the whole alt-buffer
+// scrollback re-rendered on each keypress — the source of the typing flicker.
+export const ScrollbackItem = React.memo(function ScrollbackItem({ item }) {
   if (item.kind === 'splash') {
     return React.createElement(Splash, item.splashProps);
   }
@@ -586,7 +617,7 @@ export function ScrollbackItem({ item }) {
   }
   // 'assistant' (default)
   return React.createElement(Text, { color: theme.fg }, item.text);
-}
+});
 
 // StatusBar — single row, provider · model · ctx · streaming indicator.
 // Kept intentionally minimal in v5.3; token gauges land separately once

package/tui/slash_commands.mjs

@@ -25,6 +25,7 @@ export const SLASH_COMMANDS = [
   { cmd: '/trainer',     help: 'view or set trainer provider/model: /trainer show|set <p:m>|clear' },
   { cmd: '/personality', help: 'pick a personality (or sub: list|show|install|remove|use)' },
   { cmd: '/dashboard',   help: 'open the lazyclaw web UI in your browser' },
+  { cmd: '/menu',        help: 'browse the full subcommand catalog (command palette)' },
   { cmd: '/loop',        help: 'repeat one prompt: /loop "fix lint" [--max N] [--until "<regex>"]' },
   { cmd: '/goal',        help: 'register/switch goal: /goal add NAME | /goal list' },
   { cmd: '/memory',      help: 'show layered memory: /memory [core|recent|episodic [topic]]' },
@@ -32,7 +33,7 @@ export const SLASH_COMMANDS = [
   { cmd: '/dream',       help: 'consolidate recent memory into per-topic episodic files' },
   { cmd: '/agent',       help: 'spawn or switch agent: /agent NAME' },
   { cmd: '/team',        help: 'list, create, or join a team' },
-  { cmd: '/task',        help: 'list/show/transcript/abandon/done/remove (start/tick: CLI)' },
+  { cmd: '/task',        help: 'multi-agent tasks: start/tick/list/show/transcript/abandon/done/remove' },
   { cmd: '/handoff',     help: 'hand current task off to another agent' },
   { cmd: '/exit',        help: 'leave the chat' },
   { cmd: '/quit',        help: 'alias for /exit' },