mu-coding 0.13.0 → 0.16.1

package/src/tui/plugins/InkUIService.ts

@@ -1,188 +0,0 @@
-import type { UIService } from 'mu-core';
-
-export type DialogType = 'confirm' | 'select' | 'input';
-
-export interface DialogRequest {
-  id: number;
-  type: DialogType;
-  title: string;
-  message?: string;
-  options?: string[];
-  placeholder?: string;
-  resolve: (value: unknown) => void;
-}
-
-export interface ToastRequest {
-  message: string;
-  level: 'info' | 'success' | 'warning' | 'error';
-}
-
-let nextDialogId = 0;
-
-type ToastListener = (toast: ToastRequest) => void;
-type StatusListener = (entries: Map<string, string>) => void;
-
-/**
- * InkUIService bridges plugin UI requests with Ink's React rendering.
- *
- * All event channels (dialogs, toasts, status) follow the same multi-listener
- * pattern: `subscribe`/`onToast`/`onStatusChange` return an unsubscribe
- * function. This lets multiple components observe the same service safely
- * (e.g. during hot-reload or component swaps) without one handler clobbering
- * another.
- *
- * Toasts emitted before any listener subscribes are buffered and replayed
- * to the first subscriber; this avoids losing plugin-load errors emitted
- * before the TUI mounts.
- *
- * Implements `UIService` from `mu-agents` — gives nominal typing so a
- * change on either side fails the build.
- */
-export class InkUIService implements UIService {
-  private dialogQueue: DialogRequest[] = [];
-  private dialogSubscribers: Set<() => void> = new Set();
-  private toastListeners: Set<ToastListener> = new Set();
-  private pendingToasts: ToastRequest[] = [];
-  private statusMap: Map<string, string> = new Map();
-  private statusListeners: Set<StatusListener> = new Set();
-
-  // ─── Dialog Subscription (used by DialogLayer) ──────────────────────────
-
-  subscribe(fn: () => void): () => void {
-    this.dialogSubscribers.add(fn);
-    return () => {
-      this.dialogSubscribers.delete(fn);
-    };
-  }
-
-  private notifyDialogSubscribers(): void {
-    for (const fn of this.dialogSubscribers) {
-      fn();
-    }
-  }
-
-  /** Get the current dialog at the front of the queue */
-  currentDialog(): DialogRequest | null {
-    return this.dialogQueue[0] ?? null;
-  }
-
-  /** Resolve the current dialog and advance the queue */
-  resolveDialog(value: unknown): void {
-    const dialog = this.dialogQueue.shift();
-    if (dialog) {
-      dialog.resolve(value);
-      this.notifyDialogSubscribers();
-    }
-  }
-
-  /** Cancel/dismiss the current dialog */
-  cancelDialog(): void {
-    const dialog = this.dialogQueue.shift();
-    if (dialog) {
-      dialog.resolve(dialog.type === 'confirm' ? false : null);
-      this.notifyDialogSubscribers();
-    }
-  }
-
-  // ─── Toast ──────────────────────────────────────────────────────────────
-
-  /**
-   * Subscribe to toast events. Returns an unsubscribe function. If toasts
-   * were emitted before any listener attached, they are replayed to the
-   * first subscriber once.
-   */
-  onToast(callback: ToastListener): () => void {
-    this.toastListeners.add(callback);
-    if (this.pendingToasts.length > 0) {
-      const buffered = this.pendingToasts;
-      this.pendingToasts = [];
-      for (const toast of buffered) {
-        callback(toast);
-      }
-    }
-    return () => {
-      this.toastListeners.delete(callback);
-    };
-  }
-
-  // ─── Status ─────────────────────────────────────────────────────────────
-
-  onStatusChange(callback: StatusListener): () => void {
-    this.statusListeners.add(callback);
-    return () => {
-      this.statusListeners.delete(callback);
-    };
-  }
-
-  private emitStatus(): void {
-    for (const fn of this.statusListeners) {
-      fn(this.statusMap);
-    }
-  }
-
-  getStatusEntries(): Map<string, string> {
-    return new Map(this.statusMap);
-  }
-
-  // ─── Plugin UI Methods ──────────────────────────────────────────────────
-
-  notify(message: string, level?: 'info' | 'success' | 'warning' | 'error'): void {
-    const toast: ToastRequest = { message, level: level ?? 'info' };
-    if (this.toastListeners.size === 0) {
-      this.pendingToasts.push(toast);
-      return;
-    }
-    for (const listener of this.toastListeners) {
-      listener(toast);
-    }
-  }
-
-  confirm(title: string, message: string): Promise<boolean> {
-    return new Promise((resolve) => {
-      this.dialogQueue.push({
-        id: nextDialogId++,
-        type: 'confirm',
-        title,
-        message,
-        resolve: resolve as (value: unknown) => void,
-      });
-      this.notifyDialogSubscribers();
-    });
-  }
-
-  select(title: string, options: string[]): Promise<string | null> {
-    return new Promise((resolve) => {
-      this.dialogQueue.push({
-        id: nextDialogId++,
-        type: 'select',
-        title,
-        options,
-        resolve: resolve as (value: unknown) => void,
-      });
-      this.notifyDialogSubscribers();
-    });
-  }
-
-  input(title: string, placeholder?: string): Promise<string | null> {
-    return new Promise((resolve) => {
-      this.dialogQueue.push({
-        id: nextDialogId++,
-        type: 'input',
-        title,
-        placeholder,
-        resolve: resolve as (value: unknown) => void,
-      });
-      this.notifyDialogSubscribers();
-    });
-  }
-
-  setStatus(key: string, text: string): void {
-    this.statusMap.set(key, text);
-    this.emitStatus();
-  }
-
-  clearStatus(key: string): void {
-    this.statusMap.delete(key);
-    this.emitStatus();
-  }
-}

