mu-coding 0.5.0 → 0.8.0

package/src/runtime/codingTools/read-file.ts

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync } from 'node:fs';
+import type { PluginTool } from 'mu-core';
+import { sanitizePath } from './utils';
+
+function executeReadFileSingle(rawPath: string, cwd: string, start?: number, end?: number): string {
+  const path = sanitizePath(rawPath, cwd);
+  if (!existsSync(path)) {
+    return `Error: File not found: ${path}`;
+  }
+  try {
+    const content = readFileSync(path, 'utf-8');
+    const allLines = content.split('\n');
+    const totalLines = allLines.length;
+
+    const startLine = Math.max(1, start ?? 1);
+    const endLine = end ?? totalLines;
+    const clampedStart = Math.min(startLine, totalLines);
+    const clampedEnd = Math.min(endLine, totalLines);
+
+    if (clampedStart > clampedEnd) {
+      return `Error: start (${startLine}) > end (${endLine})`;
+    }
+
+    const lines = allLines.slice(clampedStart - 1, clampedEnd);
+    const numbered = lines.map((line, i) => `${String(clampedStart + i).padStart(4)} │ ${line}`).join('\n');
+    const rangeLabel = start ? ` (lines ${clampedStart}-${clampedEnd})` : '';
+    const header = `── ${path}${rangeLabel} (${lines.length} lines) ──`;
+    return `${header}\n${numbered}`;
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : 'Unknown error'}`;
+  }
+}
+
+export function createReadFileTool(getCwd: () => string): PluginTool {
+  return {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'read',
+        description: 'Read text file(s) with line numbers. `path` may be a single path or array.',
+        parameters: {
+          type: 'object',
+          properties: {
+            path: { type: ['string', 'array'], items: { type: 'string' } },
+            start: { type: 'integer', description: '1-indexed first line, inclusive.' },
+            end: { type: 'integer', description: '1-indexed last line, inclusive.' },
+          },
+          required: ['path'],
+          additionalProperties: false,
+        },
+      },
+    },
+    display: {
+      verb: 'reading',
+      kind: 'file-read',
+      fields: { path: 'path', start: 'start', end: 'end' },
+    },
+    permission: {
+      matchKey: (args) => {
+        const p = args.path;
+        if (typeof p === 'string') return p;
+        if (Array.isArray(p)) return p[0] as string | undefined;
+        return undefined;
+      },
+    },
+    execute(args) {
+      const paths = Array.isArray(args.path) ? (args.path as string[]) : [args.path as string];
+      const start = args.start as number | undefined;
+      const end = args.end as number | undefined;
+      const cwd = getCwd();
+
+      if (paths.length === 1) {
+        return executeReadFileSingle(paths[0], cwd, start, end);
+      }
+
+      const results: string[] = [];
+      for (const path of paths) {
+        results.push(executeReadFileSingle(path, cwd, start, end));
+      }
+      return results.join('\n\n');
+    },
+  };
+}

package/src/runtime/codingTools/utils.ts

@@ -0,0 +1,21 @@
+import { isAbsolute, resolve } from 'node:path';
+
+/**
+ * Sanitize a file path from LLM arguments.
+ * Local models often wrap paths in extra quotes or add whitespace.
+ *
+ * When `cwd` is supplied, relative paths are resolved against it instead of
+ * `process.cwd()` — this lets the agent operate on a different working
+ * directory than the host process (the host passes its `PluginContext.cwd`
+ * into the builtin plugin factory at activation time).
+ */
+export function sanitizePath(raw: string, cwd?: string): string {
+  let p = raw.trim();
+  if ((p.startsWith('"') && p.endsWith('"')) || (p.startsWith("'") && p.endsWith("'"))) {
+    p = p.slice(1, -1).trim();
+  }
+  if (cwd && !isAbsolute(p)) {
+    return resolve(cwd, p);
+  }
+  return p;
+}

package/src/runtime/codingTools/write-file.ts

@@ -0,0 +1,42 @@
+import { writeFileSync } from 'node:fs';
+import type { PluginTool } from 'mu-core';
+import { sanitizePath } from './utils';
+
+export function createWriteFileTool(getCwd: () => string): PluginTool {
+  return {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'write',
+        description: 'Create or overwrite a file. Use `edit` for partial changes to existing files.',
+        parameters: {
+          type: 'object',
+          properties: {
+            path: { type: 'string' },
+            content: { type: 'string' },
+          },
+          required: ['path', 'content'],
+          additionalProperties: false,
+        },
+      },
+    },
+    display: {
+      verb: 'writing',
+      kind: 'file-write',
+      fields: { path: 'path', content: 'content' },
+    },
+    permission: {
+      matchKey: (args) => args.path as string | undefined,
+    },
+    execute(args) {
+      const path = sanitizePath(args.path as string, getCwd());
+      const content = args.content as string;
+      try {
+        writeFileSync(path, content, 'utf-8');
+        return { content: `File written: ${path}` };
+      } catch (err) {
+        return { content: `Error: ${err instanceof Error ? err.message : 'Unknown error'}`, error: true };
+      }
+    },
+  };
+}

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

@@ -1,7 +1,20 @@
-import { createBuiltinPlugin, PluginRegistry } from 'mu-agents';
+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 {
@@ -9,50 +22,142 @@ interface CreateRegistryOptions {
   config: AppConfig;
   uiService: InkUIService;
   /**
-   * Host shutdown is forwarded to plugins via PluginContext so a plugin (or
-   * Pi extension via mu-pi-compat) calling shutdown gets the same graceful
-   * path as Ctrl+C — terminal restored, plugins deactivated.
+   * 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) gets the UI service and
- * (when available) the host shutdown so tools can prompt, toast, set status
- * segments, or trigger graceful exit without extra plumbing.
+ * 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(
-  uiService: InkUIService,
-  shutdown: ShutdownFn | undefined,
-  base?: Record<string, unknown>,
-): Record<string, unknown> {
+function buildPluginConfig(inputs: PluginConfigInputs, base?: Record<string, unknown>): Record<string, unknown> {
   const merged: Record<string, unknown> = base ? { ...base } : {};
-  merged.ui = uiService;
-  if (shutdown) merged.shutdown = shutdown;
+  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;
 }
 
-export async function createRegistry(options: CreateRegistryOptions): Promise<PluginRegistry> {
+/**
+ * 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 registry = new PluginRegistry({ cwd, config: {}, ui: uiService, shutdown });
+  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 registry.register(createBuiltinPlugin());
+  await registerBuiltins(registry, options, inputs, messageBus);
 
-  // Locally dropped plugins (~/.config/mu/plugins/*.ts) go through the same
-  // loader as configured ones so they receive `{ ui, shutdown }` and get
-  // consistent error reporting.
+  // User-extension plugins ride on top of the builtins.
   for (const filePath of discoverPluginFiles()) {
-    await loadConfiguredPlugin(registry, filePath, buildPluginConfig(uiService, shutdown), uiService);
+    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(uiService, shutdown, pluginConfig), uiService);
+    await loadConfiguredPlugin(registry, name, buildPluginConfig(inputs, pluginConfig), uiService);
   }
 
-  return registry;
+  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);
+    },
+  };
+}