mu-coding 0.15.0 → 0.16.1

package/src/tui/input/cursor.ts

@@ -1,214 +0,0 @@
-// Pure helpers for editing/navigating a `(value, cursor)` pair, where `value`
-// is the buffer text (potentially multi-line) and `cursor` is a 0-based offset
-// into that string in the half-open range `[0, value.length]`.
-//
-// All operations are pure: they take the current state and return the new
-// state without mutating anything. Keeping the helpers free of any React /
-// Ink dependency makes them trivially unit-testable and cheap to reason
-// about (no hidden ordering, no refs).
-
-export interface BufferState {
-  value: string;
-  cursor: number;
-}
-
-const WORD_RE = /\w/;
-
-function clamp(n: number, min: number, max: number): number {
-  if (n < min) return min;
-  if (n > max) return max;
-  return n;
-}
-
-function clampCursor(value: string, cursor: number): number {
-  return clamp(cursor, 0, value.length);
-}
-
-// ─── Editing ──────────────────────────────────────────────────────────────────
-
-export function insertAt(state: BufferState, text: string): BufferState {
-  if (!text) return state;
-  const cursor = clampCursor(state.value, state.cursor);
-  return {
-    value: state.value.slice(0, cursor) + text + state.value.slice(cursor),
-    cursor: cursor + text.length,
-  };
-}
-
-export function deleteBackward(state: BufferState): BufferState {
-  const cursor = clampCursor(state.value, state.cursor);
-  if (cursor === 0) return state;
-  return {
-    value: state.value.slice(0, cursor - 1) + state.value.slice(cursor),
-    cursor: cursor - 1,
-  };
-}
-
-export function deleteForward(state: BufferState): BufferState {
-  const cursor = clampCursor(state.value, state.cursor);
-  if (cursor >= state.value.length) return state;
-  return {
-    value: state.value.slice(0, cursor) + state.value.slice(cursor + 1),
-    cursor,
-  };
-}
-
-export function deleteWordBackward(state: BufferState): BufferState {
-  const cursor = clampCursor(state.value, state.cursor);
-  if (cursor === 0) return state;
-  const start = wordStart(state.value, cursor);
-  return {
-    value: state.value.slice(0, start) + state.value.slice(cursor),
-    cursor: start,
-  };
-}
-
-/** Kill from cursor to end of line (Emacs-style Ctrl+K). */
-export function killToLineEnd(state: BufferState): BufferState {
-  const cursor = clampCursor(state.value, state.cursor);
-  const eol = lineEnd(state.value, cursor);
-  if (eol === cursor) {
-    // At end of line — eat the newline itself, mirroring Emacs/readline.
-    if (cursor < state.value.length) {
-      return { value: state.value.slice(0, cursor) + state.value.slice(cursor + 1), cursor };
-    }
-    return state;
-  }
-  return { value: state.value.slice(0, cursor) + state.value.slice(eol), cursor };
-}
-
-/** Kill from start of line to cursor (Emacs-style Ctrl+U). */
-export function killToLineStart(state: BufferState): BufferState {
-  const cursor = clampCursor(state.value, state.cursor);
-  const sol = lineStart(state.value, cursor);
-  if (sol === cursor) return state;
-  return { value: state.value.slice(0, sol) + state.value.slice(cursor), cursor: sol };
-}
-
-// ─── Movement ─────────────────────────────────────────────────────────────────
-
-export function moveLeft(state: BufferState): BufferState {
-  const cursor = clampCursor(state.value, state.cursor);
-  return cursor === 0 ? state : { ...state, cursor: cursor - 1 };
-}
-
-export function moveRight(state: BufferState): BufferState {
-  const cursor = clampCursor(state.value, state.cursor);
-  return cursor >= state.value.length ? state : { ...state, cursor: cursor + 1 };
-}
-
-export function moveWordLeft(state: BufferState): BufferState {
-  const cursor = clampCursor(state.value, state.cursor);
-  return { ...state, cursor: wordStart(state.value, cursor) };
-}
-
-export function moveWordRight(state: BufferState): BufferState {
-  const cursor = clampCursor(state.value, state.cursor);
-  return { ...state, cursor: wordEnd(state.value, cursor) };
-}
-
-export function moveLineHome(state: BufferState): BufferState {
-  const cursor = clampCursor(state.value, state.cursor);
-  return { ...state, cursor: lineStart(state.value, cursor) };
-}
-
-export function moveLineEnd(state: BufferState): BufferState {
-  const cursor = clampCursor(state.value, state.cursor);
-  return { ...state, cursor: lineEnd(state.value, cursor) };
-}
-
-/**
- * Move the cursor up one display line. Returns `null` when the cursor is
- * already on the first line — callers can then route the keystroke to history
- * navigation instead of swallowing it. `desiredColumn` makes vertical motion
- * "sticky": it remembers the column the user originally departed from so that
- * traversing a short line and coming back lands in the original column.
- */
-export function moveLineUp(state: BufferState, desiredColumn: number | null): BufferState | null {
-  const { row, col } = cursorRowCol(state.value, state.cursor);
-  if (row === 0) return null;
-  const targetCol = desiredColumn ?? col;
-  return { ...state, cursor: positionAt(state.value, row - 1, targetCol) };
-}
-
-export function moveLineDown(state: BufferState, desiredColumn: number | null): BufferState | null {
-  const { row, col } = cursorRowCol(state.value, state.cursor);
-  const lineCount = countLines(state.value);
-  if (row >= lineCount - 1) return null;
-  const targetCol = desiredColumn ?? col;
-  return { ...state, cursor: positionAt(state.value, row + 1, targetCol) };
-}
-
-// ─── Geometry helpers ─────────────────────────────────────────────────────────
-
-export function cursorRowCol(value: string, cursor: number): { row: number; col: number } {
-  const c = clampCursor(value, cursor);
-  let row = 0;
-  let lastNl = -1;
-  for (let i = 0; i < c; i++) {
-    if (value.charCodeAt(i) === 10) {
-      row++;
-      lastNl = i;
-    }
-  }
-  return { row, col: c - lastNl - 1 };
-}
-
-function countLines(value: string): number {
-  let count = 1;
-  for (let i = 0; i < value.length; i++) {
-    if (value.charCodeAt(i) === 10) count++;
-  }
-  return count;
-}
-
-/** Resolve a `(row, col)` pair back to a flat offset, clamping to the line length. */
-export function positionAt(value: string, row: number, col: number): number {
-  let currentRow = 0;
-  let lineStartIdx = 0;
-  for (let i = 0; i <= value.length; i++) {
-    const isEol = i === value.length || value.charCodeAt(i) === 10;
-    if (currentRow === row && isEol) {
-      const lineLength = i - lineStartIdx;
-      return lineStartIdx + Math.min(col, lineLength);
-    }
-    if (isEol) {
-      currentRow++;
-      lineStartIdx = i + 1;
-    }
-  }
-  return value.length;
-}
-
-function lineStart(value: string, cursor: number): number {
-  for (let i = cursor - 1; i >= 0; i--) {
-    if (value.charCodeAt(i) === 10) return i + 1;
-  }
-  return 0;
-}
-
-function lineEnd(value: string, cursor: number): number {
-  for (let i = cursor; i < value.length; i++) {
-    if (value.charCodeAt(i) === 10) return i;
-  }
-  return value.length;
-}
-
-/**
- * Standard "previous word boundary" semantics: skip whitespace/punctuation
- * backwards, then skip the contiguous word characters. Mirrors what shells
- * (bash/zsh) do for Ctrl+W and Alt+Left.
- */
-function wordStart(value: string, cursor: number): number {
-  let i = cursor;
-  while (i > 0 && !WORD_RE.test(value[i - 1])) i--;
-  while (i > 0 && WORD_RE.test(value[i - 1])) i--;
-  return i;
-}
-
-function wordEnd(value: string, cursor: number): number {
-  let i = cursor;
-  while (i < value.length && !WORD_RE.test(value[i])) i++;
-  while (i < value.length && WORD_RE.test(value[i])) i++;
-  return i;
-}