package/src/tui/renderApp.tsx

@@ -1,64 +0,0 @@
-import { type Instance, render } from 'ink';
-import { type SubagentRunRegistry, SubagentRunsProvider } from 'mu-agents';
-import type { ChatMessage, PluginRegistry } from 'mu-core';
-import type { ReactNode } from 'react';
-import type { ShutdownFn } from '../app/shutdown';
-import type { AppConfig } from '../config/index';
-import type { SessionPathHolder } from '../runtime/createRegistry';
-import type { HostMessageBus } from '../runtime/messageBus';
-import { ChatPanel } from './components/chat/ChatPanel';
-import { ThemeProvider } from './context/ThemeContext';
-import type { InkUIService } from './plugins/InkUIService';
-import { resolveTheme } from './theme';
-
-interface RenderAppOptions {
-  config: AppConfig;
-  initialMessages?: ChatMessage[];
-  registry: PluginRegistry;
-  messageBus: HostMessageBus;
-  uiService: InkUIService;
-  shutdown: ShutdownFn;
-  sessionPathHolder?: SessionPathHolder;
-  subagentRuns?: SubagentRunRegistry;
-}
-
-/**
- * Optionally wrap children with the subagent-runs provider so the
- * `↳ subagent` header renderer can subscribe to live status updates.
- * Wrapping is conditional because hosts that disabled the agent plugin
- * have no registry to provide.
- */
-function withSubagentProvider(runs: SubagentRunRegistry | undefined, children: ReactNode): ReactNode {
-  if (!runs) return <>{children}</>;
-  return <SubagentRunsProvider registry={runs}>{children}</SubagentRunsProvider>;
-}
-
-/**
- * Renders the chat TUI and returns the Ink `Instance` so callers (the TUI
- * channel, tests) can unmount it explicitly. Ink stays mounted until the
- * caller invokes `instance.unmount()` or the process exits.
- */
-export function renderApp(options: RenderAppOptions): Instance {
-  const theme = resolveTheme(options.config.theme);
-  return render(
-    <ThemeProvider theme={theme}>
-      {withSubagentProvider(
-        options.subagentRuns,
-        <ChatPanel
-          config={options.config}
-          initialMessages={options.initialMessages}
-          registry={options.registry}
-          messageBus={options.messageBus}
-          uiService={options.uiService}
-          shutdown={options.shutdown}
-          sessionPathHolder={options.sessionPathHolder}
-          subagentRuns={options.subagentRuns}
-        />,
-      )}
-    </ThemeProvider>,
-    {
-      exitOnCtrlC: false,
-      kittyKeyboard: { mode: 'enabled' },
-    },
-  );
-}

