lazyclaw 6.2.0 → 6.3.0

package/commands/chat.mjs

@@ -23,17 +23,16 @@ import { SLASH_COMMANDS } from '../tui/slash_commands.mjs';
 
 // Legacy (non-Ink) slash routing for dispatcher-style, ctx-only commands.
 // The Ink REPL routes every slash through _dispatchSlash/SLASH_HANDLERS, but
-// the legacy readline path uses a hand-written switch (in cmdChat). Commands
-// like /config only mutate ctx and return a sentinel, so we keep that wiring
-// in one exported helper that BOTH the legacy switch and the regression test
-// drive — this is the seam that proves /config reaches setup on the legacy
-// path (the post-loop guard re-runs cmdSetup when ctx.requestSetup is set).
-// Returns 'EXIT' when the loop must break, or undefined when the command is
-// not one this helper owns (caller falls through to its own handling).
+// the legacy readline path uses a hand-written switch (in cmdChat). This
+// exported helper is the wiring BOTH that switch and the regression test
+// drive. Returns 'EXIT' to break the loop, undefined when not owned here.
 export function legacySlashRoute(cmd, ctx) {
   switch (cmd) {
+    // Legacy readline path has no modal picker, so BOTH /setup and /config
+    // route to the full wizard here (the Ink path gives /config its
+    // single-setting picker via tui/config_picker.mjs).
     case '/config':
-      // Mirror tui/slash_dispatcher.mjs '/config': signal the host, unmount.
+    case '/setup':
       ctx.requestSetup = true;
       return 'EXIT';
     default:
@@ -297,9 +296,13 @@ export async function cmdChat(flags = {}) {
         pickerRef: _inkPickerRef,
       }), { exitOnCtrlC: true, patchConsole: true });
       await ink.waitUntilExit();
-      // /config asks to (re)run the wizard: now that Ink has released stdin,
-      // run setup, then return to the shell (re-launch `lazyclaw` to chat).
+      // /setup → full wizard (then shell). /config single step → run JUST
+      // that step now that Ink released stdin, then re-enter chat.
       if (_inkCtx.requestSetup) await (await import('./setup.mjs')).cmdSetup(undefined, [], {});
+      else if (_inkCtx.requestConfigStep) {
+        await (await import('./config_step.mjs')).runConfigStep(_inkCtx.requestConfigStep);
+        return cmdChat(flags);
+      }
       return;
     } catch (e) {
       // Fall through to legacy path on any ink failure (missing import,
@@ -1110,14 +1113,10 @@ export async function cmdChat(flags = {}) {
         } catch { /* /exit must never hang or throw */ }
         return 'EXIT';
       }
