lazyclaw 5.3.0 → 5.3.1

package/cli.mjs

@@ -2634,9 +2634,53 @@ async function cmdChat(flags = {}) {
         ctx: _inkCtx,
         writeFn: (chunk) => process.stdout.write(chunk),
       });
+      // Minimal slash dispatcher for the Ink branch. Covers the read-only
+      // info commands so the user sees something useful instead of having
+      // their slash command sent to the model as a prompt. /exit + /quit
+      // are intercepted inside ReplApp before this fires. Returning a
+      // string causes ReplApp to render the result into scrollback.
+      //
+      // The full set of mutating commands (/model, /provider, /skill,
+      // /personality, ...) still lives in the legacy readline path and
+      // remains accessible via LAZYCLAW_NO_INK=1. Wiring those through
+      // the Ink branch is a follow-up; today we at least stop sending
+      // them as prompts.
+      const _inkSlashHandler = async (line) => {
+        const cmd = line.split(/\s+/)[0];
+        switch (cmd) {
+          case '/help': {
+            const lines = ['slash commands:'];
+            for (const c of SLASH_COMMANDS) lines.push(`  ${c.cmd.padEnd(14)} — ${c.help}`);
+            return lines.join('\n') + '\n';
+          }
+          case '/status': {
+            const out = {
+              provider: activeProvName,
+              model: activeModel,
+              keyMasked: _registryMod.maskApiKey(cfg['api-key']),
+              messageCount: _inkMessages.length,
+            };
+            return JSON.stringify(out) + '\n';
+          }
+          case '/version': {
+            return `lazyclaw ${readVersionFromRepo()} (node ${process.version}, ${process.platform})\n`;
+          }
+          case '/exit':
+          case '/quit':
+            // ReplApp intercepts these before onSlashCommand fires, but
+            // return EXIT defensively in case that contract ever changes.
+            return 'EXIT';
+          default:
+            // Mutating commands still require the legacy readline path.
+            // Telling the user explicitly beats silently sending the
+            // slash text to the model as a prompt.
+            return `${cmd} is not yet wired into the ink REPL — set LAZYCLAW_NO_INK=1 and restart to use it.\n`;
+        }
+      };
       const ink = render(/* @__PURE__ */ React.createElement(ReplApp, {
         splashProps,
         runTurn: _inkRunTurn,
+        onSlashCommand: _inkSlashHandler,
       }));
       await ink.waitUntilExit();
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "5.3.0",
+  "version": "5.3.1",
   "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama, orchestrating multi-step LLM workflows, and running multi-agent Slack teams with cross-task memory. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
   "keywords": [
     "claude",

package/tui/editor.mjs

@@ -10,6 +10,13 @@
 // Enter fills, second Enter runs). Esc clears the buffer + dismisses.
 // All popup-aware branches are guarded by `slashOpen` so legacy callers
 // see the pre-v5.4 behavior verbatim.
+//
+// v5.5: <Editor/> now renders inside a round-bordered Box — the
+// Claude-CLI-style input frame. The border uses `theme.border` (a
+// muted gray) so the accent `›` and sloth gutter stay the dominant
+// amber notes. The box auto-fills the available terminal width via
+// Ink's flex defaults and grows vertically as the buffer wraps onto
+// new lines (Shift+Enter).
 import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import { theme } from './theme.mjs';
@@ -125,17 +132,29 @@ export function Editor({
       }
       // Tab / Enter — fill the buffer with the highlighted command.
       // First Enter fills, second Enter runs (matches Anthropic's UX).
+      // Exception: if the buffer already exactly matches the picked
+      // command (with or without a trailing space), there is nothing left
+      // to autocomplete. For Enter, fall through to the normal submit
+      // path so /exit, /quit, /help etc. fire on a single Enter. For Tab
+      // on an exact match, no-op.
       if (key.tab || key.return) {
         const safeIdx = Math.max(0, Math.min(slashSuggestions.length - 1, slashSelectedIndex || 0));
         const picked = slashSuggestions[safeIdx];
-        if (picked) {
-          const next = fillSlashCommand(state, picked.cmd);
-          setState(next);
-          if (onBufferChange) {
-            try { onBufferChange(next.buffer); } catch {}
+        const bufTrim = state.buffer.replace(/\s+$/, '');
+        const alreadyExact = !!picked && (state.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(state, picked.cmd);
+            setState(next);
+            if (onBufferChange) {
+              try { onBufferChange(next.buffer); } catch {}
+            }
           }
+          return;
         }
-        return;
       }
       // Anything else (printable, backspace) falls through to applyKey.
     }
@@ -156,7 +175,17 @@ export function Editor({
   const lines = state.buffer.split('\n');
   return React.createElement(
     Box,
-    { flexDirection: 'column' },
-    lines.map((ln, i) => React.createElement(Text, { key: i }, i === 0 ? theme.accent('› ') + ln : '  ' + ln))
+    {
+      borderStyle: 'round',
+      borderColor: theme.border,
+      paddingX: 1,
+      flexDirection: 'column',
+      flexShrink: 0,
+    },
+    lines.map((ln, i) => React.createElement(
+      Text,
+      { key: i },
+      i === 0 ? theme.accent('› ') + ln : '  ' + ln,
+    )),
   );
 }

package/tui/repl.mjs

@@ -130,7 +130,7 @@ 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 }) {
+export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, onSlashCommand }) {
   // 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);
@@ -163,18 +163,46 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands })
   }
 
   const handleSubmit = useCallback(async (text) => {
-    if (text === '/exit' || text === '/quit') { exit(); return; }
+    // Normalize trailing whitespace so '/exit ' (left over from a popup
+    // fill) is treated identically to '/exit'. Empty input → no-op.
+    const trimmed = (text || '').replace(/\s+$/, '');
+    if (!trimmed) return;
+    // /exit + /quit unmount the Ink app. Done inline so the popup path
+    // and the no-popup path both terminate cleanly.
+    if (trimmed === '/exit' || trimmed === '/quit') { exit(); return; }
+    // Other slash commands: hand off to the host's slash dispatcher
+    // (cli.mjs handleSlash) when one is provided. The host returns a
+    // string (or void) which we append to scrollback as an assistant
+    // turn so the user sees the result inline. If no dispatcher is
+    // wired, fall through to runTurn (legacy behavior).
+    if (trimmed.startsWith('/') && typeof onSlashCommand === 'function') {
+      const controller = new AbortController();
+      setState((s) => onUserInput(s, { text: trimmed, controller }));
+      try {
+        const result = await onSlashCommand(trimmed);
+        if (result === 'EXIT') { exit(); return; }
+        if (typeof result === 'string' && result.length > 0) {
+          setState((s) => onStreamChunk(s, { chunk: result }));
+        }
+        setState((s) => onTurnComplete(s, { reason: 'done' }));
+      } catch (err) {
+        setState((s) => onTurnComplete(s, {
+          reason: err && err.name === 'AbortError' ? 'aborted' : 'error',
+        }));
+      }
+      return;
+    }
     const controller = new AbortController();
-    setState((s) => onUserInput(s, { text, controller }));
+    setState((s) => onUserInput(s, { text: trimmed, controller }));
     try {
-      await runTurnRef.current(text, controller.signal);
+      await runTurnRef.current(trimmed, controller.signal);
       setState((s) => onTurnComplete(s, { reason: 'done' }));
     } catch (err) {
       setState((s) => onTurnComplete(s, {
         reason: err && err.name === 'AbortError' ? 'aborted' : 'error',
       }));
     }
-  }, [exit]);
+  }, [exit, onSlashCommand]);
 
   // Auto-submit queued mid-stream-interrupt message (spec §5.8). Read
   // state.nextTurnFirstMessage so the effect re-fires when promoted.
