mixdog 0.9.2 → 0.9.4

package/src/tui/app/slash-dispatch.mjs

@@ -0,0 +1,427 @@
+/**
+ * slash-dispatch.mjs — the runSlashCommand slash-command dispatcher.
+ *
+ * Extracted from App.jsx behavior-preservingly as a dependency-injection
+ * factory: the switch body reads live store/state and drives many pickers +
+ * openers, so it can't be pure. The switch body below is the original App
+ * logic verbatim (case ordering + fallthrough semantics byte-identical), with
+ * every closure identifier threaded in through the factory argument. Openers
+ * defined later in the App factory zone are passed as lazy getters so their
+ * live binding is used at call time.
+ */
+export function createSlashDispatch({
+  state,
+  store,
+  normalizeSlashCommandName,
+  setContextPanel,
+  closeUsagePanel,
+  openModelPicker,
+  modelSwitchNotice,
+  toggleVoice,
+  setVoiceEnabled,
+  isVoiceEnabled,
+  openSearchPicker,
+  openAgentsPicker,
+  openWorkflowPicker,
+  workflowSwitchNotice,
+  openOutputStylePicker,
+  outputStyleNotice,
+  openThemePicker,
+  themeNotice,
+  openEffortPicker,
+  projectNameFromPath,
+  enterProject,
+  openProjectPicker,
+  openToolsPicker,
+  openMcpPicker,
+  openSkillsPicker,
+  openPluginsPicker,
+  openHooksPicker,
+  openProviderSetupPicker,
+  openChannelSetupPicker,
+  openMemoryCorePicker,
+  parseMemoryCommand,
+  openSettingsPicker,
+  openAutoClearPicker,
+  formatDuration,
+  openResumePicker,
+  openUsagePanel,
+  openContextPicker,
+  openProfilePicker,
+  openUpdatePicker,
+  requestExit,
+}) {
+  const runSlashCommand = (cmd, arg = '') => {
+    const rawName = String(cmd || '').toLowerCase();
+    cmd = normalizeSlashCommandName(cmd);
+    if (cmd !== 'context') setContextPanel(null);
+    if (cmd !== 'usage') closeUsagePanel();
+    switch (cmd) {
+      case 'clear':
+        if (state.busy) {
+          store.pushNotice('wait for the current turn to finish before /clear', 'warn');
+          return false;
+        }
+        if (rawName === 'new') {
+          void store.newSession().then(() => {}).catch((e) => store.pushNotice(`new session failed: ${e?.message || e}`, 'error'));
+        } else {
+          void store.clear().then(() => {}).catch((e) => store.pushNotice(`clear failed: ${e?.message || e}`, 'error'));
+        }
+        return true;
+      case 'model':
+        if (!arg) {
+          openModelPicker();
+          return true;
+        }
+        void store.setModel(arg)
+          .then(ok => store.pushNotice(ok ? modelSwitchNotice() : 'Model switch is already running.', ok ? 'info' : 'warn'))
+          .catch((e) => store.pushNotice(`Couldn’t switch model: ${e?.message || e}`, 'error'));
+        return true;
+      case 'remote': {
+        // /remote = force-claim, not toggle: always turns remote ON for THIS
+        // session and steals the seat from any other session (which flips
+        // itself OFF via the superseded notification). Turn off via /channels.
+        const enabled = store.claimRemote?.() === true;
+        store.pushNotice(enabled ? 'Remote mode ON — this session owns remote now.' : 'Remote mode unavailable.', 'info');
+        return true;
+      }
+      case 'voice': {
+        // Step1 only: toggleVoice() owns config persistence (voice.enabled) +
+        // the missing-component install sequence + its own notices (OFF/ON/
+        // progress/failure). We don't push a redundant notice here; a null
+        // return means "already running" or "failed", both already noticed.
+        void toggleVoice({ pushNotice: store.pushNotice, setProgressHint: store.setProgressHint })
+          .then((result) => {
+            // true/false = new enabled state; null = failed/busy (unchanged).
+            if (result === true || result === false) setVoiceEnabled(result);
+            else if (result && typeof result === 'object') setVoiceEnabled(isVoiceEnabled());
+          });
+        return true;
+      }
+      case 'search':
+        if (state.busy) {
+          store.pushNotice('wait for the current turn to finish before /search', 'warn');
+          return false;
+        }
+        if (arg) store.pushNotice('/search sets the search provider/model; the search tool uses that model when called.', 'warn');
+        openSearchPicker();
+        return true;
+      case 'agents':
+        openAgentsPicker();
+        return true;
+      case 'workflow':
+        if (!arg) {
+          openWorkflowPicker();
+          return true;
+        }
+        void store.setWorkflow?.(arg.trim())
+          .then((result) => {
+            if (!result) {
+              store.pushNotice('Workflow switch is already running.', 'warn');
+              return;
+            }
+            store.pushNotice(workflowSwitchNotice(result), 'info');
+          })
+          .catch((e) => store.pushNotice(`Couldn’t switch workflow: ${e?.message || e}`, 'error'));
+        return true;
+      case 'outputstyle': {
+        if (state.busy) {
+          store.pushNotice('wait for the current turn to finish before /OutputStyle', 'warn');
+          return false;
+        }
+        const value = arg.trim();
+        const lower = value.toLowerCase();
+        if (!value) {
+          openOutputStylePicker();
+          return true;
+        }
+        if (lower === 'status' || lower === 'current' || lower === 'show') {
+          try {
+            const status = store.getOutputStyle?.();
+            const label = status?.current?.label || status?.current?.id || status?.configured || 'Default';
+            store.pushNotice(`Output style: ${label}`, 'info');
+          } catch (e) {
+            store.pushNotice(`Couldn’t read output style: ${e?.message || e}`, 'error');
+          }
+          return true;
+        }
+        void store.setOutputStyle?.(value)
+          .then((result) => {
+            if (!result) {
+              store.pushNotice('Output style switch is already running.', 'warn');
+              return;
+            }
+            store.pushNotice(outputStyleNotice(result), 'info');
+          })
+          .catch((e) => store.pushNotice(`Couldn’t switch output style: ${e?.message || e}`, 'error'));
+        return true;
+      }
+      case 'theme': {
+        const value = arg.trim();
+        const lower = value.toLowerCase();
+        if (!value) {
+          openThemePicker();
+          return true;
+        }
+        let themes = [];
+        try { themes = store.listThemes?.() || []; } catch (e) {
+          store.pushNotice(`could not list themes: ${e?.message || e}`, 'error');
+          return true;
+        }
+        if (lower === 'status' || lower === 'current' || lower === 'show') {
+          const id = store.getTheme?.();
+          const entry = themes.find((t) => t.id === id);
+          store.pushNotice(`Theme: ${entry?.label || id || 'default'}`, 'info');
+          return true;
+        }
+        const match = themes.find((t) => t.id.toLowerCase() === lower)
+          || themes.find((t) => String(t.label || '').toLowerCase() === lower);
+        if (!match) {
+          const ids = themes.map((t) => t.id).join(', ');
+          store.pushNotice(`usage: /theme [id]. Available: ${ids}`, 'warn');
+          return true;
+        }
+        try {
+          const applied = store.setTheme?.(match.id, { persist: true });
+          store.pushNotice(themeNotice(applied || match), 'info');
+        } catch (e) {
+          store.pushNotice(`Couldn’t set theme: ${e?.message || e}`, 'error');
+        }
+        return true;
+      }
+      case 'effort':
+        if (state.busy) {
+          store.pushNotice('wait for the current turn to finish before /effort', 'warn');
+          return false;
+        }
+        if (!arg) {
+          openEffortPicker();
+          return true;
+        }
+        void store.setEffort(arg)
+          .then(result => store.pushNotice(result ? `Effort set to ${result}` : 'Effort switch is already running.', result ? 'info' : 'warn'))
+          .catch((e) => store.pushNotice(`Couldn’t switch effort: ${e?.message || e}`, 'error'));
+        return true;
+      case 'fast': {
+        if (state.busy) {
+          store.pushNotice('wait for the current turn to finish before /fast', 'warn');
+          return false;
+        }
+        const value = String(arg || '').trim().toLowerCase();
+        const setTo = value
+          ? ['1', 'true', 'yes', 'on', 'enable', 'enabled'].includes(value)
+            ? true
+            : ['0', 'false', 'no', 'off', 'disable', 'disabled'].includes(value)
+              ? false
+              : null
+          : undefined;
+        if (setTo === null) {
+          store.pushNotice('usage: /fast [on|off]', 'warn');
+          return true;
+        }
+        const action = setTo === undefined ? store.toggleFast?.() : store.setFast?.(setTo);
+        void Promise.resolve(action)
+          .then((enabled) => {
+            if (enabled === null || enabled === undefined) {
+              store.pushNotice('Fast mode switch is already running.', 'warn');
+              return;
+            }
+            store.pushNotice(`Fast mode ${enabled ? 'on' : 'off'} for ${state.provider}/${state.model}`, 'info');
+          })
+          .catch((e) => store.pushNotice(`Couldn’t update fast mode: ${e?.message || e}`, 'error'));
+        return true;
+      }
+      case 'cwd': {
+        const nextPath = arg.trim();
+        if (!nextPath) {
+          store.pushNotice(`Project path: ${state.cwd}`, 'info');
+          return true;
+        }
+        try {
+          store.setCwd?.(nextPath, { message: `Project set: ${projectNameFromPath(nextPath)}` });
+        } catch (e) {
+          store.pushNotice(`project switch failed: ${e?.message || e}`, 'error');
+        }
+        return true;
+      }
+      case 'project': {
+        const target = arg.trim();
+        if (target) {
+          enterProject(target);
+          return true;
+        }
+        openProjectPicker();
+        return true;
+      }
+      case 'tools':
+        openToolsPicker(arg.trim());
+        return true;
+      case 'mcp':
+        openMcpPicker();
+        return true;
+      case 'skills':
+        openSkillsPicker();
+        return true;
+      case 'plugins':
+        openPluginsPicker();
+        return true;
+      case 'hooks':
+        openHooksPicker();
+        return true;
+      case 'providers':
+        void openProviderSetupPicker();
+        return true;
+      case 'channels':
+        void openChannelSetupPicker('all');
+        return true;
+      case 'schedules':
+        void openChannelSetupPicker('schedules');
+        return true;
+      case 'webhooks':
+        void openChannelSetupPicker('webhooks');
+        return true;
+      case 'auth':
+        store.pushNotice('/auth moved to /providers', 'info');
+        void openProviderSetupPicker();
+        return true;
+      case 'auth-forget': {
+        const providerId = arg.trim();
+        if (!providerId) {
+          store.pushNotice('usage: /auth-forget <provider>', 'warn');
+          return true;
+        }
+        try {
+          store.forgetProviderAuth(providerId);
+        } catch (e) {
+          store.pushNotice(`auth-forget failed: ${e?.message || e}`, 'error');
+        }
+        return true;
+      }
+      case 'memory': {
+        if (!arg.trim()) {
+          openMemoryCorePicker({ returnTo: null });
+          return true;
+        }
+        void store.memoryControl?.(parseMemoryCommand(arg))
+          .catch((e) => store.pushNotice(`memory failed: ${e?.message || e}`, 'error'));
+        return true;
+      }
+      case 'recap': {
+        const value = arg.trim().toLowerCase();
+        if (value === 'on' || value === 'off') {
+          void Promise.resolve(store.setMemoryEnabled?.(value === 'on'))
+            .then((next) => {
+              if (!next) store.pushNotice('recap setting is busy', 'warn');
+              else store.pushNotice(`Recap ${next.enabled ? 'on' : 'off'}`, 'info');
+            })
+            .catch((e) => store.pushNotice(`recap failed: ${e?.message || e}`, 'error'));
+          return true;
+        }
+        // Bare /recap opens the Memory picker: its top row is the same
+        // background-cycles toggle, plus the curated entries below.
+        openMemoryCorePicker({ returnTo: null });
+        return true;
+      }
+      case 'recall': {
+        const query = arg.trim();
+        if (!query) {
+          store.pushNotice('usage: /recall <query>', 'warn');
+          return true;
+        }
+        void store.recall?.(query)
+          .catch((e) => store.pushNotice(`recall failed: ${e?.message || e}`, 'error'));
+        return true;
+      }
+      case 'autoclear': {
+        const value = arg.trim().toLowerCase();
+        if (!value) {
+          openAutoClearPicker();
+          return true;
+        }
+        try {
+          let next;
+          if (value === 'status') {
+            next = store.getAutoClear?.();
+          } else if (value === 'on' || value === 'enable' || value === 'enabled') {
+            next = store.setAutoClear?.({ enabled: true });
+          } else if (value === 'off' || value === 'disable' || value === 'disabled') {
+            next = store.setAutoClear?.({ enabled: false });
+          } else {
+            next = store.setAutoClear?.({ duration: value });
+          }
+          if (!next) {
+            store.pushNotice('autoclear unavailable', 'warn');
+            return true;
+          }
+          store.pushNotice(`autoclear ${next.enabled ? 'on' : 'off'} · idle ${formatDuration(next.idleMs)}`, 'info');
+        } catch (e) {
+          store.pushNotice(`autoclear failed: ${e?.message || e}`, 'error');
+        }
+        return true;
+      }
+      case 'compact':
+        if (state.busy) {
+          store.pushNotice('wait for the current turn to finish before /compact', 'warn');
+          return false;
+        }
+        void store.compact()
+          .then((r) => {
+            if (!r) {
+              store.pushNotice('Compact failed.', 'warn');
+              return;
+            }
+            if (r.error) {
+              store.pushNotice('Compact failed.', 'error');
+              return;
+            }
+            if (r.changed === false && r.reason) {
+              store.pushNotice(r.reason, 'warn');
+              return;
+            }
+            if (r.changed === false) {
+              store.pushNotice('nothing to compact', 'warn');
+              return;
+            }
+            store.pushNotice('Compact done.', 'info');
+          })
+          .catch(() => store.pushNotice('Compact failed.', 'error'));
+        return true;
+      case 'resume':
+        if (state.busy) {
+          store.pushNotice('wait for the current turn to finish before /resume', 'warn');
+          return false;
+        }
+        if (arg) {
+          void store.resume(arg)
+            .then(ok => store.pushNotice(ok ? `Resumed ${arg}` : 'Couldn’t resume chat.', ok ? 'info' : 'warn'))
+            .catch((e) => store.pushNotice(`Couldn’t resume chat: ${e?.message || e}`, 'error'));
+        } else {
+          openResumePicker();
+        }
+        return true;
+      case 'usage':
+        openUsagePanel(arg);
+        return true;
+      case 'context':
+        openContextPicker();
+        return true;
+      case 'settings':
+      case 'config':
+        openSettingsPicker();
+        return true;
+      case 'profile':
+        openProfilePicker();
+        return true;
+      case 'update':
+        openUpdatePicker();
+        return true;
+      case 'quit':
+        requestExit();
+        return true;
+      default:
+        store.pushNotice(`unknown command: /${cmd}`, 'warn');
+        return true;
+    }
+  };
+  return { runSlashCommand };
+}

