mu-coding 0.5.0 → 0.9.0

package/src/runtime/messageBus.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it, mock } from 'bun:test';
+import type { ChatMessage } from 'mu-core';
+import { createMessageBus } from './messageBus';
+
+const userMsg = (text: string): ChatMessage => ({ role: 'user', content: text });
+
+describe('createMessageBus', () => {
+  it('queues appends until an appender is wired', () => {
+    const bus = createMessageBus();
+    bus.append(userMsg('hi'));
+    bus.append(userMsg('there'));
+    const seen: ChatMessage[] = [];
+    bus.setAppender((m) => seen.push(m));
+    expect(seen.map((m) => m.content)).toEqual(['hi', 'there']);
+  });
+
+  it('forwards subsequent appends through the wired appender', () => {
+    const bus = createMessageBus();
+    const appender = mock(() => {
+      /* spy only */
+    });
+    bus.setAppender(appender);
+    bus.append(userMsg('one'));
+    bus.append(userMsg('two'));
+    expect(appender).toHaveBeenCalledTimes(2);
+  });
+
+  it('drainNext returns and clears injectNext payload', () => {
+    const bus = createMessageBus();
+    bus.injectNext(userMsg('a'));
+    bus.injectNext(userMsg('b'));
+    expect(bus.drainNext().map((m) => m.content)).toEqual(['a', 'b']);
+    expect(bus.drainNext()).toEqual([]);
+  });
+
+  it('subscribe replays the current snapshot once', () => {
+    const bus = createMessageBus();
+    bus.setMessages([userMsg('hello')]);
+    const seen: string[] = [];
+    bus.subscribe((m) => seen.push(m.map((x) => x.content).join(',')));
+    expect(seen).toEqual(['hello']);
+  });
+
+  it('subscribe fires on subsequent setMessages and unsubscribes cleanly', () => {
+    const bus = createMessageBus();
+    const updates: number[] = [];
+    const off = bus.subscribe((m) => updates.push(m.length));
+    bus.setMessages([userMsg('a')]);
+    bus.setMessages([userMsg('a'), userMsg('b')]);
+    off();
+    bus.setMessages([userMsg('c')]);
+    expect(updates).toEqual([0, 1, 2]);
+  });
+
+  it('get reflects the latest setMessages snapshot', () => {
+    const bus = createMessageBus();
+    expect(bus.get()).toEqual([]);
+    const msgs = [userMsg('x')];
+    bus.setMessages(msgs);
+    expect(bus.get()).toEqual(msgs);
+  });
+});

package/src/runtime/messageBus.ts

