mu-coding 0.5.0 → 0.8.0

package/src/runtime/pluginLoader.ts

@@ -1,7 +1,7 @@
 import { readdirSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { join, resolve } from 'node:path';
-import type { Plugin, PluginRegistry } from 'mu-agents';
+import type { Plugin, PluginRegistry } from 'mu-core';
 import { getDataDir, getPluginsDir, parseBareNpmSpec } from '../config/index';
 import type { InkUIService } from '../tui/plugins/InkUIService';
 
@@ -71,36 +71,49 @@ function extractPlugin(mod: Record<string, unknown>, pluginConfig: Record<string
   return null;
 }
 
-export async function loadConfiguredPlugin(
-  registry: PluginRegistry,
+/**
+ * Loader variant that *resolves* (imports + extracts) a plugin without
+ * registering it. Used by hosts driving `startMu({ resolvePlugin })`. Errors
+ * surface via `uiService` (or are swallowed when omitted) so the host's
+ * boot log behaviour matches `loadConfiguredPlugin`.
+ */
+export async function resolveConfiguredPlugin(
   name: string,
   pluginConfig?: Record<string, unknown>,
   uiService?: InkUIService,
-): Promise<void> {
+): Promise<Plugin | null> {
   const config = pluginConfig ?? {};
   let target: string;
   try {
     target = name.startsWith('npm:') ? resolveNpmPlugin(name) : name;
   } catch (err) {
     uiService?.notify(formatPluginError(name, err), 'error');
-    return;
+    return null;
   }
-
   let mod: Record<string, unknown>;
   try {
     mod = (await import(target)) as Record<string, unknown>;
   } catch (err) {
     uiService?.notify(formatPluginError(name, err), 'error');
-    return;
+    return null;
   }
-
   const plugin = extractPlugin(mod, config);
   if (!plugin) {
     const exportKeys = Object.keys(mod).join(', ') || '(none)';
     uiService?.notify(`Plugin "${name}": no plugin export found. Exports: [${exportKeys}]`, 'error');
-    return;
+    return null;
   }
+  return plugin;
+}
 
+export async function loadConfiguredPlugin(
+  registry: PluginRegistry,
+  name: string,
+  pluginConfig?: Record<string, unknown>,
+  uiService?: InkUIService,
+): Promise<void> {
+  const plugin = await resolveConfiguredPlugin(name, pluginConfig, uiService);
+  if (!plugin) return;
   try {
     await registry.register(plugin);
   } catch (err) {

package/src/sessions/index.ts

@@ -1,8 +1,8 @@
-import { createReadStream, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createReadStream, mkdirSync, readdirSync, readFileSync } from 'node:fs';
 import { stat, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
-import type { ChatMessage } from 'mu-provider';
+import type { ChatMessage } from 'mu-core';
 import { getDataDir } from '../config/index';
 import { getProjectId, getProjectName } from './project';
 
@@ -181,10 +181,3 @@ export async function listSessionsAsync(): Promise<SessionInfo[]> {
 
   return results.filter((s): s is SessionInfo => s !== null);
 }
-
-// Sync helper preserved for legacy/test callers — wraps the same data path
-// without the streaming optimization. New code should prefer `listSessionsAsync`.
-export function saveSessionSync(path: string, messages: ChatMessage[]): void {
-  const content = messages.length > 0 ? `${messages.map((m) => JSON.stringify(m)).join('\n')}\n` : '';
-  writeFileSync(path, content, 'utf-8');
-}

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

@@ -0,0 +1,107 @@
+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

@@ -0,0 +1,49 @@
+/**
+ * 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 { Channel, 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 { renderApp } from '../renderApp';
+
+export interface TuiChannelOptions {
+  config: AppConfig;
+  initialMessages?: ChatMessage[];
+  registry: PluginRegistry;
+  messageBus: HostMessageBus;
+  uiService: InkUIService;
+  shutdown: ShutdownFn;
+}
+
+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(opts);
+    },
+    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/MessageRendererContext.ts

@@ -0,0 +1,44 @@
+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,4 +1,4 @@
-import type { PluginRegistry, ToolDisplayHint } from 'mu-agents';
+import type { PluginRegistry, ToolDisplayHint } from 'mu-core';
 import { createContext, useContext, useMemo } from 'react';
 
 type ToolDisplayMap = Map<string, ToolDisplayHint>;

package/src/tui/chat/useAttachment.ts

@@ -1,4 +1,4 @@
-import type { ImageAttachment } from 'mu-provider';
+import type { ImageAttachment } from 'mu-core';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { readClipboardImage } from '../../utils/clipboard';
 

package/src/tui/chat/useChat.ts

@@ -1,9 +1,16 @@
 import { useApp } from 'ink';
-import type { PluginRegistry } from 'mu-agents';
-import type { ChatMessage, ProviderConfig } from 'mu-provider';
-import { useEffect, useRef, useState } from 'react';
+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';
@@ -14,12 +21,15 @@ 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(
@@ -27,19 +37,34 @@ export function useChat(
   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);
 
@@ -68,11 +93,14 @@ export function useChat(
   return {
     config,
     session,
+    sessionManager,
     toggles,
     attachment,
     models,
     abort,
     sessions,
     registry,
+    uiService,
+    messageBus,
   };
 }

package/src/tui/chat/useChatPanel.ts

@@ -1,8 +1,8 @@
 import { type DOMElement as InkDOMElement, useInput } from 'ink';
-import type { PluginRegistry } from 'mu-agents';
-import type { ChatMessage, ProviderConfig } from 'mu-provider';
+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';
@@ -23,13 +23,14 @@ interface UseChatPanelOptions {
   config: ProviderConfig;
   initialMessages?: ChatMessage[];
   registry: PluginRegistry;
+  messageBus?: HostMessageBus;
   uiService?: InkUIService;
   shutdown?: ShutdownFn;
 }
 
 export function useChatPanel(options: UseChatPanelOptions) {
-  const { config, initialMessages, registry, uiService, shutdown } = options;
-  const ctx = useChat(config, registry, initialMessages, shutdown);
+  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);
@@ -64,7 +65,8 @@ export function useChatPanel(options: UseChatPanelOptions) {
     quitWarning: ctx.abort.quitWarning,
     error: ctx.session.error,
     modelError: ctx.models.modelError,
-    tokensPerSecond: ctx.session.stream.tps,
+    totalTokens: ctx.session.stream.totalTokens,
+    cachedTokens: ctx.session.stream.cachedTokens,
     pluginStatus,
   });