package/src/tui/app/text-layout.mjs

@@ -0,0 +1,46 @@
+/**
+ * text-layout.mjs — prompt-box row-reservation helpers extracted verbatim from
+ * App.jsx. Pure grapheme wrap math (displayWidth policy); no React, no App state.
+ */
+import { displayWidth } from '../display-width.mjs';
+
+const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+
+export function wrappedTextRows(value, width) {
+  const w = Math.max(1, Math.floor(Number(width) || 1));
+  let row = 0;
+  let col = 0;
+  const segments = [...graphemeSegmenter.segment(String(value ?? ''))];
+  for (let i = 0; i < segments.length; i += 1) {
+    const { segment } = segments[i];
+    if (segment === '\n') {
+      row += 1;
+      col = 0;
+      continue;
+    }
+    const segmentWidth = displayWidth(segment);
+    if (segmentWidth === 0) continue;
+    // Same wrap-ansi hard/wordWrap:false wrapping as caretPosition — keep the
+    // reserved row count in lock-step with the caret math so the prompt box
+    // height matches ink's actual wrap for wide-char lines.
+    if (col > 0 && col + segmentWidth > w) {
+      row += 1;
+      col = 0;
+    }
+    col += segmentWidth;
+    if (col === w && i < segments.length - 1) {
+      row += 1;
+      col = 0;
+    }
+  }
+  return row + 1;
+}
+
+export function promptContentRows(value, contentColumns) {
+  // PromptInput appends a blank trailing cell when the caret is at end-of-input
+  // so the native cursor always has a rendered cell. App does not own the cursor
+  // offset, so reserve for the worst common case: caret at the end. This can
+  // over-reserve by one row at exact wrap boundaries, but never under-reserves
+  // and therefore prevents transcript rows from bleeding into the prompt box.
+  return wrappedTextRows(`${String(value ?? '')} `, contentColumns);
+}