@@ -0,0 +1,78 @@
+import type { ChatMessage, MessageBus } from 'mu-core';
+
+type MessageListener = (messages: ChatMessage[]) => void;
+type Appender = (message: ChatMessage) => void;
+
+export interface HostMessageBus extends MessageBus {
+  /**
+   * Provide the live "append a message to the transcript" hook from the React
+   * tree. Called by `useChatSession` once it has stable `setMessages`. Until
+   * the hook is wired, `append` queues messages so plugin activations during
+   * registry construction don't lose entries.
+   */
+  setAppender: (fn: Appender | null) => void;
+  /**
+   * Replace the current `messages` array reported via `get()` and broadcast
+   * to subscribers. Driven by the chat session whenever the transcript
+   * changes (user send, streamed response, session reload, ...).
+   */
+  setMessages: (messages: ChatMessage[]) => void;
+}
+
+/**
+ * Host-side bridge between plugins and the live chat transcript.
+ *
+ * Plugins call `append`/`injectNext`/`get`/`subscribe` through the registry
+ * `PluginContext`. The mu-coding chat session wires the live transcript and
+ * appender into this bus so calls made before the React tree mounts are
+ * buffered and replayed once the wiring lands.
+ */
+export function createMessageBus(): HostMessageBus {
+  let appender: Appender | null = null;
+  const pendingAppends: ChatMessage[] = [];
+  const pendingNextTurn: ChatMessage[] = [];
+  let currentMessages: ChatMessage[] = [];
+  const listeners = new Set<MessageListener>();
+
+  const flushAppends = (): void => {
+    if (!appender) return;
+    while (pendingAppends.length) {
+      const msg = pendingAppends.shift();
+      if (msg) appender(msg);
+    }
+  };
+
+  return {
+    append(message) {
+      if (appender) appender(message);
+      else pendingAppends.push(message);
+    },
+    injectNext(message) {
+      pendingNextTurn.push(message);
+    },
+    drainNext() {
+      const out = pendingNextTurn.slice();
+      pendingNextTurn.length = 0;
+      return out;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      // Replay current snapshot so subscribers don't miss the initial state.
+      listener(currentMessages);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    get() {
+      return currentMessages;
+    },
+    setAppender(fn) {
+      appender = fn;
+      flushAppends();
+    },
+    setMessages(next) {
+      currentMessages = next;
+      for (const fn of listeners) fn(next);
+    },
+  };
+}

package/src/runtime/pluginLoader.ts

@@ -1,7 +1,8 @@
 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 { installNpmPackage } from '../cli/install';
 import { getDataDir, getPluginsDir, parseBareNpmSpec } from '../config/index';
 import type { InkUIService } from '../tui/plugins/InkUIService';
 
@@ -31,14 +32,44 @@ function formatPluginError(name: string, err: unknown): string {
   return parts.join(': ');
 }
 
-function resolveNpmPlugin(specifier: string): string {
-  const { name } = parseBareNpmSpec(specifier.slice(4));
+/**
+ * Resolve an `npm:<spec>` plugin specifier to an absolute path on disk.
+ *
+ * If the package isn't installed yet, runs `bun add <spec>` against the mu
+ * data dir and retries — so users can list a plugin in `config.plugins`
+ * without having to invoke `mu install` first.
+ *
+ * `uiService` is optional: when provided, surface "Installing …" / failure
+ * messages through the TUI; otherwise fall back to stderr so the host's
+ * boot log still shows what happened.
+ */
+async function resolveNpmPlugin(specifier: string, uiService?: InkUIService): Promise<string> {
+  const bare = specifier.slice(4);
+  const { name } = parseBareNpmSpec(bare);
   const dataDir = getDataDir();
+  const require = createRequire(resolve(dataDir, 'package.json'));
+
   try {
-    const require = createRequire(resolve(dataDir, 'package.json'));
     return require.resolve(name);
-  } catch (err) {
-    throw new Error(`Cannot resolve "${name}" from ${dataDir}/node_modules — is it installed?`, { cause: err });
+  } catch (_firstErr) {
+    const installMsg = `Installing ${name}…`;
+    if (uiService) uiService.notify(installMsg, 'info');
+    else console.error(`[mu] ${installMsg}`);
+
+    try {
+      installNpmPackage(bare, { silent: true });
+    } catch (installErr) {
+      throw new Error(`Failed to auto-install "${name}" into ${dataDir}/node_modules`, { cause: installErr });
+    }
+
+    try {
+      return require.resolve(name);
+    } catch (retryErr) {
+      throw new Error(
+        `Auto-installed "${name}" but cannot resolve it from ${dataDir}/node_modules — install may have failed silently`,
+        { cause: retryErr },
+      );
+    }
   }
 }
 
@@ -71,36 +102,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;
+    target = name.startsWith('npm:') ? await resolveNpmPlugin(name, uiService) : 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,62 @@
+/**
+ * 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/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/useAbort.ts

@@ -7,9 +7,14 @@ function useDoublePress(timeoutMs: number) {
 
   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);

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,18 @@
 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 { 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';
@@ -14,12 +23,16 @@ 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(
@@ -27,19 +40,37 @@ export function useChat(
   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);
 
@@ -68,11 +99,15 @@ export function useChat(
   return {
     config,
     session,
+    sessionManager,
     toggles,
     attachment,
     models,
     abort,
     sessions,
     registry,
+    uiService,
+    messageBus,
+    subagentRuns,
   };
 }