mu-coding 0.13.0 → 0.16.1

package/src/tui/chat/useChatPanel.ts

@@ -1,119 +0,0 @@
-import { type DOMElement as InkDOMElement, useInput } from 'ink';
-import type { SubagentRunRegistry } from 'mu-agents';
-import type { ChatMessage, PluginRegistry, ProviderConfig } from 'mu-core';
-import { useEffect, useMemo, useRef } from 'react';
-import type { ShutdownFn } from '../../app/shutdown';
-import type { SessionPathHolder } from '../../runtime/createRegistry';
-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';
-import { type SubagentBrowserState, useSubagentBrowser } from './useSubagentBrowser';
-
-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;
-  sessionPathHolder?: SessionPathHolder;
-  subagentRuns?: SubagentRunRegistry;
-}
-
-export function useChatPanel(options: UseChatPanelOptions) {
-  const { config, initialMessages, registry, messageBus, uiService, shutdown, sessionPathHolder, subagentRuns } =
-    options;
-  const ctx = useChat(
-    config,
-    registry,
-    initialMessages,
-    shutdown,
-    uiService,
-    messageBus,
-    sessionPathHolder,
-    subagentRuns,
-  );
-  const browser = useSubagentBrowser(subagentRuns);
-  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 contextLimit = ctx.models.models.find((m) => m.id === ctx.models.currentModel)?.contextLimit;
-  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,
-    contextLimit,
-    pluginStatus,
-  });
-
-  const bodyProps: ChatPanelBodyProps = {
-    width,
-    height,
-    viewRef,
-    contentRef,
-    scrollOffset,
-    viewHeight,
-    contentHeight,
-    isActive: !anyModalOpen && browser.mode.kind === 'chat',
-    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,
-    browser,
-  };
-
-  return { ctx, bodyProps };
-}
-
-export type { SubagentBrowserState };

package/src/tui/chat/useChatSession.ts

@@ -1,382 +0,0 @@
-import type { ChatMessage, ProviderConfig, Session } from 'mu-core';
-import { type PluginRegistry, runDecorateMessageHooks, runTransformUserInputHooks } from 'mu-core';
-import { useCallback, useEffect, useRef, useState } from 'react';
-import type { SessionPathHolder } from '../../runtime/createRegistry';
-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;
-  /**
-   * Compact the current transcript: ask the model to summarize the entire
-   * conversation, then replace the transcript with `[user marker, assistant
-   * summary]`. Frees context while keeping intent + key decisions in scope.
-   */
-  onCompact: () => Promise<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;
-  sessionPathHolder?: SessionPathHolder;
-}
-
-/**
- * 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;
-}
-
-interface OnCompactDeps {
-  streaming: boolean;
-  session: Session;
-  config: ProviderConfig;
-  currentModel: string;
-  registry: PluginRegistry;
-  controllerRef: React.RefObject<AbortController | null>;
-  saveCurrent: (messages: ChatMessage[]) => void;
-}
-
-const COMPACT_INSTRUCTION =
-  'Compact this conversation. Produce ONE concise summary that captures: ' +
-  "1) the user's overall intent, 2) key decisions made, 3) files modified " +
-  '(paths with line refs where relevant), 4) open tasks / next steps, and ' +
-  '5) any important context the assistant should retain. Output ONLY the ' +
-  'summary text — no preface, no markdown headers.';
-
-/**
- * Walk a transcript backwards starting at `fromIndex` and return the first
- * assistant message with non-empty content. Used by the compact flow to
- * locate the summary the LLM produced for the freshly-injected request.
- */
-function findLatestAssistantContent(messages: ChatMessage[], fromIndex: number): string {
-  for (let i = messages.length - 1; i >= fromIndex; i--) {
-    const m = messages[i];
-    if (m.role === 'assistant' && m.content && m.content.trim().length > 0) {
-      return m.content;
-    }
-  }
-  return '';
-}
-
-function useOnCompact(deps: OnCompactDeps): () => Promise<void> {
-  const { streaming, session, config, currentModel, registry, controllerRef, saveCurrent } = deps;
-  return useCallback(async () => {
-    if (streaming) return;
-    const before = session.getMessages();
-    if (before.length === 0) return;
-    const beforeCount = before.length;
-
-    // Hide the summarization instruction from the on-screen transcript
-    // (`display.hidden`) but keep it in the LLM payload. Once the run
-    // completes we replace the entire transcript anyway.
-    const summaryInstruction: ChatMessage = {
-      role: 'user',
-      content: COMPACT_INSTRUCTION,
-      display: { hidden: true },
-    };
-    const controller = new AbortController();
-    controllerRef.current = controller;
-    controller.signal.addEventListener('abort', () => session.abort(), { once: true });
-    try {
-      await session.runTurn({ userMessage: summaryInstruction, config, model: currentModel, registry });
-      const summary = findLatestAssistantContent(session.getMessages(), beforeCount);
-      if (!summary) return;
-      // Replace the entire history with a single user marker + the assistant
-      // summary. The next turn runs with a tiny context, "resumed" from
-      // the compacted state.
-      const compacted: ChatMessage[] = [
-        { role: 'user', content: '[Conversation compacted — context below preserves prior intent and decisions]' },
-        { role: 'assistant', content: summary },
-      ];
-      session.setMessages(compacted);
-      saveCurrent(compacted);
-    } finally {
-      controllerRef.current = null;
-    }
-  }, [streaming, session, config, currentModel, registry, controllerRef, saveCurrent]);
-}
-
-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;
-
-      // `continue` signals the hook handled the user message itself
-      // (e.g. mu-agents' @-mention dispatch path appends the user msg
-      // live, runs the subagent live, and queues the synthetic tool
-      // flow for the upcoming turn). We skip the userMessage push but
-      // still drain the queue and stream the LLM follow-up.
-      const isContinue = transform.kind === 'continue';
-      const finalText = transform.kind === 'transform' ? transform.text : text;
-
-      const userMsg: ChatMessage | undefined = isContinue
-        ? undefined
-        : await runDecorateMessageHooks(registry.getHooks(), {
-            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, deps.sessionPathHolder);
-  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 onCompact = useOnCompact({
-    streaming,
-    session,
-    config,
-    currentModel,
-    registry,
-    controllerRef,
-    saveCurrent,
-  });
-
-  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,
-    onCompact,
-  };
-}