-      case '/config': {
-        // Route through the shared legacySlashRoute helper (covered by
-        // tests/f-config-slash-splash.test.mjs) so the legacy path's /config
-        // wiring is the exact code the regression test exercises. It sets
-        // _legacyCtx.requestSetup and returns 'EXIT'; the post-loop guard at the
-        // bottom of cmdChat re-runs the setup wizard when requestSetup is set.
-        // Without this case the legacy readline path fell through to `default:`
-        // and printed "unknown slash" instead of launching setup.
+      case '/config':
+      case '/setup': {
+        // Shared legacySlashRoute wiring (tests/f-config-slash-splash.test.mjs):
+        // sets requestSetup + 'EXIT'; the post-loop guard runs the wizard.
         return legacySlashRoute(cmd, _legacyCtx);
       }
       default: {

package/commands/config_step.mjs

@@ -0,0 +1,39 @@
+// commands/config_step.mjs — run ONE setup step outside the full wizard.
+//
+// Backs the in-chat `/config` picker: credential steps (channel tokens,
+// outbound webhook) need raw readline prompts that can't run inside the Ink
+// REPL, so the REPL unmounts with ctx.requestConfigStep set, chat.mjs calls
+// runConfigStep(step) here, and then re-enters chat — the user changes one
+// value (e.g. a webhook URL) without re-walking every wizard step.
+
+import path from 'node:path';
+import { configPath } from '../lib/config.mjs';
+import { _quickPrompt } from '../tui/pickers.mjs';
+import { runChannelStep, runWebhookStep } from './setup_channels.mjs';
+
+const COLORS = {
+  accent: (s) => `\x1b[38;2;217;179;90m${s}\x1b[0m`,
+  bold:   (s) => `\x1b[1m${s}\x1b[0m`,
+  dim:    (s) => `\x1b[2m${s}\x1b[0m`,
+  ok:     (s) => `\x1b[32m${s}\x1b[0m`,
+  warn:   (s) => `\x1b[33m${s}\x1b[0m`,
+};
+
+export async function runConfigStep(step, deps = {}) {
+  const prompt = deps.prompt || _quickPrompt;
+  const colors = deps.colors || COLORS;
+  const write = deps.write || ((s) => process.stdout.write(s));
+  const cfgDir = deps.cfgDir || path.dirname(configPath());
+
+  write(`\n  ${colors.bold(`⚙ config — ${step}`)}\n`);
+  if (step === 'channel') {
+    await runChannelStep({ cfgDir, prompt, colors, write });
+    return true;
+  }
+  if (step === 'webhook') {
+    await runWebhookStep({ prompt, colors, write });
+    return true;
+  }
+  write(`  ${colors.warn(`unknown config step: ${step}`)}\n`);
+  return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "6.2.0",
+  "version": "6.3.0",
   "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/config_picker.mjs

@@ -0,0 +1,54 @@
+// tui/config_picker.mjs — the `/config` slash: change ONE setting without
+// re-running the whole wizard.
+//
+// Split of duties (user-requested):
+//   /setup  — first-run / full re-setup: leaves chat and runs EVERY wizard
+//             step (the behavior /config used to have).
+//   /config — settings editor: pick a single item. In-chat items (provider /
+//             model / context / trainer / orchestrator) delegate to their
+//             existing slash handlers and stay inside chat; credential items
+//             (channel tokens, outbound webhook) need readline prompts, so
+//             they unmount, run JUST that step, and re-enter chat.
+//
+// On the legacy readline path (no ctx.openPicker modal) /config falls back
+// to the full wizard — same as before, no silent degradation.
+
+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: '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' },
+  { id: 'webhook',      label: 'outbound webhook',    desc: 'message-send webhook URL — leaves chat, then returns' },
+  { id: 'wizard',       label: 'everything (full wizard)', desc: 'rerun all setup steps — same as /setup' },
+];
+
+export async function runConfigSlash(_args, ctx, handlers) {
+  if (typeof ctx.openPicker !== 'function') {
+    // Legacy readline path has no modal picker — keep the old /config
+    // behavior there (full wizard) rather than failing.
+    ctx.requestSetup = true;
+    return 'EXIT';
+  }
+  const picked = await ctx.openPicker({
+    kind: 'config-item',
+    title: 'config — change one setting',
+    subtitle: 'Enter to edit · Esc to cancel · /setup reruns the whole wizard',
+    items: CONFIG_ITEMS.map((i) => ({ id: i.id, label: i.label, desc: i.desc })),
+  });
+  const id = typeof picked === 'string' ? picked : (picked && picked.id);
+  if (!id || id === 'CANCEL') return 'config: cancelled';
+  if (id === 'wizard') { ctx.requestSetup = true; return 'EXIT'; }
+  if (id === 'channel' || id === 'webhook') {
+    // These steps need raw readline prompts (secrets), so the REPL unmounts,
+    // chat.mjs runs the single step, and chat restarts automatically.
+    ctx.requestConfigStep = id;
+    return 'EXIT';
+  }
+  const handler = handlers && handlers.get && handlers.get(`/${id}`);
+  if (!handler) return `config: no in-chat editor for "${id}"`;
+  return handler('', ctx);
+}
+
+export { CONFIG_ITEMS };

package/tui/editor.mjs

@@ -422,7 +422,12 @@ export function Editor({
     try {
       process.stdout.write(`${undo}\x1b[${rowsUp}A\x1b[${colTarget}G\x1b[?25h`);
     } catch { /* stdout closed — swallow */ }
-  }, [state.buffer, state.cursor, altEnabled]);
+  });
+  // ^ NO dependency array — re-anchor after EVERY commit. Renders triggered
+  // by OTHER components (status-bar ticks, streaming output) redraw the
+  // frame and park the terminal cursor below it; with buffer-only deps the
+  // anchor didn't re-run and the cursor drifted out of the box whenever the
+  // user wasn't typing. The pending-offset undo above makes repeats safe.
 
   const lines = state.buffer.split('\n');
   // Ink's <Text wrap="wrap"> uses wrap-ansi (string-width aware) but the
