mu-coding 0.4.0 → 0.5.0

package/src/tui/{services/uiService.ts → plugins/InkUIService.ts}

@@ -1,3 +1,5 @@
+import type { UIService } from 'mu-agents';
+
 export type DialogType = 'confirm' | 'select' | 'input';
 
 export interface DialogRequest {
@@ -17,32 +19,44 @@ export interface ToastRequest {
 
 let nextDialogId = 0;
 
+type ToastListener = (toast: ToastRequest) => void;
+type StatusListener = (entries: Map<string, string>) => void;
+
 /**
- * InkUIService bridges plugin UI requests with ink's React rendering.
+ * InkUIService bridges plugin UI requests with Ink's React rendering.
+ *
+ * All event channels (dialogs, toasts, status) follow the same multi-listener
+ * pattern: `subscribe`/`onToast`/`onStatusChange` return an unsubscribe
+ * function. This lets multiple components observe the same service safely
+ * (e.g. during hot-reload or component swaps) without one handler clobbering
+ * another.
  *
- * Dialog methods (confirm, select, input) push requests into a queue.
- * The TUI's DialogLayer component consumes the queue and renders appropriate modals.
- * When the user interacts, the promise is resolved.
+ * Toasts emitted before any listener subscribes are buffered and replayed
+ * to the first subscriber; this avoids losing plugin-load errors emitted
+ * before the TUI mounts.
  *
- * This class implements the same shape as mu-pi-compat's UIService interface
- * via structural typing — no import needed.
+ * Implements `UIService` from `mu-agents` — gives nominal typing so a
+ * change on either side fails the build.
  */
-export class InkUIService {
+export class InkUIService implements UIService {
   private dialogQueue: DialogRequest[] = [];
-  private subscribers: Set<() => void> = new Set();
-  private toastCallback: ((toast: ToastRequest) => void) | null = null;
+  private dialogSubscribers: Set<() => void> = new Set();
+  private toastListeners: Set<ToastListener> = new Set();
+  private pendingToasts: ToastRequest[] = [];
   private statusMap: Map<string, string> = new Map();
-  private statusCallback: ((entries: Map<string, string>) => void) | null = null;
+  private statusListeners: Set<StatusListener> = new Set();
 
-  // ─── Subscription (used by React hooks) ─────────────────────────────────
+  // ─── Dialog Subscription (used by DialogLayer) ──────────────────────────
 
   subscribe(fn: () => void): () => void {
-    this.subscribers.add(fn);
-    return () => this.subscribers.delete(fn);
+    this.dialogSubscribers.add(fn);
+    return () => {
+      this.dialogSubscribers.delete(fn);
+    };
   }
 
-  private notifySubscribers(): void {
-    for (const fn of this.subscribers) {
+  private notifyDialogSubscribers(): void {
+    for (const fn of this.dialogSubscribers) {
       fn();
     }
   }
@@ -57,7 +71,7 @@ export class InkUIService {
     const dialog = this.dialogQueue.shift();
     if (dialog) {
       dialog.resolve(value);
-      this.notifySubscribers();
+      this.notifyDialogSubscribers();
     }
   }
 
@@ -66,27 +80,44 @@ export class InkUIService {
     const dialog = this.dialogQueue.shift();
     if (dialog) {
       dialog.resolve(dialog.type === 'confirm' ? false : null);
-      this.notifySubscribers();
+      this.notifyDialogSubscribers();
     }
   }
 
   // ─── Toast ──────────────────────────────────────────────────────────────
 
-  private pendingToasts: ToastRequest[] = [];
-
-  onToast(callback: (toast: ToastRequest) => void): void {
-    this.toastCallback = callback;
-    // Flush any toasts that fired before the TUI mounted
-    for (const toast of this.pendingToasts) {
-      callback(toast);
+  /**
+   * Subscribe to toast events. Returns an unsubscribe function. If toasts
+   * were emitted before any listener attached, they are replayed to the
+   * first subscriber once.
+   */
+  onToast(callback: ToastListener): () => void {
+    this.toastListeners.add(callback);
+    if (this.pendingToasts.length > 0) {
+      const buffered = this.pendingToasts;
+      this.pendingToasts = [];
+      for (const toast of buffered) {
+        callback(toast);
+      }
     }
-    this.pendingToasts = [];
+    return () => {
+      this.toastListeners.delete(callback);
+    };
   }
 
   // ─── Status ─────────────────────────────────────────────────────────────
 
-  onStatusChange(callback: (entries: Map<string, string>) => void): void {
-    this.statusCallback = callback;
+  onStatusChange(callback: StatusListener): () => void {
+    this.statusListeners.add(callback);
+    return () => {
+      this.statusListeners.delete(callback);
+    };
+  }
+
+  private emitStatus(): void {
+    for (const fn of this.statusListeners) {
+      fn(this.statusMap);
+    }
   }
 
   getStatusEntries(): Map<string, string> {
@@ -97,10 +128,12 @@ export class InkUIService {
 
   notify(message: string, level?: 'info' | 'success' | 'warning' | 'error'): void {
     const toast: ToastRequest = { message, level: level ?? 'info' };
-    if (this.toastCallback) {
-      this.toastCallback(toast);
-    } else {
+    if (this.toastListeners.size === 0) {
       this.pendingToasts.push(toast);
+      return;
+    }
+    for (const listener of this.toastListeners) {
+      listener(toast);
     }
   }
 
@@ -113,7 +146,7 @@ export class InkUIService {
         message,
         resolve: resolve as (value: unknown) => void,
       });
-      this.notifySubscribers();
+      this.notifyDialogSubscribers();
     });
   }
 
@@ -126,7 +159,7 @@ export class InkUIService {
         options,
         resolve: resolve as (value: unknown) => void,
       });
-      this.notifySubscribers();
+      this.notifyDialogSubscribers();
     });
   }
 
@@ -139,17 +172,17 @@ export class InkUIService {
         placeholder,
         resolve: resolve as (value: unknown) => void,
       });
-      this.notifySubscribers();
+      this.notifyDialogSubscribers();
     });
   }
 
   setStatus(key: string, text: string): void {
     this.statusMap.set(key, text);
-    this.statusCallback?.(this.statusMap);
+    this.emitStatus();
   }
 
   clearStatus(key: string): void {
     this.statusMap.delete(key);
-    this.statusCallback?.(this.statusMap);
+    this.emitStatus();
   }
 }