package/src/tui/input/dumpContext.ts

@@ -1,107 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import type { ChatMessage, PluginRegistry, ProviderConfig, ToolDefinition } from 'mu-core';
-
-/**
- * Render a plain-text view of the full LLM context — the merged system
- * prompt, registered tool definitions, and the message transcript — in the
- * order and shape mirrored from `mu-provider/src/stream.ts buildMessages`.
- *
- * This is a *logical* view: the exact token framing applied on the wire is
- * controlled by the server's per-model chat template (ChatML, Llama-3,
- * Hermes, etc.) and cannot be reproduced client-side. The dump captures
- * what the model semantically receives, which is what matters for
- * estimating token usage and pruning context.
- */
-function mergedSystemPrompt(config: ProviderConfig, pluginPrompts: string[]): string {
-  return pluginPrompts.length > 0
-    ? [config.systemPrompt, ...pluginPrompts].filter(Boolean).join('\n\n')
-    : (config.systemPrompt ?? '');
-}
-
-function renderTools(tools: ToolDefinition[]): string {
-  if (tools.length === 0) return '=== TOOLS (0) ===\n(no tools registered)\n';
-  const blocks = tools.map((t, i) => {
-    // Compact JSON mirrors what gets injected into the system prompt by
-    // most chat templates — pretty-printing here would misrepresent the
-    // actual on-the-wire token cost.
-    const params = JSON.stringify(t.function.parameters);
-    const desc = t.function.description ? ` ${t.function.description}` : '';
-    return `[${i + 1}] ${t.function.name}${desc}\n    parameters: ${params}`;
-  });
-  return `=== TOOLS (${tools.length}) ===\n${blocks.join('\n')}\n`;
-}
-
-function renderUser(m: ChatMessage): string {
-  const lines: string[] = [];
-  const hasImages = (m.images?.length ?? 0) > 0;
-  const text = m.content.trim() || (hasImages ? '(image attached)' : '');
-  if (text) lines.push(text);
-  if (m.images) {
-    for (const img of m.images) {
-      lines.push(`[image: ${img.mimeType}, ${img.name}]`);
-    }
-  }
-  return lines.join('\n');
-}
-
-function renderAssistant(m: ChatMessage): string {
-  const lines: string[] = [];
-  if (m.content) {
-    lines.push(m.content);
-  } else if (m.toolCalls?.length) {
-    lines.push('(no content)');
-  }
-  if (m.toolCalls) {
-    for (const tc of m.toolCalls) {
-      lines.push(`[tool_call id=${tc.id}] ${tc.function.name}(${tc.function.arguments})`);
-    }
-  }
-  return lines.join('\n');
-}
-
-function renderMessage(m: ChatMessage, index: number): string {
-  if (m.role === 'tool') {
-    const header = `--- [${index}] tool (call_id=${m.toolCallId ?? ''}) ---`;
-    return `${header}\n${m.content}`;
-  }
-  const header = `--- [${index}] ${m.role} ---`;
-  let body: string;
-  if (m.role === 'user') body = renderUser(m);
-  else if (m.role === 'assistant') body = renderAssistant(m);
-  else body = m.content; // system / fallback
-  return `${header}\n${body}`;
-}
-
-function renderContext(
-  config: ProviderConfig,
-  messages: ChatMessage[],
-  tools: ToolDefinition[],
-  pluginPrompts: string[],
-): string {
-  const system = mergedSystemPrompt(config, pluginPrompts);
-  const header = `# Logical context view — exact token framing depends on the server-side chat template for model "${config.model ?? '(unset)'}".\n`;
-  const systemBlock = `=== SYSTEM ===\n${system || '(empty)'}\n`;
-  const toolsBlock = renderTools(tools);
-  const messagesHeader = `=== MESSAGES (${messages.length}) ===`;
-  const messagesBlock = messages.map((m, i) => renderMessage(m, i + 1)).join('\n\n');
-  return [header, systemBlock, toolsBlock, messagesHeader, messagesBlock].join('\n');
-}
-
-/**
- * Build the plain-text context view and write it to a temp file. Returns
- * the absolute path so the caller can surface it (e.g. via toast).
- */
-export async function dumpContext(
-  config: ProviderConfig,
-  messages: ChatMessage[],
-  registry: PluginRegistry,
-): Promise<string> {
-  const pluginPrompts = await registry.getSystemPrompts();
-  const tools = registry.getToolDefinitions();
-  const text = renderContext(config, messages, tools, pluginPrompts);
-  const path = join(tmpdir(), `mu-context-${Date.now()}.txt`);
-  await writeFile(path, text, 'utf-8');
-  return path;
-}