package/src/tui/theme/index.ts

@@ -1 +0,0 @@
-export { resolveTheme } from './merge';

package/src/tui/theme/merge.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { mergeTheme, resolveTheme } from './merge';
-import { DEFAULT_THEME } from './presets';
-
-describe('mergeTheme', () => {
-  it('returns the base theme untouched when no override is provided', () => {
-    expect(mergeTheme(DEFAULT_THEME)).toBe(DEFAULT_THEME);
-  });
-
-  it('merges leaf overrides without dropping siblings', () => {
-    const merged = mergeTheme(DEFAULT_THEME, { input: { cursor: '#ff00ff' } });
-    expect(merged.input.cursor).toBe('#ff00ff');
-    expect(merged.input.background).toBe(DEFAULT_THEME.input.background);
-    expect(merged.user).toEqual(DEFAULT_THEME.user);
-  });
-
-  it('does not mutate the base theme', () => {
-    const before = DEFAULT_THEME.input.cursor;
-    mergeTheme(DEFAULT_THEME, { input: { cursor: '#000000' } });
-    expect(DEFAULT_THEME.input.cursor).toBe(before);
-  });
-
-  it('ignores non-object sections defensively', () => {
-    // biome-ignore lint/suspicious/noExplicitAny: testing malformed user input on purpose
-    const merged = mergeTheme(DEFAULT_THEME, { input: 'red' as any });
-    expect(merged.input).toEqual(DEFAULT_THEME.input);
-  });
-});
-
-describe('resolveTheme', () => {
-  it('returns the default theme when config is undefined', () => {
-    expect(resolveTheme(undefined)).toBe(DEFAULT_THEME);
-  });
-
-  it('applies overrides on top of the default theme', () => {
-    const theme = resolveTheme({ user: { border: 'magenta' } });
-    expect(theme.user.border).toBe('magenta');
-    expect(theme.input).toEqual(DEFAULT_THEME.input);
-  });
-
-  it('returns default for non-object input', () => {
-    // biome-ignore lint/suspicious/noExplicitAny: malformed value
-    expect(resolveTheme(42 as any)).toBe(DEFAULT_THEME);
-    // biome-ignore lint/suspicious/noExplicitAny: malformed value
-    expect(resolveTheme(null as any)).toBe(DEFAULT_THEME);
-    // biome-ignore lint/suspicious/noExplicitAny: string presets are no longer supported
-    expect(resolveTheme('dark' as any)).toBe(DEFAULT_THEME);
-  });
-});

package/src/tui/theme/merge.ts

