mu-coding 0.4.0 → 0.8.0

package/src/runtime/createRegistry.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, it, mock } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { PluginRegistry } from 'mu-core';
+import type { AppConfig } from '../config/index';
+import { InkUIService } from '../tui/plugins/InkUIService';
+import { createRegistry } from './createRegistry';
+
+// ─── renderApp mock ───────────────────────────────────────────────────────────
+// Captures the options renderApp is called with so tests can assert what the
+// TUI actually receives — specifically, that the concrete PluginRegistry (with
+// subscription methods) is passed rather than the narrow PluginRegistryView.
+// This mock must be declared before any test imports createRegistry so Bun's
+// module mock intercepts the import in the plugin chain.
+
+const capturedRenderArgs: Array<{ registry: PluginRegistry }> = [];
+const noop = (): void => {
+  /* stub */
+};
+mock.module('../tui/renderApp', () => ({
+  renderApp: (opts: { registry: PluginRegistry }) => {
+    capturedRenderArgs.push(opts);
+    return {
+      unmount: noop,
+      waitUntilExit: async (): Promise<void> => {
+        /* stub */
+      },
+      rerender: noop,
+      cleanup: noop,
+      clear: noop,
+    };
+  },
+}));
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function fakeConfig(): AppConfig {
+  return {
+    baseUrl: 'http://localhost:0',
+    model: 'test-model',
+    maxTokens: 1024,
+    temperature: 0.7,
+    streamTimeoutMs: 10_000,
+  };
+}
+
+/** Methods the TUI subscribes to at runtime (not part of PluginRegistryView). */
+const TUI_REGISTRY_METHODS = [
+  'onStatusChange',
+  'getStatusSegments',
+  'onRenderersChange',
+  'getRenderers',
+  'onShortcutsChange',
+  'getShortcuts',
+  'getCommands',
+] as const;
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('createRegistry — activation order + plugin propagation', () => {
+  it('registers builtins so coding-agents see ctx.agents', async () => {
+    const cwd = mkdtempSync(join(tmpdir(), 'mu-cr-'));
+    try {
+      const ui = new InkUIService();
+      const { registry, channels, providers } = await createRegistry({
+        cwd,
+        config: fakeConfig(),
+        uiService: ui,
+      });
+
+      // Provider registered.
+      expect(providers.list().some((p) => p.id === 'openai')).toBe(true);
+
+      // All builtin plugins loaded in the correct order.
+      const names = registry.getPlugins().map((p) => p.name);
+      expect(names).toContain('mu-openai-provider');
+      expect(names).toContain('mu-agents');
+      expect(names).toContain('mu-coding');
+      // mu-coding-agents is opt-in via `config.plugins`, not auto-registered.
+      expect(names).not.toContain('mu-coding-agents');
+
+      // TUI channel registered.
+      expect(channels.list().map((c) => c.id)).toContain('tui');
+
+      // mu-agents exposes its approval gateway publicly.
+      interface GatewayBearer {
+        approvalGateway?: { registerChannel: unknown };
+      }
+      const agent = registry.getPlugin<GatewayBearer & { name: string; [k: string]: unknown }>('mu-agents');
+      expect(agent?.approvalGateway).toBeDefined();
+    } finally {
+      rmSync(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it('TUI channel receives concrete PluginRegistry (not the narrow View)', async () => {
+    // This test is the REAL regression guard: it calls channels.startAll()
+    // which invokes tuiChannel.start() → renderApp(opts). The mock above
+    // captures `opts.registry`. If createCodingPlugin ever reverts to passing
+    // `ctx.registry` (the narrow View), the TUI methods below will be absent
+    // and the test fails — exactly mirroring the runtime crash that would occur.
+    const cwd = mkdtempSync(join(tmpdir(), 'mu-cr-'));
+    try {
+      const ui = new InkUIService();
+      capturedRenderArgs.length = 0;
+      const { channels } = await createRegistry({
+        cwd,
+        config: fakeConfig(),
+        uiService: ui,
+      });
+
+      await channels.startAll();
+      await channels.stopAll();
+
+      expect(capturedRenderArgs).toHaveLength(1);
+      const reg = capturedRenderArgs[0].registry as unknown as Record<string, unknown>;
+      for (const method of TUI_REGISTRY_METHODS) {
+        expect(typeof reg[method], `registry.${method} should be a function`).toBe('function');
+      }
+    } finally {
+      capturedRenderArgs.length = 0;
+      rmSync(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it('agent slash command is contributed by mu-agents (no coding-agents by default)', async () => {
+    const cwd = mkdtempSync(join(tmpdir(), 'mu-cr-'));
+    try {
+      const ui = new InkUIService();
+      const { registry } = await createRegistry({
+        cwd,
+        config: fakeConfig(),
+        uiService: ui,
+      });
+
+      const commandNames = registry.getCommands().map((c) => c.name);
+      expect(commandNames).toContain('agent');
+      // build/plan/review come from mu-agents' DEFAULT_PRIMARY_AGENTS.
+      // `explore` originates from mu-coding-agents, which is no longer auto-loaded.
+      expect(commandNames).not.toContain('explore');
+    } finally {
+      rmSync(cwd, { recursive: true, force: true });
+    }
+  });
+});

package/src/runtime/createRegistry.ts

@@ -0,0 +1,163 @@
+import { createAgentsPlugin } from 'mu-agents';
+import type { ChatMessage } from 'mu-core';
+import {
+  type ActivityBus,
+  type ChannelRegistry,
+  createActivityBus,
+  createChannelRegistry,
+  createProviderRegistry,
+  PluginRegistry,
+  type ProviderRegistry,
+} from 'mu-core';
+import { createOpenAIProviderPlugin } from 'mu-openai-provider';
+import type { ShutdownFn } from '../app/shutdown';
+import type { AppConfig } from '../config/index';
+import { createCodingPlugin } from '../plugin';
+import type { InkUIService } from '../tui/plugins/InkUIService';
+import { createMessageBus, type HostMessageBus } from './messageBus';
+import { discoverPluginFiles, loadConfiguredPlugin } from './pluginLoader';
+
+interface CreateRegistryOptions {
+  cwd: string;
+  config: AppConfig;
+  uiService: InkUIService;
+  /**
+   * Initial transcript injected into the TUI's session (e.g. resumed from
+   * disk via `mu -c`). Threaded through to the coding plugin's TUI channel.
+   */
+  initialMessages?: ChatMessage[];
+  /**
+   * Host shutdown is forwarded to plugins via PluginContext so a plugin
+   * calling shutdown gets the same graceful path as Ctrl+C — terminal
+   * restored, plugins deactivated.
+   *
+   * Optional because some callers (tests, single-shot) don't have one.
+   */
+  shutdown?: ShutdownFn;
+}
+
+interface RegistryBundle {
+  registry: PluginRegistry;
+  messageBus: HostMessageBus;
+  providers: ProviderRegistry;
+  channels: ChannelRegistry;
+  activity: ActivityBus;
+}
+
+interface PluginConfigInputs {
+  uiService: InkUIService;
+  shutdown: ShutdownFn | undefined;
+  appConfig: AppConfig;
+}
+
+/**
+ * Build the plugin config object passed into a plugin's factory.
+ * Every plugin (configured or locally discovered) receives:
+ *  - `ui` — UIService for dialogs/toasts/status
+ *  - `shutdown` — graceful shutdown hook (when available)
+ *  - `config` — the host's ProviderConfig snapshot (baseUrl, model, …) so
+ *    plugins that need to call the LLM (e.g. subagents) don't have to be
+ *    re-configured manually
+ *  - `model` — the host's currently configured model id
+ */
+function buildPluginConfig(inputs: PluginConfigInputs, base?: Record<string, unknown>): Record<string, unknown> {
+  const merged: Record<string, unknown> = base ? { ...base } : {};
+  merged.ui = inputs.uiService;
+  if (inputs.shutdown) merged.shutdown = inputs.shutdown;
+  // Forward provider info so plugins can re-issue LLM calls (e.g. subagents)
+  // without forcing users to duplicate `baseUrl`/`model` in plugin config.
+  if (!('config' in merged)) merged.config = inputs.appConfig;
+  if (!('model' in merged) && inputs.appConfig.model) merged.model = inputs.appConfig.model;
+  return merged;
+}
+
+/**
+ * Fallback shutdown used when the host (typically tests) doesn't supply one.
+ * Logs a warning when a plugin actually invokes it: production hosts always
+ * pass the real `registerShutdown(...)` handle, so an invocation here means
+ * either the test setup forgot to mock the plugin's shutdown call or a
+ * plugin is reaching for `ctx.shutdown()` in an environment that can't honour
+ * it. Resolves cleanly so the calling plugin sees no behavioural change.
+ */
+async function noopShutdown(code?: number): Promise<void> {
+  console.warn(`[mu-coding] noopShutdown invoked (code=${code ?? 0}); host did not register a real shutdown handler.`);
+}
+
+/**
+ * Wire mu-coding's standard plugin set:
+ *  1. mu-openai-provider — registers the OpenAI streaming provider
+ *  2. mu-agents          — agent switcher + permissions + approval gateway
+ *  3. mu-coding          — coding tools + TUI channel + Ink approval channel
+ *                          (registered against mu-agents' gateway)
+ *
+ * Order matters: mu-coding must activate *after* mu-agents so the approval
+ * channel finds the gateway via `ctx.getPlugin('mu-agents')`.
+ *
+ * Optional plugins (mu-coding-agents, mu-repomap, …) are opt-in via
+ * `config.plugins` and loaded below by `loadConfiguredPlugin`.
+ */
+async function registerBuiltins(
+  registry: PluginRegistry,
+  options: CreateRegistryOptions,
+  inputs: PluginConfigInputs,
+  messageBus: HostMessageBus,
+): Promise<void> {
+  await registry.register(createOpenAIProviderPlugin());
+  await registry.register(
+    createAgentsPlugin({
+      config: options.config,
+      model: options.config.model,
+      approvalChannelId: 'tui',
+    }),
+  );
+  await registry.register(
+    createCodingPlugin({
+      appConfig: options.config,
+      initialMessages: options.initialMessages,
+      messageBus,
+      uiService: options.uiService,
+      shutdown: options.shutdown ?? noopShutdown,
+      // Pass the concrete registry: the TUI subscribes to renderer / shortcut
+      // / status streams that are not part of the narrow `PluginRegistryView`
+      // exposed via `ctx.registry`.
+      registry,
+    }),
+  );
+  // Silence unused-input warning when no configured/local plugins exist.
+  void inputs;
+}
+
+export async function createRegistry(options: CreateRegistryOptions): Promise<RegistryBundle> {
+  const { cwd, config, uiService, shutdown } = options;
+  const messageBus = createMessageBus();
+  const providers = createProviderRegistry();
+  const channels = createChannelRegistry();
+  const activity = createActivityBus();
+  const registry = new PluginRegistry({
+    cwd,
+    config: {},
+    ui: uiService,
+    shutdown,
+    messages: messageBus,
+    providers,
+    channels,
+    activity,
+  });
+
+  const inputs: PluginConfigInputs = { uiService, shutdown, appConfig: config };
+
+  await registerBuiltins(registry, options, inputs, messageBus);
+
+  // User-extension plugins ride on top of the builtins.
+  for (const filePath of discoverPluginFiles()) {
+    await loadConfiguredPlugin(registry, filePath, buildPluginConfig(inputs), uiService);
+  }
+
+  for (const entry of config.plugins ?? []) {
+    const name = typeof entry === 'string' ? entry : entry.name;
+    const pluginConfig = typeof entry === 'string' ? undefined : entry.config;
+    await loadConfiguredPlugin(registry, name, buildPluginConfig(inputs, pluginConfig), uiService);
+  }
+
+  return { registry, messageBus, providers, channels, activity };
+}

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

@@ -0,0 +1,122 @@
+import { readdirSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join, resolve } from 'node:path';
+import type { Plugin, PluginRegistry } from 'mu-core';
+import { getDataDir, getPluginsDir, parseBareNpmSpec } from '../config/index';
+import type { InkUIService } from '../tui/plugins/InkUIService';
+
+export function discoverPluginFiles(): string[] {
+  const dir = getPluginsDir();
+  try {
+    return readdirSync(dir)
+      .filter((f) => f.endsWith('.ts'))
+      .map((f) => join(dir, f));
+  } catch {
+    return [];
+  }
+}
+
+function formatPluginError(name: string, err: unknown): string {
+  const parts: string[] = [`Plugin "${name}" failed`];
+  let current: unknown = err;
+  while (current) {
+    if (current instanceof Error) {
+      parts.push(current.message);
+      current = current.cause;
+    } else {
+      parts.push(String(current));
+      break;
+    }
+  }
+  return parts.join(': ');
+}
+
+function resolveNpmPlugin(specifier: string): string {
+  const { name } = parseBareNpmSpec(specifier.slice(4));
+  const dataDir = getDataDir();
+  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 });
+  }
+}
+
+function isPluginShape(value: unknown): value is Plugin {
+  return typeof value === 'object' && value !== null && 'name' in value && typeof (value as Plugin).name === 'string';
+}
+
+/**
+ * Extract a plugin from a loaded module. Tries (in order):
+ *   1. `module.default` as a factory function
+ *   2. `module.createPlugin` as a factory function
+ *   3. `module.default` as a Plugin object
+ *   4. `module` as a Plugin object
+ *
+ * Returns `null` if no plugin shape matches; the caller should report this
+ * with the list of available exports for debugging.
+ */
+function extractPlugin(mod: Record<string, unknown>, pluginConfig: Record<string, unknown>): Plugin | null {
+  const factory = (mod.default ?? mod.createPlugin) as unknown;
+  if (typeof factory === 'function') {
+    const result = (factory as (cfg: Record<string, unknown>) => unknown)(pluginConfig);
+    return isPluginShape(result) ? result : null;
+  }
+  if (isPluginShape(mod.default)) {
+    return mod.default;
+  }
+  if (isPluginShape(mod)) {
+    return mod;
+  }
+  return null;
+}
+
+/**
+ * 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<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 null;
+  }
+  let mod: Record<string, unknown>;
+  try {
+    mod = (await import(target)) as Record<string, unknown>;
+  } catch (err) {
+    uiService?.notify(formatPluginError(name, err), 'error');
+    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 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) {
+    uiService?.notify(formatPluginError(name, err), 'error');
+  }
+}

package/src/sessions/index.test.ts

@@ -0,0 +1,66 @@
+import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { clearSessionCache, listSessionsAsync, loadSession, saveSession } from './index';
+
+let tmpRoot: string;
+let originalDataHome: string | undefined;
+
+beforeAll(() => {
+  tmpRoot = mkdtempSync(join(tmpdir(), 'mu-sessions-'));
+  originalDataHome = process.env.XDG_DATA_HOME;
+  process.env.XDG_DATA_HOME = tmpRoot;
+});
+
+afterAll(() => {
+  if (originalDataHome === undefined) {
+    delete process.env.XDG_DATA_HOME;
+  } else {
+    process.env.XDG_DATA_HOME = originalDataHome;
+  }
+  clearSessionCache();
+});
+
+describe('saveSession / loadSession', () => {
+  it('round-trips messages as JSONL', async () => {
+    const path = join(tmpRoot, 'roundtrip.jsonl');
+    const messages = [
+      { role: 'user' as const, content: 'hi' },
+      { role: 'assistant' as const, content: 'hello' },
+    ];
+    await saveSession(path, messages);
+
+    const raw = readFileSync(path, 'utf-8');
+    expect(raw.split('\n').filter(Boolean)).toHaveLength(2);
+
+    const loaded = loadSession(path);
+    expect(loaded).toEqual(messages);
+  });
+
+  it('returns [] for missing files', () => {
+    expect(loadSession(join(tmpRoot, 'does-not-exist.jsonl'))).toEqual([]);
+  });
+
+  it('skips malformed JSONL lines', () => {
+    const path = join(tmpRoot, 'partial.jsonl');
+    writeFileSync(path, '{"role":"user","content":"ok"}\n{not json}\n{"role":"assistant","content":"yo"}\n');
+    const loaded = loadSession(path);
+    expect(loaded).toHaveLength(2);
+    expect(loaded[0].role).toBe('user');
+    expect(loaded[1].role).toBe('assistant');
+  });
+
+  it('writes empty content for empty arrays', async () => {
+    const path = join(tmpRoot, 'empty.jsonl');
+    await saveSession(path, []);
+    expect(readFileSync(path, 'utf-8')).toBe('');
+  });
+});
+
+describe('listSessionsAsync', () => {
+  it('returns [] when no project sessions exist', async () => {
+    const list = await listSessionsAsync();
+    expect(Array.isArray(list)).toBe(true);
+  });
+});