package/src/tui/input/sanitize.ts

@@ -1,33 +0,0 @@
-// Matches xterm SGR (1006) mouse-event sequences after Ink has stripped the
-// leading \x1b. Format: \x1b[<button;x;y[Mm]
-//   - M = press / motion
-//   - m = release
-// Examples: "[<0;126;31M", "[<32;36;51M", "[<0;31;51m"
-const SGR_MOUSE_RE = /\[<\d+;\d+;\d+[Mm]/g;
-
-const SGR_MOUSE_EXACT_RE = /^\[<\d+;\d+;\d+[Mm]$/;
-
-/** Single-event chunk (Ink usually delivers one event per input call). */
-export function isMouseSequence(input: string): boolean {
-  return SGR_MOUSE_EXACT_RE.test(input);
-}
-
-/**
- * Strip terminal-input bytes that should never become text:
- *  1. Any embedded SGR mouse-event sequences (clicks/drags/release/wheel).
- *  2. ASCII control bytes < 0x20 *except* \t and \n which paste should keep.
- *
- * Multi-event chunks (e.g. fast clicks batched into one data frame) are
- * handled because the regex is global.
- */
-export function sanitizeTerminalInput(text: string): string {
-  const stripped = text.replace(SGR_MOUSE_RE, '');
-  let out = '';
-  for (const ch of stripped) {
-    const code = ch.charCodeAt(0);
-    if (ch === '\t' || ch === '\n' || code >= 0x20) {
-      out += ch;
-    }
-  }
-  return out;
-}

package/src/tui/input/useCommandExecutor.ts

@@ -1,32 +0,0 @@
-import type { CommandContext, SlashCommand as PluginSlashCommand } from 'mu-core';
-import { useCallback, useMemo } from 'react';
-import { BUILTIN_COMMANDS, fromPluginCommand, type SlashCommand } from './commands';
-import type { InputActions } from './useInputHandler';
-
-interface CommandExecutorOptions {
-  actions: InputActions;
-  context: CommandContext;
-  pluginCommands: PluginSlashCommand[];
-}
-
-export function useCommandExecutor(options: CommandExecutorOptions) {
-  const { actions, context, pluginCommands } = options;
-
-  const commands = useMemo(
-    () => [...BUILTIN_COMMANDS, ...pluginCommands.map((command) => fromPluginCommand(command, context))],
-    [context, pluginCommands],
-  );
-
-  const execute = useCallback(
-    (command: SlashCommand, args: string) => {
-      if (command.execute) {
-        void command.execute(args);
-        return;
-      }
-      command.invoke?.(actions, args);
-    },
-    [actions],
-  );
-
-  return { commands, execute };
-}

package/src/tui/input/useInputBox.ts

@@ -1,265 +0,0 @@
-import type { InputInfoSegment } from 'mu-core';
-import { useCallback, useMemo, useRef } from 'react';
-import { useChatContext } from '../chat/ChatContext';
-import type { InkUIService } from '../plugins/InkUIService';
-import { runUpdateInTui, type UpdateScope } from '../update/runUpdateInTui';
-import { dumpContext } from './dumpContext';
-import type { InputBoxViewProps } from './InputBoxView';
-import { useCommandExecutor } from './useCommandExecutor';
-import { type InputActions, type MentionMode, useInputHandler } from './useInputHandler';
-import { type MentionPickerState, useMentionPicker } from './useMentionPicker';
-import { usePluginShortcuts } from './usePluginShortcuts';
-
-function parseUpdateScope(args: string): UpdateScope | null {
-  const trimmed = args.trim().toLowerCase();
-  if (trimmed === '' || trimmed === 'all') return 'all';
-  if (trimmed === 'plugins') return 'plugins';
-  if (trimmed === 'self' || trimmed === 'mu') return 'self';
-  return null;
-}
-
-export interface InputBoxProps {
-  onSubmit: (text: string) => void;
-  onScrollUp?: () => void;
-  onScrollDown?: () => void;
-  isActive?: boolean;
-  model?: string;
-  history?: string[];
-  /**
-   * Extra info chips rendered in the footer (before the model). Generic
-   * mechanism for upstream consumers to surface context (active agent,
-   * branch, ...) without `InputBox` knowing what they are.
-   */
-  infoSegments?: InputInfoSegment[];
-}
-
-interface BufferDraft {
-  value: string;
-  cursor: number;
-}
-
-/**
- * Replace `[triggerStart, cursor)` (the `<trigger><partial>` token) with the
- * chosen completion value plus a trailing space, so the user is left in a
- * sensible position for further input. File completions drop the trigger
- * (`@`) entirely — the path stands alone in the prompt — while other
- * categories (agents) keep the `@` prefix as a visible marker.
- */
-function applyMention(
-  value: string,
-  triggerStart: number,
-  cursor: number,
-  trigger: string,
-  completion: string,
-  category: string | undefined,
-): BufferDraft {
-  const before = value.slice(0, triggerStart);
-  const after = value.slice(cursor);
-  const keepTrigger = category !== 'files';
-  const insertion = `${keepTrigger ? trigger : ''}${completion} `;
-  return { value: before + insertion + after, cursor: triggerStart + insertion.length };
-}
-
-interface InputHandle {
-  value: string;
-  cursor: number;
-  setBuffer: (value: string, cursor: number) => void;
-}
-
-/**
- * Build the mention-mode controls for the picker that the input handler
- * consumes via a ref. Returns `null` when no completions are available so
- * the handler skips the override and runs the default editing bindings.
- */
-function buildMentionMode(mentions: MentionPickerState, input: InputHandle): MentionMode | null {
-  if (!mentions.trigger || mentions.completions.length === 0) return null;
-  return {
-    active: true,
-    count: mentions.completions.length,
-    selectedIndex: mentions.selectedIndex,
-    next: () => mentions.setSelectedIndex((mentions.selectedIndex + 1) % mentions.completions.length),
-    prev: () =>
-      mentions.setSelectedIndex(
-        mentions.selectedIndex === 0 ? mentions.completions.length - 1 : mentions.selectedIndex - 1,
-      ),
-    accept: () => {
-      const completion = mentions.completions[mentions.selectedIndex];
-      const trig = mentions.trigger;
-      if (!(completion && trig)) return;
-      const draft = applyMention(
-        input.value,
-        mentions.triggerStart,
-        input.cursor,
-        trig,
-        completion.value,
-        completion.category,
-      );
-      input.setBuffer(draft.value, draft.cursor);
-    },
-  };
-}
-
-interface ActionDeps {
-  abort: ReturnType<typeof useChatContext>['abort'];
-  attachment: ReturnType<typeof useChatContext>['attachment'];
-  session: ReturnType<typeof useChatContext>['session'];
-  models: ReturnType<typeof useChatContext>['models'];
-  toggles: ReturnType<typeof useChatContext>['toggles'];
-  onShowContext: () => Promise<void>;
-  onUpdate: (args: string) => void;
-  onScrollUp?: () => void;
-  onScrollDown?: () => void;
-}
-
-function useInputActions(deps: ActionDeps): InputActions {
-  const { abort, attachment, session, models, toggles, onShowContext, onUpdate, onScrollUp, onScrollDown } = deps;
-  return useMemo<InputActions>(
-    () => ({
-      onCtrlC: abort.onCtrlC,
-      onEsc: abort.onEsc,
-      onPaste: attachment.onPaste,
-      onNew: session.onNew,
-      onCompact: () => {
-        void session.onCompact();
-      },
-      onCycleModel: models.cycleModel,
-      onTogglePicker: toggles.onTogglePicker,
-      onToggleSessionPicker: toggles.onToggleSessionPicker,
-      onShowContext,
-      onUpdate,
-      onScrollUp,
-      onScrollDown,
-      modelCount: models.models.length,
-    }),
-    [
-      abort.onCtrlC,
-      abort.onEsc,
-      attachment.onPaste,
-      session.onNew,
-      session.onCompact,
-      models.cycleModel,
-      models.models.length,
-      toggles.onTogglePicker,
-      toggles.onToggleSessionPicker,
-      onShowContext,
-      onUpdate,
-      onScrollUp,
-      onScrollDown,
-    ],
-  );
-}
-
-function useOnUpdate(uiService: InkUIService | undefined) {
-  return useCallback(
-    (args: string) => {
-      if (!uiService) return;
-      const scope = parseUpdateScope(args);
-      if (!scope) {
-        uiService.notify('Usage: /update [plugins|self|all]', 'warning');
-        return;
-      }
-      uiService.notify(scope === 'all' ? 'Starting update…' : `Starting ${scope} update…`, 'info');
-      void runUpdateInTui(scope, uiService);
-    },
-    [uiService],
-  );
-}
-
-const EMPTY_SEGMENTS: InputInfoSegment[] = [];
-
-export function useInputBox({
-  onSubmit,
-  onScrollUp,
-  onScrollDown,
-  isActive = true,
-  model = '',
-  history = [],
-  infoSegments = EMPTY_SEGMENTS,
-}: InputBoxProps): InputBoxViewProps {
-  const { config, session, toggles, attachment, models, abort, registry, uiService } = useChatContext();
-  // Ref pattern: the mention controls depend on the input handler's
-  // `value`/`cursor`, but the handler also needs to reach the controls at key
-  // dispatch time. Pushing the latest snapshot into a ref every render lets
-  // both directions flow without re-calling hooks.
-  const mentionRef = useRef<MentionMode | null>(null);
-
-  const onShowContext = useCallback(async () => {
-    try {
-      const path = await dumpContext(config, session.messages, registry);
-      uiService?.notify(`Context written to ${path}`, 'success');
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : 'Unknown error';
-      uiService?.notify(`Failed to dump context: ${msg}`, 'error');
-    }
-  }, [config, session.messages, registry, uiService]);
-
-  const onUpdate = useOnUpdate(uiService);
-
-  const actions = useInputActions({
-    abort,
-    attachment,
-    session,
-    models,
-    toggles,
-    onShowContext,
-    onUpdate,
-    onScrollUp,
-    onScrollDown,
-  });
-
-  const commandContext = useMemo(
-    () => ({ messages: session.messages, cwd: process.cwd(), config }),
-    [session.messages, config],
-  );
-
-  // `registry.getCommands()` allocates a fresh array each call; cache by
-  // registry identity so `useCommandExecutor`'s memo can hit.
-  const pluginCommands = useMemo(() => registry.getCommands(), [registry]);
-
-  const commandExecutor = useCommandExecutor({
-    actions,
-    context: commandContext,
-    pluginCommands,
-  });
-
-  const { handlers: pluginShortcuts } = usePluginShortcuts(registry);
-
-  const input = useInputHandler({
-    isActive,
-    streaming: session.streaming,
-    history,
-    actions,
-    onSubmit,
-    availableCommands: commandExecutor.commands,
-    onCommand: commandExecutor.execute,
-    pluginShortcuts,
-    mentionRef,
-  });
-
-  const mentions = useMentionPicker(registry, input.value, input.cursor);
-
-  // Update the ref every render so the dispatch closure sees the latest.
-  mentionRef.current = buildMentionMode(mentions, input);
-
-  return {
-    value: input.value,
-    cursor: input.cursor,
-    commands: input.commands,
-    cmdIndex: input.cmdIndex,
-    isCommandMode: input.isCommandMode,
-    streaming: session.streaming,
-    isActive,
-    model,
-    infoSegments,
-    attachmentName: attachment.attachment?.name ?? null,
-    attachmentError: attachment.attachmentError,
-    mentions:
-      mentions.completions.length > 0
-        ? {
-            completions: mentions.completions,
-            selectedIndex: mentions.selectedIndex,
-            partial: mentions.partial,
-          }
-        : null,
-  };
-}