@@ -1,43 +0,0 @@
-import { DEFAULT_THEME } from './presets';
-import type { PartialTheme, Theme, ThemeConfig } from './types';
-
-/**
- * Two-level deep merge tailored to the `Theme` shape: each top-level key maps
- * to an object of color leaves (strings), so we never need recursion beyond
- * one nesting level. Keeping it flat avoids accidentally merging into nested
- * structures users haven't opted into and also avoids `any`/recursion that
- * would trip Biome's complexity rules.
- */
-function mergeTheme(base: Theme, override?: PartialTheme): Theme {
-  if (!override) return base;
-  const out: Theme = { ...base };
-  const keys = Object.keys(override) as (keyof Theme)[];
-  for (const key of keys) {
-    mergeSection(out, base, override, key);
-  }
-  return out;
-}
-
-function mergeSection<K extends keyof Theme>(out: Theme, base: Theme, override: PartialTheme, key: K): void {
-  const section = override[key];
-  if (section && typeof section === 'object') {
-    out[key] = { ...base[key], ...section };
-  }
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-/**
- * Resolve the user-supplied `theme` field from config.json into a fully
- * populated `Theme`. Tolerates malformed input (wrong type) by silently
- * falling back to the default — config corruption should never crash the TUI.
- */
-export function resolveTheme(config: ThemeConfig | undefined): Theme {
-  if (config === undefined) return DEFAULT_THEME;
-  if (!isPlainObject(config)) return DEFAULT_THEME;
-  return mergeTheme(DEFAULT_THEME, config as PartialTheme);
-}
-
-export { mergeTheme };

package/src/tui/theme/presets.ts

@@ -1,90 +0,0 @@
-import type { Theme } from './types';
-
-/**
- * The single built-in theme. Reproduces the exact hard-coded colors that
- * lived inline in the components prior to the theme extraction — using it
- * must be a visual no-op. Users may still override individual leaves via
- * the `theme` field in their config.
- */
-export const DEFAULT_THEME: Theme = {
-  input: {
-    background: '#222222',
-    text: 'white',
-    cursor: 'white',
-    commandHighlight: 'green',
-    footerHint: 'gray',
-    attachmentName: 'cyan',
-    attachmentError: 'red',
-    modelLabel: 'white',
-  },
-  user: {
-    background: '#1a1a1a',
-    border: 'yellow',
-    attachment: 'cyan',
-  },
-  assistant: {
-    text: 'white',
-  },
-  tool: {
-    success: 'green',
-    error: 'red',
-    previewBackground: '#2a2a2a',
-    previewText: 'white',
-    summaryDim: 'gray',
-    warning: 'yellow',
-  },
-  reasoning: {
-    title: 'yellow',
-    body: 'gray',
-  },
-  modal: {
-    background: '#1a1a1a',
-    hint: 'gray',
-  },
-  toast: {
-    background: '#1a1a1a',
-    defaultColor: 'green',
-    closeHint: 'gray',
-  },
-  dropdown: {
-    selected: 'green',
-    description: 'gray',
-    placeholder: 'gray',
-    cursor: 'white',
-    empty: 'gray',
-  },
-  dialog: {
-    confirmYes: 'green',
-    confirmNo: 'red',
-    hint: 'gray',
-    cursor: 'white',
-    placeholder: 'gray',
-  },
-  diff: {
-    added: 'green',
-    removed: 'red',
-    context: 'gray',
-    warning: 'yellow',
-  },
-  status: {
-    separator: 'gray',
-  },
-  markdown: {
-    heading: 'cyan',
-    codeBackground: '#2a2a2a',
-    codeText: 'yellow',
-    codeBlockBackground: '#2a2a2a',
-    codeBlockText: 'white',
-    link: 'cyan',
-    blockquote: 'gray',
-    bullet: 'cyan',
-    tableBorder: 'gray',
-  },
-  common: {
-    error: 'red',
-    warning: 'yellow',
-    success: 'green',
-    accent: 'cyan',
-    info: 'blue',
-  },
-};

package/src/tui/theme/types.ts

@@ -1,138 +0,0 @@
-// Theme type definitions. Kept free of any Ink import so the type can travel
-// to `config/index.ts` without dragging the renderer into the config layer.
-//
-// Color values are plain strings: either an Ink-supported color name
-// ("red", "cyan", "yellow"...) or a hex code ("#1a1a1a"). All optional fields
-// in `PartialTheme` mirror this so users can override one leaf at a time
-// without having to redeclare a full theme.
-
-interface ThemeInput {
-  background: string;
-  text: string;
-  cursor: string;
-  commandHighlight: string;
-  footerHint: string;
-  attachmentName: string;
-  attachmentError: string;
-  modelLabel: string;
-}
-
-interface ThemeUser {
-  background: string;
-  border: string;
-  attachment: string;
-}
-
-interface ThemeAssistant {
-  text: string;
-}
-
-interface ThemeTool {
-  success: string;
-  error: string;
-  previewBackground: string;
-  previewText: string;
-  summaryDim: string;
-  warning: string;
-}
-
-interface ThemeReasoning {
-  title: string;
-  body: string;
-}
-
-interface ThemeModal {
-  background: string;
-  hint: string;
-}
-
-interface ThemeToast {
-  background: string;
-  defaultColor: string;
-  closeHint: string;
-}
-
-interface ThemeDropdown {
-  selected: string;
-  description: string;
-  placeholder: string;
-  cursor: string;
-  empty: string;
-}
-
-interface ThemeDialog {
-  confirmYes: string;
-  confirmNo: string;
-  hint: string;
-  cursor: string;
-  placeholder: string;
-}
-
-interface ThemeDiff {
-  added: string;
-  removed: string;
-  context: string;
-  warning: string;
-}
-
-interface ThemeStatus {
-  separator: string;
-}
-
-interface ThemeMarkdown {
-  /** Heading text color (h1/h2/h3 share this color, h1 is also bold). */
-  heading: string;
-  /** Inline code background. */
-  codeBackground: string;
-  /** Inline code text color. */
-  codeText: string;
-  /** Fenced code-block background. */
-  codeBlockBackground: string;
-  /** Fenced code-block text color. */
-  codeBlockText: string;
-  /** Link `[label](url)` rendering — label color. */
-  link: string;
-  /** Blockquote (`> …`) text color (also dimmed). */
-  blockquote: string;
-  /** List bullet color. */
-  bullet: string;
-  /** Table border color. */
-  tableBorder: string;
-}
-
-interface ThemeCommon {
-  error: string;
-  warning: string;
-  success: string;
-  accent: string;
-  info: string;
-}
-
-export interface Theme {
-  input: ThemeInput;
-  user: ThemeUser;
-  assistant: ThemeAssistant;
-  tool: ThemeTool;
-  reasoning: ThemeReasoning;
-  modal: ThemeModal;
-  toast: ThemeToast;
-  dropdown: ThemeDropdown;
-  dialog: ThemeDialog;
-  diff: ThemeDiff;
-  status: ThemeStatus;
-  markdown: ThemeMarkdown;
-  common: ThemeCommon;
-}
-
-type DeepPartial<T> = {
-  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
-};
-
-export type PartialTheme = DeepPartial<Theme>;
-
-/**
- * Shape stored in `~/.config/mu/config.json` under the `theme` key. An object
- * with per-leaf overrides on top of the default theme. Kept loose on purpose:
- * malformed input falls back to the default theme rather than throwing.
- */
-export type ThemeConfig = PartialTheme;

package/src/tui/update/runUpdateInTui.ts

@@ -1,127 +0,0 @@
-/**
- * TUI-friendly update runner — same semantics as `mu update` from the CLI,
- * but never writes to stdout/stderr (Ink owns the terminal). Progress and
- * results are surfaced as toasts via `uiService.notify`.
- *
- * Mirrors `cli/update.ts` but uses `child_process.execFile` with `stdio:
- * 'pipe'` so subprocess output is buffered, not streamed to the TUI's tty.
- */
-
-import { execFile } from 'node:child_process';
-import { realpathSync } from 'node:fs';
-import { promisify } from 'node:util';
-import { ensureDataDir } from '../../cli/install';
-import { invalidateUpdateCheckCache } from '../../runtime/startupUpdateCheck';
-import { listConfiguredNpmPlugins, PACKAGE_NAME } from '../../runtime/updateCheck';
-import type { InkUIService } from '../plugins/InkUIService';
-
-const execFileAsync = promisify(execFile);
-
-export type UpdateScope = 'all' | 'plugins' | 'self';
-
-interface SelfInstallStrategy {
-  manager: 'bun' | 'npm' | 'pnpm' | 'yarn' | 'unknown';
-  command?: [string, string[]];
-}
-
-function detectSelfInstall(): SelfInstallStrategy {
-  let bin = process.argv[1] ?? '';
-  try {
-    bin = realpathSync(bin);
-  } catch {
-    // keep raw argv
-  }
-  const norm = bin.replace(/\\/g, '/');
-  if (norm.includes('/.bun/') || norm.includes('/bun/install/')) {
-    return { manager: 'bun', command: ['bun', ['add', '-g', `${PACKAGE_NAME}@latest`]] };
-  }
-  if (norm.includes('/pnpm/')) {
-    return { manager: 'pnpm', command: ['pnpm', ['add', '-g', `${PACKAGE_NAME}@latest`]] };
-  }
-  if (norm.includes('/.yarn/') || norm.includes('/yarn/global/')) {
-    return { manager: 'yarn', command: ['yarn', ['global', 'add', `${PACKAGE_NAME}@latest`]] };
-  }
-  if (norm.includes('/npm/') || norm.includes('node_modules/.bin/mu')) {
-    return { manager: 'npm', command: ['npm', ['i', '-g', `${PACKAGE_NAME}@latest`]] };
-  }
-  return { manager: 'unknown' };
-}
-
-async function updatePlugin(name: string, dataDir: string): Promise<boolean> {
-  try {
-    await execFileAsync('bun', ['update', '--latest', name], { cwd: dataDir });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function updatePlugins(ui: InkUIService): Promise<{ ok: number; failed: number; total: number }> {
-  const dataDir = ensureDataDir();
-  const names = listConfiguredNpmPlugins();
-  if (names.length === 0) return { ok: 0, failed: 0, total: 0 };
-
-  let ok = 0;
-  let failed = 0;
-  for (const name of names) {
-    ui.notify(`Updating ${name}…`, 'info');
-    if (await updatePlugin(name, dataDir)) ok += 1;
-    else {
-      failed += 1;
-      ui.notify(`Failed to update ${name}`, 'error');
-    }
-  }
-  return { ok, failed, total: names.length };
-}
-
-async function updateSelf(ui: InkUIService): Promise<boolean> {
-  const strategy = detectSelfInstall();
-  if (!strategy.command) {
-    ui.notify(`Cannot auto-detect mu's installer. Re-install manually: bun add -g ${PACKAGE_NAME}@latest`, 'warning');
-    return false;
-  }
-  const [bin, args] = strategy.command;
-  ui.notify(`Updating mu via ${strategy.manager}…`, 'info');
-  try {
-    await execFileAsync(bin, args);
-    ui.notify('mu updated. Restart your session to pick up the new version.', 'success');
-    return true;
-  } catch (err) {
-    const message = err instanceof Error ? err.message.split('\n')[0] : String(err);
-    ui.notify(`Failed to update mu: ${message}`, 'error');
-    return false;
-  }
-}
-
-/**
- * Entry point used by the `/update` slash command. Fire-and-forget — the
- * caller voids the returned promise. All progress / errors land in toasts.
- */
-export async function runUpdateInTui(scope: UpdateScope, ui: InkUIService): Promise<void> {
-  if (scope === 'plugins') {
-    const { ok, failed, total } = await updatePlugins(ui);
-    if (total === 0) ui.notify('No npm plugins configured.', 'info');
-    else if (failed === 0) ui.notify(`Updated ${ok}/${total} plugin${total === 1 ? '' : 's'}.`, 'success');
-    else ui.notify(`Plugins: ${ok} updated, ${failed} failed.`, 'warning');
-    invalidateUpdateCheckCache();
-    return;
-  }
-
-  if (scope === 'self') {
-    await updateSelf(ui);
-    invalidateUpdateCheckCache();
-    return;
-  }
-
-  // 'all'
-  const plugins = await updatePlugins(ui);
-  const selfOk = await updateSelf(ui);
-  if (plugins.total === 0 && selfOk) {
-    // mu-only success already toasted; nothing to add
-  } else if (plugins.failed === 0 && selfOk) {
-    ui.notify('Update complete.', 'success');
-  } else {
-    ui.notify('Update finished with errors — see prior messages.', 'warning');
-  }
-  invalidateUpdateCheckCache();
-}