@@ -234,7 +262,17 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands })
     setSelectedSuggestion(0);
   }, []);
 
-  const showSlashPopup = bufferPeek.startsWith('/') && filtered.length > 0;
+  // Hide the popup when the buffer already exactly matches the only
+  // remaining suggestion (with or without a trailing space). Otherwise
+  // the popup intercepts Enter and the fully-typed command (e.g.
+  // '/exit') never reaches handleSubmit. Belt-and-suspenders with the
+  // editor-side fall-through in tui/editor.mjs.
+  const _bufTrimmed = bufferPeek.replace(/\s+$/, '');
+  const _exactOnly =
+    filtered.length === 1 &&
+    (filtered[0].cmd === bufferPeek || filtered[0].cmd === _bufTrimmed);
+  const showSlashPopup =
+    bufferPeek.startsWith('/') && filtered.length > 0 && !_exactOnly;
 
   return React.createElement(
     Box,

package/tui/splash.mjs

@@ -382,14 +382,55 @@ export function Splash(props) {
   const palette = wordmark.palette;
   const gradient = wordmark.gradient;
   const showWordmark = cols >= WORDMARK_BREAKPOINT;
+  // Sloth banner is emitted at the TOP of NARROW output (45..89) only when
+  // it fits inside the terminal width — see renderNarrow() guard.
+  const showSlothNarrow =
+    cols >= NARROW_BREAKPOINT && cols < MEDIUM_BREAKPOINT &&
+    cols >= banner.width + LMARGIN.length * 2;
+
+  // Per-tier sloth row range [start, end). MEDIUM interleaves the sloth
+  // inside panel rows, so it gets colored via the border regex below — no
+  // dedicated band is needed for that tier.
+  let slothStart = -1, slothEnd = -1;
+  if (showWordmark) {
+    slothStart = wordmark.height + 1 + 1; // wordmark + blank + panel-top
+    slothEnd   = slothStart + banner.height;
+  } else if (showSlothNarrow) {
+    slothStart = 0; // sloth is the first thing emitted
+    slothEnd   = banner.height;
+  }
+
+  // Section headers / summary / compact headline on NARROW that should be
+  // amber to match the WIDE wordmark accent. Matched by exact content.
+  const ACCENT_HEADERS = new Set(['Subcommands', 'Available Tools', 'Available Skills']);
+  // Panel border / status separator glyphs (leading box-drawing after
+  // optional whitespace). Catches ╭ ╰ │ as well as ─ separators.
+  const BORDER_RE = /^\s*[╭╰│├┤┬┴┼─╮╯]/;
+  // NARROW compact headline (e.g. "  lazyclaw 5.3.0").
+  const HEADLINE_RE = /^\s*lazyclaw\s+\S/;
+  // NARROW summary line ("N subcmds · M tools · K skills · /help" or its
+  // wrapped variant). Also catches "/help for commands".
+  const SUMMARY_RE = /(subcmds\s+·|tools\s+·\s+\d+\s+skills|\/help\s+for\s+commands)/;
 
   return React.createElement(
     Box,
     { flexDirection: 'column' },
     lines.map((line, i) => {
       let color;
-      if (showWordmark && i < wordmark.height) color = palette[gradient[i] ?? 1];
-      else if (showWordmark && i < wordmark.height + 1 + 1 + banner.height) color = theme.fg;
+      const trimmed = line.trim();
+      if (showWordmark && i < wordmark.height) {
+        color = palette[gradient[i] ?? 1]; // wordmark gradient
+      } else if (i >= slothStart && i < slothEnd) {
+        color = theme.fg; // sloth band — any tier that stacks the sloth
+      } else if (BORDER_RE.test(line)) {
+        color = theme.fg; // panel borders + status separators
+      } else if (ACCENT_HEADERS.has(trimmed)) {
+        color = theme.fg; // section headers
+      } else if (!showWordmark && HEADLINE_RE.test(line) && /\d/.test(line)) {
+        color = theme.fg; // narrow/medium compact headline ("lazyclaw 5.x.y")
+      } else if (!showWordmark && SUMMARY_RE.test(line)) {
+        color = theme.fg; // narrow/medium summary line
+      }
       return React.createElement(Text, { key: i, color }, line);
     })
   );

package/tui/theme.mjs

@@ -1,9 +1,14 @@
 // tui/theme.mjs — single source of truth for lazyclaw v5 color tokens.
 // The amber hex is also stamped into tui/banner.generated.mjs so the
 // sloth gutter and the prompt accent stay visually paired.
+//
+// v5.5: added `border` token for the chat-input frame (Claude-CLI-style
+// rounded box around the editor). Kept subtly grayer than `amber` so the
+// frame doesn't compete with the accent `›` or the sloth gutter.
 import chalk from 'chalk';
 
 const AMBER_HEX = '#FFB347';
+const BORDER_HEX = '#5A5A5A';
 
 function amber(text) {
   return chalk.hex(AMBER_HEX)(text);
@@ -28,6 +33,7 @@ function plain(text) {
 export const theme = {
   amber: AMBER_HEX,
   fg: AMBER_HEX,
+  border: BORDER_HEX,
   colorize: amber,
   dim,
   accent,