package/src/tui/renderApp.tsx

@@ -0,0 +1,30 @@
+import { render } from 'ink';
+import type { PluginRegistry } from 'mu-agents';
+import type { ChatMessage, ProviderConfig } from 'mu-provider';
+import type { ShutdownFn } from '../app/shutdown';
+import { ChatPanel } from './components/chat/ChatPanel';
+import type { InkUIService } from './plugins/InkUIService';
+
+interface RenderAppOptions {
+  config: ProviderConfig;
+  initialMessages?: ChatMessage[];
+  registry: PluginRegistry;
+  uiService: InkUIService;
+  shutdown: ShutdownFn;
+}
+
+export function renderApp(options: RenderAppOptions): void {
+  render(
+    <ChatPanel
+      config={options.config}
+      initialMessages={options.initialMessages}
+      registry={options.registry}
+      uiService={options.uiService}
+      shutdown={options.shutdown}
+    />,
+    {
+      exitOnCtrlC: false,
+      kittyKeyboard: { mode: 'enabled' },
+    },
+  );
+}

package/src/utils/clipboard.ts

@@ -0,0 +1,97 @@
+import { execFileSync, execSync } from 'node:child_process';
+import { existsSync, readFileSync, statSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { ImageAttachment } from 'mu-provider';
+
+const CLIPBOARD_TIMEOUT = 3000;
+
+function tryExecFile(file: string, args: string[]): boolean {
+  try {
+    execFileSync(file, args, { stdio: 'pipe', timeout: CLIPBOARD_TIMEOUT });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function tryShell(command: string): boolean {
+  try {
+    execSync(command, { stdio: 'pipe', timeout: CLIPBOARD_TIMEOUT });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function commandExists(name: string): boolean {
+  return tryExecFile('which', [name]);
+}
+
+function extractMacImage(tmpFile: string): boolean {
+  if (commandExists('pngpaste')) {
+    return tryExecFile('pngpaste', [tmpFile]);
+  }
+  // Each `-e` is a discrete script line — passing as separate args avoids shell quoting traps.
+  return tryExecFile('osascript', [
+    '-e',
+    'tell application "System Events"',
+    '-e',
+    'set imgData to the clipboard as «class PNGf»',
+    '-e',
+    `set fp to open for access POSIX file "${tmpFile}" with write permission`,
+    '-e',
+    'write imgData to fp',
+    '-e',
+    'close access fp',
+    '-e',
+    'end tell',
+  ]);
+}
+
+function extractLinuxImage(tmpFile: string): boolean {
+  // xclip / wl-paste write to stdout; redirection still requires a shell.
+  // tmpFile is constructed from tmpdir() + a numeric timestamp, so quoting is safe.
+  if (tryShell(`xclip -selection clipboard -t image/png -o > "${tmpFile}"`)) {
+    return true;
+  }
+  return tryShell(`wl-paste --type image/png > "${tmpFile}"`);
+}
+
+function extractPlatformImage(tmpFile: string): boolean {
+  if (process.platform === 'darwin') {
+    return extractMacImage(tmpFile);
+  }
+  if (process.platform === 'linux') {
+    return extractLinuxImage(tmpFile);
+  }
+  return false;
+}
+
+function readTmpAsAttachment(tmpFile: string): ImageAttachment | null {
+  if (!existsSync(tmpFile)) {
+    return null;
+  }
+  if (statSync(tmpFile).size === 0) {
+    unlinkSync(tmpFile);
+    return null;
+  }
+  const buffer = readFileSync(tmpFile);
+  unlinkSync(tmpFile);
+  return { data: buffer.toString('base64'), mimeType: 'image/png', name: 'clipboard.png' };
+}
+
+export function readClipboardImage(): ImageAttachment | null {
+  const tmpFile = join(tmpdir(), `mu-clip-${Date.now()}.png`);
+  try {
+    if (!extractPlatformImage(tmpFile)) {
+      return null;
+    }
+    return readTmpAsAttachment(tmpFile);
+  } catch {
+    if (existsSync(tmpFile)) {
+      unlinkSync(tmpFile);
+    }
+    return null;
+  }
+}

package/src/utils/diff.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'bun:test';
+import { computeDiff, renderDiff } from './diff';
+
+describe('computeDiff', () => {
+  it('emits only context lines when texts are identical', () => {
+    const diff = computeDiff('a\nb\nc', 'a\nb\nc');
+    expect(diff.lines.every((l) => l.type === 'context')).toBe(true);
+    expect(diff.lines.find((l) => l.type === 'old')).toBeUndefined();
+    expect(diff.lines.find((l) => l.type === 'new')).toBeUndefined();
+    expect(diff.totalOldLines).toBe(3);
+    expect(diff.totalNewLines).toBe(3);
+  });
+
+  it('detects an added line in the middle', () => {
+    const diff = computeDiff('a\nb\nc', 'a\nx\nb\nc');
+    const types = diff.lines.map((l) => l.type);
+    expect(types).toContain('new');
+    expect(diff.lines.find((l) => l.type === 'new')?.value).toBe('x');
+  });
+
+  it('detects a removed line', () => {
+    const diff = computeDiff('a\nb\nc', 'a\nc');
+    expect(diff.lines.find((l) => l.type === 'old')?.value).toBe('b');
+  });
+
+  it('returns no lines when either side exceeds the size limit', () => {
+    const huge = Array.from({ length: 600 }, (_, i) => `line${i}`).join('\n');
+    const diff = computeDiff(huge, huge.replace('line0', 'lineX'));
+    expect(diff.lines).toEqual([]);
+    expect(diff.totalOldLines).toBe(600);
+  });
+
+  it('emits up to CONTEXT_LINES of leading/trailing context', () => {
+    const diff = computeDiff('a\nb\nc\nd\ne', 'a\nb\nc\nX\ne');
+    const contextValues = diff.lines.filter((l) => l.type === 'context').map((l) => l.value);
+    expect(contextValues).toContain('c');
+    expect(contextValues).toContain('e');
+  });
+});
+
+describe('renderDiff', () => {
+  it('prefixes added/removed/context lines and reports truncation', () => {
+    const diff = computeDiff('a\nb', 'a\nc');
+    const { lines, truncated } = renderDiff(diff, 100);
+    expect(lines.some((l) => l.startsWith('-'))).toBe(true);
+    expect(lines.some((l) => l.startsWith('+'))).toBe(true);
+    expect(truncated).toBe(false);
+  });
+
+  it('reports truncated when diff exceeds maxLines', () => {
+    const diff = computeDiff('a', Array.from({ length: 50 }, (_, i) => `n${i}`).join('\n'));
+    const { lines, truncated } = renderDiff(diff, 5);
+    expect(lines).toHaveLength(5);
+    expect(truncated).toBe(true);
+  });
+});

package/src/cli.ts

@@ -1,96 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import type { ChatMessage } from 'mu-provider';
-import { getLatestSession, loadSession } from './session';
-
-interface CliArgs {
-  model?: string;
-  continueSession?: boolean;
-  sessionPath?: string;
-}
-
-function printHelp(): never {
-  console.log(`mu — minimal terminal AI assistant
-
-Usage:
-  mu                        Start interactive chat
-  mu -m model               Interactive with specific model
-  mu -c                     Continue most recent session
-  mu --session <path>       Resume a specific session file
-  mu install npm:<package>  Install a plugin from npm
-  mu uninstall npm:<pkg>    Remove an installed plugin
-  mu -v, --version          Print version and exit
-
-Config (XDG):
-  ~/.config/mu/config.json  — configuration (baseUrl, model, streamTimeoutMs)
-  ~/.config/mu/SYSTEM.md    — system prompt
-  ~/.local/share/mu/sessions/ — saved conversation sessions (JSONL)
-  ~/.cache/mu/repomap/        — code index cache
-
-Keyboard shortcuts (interactive):
-  Ctrl+C  Abort / Quit (press twice)
-  Esc     Stop generation (press twice while streaming)
-  Enter       Send message
-  Shift+Enter New line
-  Ctrl+S      Send message
-  ↑ / ↓   Navigate input history
-  Ctrl+N  New conversation
-  Ctrl+M  Cycle models
-  Ctrl+O  Model picker
-  Ctrl+V  Paste image from clipboard`);
-  process.exit(0);
-}
-
-function printVersion(): never {
-  const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
-  console.log(`mu ${pkg.version}`);
-  process.exit(0);
-}
-
-export function parseArgs(): CliArgs {
-  const args = process.argv.slice(2);
-  const result: CliArgs = {};
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === '-m' && args[i + 1]) {
-      result.model = args[++i];
-    } else if (arg === '-c' || arg === '--continue') {
-      result.continueSession = true;
-    } else if (arg === '--session' && args[i + 1]) {
-      result.sessionPath = args[++i];
-    } else if (arg === '-v' || arg === '--version') {
-      printVersion();
-    } else if (arg === '-h' || arg === '--help') {
-      printHelp();
-    }
-  }
-
-  return result;
-}
-
-export function resolveInitialMessages(cliArgs: CliArgs): ChatMessage[] | undefined {
-  if (cliArgs.sessionPath) {
-    const msgs = loadSession(cliArgs.sessionPath);
-    if (msgs.length === 0) {
-      console.error(`Error: session file is empty or not found: ${cliArgs.sessionPath}`);
-      process.exit(1);
-    }
-    return msgs;
-  }
-  if (cliArgs.continueSession) {
-    const latest = getLatestSession();
-    if (!latest) {
-      console.error('Error: no sessions found');
-      process.exit(1);
-    }
-    const msgs = loadSession(latest);
-    if (msgs.length === 0) {
-      console.error('Error: latest session is empty');
-      process.exit(1);
-    }
-    console.log(`Resuming session: ${latest}`);
-    return msgs;
-  }
-  return undefined;
-}

package/src/clipboard.ts

@@ -1,62 +0,0 @@
-import { execSync } from 'node:child_process';
-import { existsSync, readFileSync, statSync, unlinkSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import type { ImageAttachment } from 'mu-provider';
-
-const CLIPBOARD_TIMEOUT = 3000;
-
-function tryExecSync(command: string): boolean {
-  try {
-    execSync(command, { stdio: 'pipe', timeout: CLIPBOARD_TIMEOUT });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function extractPlatformImage(tmpFile: string): boolean {
-  if (process.platform === 'darwin') {
-    if (tryExecSync('which pngpaste')) {
-      return tryExecSync(`pngpaste "${tmpFile}"`);
-    }
-    return tryExecSync(
-      `osascript -e 'tell application "System Events" -e 'set imgData to the clipboard as «class PNGf»' -e 'set fp to open for access POSIX file "${tmpFile}" with write permission' -e 'write imgData to fp' -e 'close access fp' -e 'end tell'`,
-    );
-  }
-  if (process.platform === 'linux') {
-    if (tryExecSync(`xclip -selection clipboard -t image/png -o > "${tmpFile}"`)) {
-      return true;
-    }
-    return tryExecSync(`wl-paste --type image/png > "${tmpFile}"`);
-  }
-  return false;
-}
-
-function readTmpAsAttachment(tmpFile: string): ImageAttachment | null {
-  if (!existsSync(tmpFile)) {
-    return null;
-  }
-  if (statSync(tmpFile).size === 0) {
-    unlinkSync(tmpFile);
-    return null;
-  }
-  const buffer = readFileSync(tmpFile);
-  unlinkSync(tmpFile);
-  return { data: buffer.toString('base64'), mimeType: 'image/png', name: 'clipboard.png' };
-}
-
-export function readClipboardImage(): ImageAttachment | null {
-  const tmpFile = join(tmpdir(), `mu-clip-${Date.now()}.png`);
-  try {
-    if (!extractPlatformImage(tmpFile)) {
-      return null;
-    }
-    return readTmpAsAttachment(tmpFile);
-  } catch {
-    if (existsSync(tmpFile)) {
-      unlinkSync(tmpFile);
-    }
-    return null;
-  }
-}

package/src/config.ts

@@ -1,116 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import type { ProviderConfig } from 'mu-provider';
-
-export interface AppConfig extends ProviderConfig {
-  plugins?: Array<string | { name: string; config?: Record<string, unknown> }>;
-}
-
-export function getPluginsDir(): string {
-  return join(CONFIG_DIR, 'plugins');
-}
-
-// XDG Base Directory paths
-const HOME = homedir();
-const CONFIG_DIR = process.env.XDG_CONFIG_HOME ? join(process.env.XDG_CONFIG_HOME, 'mu') : join(HOME, '.config', 'mu');
-const DATA_DIR = process.env.XDG_DATA_HOME
-  ? join(process.env.XDG_DATA_HOME, 'mu')
-  : join(HOME, '.local', 'share', 'mu');
-const CACHE_DIR = process.env.XDG_CACHE_HOME ? join(process.env.XDG_CACHE_HOME, 'mu') : join(HOME, '.cache', 'mu');
-
-const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
-const SYSTEM_PROMPT_PATH = join(CONFIG_DIR, 'SYSTEM.md');
-
-export function getConfigDir(): string {
-  return CONFIG_DIR;
-}
-
-export function getDataDir(): string {
-  return DATA_DIR;
-}
-
-export function getCacheDir(): string {
-  return CACHE_DIR;
-}
-
-function tryRead(path: string): string | undefined {
-  try {
-    return readFileSync(path, 'utf-8').trim() || undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function tryParseJson(text: string | undefined): Partial<AppConfig> {
-  if (!text) {
-    return {};
-  }
-  try {
-    return JSON.parse(text);
-  } catch {
-    return {};
-  }
-}
-
-function envInt(key: string): number | undefined {
-  const v = process.env[key];
-  if (!v) {
-    return undefined;
-  }
-  const n = Number.parseInt(v, 10);
-  return Number.isNaN(n) ? undefined : n;
-}
-
-function envFloat(key: string): number | undefined {
-  const v = process.env[key];
-  if (!v) {
-    return undefined;
-  }
-  const n = Number.parseFloat(v);
-  return Number.isNaN(n) ? undefined : n;
-}
-
-export function loadConfig(cliModel?: string): AppConfig {
-  const file = tryParseJson(tryRead(CONFIG_PATH));
-
-  const config: AppConfig = {
-    baseUrl: process.env.MU_BASE_URL || file.baseUrl || 'http://localhost:8080/v1',
-    model: cliModel || process.env.MU_MODEL || file.model,
-    maxTokens: envInt('MU_MAX_TOKENS') ?? file.maxTokens ?? 4096,
-    temperature: envFloat('MU_TEMPERATURE') ?? file.temperature ?? 0.7,
-    streamTimeoutMs: envInt('MU_STREAM_TIMEOUT') ?? file.streamTimeoutMs ?? 60_000,
-    systemPrompt: process.env.MU_SYSTEM_PROMPT || file.systemPrompt || tryRead(SYSTEM_PROMPT_PATH),
-    plugins: file.plugins,
-  };
-
-  if (!existsSync(CONFIG_PATH)) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    const KEYS = [
-      'baseUrl',
-      'model',
-      'maxTokens',
-      'temperature',
-      'streamTimeoutMs',
-      'systemPrompt',
-      'plugins',
-    ] as const;
-    const fileConfig = Object.fromEntries(
-      KEYS.filter((k) => file[k] !== undefined).map((k) => [k, file[k]]),
-    ) as Partial<AppConfig>;
-    writeFileSync(CONFIG_PATH, JSON.stringify(fileConfig, null, 2), 'utf-8');
-  }
-
-  return config;
-}
-
-export function saveConfig(updates: Partial<AppConfig>): void {
-  const file = tryParseJson(tryRead(CONFIG_PATH));
-  const merged = { ...file, ...updates };
-  const KEYS = ['baseUrl', 'model', 'maxTokens', 'temperature', 'streamTimeoutMs', 'systemPrompt', 'plugins'] as const;
-  const fileConfig = Object.fromEntries(
-    KEYS.filter((k) => merged[k] !== undefined).map((k) => [k, merged[k]]),
-  ) as Partial<AppConfig>;
-  mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_PATH, JSON.stringify(fileConfig, null, 2), 'utf-8');
-}