mu-coding 0.13.0 → 0.16.1

package/src/sessions/peek.test.ts

@@ -1,88 +0,0 @@
-/**
- * Verifies the streaming `listSessionsAsync` end-to-end against a tmp data
- * directory laid out exactly like a real `~/.local/share/mu/sessions/<proj>`.
- * The cache is exercised by listing twice and confirming we get the same
- * structural result without re-reading.
- */
-import { afterEach, beforeAll, describe, expect, it } from 'bun:test';
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { clearSessionCache, listSessionsAsync } from './index';
-import { getProjectId } from './project';
-
-const PROJECT_ID = getProjectId();
-
-let tmpRoot: string;
-let sessionsDir: string;
-
-beforeAll(() => {
-  tmpRoot = mkdtempSync(join(tmpdir(), 'mu-peek-'));
-  process.env.XDG_DATA_HOME = tmpRoot;
-  sessionsDir = join(tmpRoot, 'mu', 'sessions', PROJECT_ID);
-  mkdirSync(sessionsDir, { recursive: true });
-});
-
-afterEach(() => {
-  clearSessionCache();
-});
-
-function writeSession(name: string, messages: Array<{ role: string; content: string }>): string {
-  const path = join(sessionsDir, name);
-  writeFileSync(path, `${messages.map((m) => JSON.stringify(m)).join('\n')}\n`);
-  return path;
-}
-
-describe('listSessionsAsync', () => {
-  it('captures message count and the first user preview', async () => {
-    writeSession('2026-01-01.jsonl', [
-      { role: 'user', content: 'hello world' },
-      { role: 'assistant', content: 'hi back' },
-      { role: 'user', content: 'a follow-up' },
-    ]);
-
-    const list = await listSessionsAsync();
-    const entry = list.find((s) => s.name === '2026-01-01');
-    expect(entry).toBeDefined();
-    expect(entry?.messageCount).toBe(3);
-    expect(entry?.preview).toBe('hello world');
-  });
-
-  it('handles malformed lines without crashing', async () => {
-    writeSession('2026-01-02.jsonl', [{ role: 'user', content: 'ok' }]);
-    // Append a junk line outside the structured writer.
-    const broken = join(sessionsDir, '2026-01-03.jsonl');
-    writeFileSync(broken, '{"role":"user","content":"valid"}\n{not-json\n');
-
-    const list = await listSessionsAsync();
-    const entry = list.find((s) => s.name === '2026-01-03');
-    expect(entry?.messageCount).toBe(2);
-    expect(entry?.preview).toBe('valid');
-  });
-
-  it('reports a placeholder when no user message is present', async () => {
-    writeSession('2026-01-04.jsonl', [{ role: 'assistant', content: 'no user here' }]);
-    const list = await listSessionsAsync();
-    const entry = list.find((s) => s.name === '2026-01-04');
-    expect(entry?.preview).toBe('(no user message)');
-  });
-
-  it('truncates long previews to PREVIEW_LENGTH and replaces newlines', async () => {
-    const longMessage = `line one\n${'x'.repeat(200)}`;
-    writeSession('2026-01-05.jsonl', [{ role: 'user', content: longMessage }]);
-    const list = await listSessionsAsync();
-    const entry = list.find((s) => s.name === '2026-01-05');
-    expect(entry?.preview).not.toContain('\n');
-    expect(entry?.preview.length).toBe(80);
-  });
-
-  it('serves cached results on the second call (same mtime)', async () => {
-    writeSession('2026-01-06.jsonl', [{ role: 'user', content: 'cached' }]);
-    const first = await listSessionsAsync();
-    const second = await listSessionsAsync();
-    const a = first.find((s) => s.name === '2026-01-06');
-    const b = second.find((s) => s.name === '2026-01-06');
-    expect(a?.preview).toBe(b?.preview);
-    expect(a?.messageCount).toBe(b?.messageCount);
-  });
-});

package/src/sessions/project.ts