@@ -446,6 +451,17 @@ export function Editor({
       });
     }
   }
+  // 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.
+  if (!modalOpen && renderedLines.length > 0) {
+    const last = renderedLines[renderedLines.length - 1];
+    last.text = `${last.text}\x1b[7m \x1b[27m`;
+  }
   return React.createElement(
     Box,
     {

package/tui/slash_commands.mjs

@@ -26,7 +26,8 @@ export const SLASH_COMMANDS = [
   { 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: '/config',      help: 'leave chat and re-run the setup wizard (provider, model, channels)' },
+  { cmd: '/setup',       help: 'first-run / full re-setup: leave chat and run every wizard step' },
+  { cmd: '/config',      help: 'change ONE setting: provider, model, context, channel creds, webhook, …' },
   { cmd: '/channels',    help: 'view configured channels; /channels <name> on|off to toggle' },
   { cmd: '/orchestrator', help: 'multi-agent: status | on | off | planner <spec> | worker add|remove <spec>' },
   { cmd: '/context',      help: 'chat history window: status | turns <N> | tokens <N>' },

package/tui/slash_dispatcher.mjs

@@ -1,8 +1,6 @@
 // tui/slash_dispatcher.mjs — single source of slash-command routing for the
 // Ink chat REPL (v5.4). Lifted from cli.mjs's legacy readline handler so the
-// Ink branch stops shipping the "not yet wired" placeholder and so future
-// channels (Slack/Telegram inline commands, /handoff cross-channel control)
-// can share one dispatch table.
+// Ink branch and future channel surfaces share one dispatch table.
 //
 // Contract:
 //   dispatchSlash(cmd, args, ctx, write) → Promise<string|'EXIT'|void>
@@ -1814,17 +1812,18 @@ export const SLASH_HANDLERS = new Map([
   ['/channels', _channels],
   ['/orchestrator', _orchestrator],
   ['/context', _context],
-  // /config — unmount and let chat.mjs run the setup wizard (ctx.requestSetup).
-  ['/config', async (_a, ctx) => { ctx.requestSetup = true; return 'EXIT'; }],
+  // /setup — full wizard (every step); /config — pick ONE setting to change
+  // (in-chat where possible; credential steps unmount, run, re-enter chat).
+  ['/setup', async (_a, ctx) => { ctx.requestSetup = true; return 'EXIT'; }],
+  ['/config', async (a, ctx) => (await import('./config_picker.mjs')).runConfigSlash(a, ctx, SLASH_HANDLERS)],
   ['/exit', async () => 'EXIT'],
   ['/quit', async () => 'EXIT'],
 ]);
 
 /**
- * Primary entry point. Resolves the command name to a handler in
- * SLASH_HANDLERS and invokes it. Unknown commands return a friendly
- * "unknown" string (caller renders to scrollback) rather than throwing,
- * so the user sees feedback instead of an error toast.
+ * Primary entry point. Resolves the command name to a SLASH_HANDLERS entry
+ * and invokes it. Unknown commands return a friendly "unknown" string
+ * (rendered to scrollback) rather than throwing.
  */
 export async function dispatchSlash(cmd, args, ctx, write) {
   const handler = SLASH_HANDLERS.get(cmd);