mu-coding 0.4.0 → 0.8.0

package/src/tui/chat/useChat.ts

@@ -0,0 +1,106 @@
+import { useApp } from 'ink';
+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 { 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;
+}
+
+export function useChat(
+  config: ProviderConfig,
+  registry: PluginRegistry,
+  initialMessages?: ChatMessage[],
+  shutdown?: ShutdownFn,
+  uiService?: InkUIService,
+  messageBus?: HostMessageBus,
+): 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,
+  });
+  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,
+  };
+}

package/src/tui/chat/useChatPanel.ts

@@ -0,0 +1,98 @@
+import { type DOMElement as InkDOMElement, useInput } from 'ink';
+import type { ChatMessage, PluginRegistry, ProviderConfig } from 'mu-core';
+import { useEffect, useMemo, useRef } from 'react';
+import type { ShutdownFn } from '../../app/shutdown';
+import type { HostMessageBus } from '../../runtime/messageBus';
+import type { ChatPanelBodyProps } from '../components/chat/ChatPanelBody';
+import { useToast } from '../components/primitives/toast';
+import { useScroll } from '../hooks/useScroll';
+import { useMeasure, useTerminalSize } from '../hooks/useTerminal';
+import type { InkUIService, ToastRequest } from '../plugins/InkUIService';
+import { useChat } from './useChat';
+import { usePluginStatus } from './usePluginStatus';
+import { useStatusSegments } from './useStatusSegments';
+
+const TOAST_LEVEL_COLORS: Record<string, string> = {
+  info: 'cyan',
+  success: 'green',
+  warning: 'yellow',
+  error: 'red',
+};
+
+interface UseChatPanelOptions {
+  config: ProviderConfig;
+  initialMessages?: ChatMessage[];
+  registry: PluginRegistry;
+  messageBus?: HostMessageBus;
+  uiService?: InkUIService;
+  shutdown?: ShutdownFn;
+}
+
+export function useChatPanel(options: UseChatPanelOptions) {
+  const { config, initialMessages, registry, messageBus, uiService, shutdown } = options;
+  const ctx = useChat(config, registry, initialMessages, shutdown, uiService, messageBus);
+  const { width, height } = useTerminalSize();
+  const viewRef = useRef<InkDOMElement>(null);
+  const contentRef = useRef<InkDOMElement>(null);
+  // The composite key only needs to change when content visible to the layout
+  // shifts: number of messages or active stream length. Mapping over every
+  // message's content per render was O(n) wasted work.
+  const measureKey = useMemo(
+    () =>
+      [ctx.session.messages.length, ctx.session.stream.text.length, ctx.session.stream.reasoning?.length ?? 0].join(
+        '|',
+      ),
+    [ctx.session.messages.length, ctx.session.stream.text.length, ctx.session.stream.reasoning?.length],
+  );
+  const { viewHeight, contentHeight } = useMeasure(viewRef, contentRef, measureKey);
+  const { scrollOffset, onScrollUp, onScrollDown } = useScroll(contentHeight, viewHeight);
+  const anyModalOpen = ctx.toggles.showModelPicker || ctx.toggles.showSessionPicker;
+  const pluginStatus = usePluginStatus(registry, uiService);
+  const { toasts, show, dismiss } = useToast();
+
+  useInput((input, key) => key.ctrl && input === 'c' && ctx.abort.onCtrlC(), { isActive: anyModalOpen });
+
+  useEffect(() => {
+    if (!uiService) return;
+    return uiService.onToast((toast: ToastRequest) => {
+      show(toast.message, TOAST_LEVEL_COLORS[toast.level] ?? 'white');
+    });
+  }, [uiService, show]);
+
+  const statusSegments = useStatusSegments({
+    streaming: ctx.session.streaming,
+    abortWarning: ctx.abort.abortWarning,
+    quitWarning: ctx.abort.quitWarning,
+    error: ctx.session.error,
+    modelError: ctx.models.modelError,
+    totalTokens: ctx.session.stream.totalTokens,
+    cachedTokens: ctx.session.stream.cachedTokens,
+    pluginStatus,
+  });
+
+  const bodyProps: ChatPanelBodyProps = {
+    width,
+    height,
+    viewRef,
+    contentRef,
+    scrollOffset,
+    viewHeight,
+    contentHeight,
+    isActive: !anyModalOpen,
+    onScrollUp,
+    onScrollDown,
+    uiService,
+    messages: ctx.session.messages,
+    streaming: ctx.session.streaming,
+    stream: ctx.session.stream,
+    error: ctx.session.error,
+    onSubmit: ctx.session.onSend,
+    model: ctx.models.currentModel,
+    history: ctx.session.inputHistory,
+    statusSegments,
+    toasts,
+    onDismissToast: dismiss,
+  };
+
+  return { ctx, bodyProps };
+}