package/src/tui/app/theme-effort-pickers.mjs

@@ -0,0 +1,154 @@
+/**
+ * theme-effort-pickers.mjs — the Theme picker + Effort picker cluster.
+ *
+ * Extracted from App.jsx behavior-preservingly as a dependency-injection
+ * factory (these openers drive setPicker + the prompt/pane setters and read
+ * live App state, so they can't be pure). Every function body is the original
+ * App logic verbatim, with closure identifiers threaded through the factory
+ * argument. themeNotice moves here alongside its sole external callers being
+ * re-exported so the runSlashCommand /theme-by-id path keeps using it.
+ */
+import { theme } from '../theme.mjs';
+
+export const themeNotice = (applied) => `Theme set to ${applied?.label || applied?.id || 'default'}`;
+
+export function createThemeEffortPickers({
+  state,
+  store,
+  setPicker,
+  setProviderPrompt,
+  setChannelPrompt,
+  setHookPrompt,
+  setSettingsPrompt,
+  setContextPanel,
+  closeUsagePanel,
+  clean,
+}) {
+  const openThemePicker = (options = {}) => {
+    const returnTo = typeof options.returnTo === 'function' ? options.returnTo : null;
+    const onboarding = options.onboarding || null;
+    let themes = [];
+    try {
+      themes = store.listThemes?.() || [];
+    } catch (e) {
+      store.pushNotice(`could not list themes: ${e?.message || e}`, 'error');
+      return;
+    }
+    if (!themes.length) {
+      store.pushNotice('no themes available', 'warn');
+      return;
+    }
+    const currentId = store.getTheme?.() || themes.find((t) => t.current)?.id || themes[0]?.id;
+    let highlightedThemeId = currentId;
+    const items = themes.map((entry) => ({
+      value: entry.id,
+      label: entry.label || entry.id,
+      marker: entry.id === currentId ? '✓' : '',
+      description: entry.description || 'color theme',
+      _theme: entry,
+    }));
+    setProviderPrompt(null);
+    setChannelPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    setContextPanel(null);
+    closeUsagePanel();
+    const applyTheme = (id, { persist = true } = {}) => {
+      try {
+        return store.setTheme?.(id, { persist });
+      } catch (e) {
+        store.pushNotice(`Couldn’t set theme: ${e?.message || e}`, 'error');
+        return null;
+      }
+    };
+    // Onboarding: Enter (row) and ConfirmBar Next both persist the highlighted
+    // theme, then advance; Back restores the original palette then steps back.
+    const saveTheme = (id, { advance = false } = {}) => {
+      setPicker(null);
+      const applied = applyTheme(id, { persist: true });
+      store.pushNotice(themeNotice(applied || { id }), 'info');
+      if (advance && onboarding) onboarding.onAdvance?.();
+      else if (returnTo) returnTo();
+    };
+    setPicker({
+      title: 'Theme',
+      description: 'Choose the color theme that looks best with your terminal.',
+      help: onboarding ? undefined : (returnTo ? '↑/↓ Preview · Enter Choose · Esc Settings' : '↑/↓ Preview · Enter Choose · Esc Back'),
+      labelWidth: 22,
+      initialIndex: Math.max(0, items.findIndex((item) => item.value === currentId)),
+      items,
+      confirmBar: onboarding ? {
+        buttons: [
+          { value: 'back', label: '◀ Back' },
+          { value: 'next', label: 'Next ▶' },
+        ],
+        onConfirm: (button) => {
+          if (button.value === 'back') {
+            // Restore the palette active before the picker opened, then step back.
+            if (currentId) applyTheme(currentId, { persist: false });
+            onboarding.onBack?.();
+            return;
+          }
+          saveTheme(highlightedThemeId, { advance: true });
+        },
+      } : (options.confirmBar || null),
+      // Live preview while moving: apply (no persist) so the surface re-tones
+      // as the selection moves. Enter persists; Esc restores the original.
+      onHighlight: (_value, item) => {
+        if (item?._theme?.id) {
+          highlightedThemeId = item._theme.id;
+          applyTheme(item._theme.id, { persist: false });
+        }
+      },
+      onSelect: (_value, item) => {
+        const entry = item?._theme;
+        if (!entry) return;
+        saveTheme(entry.id, { advance: Boolean(onboarding) });
+      },
+      onCancel: () => {
+        setPicker(null);
+        // Restore the theme that was active before the picker opened.
+        if (currentId) applyTheme(currentId, { persist: false });
+        if (onboarding) onboarding.onCancel?.();
+        else if (returnTo) returnTo();
+      },
+    });
+  };
+
+  const openEffortPicker = () => {
+    setProviderPrompt(null);
+    setChannelPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    const items = Array.isArray(state.effortOptions) && state.effortOptions.length > 0
+      ? state.effortOptions
+      : [];
+    if (!items.length) {
+      store.pushNotice('Current model has no effort levels.', 'warn');
+      return;
+    }
+    const current = state.effort || items[0]?.value || '';
+    const pickerItems = items.map((item) => ({
+      ...item,
+      marker: item?.value === current ? '✓' : '',
+      markerColor: theme.success,
+      description: clean(item?.description).toLowerCase() === 'current' ? '' : item?.description,
+    }));
+    setPicker({
+      title: 'Effort',
+      description: 'Reasoning effort for the current model.',
+      items: pickerItems,
+      onSelect: (value) => {
+        setPicker(null);
+        void store.setEffort(value)
+          .then(result => store.pushNotice(result ? `Effort set to ${result}` : 'Effort switch is already running.', result ? 'info' : 'warn'))
+          .catch((e) => store.pushNotice(`Couldn’t switch effort: ${e?.message || e}`, 'error'));
+      },
+      onCancel: () => {
+        setPicker(null);
+      },
+    });
+  };
+
+  return { openThemePicker, openEffortPicker };
+}