package/src/tui/chat/useModels.ts

@@ -1,83 +0,0 @@
-import type { ApiModel } from 'mu-core';
-import { fetchModelContextLimit, listModels } from 'mu-openai-provider';
-import { useCallback, useEffect, useState } from 'react';
-import { saveConfig } from '../../config/index';
-
-export interface ModelListState {
-  models: ApiModel[];
-  currentModel: string;
-  modelError: string | null;
-  cycleModel: () => void;
-  selectModel: (id: string) => void;
-}
-
-export function useModelList(baseUrl: string, preferredModel?: string): ModelListState {
-  const [models, setModels] = useState<ApiModel[]>([]);
-  const [currentModel, setCurrentModel] = useState(preferredModel ?? '');
-  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;
-        }
-        setError(null);
-        setModels(list);
-        const target = preferredModel && list.some((m) => m.id === preferredModel) ? preferredModel : list[0].id;
-        setCurrentModel(target);
-      })
-      .catch((err) => {
-        if (cancelled) return;
-        setError(err instanceof Error ? err.message : 'Failed to fetch models');
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [baseUrl, preferredModel]);
-
-  // Lazily probe the active model's context window. Fires whenever the
-  // selection changes; skips if we already know the limit for that id.
-  // Runs in the background so the UI never blocks waiting for `/props`.
-  // Triggers a model load on llama-swap-style proxies, but only for the
-  // model the user has actually picked — same model the next chat would
-  // load anyway.
-  useEffect(() => {
-    if (!(baseUrl && currentModel)) return;
-    const known = models.find((m) => m.id === currentModel);
-    if (!known || known.contextLimit !== undefined) return;
-    let cancelled = false;
-    fetchModelContextLimit(baseUrl, currentModel)
-      .then((limit) => {
-        if (cancelled || !limit) return;
-        setModels((prev) => prev.map((m) => (m.id === currentModel ? { ...m, contextLimit: limit } : m)));
-      })
-      .catch(() => {
-        /* silently ignore — providers without `/props` just don't get a limit */
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [baseUrl, currentModel, models]);
-
-  const cycleModel = useCallback(() => {
-    if (models.length === 0) {
-      return;
-    }
-    const idx = models.findIndex((m) => m.id === currentModel);
-    setCurrentModel(models[(idx + 1) % models.length].id);
-  }, [models, currentModel]);
-
-  const selectModel = useCallback((id: string) => {
-    setCurrentModel(id);
-    saveConfig({ model: id });
-  }, []);
-
-  return { models, currentModel, cycleModel, selectModel, modelError: error };
-}

package/src/tui/chat/usePluginStatus.ts

@@ -1,44 +0,0 @@
-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]);
-}