package/src/tui/chat/useChatSession.ts

@@ -0,0 +1,284 @@
+import type { ChatMessage, ProviderConfig, Session } from 'mu-core';
+import { type PluginRegistry, runTransformUserInputHooks } from 'mu-core';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { HostMessageBus } from '../../runtime/messageBus';
+import type { AttachmentState } from './useAttachment';
+import { useSessionPersistence } from './useSessionPersistence';
+
+export interface StreamState {
+  text: string;
+  reasoning: string;
+  totalTokens: number;
+  cachedTokens: number;
+}
+
+const EMPTY_STREAM: StreamState = { text: '', reasoning: '', totalTokens: 0, cachedTokens: 0 };
+
+export interface ChatSessionState {
+  messages: ChatMessage[];
+  streaming: boolean;
+  error: string | null;
+  stream: StreamState;
+  inputHistory: string[];
+  onSend: (text: string) => Promise<void>;
+  onNew: () => void;
+  onLoadSession: (path: string) => void;
+}
+
+interface SessionDeps {
+  /**
+   * mu-core Session instance owned by the host. Authoritative for the
+   * transcript — this hook only mirrors it into React state and writes
+   * persistence on each message_changed event.
+   */
+  session: Session;
+  /** Provider config used as `runTurn` override (model lookup happens here). */
+  config: ProviderConfig;
+  /** Currently selected model id (may shift across sends). */
+  currentModel: string;
+  attachment: AttachmentState;
+  controllerRef: React.RefObject<AbortController | null>;
+  initialMessages?: ChatMessage[];
+  registry: PluginRegistry;
+  messageBus?: HostMessageBus;
+}
+
+/**
+ * Wire the host MessageBus to the Session: bus.append flows through
+ * `session.appendSynthetic` so every subscriber (TUI, broadcaster) sees the
+ * same change. `bus.get()` mirrors the live transcript.
+ */
+function useMessageBusWiring(messageBus: HostMessageBus | undefined, messages: ChatMessage[], session: Session): void {
+  useEffect(() => {
+    messageBus?.setMessages(messages);
+  }, [messageBus, messages]);
+
+  useEffect(() => {
+    if (!messageBus) return;
+    messageBus.setAppender((message) => {
+      session.appendSynthetic(message);
+    });
+    return () => {
+      messageBus.setAppender(null);
+    };
+  }, [messageBus, session]);
+}
+
+interface SubscriptionDeps {
+  session: Session;
+  setMessages: React.Dispatch<React.SetStateAction<ChatMessage[]>>;
+  setStream: React.Dispatch<React.SetStateAction<StreamState>>;
+  setStreaming: React.Dispatch<React.SetStateAction<boolean>>;
+  setError: React.Dispatch<React.SetStateAction<string | null>>;
+  saveCurrent: (messages: ChatMessage[]) => void;
+}
+
+/**
+ * Subscribe React state to mu-core Session events. Session is authoritative;
+ * this hook only mirrors. Persistence is driven from the same stream so disk
+ * writes are guaranteed to match what the user sees, but writes are
+ * coalesced to once per `stream_ended` to keep tool-heavy turns light on I/O.
+ */
+/**
+ * Build the event handler. Extracted so the cognitive complexity of the
+ * dispatch lives outside the React effect closure (the effect itself is
+ * just `session.subscribe(handler)`).
+ */
+function makeSessionEventHandler(
+  deps: SubscriptionDeps,
+  lastMessagesRef: React.MutableRefObject<ChatMessage[]>,
+): (event: import('mu-core').SessionEvent) => void {
+  const { setMessages, setStream, setStreaming, setError, saveCurrent } = deps;
+  return (event) => {
+    if (event.type === 'messages_changed') {
+      lastMessagesRef.current = event.messages;
+      setMessages(event.messages);
+      return;
+    }
+    if (event.type === 'stream_partial') {
+      setStream((s) => ({ ...s, text: event.text, reasoning: event.reasoning ?? '' }));
+      return;
+    }
+    if (event.type === 'stream_started') {
+      setStreaming(true);
+      setError(null);
+      return;
+    }
+    if (event.type === 'stream_ended') {
+      setStreaming(false);
+      setStream((s) => ({ ...s, text: '', reasoning: '' }));
+      if (lastMessagesRef.current.length > 0) saveCurrent(lastMessagesRef.current);
+      return;
+    }
+    if (event.type === 'usage') {
+      setStream((s) => ({
+        ...s,
+        totalTokens: s.totalTokens + event.totalTokens,
+        cachedTokens: s.cachedTokens + event.cachedTokens,
+      }));
+      return;
+    }
+    if (event.type === 'error') {
+      setError(event.message);
+    }
+  };
+}
+
+function useSessionSubscription(deps: SubscriptionDeps): void {
+  const { session, setMessages, setStream, setStreaming, setError, saveCurrent } = deps;
+  // The "last completed transcript" buffer survives effect re-subscriptions
+  // (e.g. if `saveCurrent` identity ever changes mid-stream). Without a ref
+  // we'd lose the in-flight save target on the next deps change.
+  const lastMessagesRef = useRef<ChatMessage[]>([]);
+  useEffect(() => {
+    const handler = makeSessionEventHandler(
+      { session, setMessages, setStream, setStreaming, setError, saveCurrent },
+      lastMessagesRef,
+    );
+    return session.subscribe(handler);
+  }, [session, setMessages, setStream, setStreaming, setError, saveCurrent]);
+}
+
+interface OnSendDeps {
+  session: Session;
+  config: ProviderConfig;
+  currentModel: string;
+  attachment: AttachmentState;
+  controllerRef: React.RefObject<AbortController | null>;
+  registry: PluginRegistry;
+  messageBus?: HostMessageBus;
+  appendHistory: (text: string) => void;
+  streaming: boolean;
+}
+
+function useOnSend(deps: OnSendDeps): (text: string) => Promise<void> {
+  const { session, config, currentModel, attachment, controllerRef, registry, messageBus, appendHistory, streaming } =
+    deps;
+  return useCallback(
+    async (text: string) => {
+      if (streaming) return;
+
+      const transform = await runTransformUserInputHooks(registry.getHooks(), text);
+      if (transform.kind === 'intercept') return;
+      const finalText = transform.kind === 'transform' ? transform.text : text;
+
+      const userMsg: ChatMessage = {
+        role: 'user',
+        content: finalText,
+        ...(attachment.attachment ? { images: [attachment.attachment] } : {}),
+      };
+
+      const injections = messageBus?.drainNext() ?? [];
+      for (const inj of injections) session.queueForNextTurn(inj);
+
+      appendHistory(text);
+      attachment.clear();
+
+      const controller = new AbortController();
+      controllerRef.current = controller;
+      controller.signal.addEventListener('abort', () => session.abort(), { once: true });
+
+      try {
+        await session.runTurn({
+          userMessage: userMsg,
+          config,
+          model: currentModel,
+          registry,
+        });
+      } finally {
+        controllerRef.current = null;
+      }
+    },
+    [streaming, session, config, currentModel, attachment, controllerRef, registry, messageBus, appendHistory],
+  );
+}
+
+/**
+ * Top-level chat-session hook. Composes:
+ *  - mu-core `Session` — single source of truth for the transcript
+ *  - `useSessionPersistence` — disk write + history + session paths
+ *
+ * The hook is purely reactive: it subscribes to session events and exposes
+ * the resulting state, plus thin wrappers around `session.runTurn` /
+ * `session.setMessages` for user actions.
+ */
+export function useChatSession(deps: SessionDeps): ChatSessionState {
+  const { session, config, currentModel, attachment, controllerRef, initialMessages, registry, messageBus } = deps;
+  const persistence = useSessionPersistence(initialMessages);
+  const { appendHistory, saveCurrent, resetForNew, loadFromPath } = persistence;
+
+  // Initial seed: feed any persisted messages into the session once.
+  // The session subscription below will then mirror them into React state.
+  useEffect(() => {
+    if (initialMessages?.length) session.setMessages(initialMessages);
+    // Run once per session instance.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [session, initialMessages?.length, initialMessages]);
+
+  const [messages, setMessages] = useState<ChatMessage[]>(() => initialMessages ?? []);
+  const [streaming, setStreaming] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [stream, setStream] = useState<StreamState>(EMPTY_STREAM);
+
+  useMessageBusWiring(messageBus, messages, session);
+  useSessionSubscription({ session, setMessages, setStream, setStreaming, setError, saveCurrent });
+
+  const onSend = useOnSend({
+    session,
+    config,
+    currentModel,
+    attachment,
+    controllerRef,
+    registry,
+    messageBus,
+    appendHistory,
+    streaming,
+  });
+
+  const onNew = useCallback(() => {
+    // Abort any in-flight turn *before* rotating the session path.
+    // Without this, the streaming `runTurn` keeps emitting `messages_changed`
+    // events that are saved to the newly-rotated path via `stream_ended`,
+    // mixing the old transcript into the brand-new file.
+    if (controllerRef.current) {
+      controllerRef.current.abort();
+      controllerRef.current = null;
+    }
+    resetForNew();
+    // `session.setMessages([])` emits `messages_changed` which the
+    // subscription mirrors into React state, so we don't double-write here.
+    session.setMessages([]);
+    setStream(EMPTY_STREAM);
+    setError(null);
+    attachment.clear();
+  }, [resetForNew, session, attachment, controllerRef]);
+
+  const onLoadSession = useCallback(
+    (path: string) => {
+      const loaded = loadFromPath(path);
+      if (loaded.length === 0) return;
+      // Abort any in-flight turn before replacing the transcript, for the
+      // same reason as onNew above.
+      if (controllerRef.current) {
+        controllerRef.current.abort();
+        controllerRef.current = null;
+      }
+      // setMessages emits messages_changed → React state mirrors it.
+      session.setMessages(loaded);
+      setStream(EMPTY_STREAM);
+      setError(null);
+    },
+    [loadFromPath, session, controllerRef],
+  );
+
+  return {
+    messages,
+    streaming,
+    error,
+    stream,
+    inputHistory: persistence.inputHistory,
+    onSend,
+    onNew,
+    onLoadSession,
+  };
+}

package/src/tui/{useModelList.ts → chat/useModels.ts}

@@ -1,6 +1,7 @@
-import { type ApiModel, listModels } from 'mu-provider';
+import type { ApiModel } from 'mu-core';
+import { listModels } from 'mu-openai-provider';
 import { useCallback, useEffect, useState } from 'react';
-import { saveConfig } from '../config';
+import { saveConfig } from '../../config/index';
 
 export interface ModelListState {
   models: ApiModel[];
@@ -16,8 +17,13 @@ export function useModelList(baseUrl: string, preferredModel?: string): ModelLis
   const [error, setError] = useState<string | null>(null);
 
   useEffect(() => {
+    // Guard against late resolution: if the user quits or `baseUrl` changes
+    // before the request settles, swallow the response so we don't call
+    // setState on an unmounted hook.
+    let cancelled = false;
     listModels(baseUrl)
       .then((list) => {
+        if (cancelled) return;
         if (list.length === 0) {
           setError(`No models found at ${baseUrl}`);
           return;
@@ -28,8 +34,12 @@ export function useModelList(baseUrl: string, preferredModel?: string): ModelLis
         setCurrentModel(target);
       })
       .catch((err) => {
+        if (cancelled) return;
         setError(err instanceof Error ? err.message : 'Failed to fetch models');
       });
+    return () => {
+      cancelled = true;
+    };
   }, [baseUrl, preferredModel]);
 
   const cycleModel = useCallback(() => {

package/src/tui/chat/usePluginStatus.ts

@@ -0,0 +1,44 @@
+import type { PluginRegistry, StatusSegment } from 'mu-core';
+import { useEffect, useMemo, useState } from 'react';
+import type { InkUIService } from '../plugins/InkUIService';
+
+/**
+ * Aggregate plugin status from the two complementary channels into one
+ * flat segment list:
+ *
+ *  1. `registry.onStatusChange` — push-based, structured `StatusSegment[]` per
+ *     plugin (color/dim metadata). Producers use `PluginContext.setStatusLine`.
+ *  2. `uiService.onStatusChange` — free-form `key → text` map. Producers use
+ *     `UIService.setStatus` (e.g. `mu-repomap` progress, Pi `pi.ui.setStatus`,
+ *     Pi `pi.ui.setWidget`). Rendered as dim text since the API carries no
+ *     color metadata.
+ *
+ * The split lets producers pick the right granularity; callers see a single
+ * pre-merged list ready for the status bar.
+ */
+export function usePluginStatus(registry: PluginRegistry, uiService?: InkUIService): StatusSegment[] {
+  const [pluginStatus, setPluginStatus] = useState<StatusSegment[]>([]);
+  const [uiStatus, setUiStatus] = useState<StatusSegment[]>([]);
+
+  useEffect(() => {
+    setPluginStatus(registry.getStatusSegments());
+    return registry.onStatusChange(() => {
+      setPluginStatus(registry.getStatusSegments());
+    });
+  }, [registry]);
+
+  useEffect(() => {
+    if (!uiService) return;
+    const apply = (entries: Map<string, string>) => {
+      const segments: StatusSegment[] = [];
+      for (const [, text] of entries) {
+        segments.push({ text, dim: true });
+      }
+      setUiStatus(segments);
+    };
+    apply(uiService.getStatusEntries());
+    return uiService.onStatusChange(apply);
+  }, [uiService]);
+
+  return useMemo(() => [...pluginStatus, ...uiStatus], [pluginStatus, uiStatus]);
+}

package/src/tui/chat/useSessionPersistence.ts

@@ -0,0 +1,68 @@
+import type { ChatMessage } from 'mu-core';
+import { useCallback, useRef, useState } from 'react';
+import { generateSessionPath, loadSession, saveSession } from '../../sessions/index';
+
+export interface SessionPersistenceState {
+  inputHistory: string[];
+  appendHistory: (text: string) => void;
+  sessionPathRef: React.RefObject<string>;
+  /** Persist the given transcript to the current session file. */
+  saveCurrent: (messages: ChatMessage[]) => void;
+  /** Reset to a brand-new session: rotates the file path. */
+  resetForNew: () => void;
+  /**
+   * Load a transcript from disk and adopt its path. Returns the loaded
+   * messages so the caller can hand them to the session.
+   */
+  loadFromPath: (path: string) => ChatMessage[];
+  /** Replace history (used after resume / load). */
+  setHistory: (history: string[]) => void;
+}
+
+function userPromptsFrom(messages: ChatMessage[]): string[] {
+  return messages.filter((m) => m.role === 'user').map((m) => m.content);
+}
+
+/**
+ * Side-channel persistence: history bookkeeping, on-disk save, and session
+ * file path management. Does NOT own the transcript — `Session` is the
+ * single source of truth in the new architecture, this hook only writes to
+ * disk and tracks the current target path.
+ *
+ * Save errors are logged to stderr and do not surface to the chat error
+ * channel — they're considered non-fatal (next save attempt may succeed).
+ */
+export function useSessionPersistence(initialMessages?: ChatMessage[]): SessionPersistenceState {
+  const [inputHistory, setInputHistory] = useState<string[]>(userPromptsFrom(initialMessages ?? []));
+  const sessionPathRef = useRef(generateSessionPath());
+
+  const appendHistory = useCallback((text: string) => {
+    setInputHistory((prev) => [...prev, text]);
+  }, []);
+
+  const saveCurrent = useCallback((finalMessages: ChatMessage[]) => {
+    saveSession(sessionPathRef.current, finalMessages).catch((err) => {
+      console.error('Failed to save session:', err);
+    });
+  }, []);
+
+  const resetForNew = useCallback(() => {
+    sessionPathRef.current = generateSessionPath();
+    setInputHistory([]);
+  }, []);
+
+  const loadFromPath = useCallback((path: string): ChatMessage[] => {
+    const msgs = loadSession(path);
+    if (msgs.length > 0) {
+      sessionPathRef.current = path;
+      setInputHistory(userPromptsFrom(msgs));
+    }
+    return msgs;
+  }, []);
+
+  const setHistory = useCallback((history: string[]) => {
+    setInputHistory(history);
+  }, []);
+
+  return { inputHistory, appendHistory, sessionPathRef, saveCurrent, resetForNew, loadFromPath, setHistory };
+}