@@ -1,51 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
-
-function findGitRoot(from: string): string | null {
-  try {
-    const root = execFileSync('git', ['rev-parse', '--show-toplevel'], {
-      cwd: from,
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim();
-    return root || null;
-  } catch {
-    return null;
-  }
-}
-
-// The project root is determined once per process — `process.cwd()` doesn't
-// move during a TUI session and shelling out to git on every save is wasteful.
-let cachedRoot: string | null = null;
-
-function getProjectRoot(): string {
-  if (cachedRoot !== null) {
-    return cachedRoot;
-  }
-  const cwd = process.cwd();
-  cachedRoot = findGitRoot(cwd) ?? cwd;
-  return cachedRoot;
-}
-
-let cachedId: string | null = null;
-let cachedName: string | null = null;
-
-export function getProjectId(): string {
-  if (cachedId !== null) {
-    return cachedId;
-  }
-  const root = getProjectRoot();
-  const hash = createHash('sha256').update(root).digest('hex').slice(0, 12);
-  const name = root.split('/').pop() || 'unknown';
-  cachedId = `${name}-${hash}`;
-  return cachedId;
-}
-
-export function getProjectName(): string {
-  if (cachedName !== null) {
-    return cachedName;
-  }
-  const root = getProjectRoot();
-  cachedName = root.split('/').pop() || root;
-  return cachedName;
-}

package/src/tui/channel/tuiChannel.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, it, mock } from 'bun:test';
-import type { ChatMessage, PluginRegistry } from 'mu-core';
-import type { ShutdownFn } from '../../app/shutdown';
-import type { AppConfig } from '../../config/index';
-import type { HostMessageBus } from '../../runtime/messageBus';
-import type { InkUIService } from '../plugins/InkUIService';
-import { createTuiChannel } from './tuiChannel';
-
-// Stub renderApp by mocking the import surface. We can't actually mount Ink
-// in a non-TTY test environment, but we can verify the channel structure
-// and that the registry passed in has the methods the TUI subscribes to.
-const noop = (): void => {
-  /* stub */
-};
-
-const renderArgs: Array<{ registry: PluginRegistry; config: AppConfig }> = [];
-mock.module('../renderApp', () => ({
-  renderApp: (opts: { registry: PluginRegistry; config: AppConfig }) => {
-    renderArgs.push(opts);
-    return {
-      unmount: noop,
-      waitUntilExit: async () => {
-        /* stub */
-      },
-      rerender: noop,
-      cleanup: noop,
-      clear: noop,
-    };
-  },
-}));
-
-const fakeOpts = {
-  config: {} as AppConfig,
-  initialMessages: [] as ChatMessage[],
-  registry: {} as PluginRegistry,
-  messageBus: {} as HostMessageBus,
-  uiService: {} as InkUIService,
-  shutdown: (async () => {
-    /* test shutdown stub */
-  }) as ShutdownFn,
-};
-
-describe('createTuiChannel', () => {
-  it('exposes id="tui"', () => {
-    const ch = createTuiChannel(fakeOpts);
-    expect(ch.id).toBe('tui');
-  });
-
-  it('start is idempotent — second start is a no-op', async () => {
-    const ch = createTuiChannel(fakeOpts);
-    await ch.start();
-    await ch.start(); // should not throw / re-mount
-  });
-
-  it('stop without start is a no-op', async () => {
-    const ch = createTuiChannel(fakeOpts);
-    await ch.stop?.();
-  });
-
-  it('start → stop → start cycles cleanly', async () => {
-    const ch = createTuiChannel(fakeOpts);
-    await ch.start();
-    await ch.stop?.();
-    await ch.start();
-    await ch.stop?.();
-  });
-});
-
-describe('createTuiChannel — registry shape contract', () => {
-  it('forwards a registry that exposes the subscription methods the TUI relies on', async () => {
-    // Build a registry mock whose methods are all functions; the channel's
-    // `start()` calls renderApp which (in production) mounts components that
-    // immediately invoke onStatusChange / onRenderersChange / etc.
-    const stubFn = (): (() => void) => () => {
-      /* unsub */
-    };
-    const fakeRegistry: Record<string, unknown> = {
-      getTools: () => [],
-      getFilteredTools: async () => [],
-      getHooks: () => [],
-      getStatusSegments: () => new Map(),
-      onStatusChange: stubFn(),
-      getRenderers: () => [],
-      onRenderersChange: stubFn(),
-      getShortcuts: () => [],
-      onShortcutsChange: stubFn(),
-      getCommands: () => [],
-    };
-    const ch = createTuiChannel({ ...fakeOpts, registry: fakeRegistry as unknown as PluginRegistry });
-    renderArgs.length = 0;
-    await ch.start();
-    expect(renderArgs).toHaveLength(1);
-    const seen = renderArgs[0].registry as unknown as Record<string, unknown>;
-    for (const method of [
-      'onStatusChange',
-      'getStatusSegments',
-      'onRenderersChange',
-      'getRenderers',
-      'onShortcutsChange',
-      'getShortcuts',
-      'getCommands',
-    ]) {
-      expect(typeof seen[method]).toBe('function');
-    }
-    await ch.stop?.();
-  });
-});

package/src/tui/channel/tuiChannel.ts

@@ -1,62 +0,0 @@
-/**
- * TUI Channel — wraps Ink rendering inside the mu-core `Channel` contract.
- * `start()` mounts the app and captures the Ink instance; `stop()` unmounts
- * it cleanly so `channels.stopAll()` restores the terminal.
- */
-
-import type { Instance } from 'ink';
-import type { SubagentRunRegistry } from 'mu-agents';
-import type { Channel, ChatMessage, PluginRegistry } from 'mu-core';
-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 type { InkUIService } from '../plugins/InkUIService';
-import { renderApp } from '../renderApp';
-
-export interface TuiChannelOptions {
-  config: AppConfig;
-  initialMessages?: ChatMessage[];
-  registry: PluginRegistry;
-  messageBus: HostMessageBus;
-  uiService: InkUIService;
-  shutdown: ShutdownFn;
-  sessionPathHolder?: SessionPathHolder;
-  subagentRuns?: SubagentRunRegistry;
-}
-
-export function createTuiChannel(opts: TuiChannelOptions): Channel {
-  let instance: Instance | null = null;
-  return {
-    id: 'tui',
-    async start() {
-      // Idempotent: re-starting after a stop remounts; re-starting while
-      // mounted is a no-op.
-      if (instance) return;
-      instance = renderApp({
-        config: opts.config,
-        initialMessages: opts.initialMessages,
-        registry: opts.registry,
-        messageBus: opts.messageBus,
-        uiService: opts.uiService,
-        shutdown: opts.shutdown,
-        sessionPathHolder: opts.sessionPathHolder,
-        subagentRuns: opts.subagentRuns,
-      });
-    },
-    async stop() {
-      if (!instance) return;
-      try {
-        instance.unmount();
-        // Wait for Ink's exit promise so `stopAll()` callers know the
-        // terminal has been restored before they continue (e.g. emitting
-        // a final shutdown message to stdout).
-        await instance.waitUntilExit().catch(() => {
-          /* unmount-induced exit rejects with the cause; we don't care */
-        });
-      } finally {
-        instance = null;
-      }
-    },
-  };
-}

package/src/tui/chat/ChatContext.ts

@@ -1,10 +0,0 @@
-import { createContext, useContext } from 'react';
-import type { ChatContextValue } from './useChat';
-
-export const ChatContext = createContext<ChatContextValue | null>(null);
-
-export function useChatContext() {
-  const ctx = useContext(ChatContext);
-  if (!ctx) throw new Error('useChatContext requires ChatProvider');
-  return ctx;
-}

package/src/tui/chat/MessageRendererContext.ts

@@ -1,44 +0,0 @@
-import type { ChatMessage, PluginRegistry } from 'mu-core';
-import { createContext, type ReactNode, useContext, useEffect, useState } from 'react';
-
-/**
- * Plugin renderers are typed `unknown` in mu-agents (kept renderer-agnostic);
- * the host narrows to React at the boundary so renderer authors can return
- * any `ReactNode`.
- */
-type ReactMessageRenderer = (msg: ChatMessage) => ReactNode;
-
-type RendererMap = Map<string, ReactMessageRenderer>;
-
-const MessageRendererContext = createContext<RendererMap>(new Map());
-
-export const MessageRendererProvider = MessageRendererContext.Provider;
-
-/** Hook used by `MessageItem` to look up custom renderers by `customType`. */
-export function useMessageRenderer(customType: string | undefined): ReactMessageRenderer | undefined {
-  const map = useContext(MessageRendererContext);
-  if (!customType) return undefined;
-  return map.get(customType);
-}
-
-/**
- * Track the registry's custom renderer set. Re-builds the map whenever a
- * plugin registers or unregisters one. The cast from `unknown` to ReactNode
- * happens here so descendant components stay strictly typed.
- */
-export function useRegistryRenderers(registry: PluginRegistry): RendererMap {
-  const [map, setMap] = useState<RendererMap>(() => buildMap(registry));
-  useEffect(() => {
-    setMap(buildMap(registry));
-    return registry.onRenderersChange(() => setMap(buildMap(registry)));
-  }, [registry]);
-  return map;
-}
-
-function buildMap(registry: PluginRegistry): RendererMap {
-  const out: RendererMap = new Map();
-  for (const [customType, renderer] of registry.getRenderers()) {
-    out.set(customType, (msg) => renderer(msg) as ReactNode);
-  }
-  return out;
-}

package/src/tui/chat/ToolDisplayContext.ts

@@ -1,33 +0,0 @@
-import type { PluginRegistry, ToolDisplayHint } from 'mu-core';
-import { createContext, useContext, useMemo } from 'react';
-
-type ToolDisplayMap = Map<string, ToolDisplayHint>;
-
-const ToolDisplayContext = createContext<ToolDisplayMap>(new Map());
-
-export const ToolDisplayProvider = ToolDisplayContext.Provider;
-
-/** Hook used by tool renderers to look up rendering hints for a tool name. */
-export function useToolDisplay(name: string): ToolDisplayHint | undefined {
-  const map = useContext(ToolDisplayContext);
-  return map.get(name);
-}
-
-/**
- * Build a lookup table from the registry, keyed by tool function name. Tools
- * without a `display` hint are omitted; the renderer falls back to a generic
- * preview block. Memoized on the registry reference — registration is
- * effectively startup-only today, but the dependency makes the contract
- * explicit if hot-loading lands later.
- */
-export function useToolDisplayMap(registry: PluginRegistry): ToolDisplayMap {
-  return useMemo(() => {
-    const map: ToolDisplayMap = new Map();
-    for (const tool of registry.getTools()) {
-      if (tool.display) {
-        map.set(tool.definition.function.name, tool.display);
-      }
-    }
-    return map;
-  }, [registry]);
-}

package/src/tui/chat/useAbort.ts

@@ -1,85 +0,0 @@
-import { useCallback, useRef, useState } from 'react';
-import { restoreTerminal, type ShutdownFn } from '../../app/shutdown';
-
-function useDoublePress(timeoutMs: number) {
-  const [warning, setWarning] = useState(false);
-  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-
-  const confirm = useCallback(() => {
-    if (warning) {
-      // Confirmed press: cancel the pending auto-reset and clear the
-      // warning flag immediately so the status hint ("Esc again to stop"
-      // / "Ctrl+C again to quit") disappears as soon as the action fires.
-      if (timerRef.current) {
-        clearTimeout(timerRef.current);
-        timerRef.current = null;
-      }
-      setWarning(false);
-      return true;
-    }
-    setWarning(true);
-    if (timerRef.current) {
-      clearTimeout(timerRef.current);
-    }
-    timerRef.current = setTimeout(() => {
-      setWarning(false);
-      timerRef.current = null;
-    }, timeoutMs);
-    return false;
-  }, [warning, timeoutMs]);
-
-  return { warning, confirm };
-}
-
-export interface AbortState {
-  controllerRef: React.RefObject<AbortController | null>;
-  quitWarning: boolean;
-  abortWarning: boolean;
-  onCtrlC: () => void;
-  onEsc: () => void;
-}
-
-export function useAbort(
-  streaming: boolean,
-  controllerRef: React.RefObject<AbortController | null>,
-  exit: () => void,
-  timeoutMs: number,
-  shutdown?: ShutdownFn,
-): AbortState {
-  const { warning: quitWarning, confirm: onCtrlC } = useDoublePress(timeoutMs);
-  const { warning: abortWarning, confirm: onEsc } = useDoublePress(timeoutMs);
-
-  const handleCtrlC = useCallback(() => {
-    if (streaming && controllerRef.current) {
-      controllerRef.current.abort();
-      controllerRef.current = null;
-      return;
-    }
-    if (!onCtrlC()) {
-      return;
-    }
-    // Restore the terminal first so even a hanging shutdown leaves a usable
-    // prompt, then unmount Ink (fires `useScroll`/etc. cleanups), then run
-    // the registry shutdown which `process.exit`s when complete.
-    restoreTerminal();
-    exit();
-    if (shutdown) {
-      void shutdown(0);
-    } else {
-      // Fallback for callers that didn't wire a shutdown function.
-      setTimeout(() => process.exit(0), 500);
-    }
-  }, [streaming, onCtrlC, exit, controllerRef, shutdown]);
-
-  const handleEsc = useCallback(() => {
-    if (!(streaming && controllerRef.current)) {
-      return;
-    }
-    if (onEsc()) {
-      controllerRef.current.abort();
-      controllerRef.current = null;
-    }
-  }, [streaming, onEsc, controllerRef]);
-
-  return { controllerRef, quitWarning, abortWarning, onCtrlC: handleCtrlC, onEsc: handleEsc };
-}

package/src/tui/chat/useAttachment.ts

@@ -1,74 +0,0 @@
-import type { ImageAttachment } from 'mu-core';
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { readClipboardImage } from '../../utils/clipboard';
-
-const ERROR_TIMEOUT_MS = 3000;
-
-export interface AttachmentState {
-  attachment: ImageAttachment | null;
-  attachmentError: string | null;
-  onPaste: () => void;
-  clear: () => void;
-}
-
-export function useAttachment(): AttachmentState {
-  const [attachment, setAttachment] = useState<ImageAttachment | null>(null);
-  const [attachmentError, setAttachmentError] = useState<string | null>(null);
-  const errorTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-
-  const cancelErrorTimer = useCallback(() => {
-    if (errorTimerRef.current) {
-      clearTimeout(errorTimerRef.current);
-      errorTimerRef.current = null;
-    }
-  }, []);
-
-  // Cancel any pending error-clear timer if the component unmounts.
-  useEffect(() => cancelErrorTimer, [cancelErrorTimer]);
-
-  const onPaste = useCallback(() => {
-    cancelErrorTimer();
-    const img = readClipboardImage();
-    if (img) {
-      setAttachment(img);
-      setAttachmentError(null);
-      return;
-    }
-    setAttachmentError('No image on clipboard');
-    errorTimerRef.current = setTimeout(() => {
-      setAttachmentError(null);
-      errorTimerRef.current = null;
-    }, ERROR_TIMEOUT_MS);
-  }, [cancelErrorTimer]);
-
-  const clear = useCallback(() => {
-    cancelErrorTimer();
-    setAttachment(null);
-    setAttachmentError(null);
-  }, [cancelErrorTimer]);
-
-  return { attachment, attachmentError, onPaste, clear };
-}
-
-type PickerKind = 'model' | 'sessions' | null;
-
-export interface TogglesState {
-  showModelPicker: boolean;
-  showSessionPicker: boolean;
-  onTogglePicker: () => void;
-  onToggleSessionPicker: () => void;
-}
-
-/**
- * At most one picker is visible at a time. Toggling on a picker while the
- * other is open swaps to the new one rather than stacking modals.
- */
-export function useToggles(): TogglesState {
-  const [picker, setPicker] = useState<PickerKind>(null);
-  return {
-    showModelPicker: picker === 'model',
-    showSessionPicker: picker === 'sessions',
-    onTogglePicker: useCallback(() => setPicker((p) => (p === 'model' ? null : 'model')), []),
-    onToggleSessionPicker: useCallback(() => setPicker((p) => (p === 'sessions' ? null : 'sessions')), []),
-  };
-}

package/src/tui/chat/useChat.ts

@@ -1,113 +0,0 @@
-import { useApp } from 'ink';
-import type { SubagentRunRegistry } from 'mu-agents';
-import {
-  type ChatMessage,
-  createSessionManager,
-  type PluginRegistry,
-  type ProviderConfig,
-  type SessionManager,
-} from 'mu-core';
-import { useEffect, useMemo, useRef, useState } from 'react';
-import type { ShutdownFn } from '../../app/shutdown';
-import type { SessionPathHolder } from '../../runtime/createRegistry';
-import type { HostMessageBus } from '../../runtime/messageBus';
-import { listSessionsAsync, type SessionInfo } from '../../sessions/index';
-import type { InkUIService } from '../plugins/InkUIService';
-import { type AbortState, useAbort } from './useAbort';
-import { type AttachmentState, type TogglesState, useAttachment, useToggles } from './useAttachment';
-import { type ChatSessionState, useChatSession } from './useChatSession';
-import { type ModelListState, useModelList } from './useModels';
-
-const ABORT_TIMEOUT_MS = 2000;
-
-export interface ChatContextValue {
-  config: ProviderConfig;
-  session: ChatSessionState;
-  sessionManager: SessionManager;
-  toggles: TogglesState;
-  attachment: AttachmentState;
-  models: ModelListState;
-  abort: AbortState;
-  sessions: SessionInfo[];
-  registry: PluginRegistry;
-  uiService?: InkUIService;
-  messageBus?: HostMessageBus;
-  subagentRuns?: SubagentRunRegistry;
-}
-
-export function useChat(
-  config: ProviderConfig,
-  registry: PluginRegistry,
-  initialMessages?: ChatMessage[],
-  shutdown?: ShutdownFn,
-  uiService?: InkUIService,
-  messageBus?: HostMessageBus,
-  sessionPathHolder?: SessionPathHolder,
-  subagentRuns?: SubagentRunRegistry,
-): ChatContextValue {
-  const { exit } = useApp();
-  const controllerRef = useRef<AbortController | null>(null);
-  const attachment = useAttachment();
-  const toggles = useToggles();
-  const models = useModelList(config.baseUrl, config.model);
-  // Stable SessionManager + Session for the lifetime of the chat hook. Model
-  // updates flow through `runTurn(options)` per call, so we don't need to
-  // re-instantiate on every change.
-  const sessionManager = useMemo(
-    () => createSessionManager({ registry, config, model: models.currentModel || config.model || 'unknown' }),
-    [registry, config, models.currentModel],
-  );
-  const muSession = useMemo(
-    () => sessionManager.getOrCreate('tui', { initialMessages }),
-    [sessionManager, initialMessages],
-  );
-  const session = useChatSession({
-    session: muSession,
-    config,
-    currentModel: models.currentModel,
-    attachment,
-    controllerRef,
-    initialMessages,
-    registry,
-    messageBus,
-    sessionPathHolder,
-  });
-  const abort = useAbort(session.streaming, controllerRef, exit, ABORT_TIMEOUT_MS, shutdown);
-
-  // Stream the session list asynchronously when the picker opens. Empty until
-  // the first listing settles; subsequent opens hit the in-memory peek cache
-  // so they're effectively instant.
-  const [sessions, setSessions] = useState<SessionInfo[]>([]);
-  useEffect(() => {
-    if (!toggles.showSessionPicker) {
-      setSessions([]);
-      return;
-    }
-    let cancelled = false;
-    listSessionsAsync()
-      .then((list) => {
-        if (!cancelled) setSessions(list);
-      })
-      .catch(() => {
-        if (!cancelled) setSessions([]);
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [toggles.showSessionPicker]);
-
-  return {
-    config,
-    session,
-    sessionManager,
-    toggles,
-    attachment,
-    models,
-    abort,
-    sessions,
-    registry,
-    uiService,
-    messageBus,
-    subagentRuns,
-  };
-}