mu-coding 0.15.0 → 0.16.1

package/src/ui/transcript.ts

@@ -0,0 +1,399 @@
+import type { ContentPart, Message } from 'mu-core';
+import { column, type Component, truncateToWidth, visibleWidth, wrapText } from 'mu-tui';
+import type { AgentSessionEvent } from 'mu-harness';
+import { renderMarkdown } from './markdown';
+import { styleToAnsi, type Theme } from './theme';
+
+const RESET = '\x1b[0m';
+const PAD = 1;
+const COLLAPSE_LIMIT = 8;
+
+export type Entry =
+  | { kind: 'user'; text: string }
+  | { kind: 'reasoning'; text: string; closed: boolean }
+  | { kind: 'assistant'; text: string }
+  | { kind: 'tool_call'; name: string; input: unknown }
+  | { kind: 'shell'; cmd: string; output: string; error: boolean }
+  | {
+    kind: 'subagent';
+    agent: string;
+    status: SubAgentStatus;
+    tools: number;
+    activity: string;
+    result: string;
+    log: string[];
+    open: boolean;
+  }
+  | { kind: 'note'; text: string; error: boolean };
+
+type ReasoningEntry = Extract<Entry, { kind: 'reasoning' }>;
+type SubAgentEntry = Extract<Entry, { kind: 'subagent' }>;
+
+export type SubAgentStatus = 'running' | 'done' | 'error';
+
+export interface SubAgentHandle {
+  addTool(label: string): void;
+  finish(result: string): void;
+  fail(message: string): void;
+}
+
+const partsToText = (parts: readonly ContentPart[]): string =>
+  parts.map((part) => (part.type === 'text' ? part.text : part.type === 'tool_result' ? partsToText(part.content) : ''))
+    .join('');
+
+const isToolResults = (message: Message): boolean =>
+  message.content.length > 0 && message.content.every((part) => part.type === 'tool_result');
+
+export class Transcript {
+  entries: Entry[] = [];
+  expanded = false;
+  thinkingVisible = false;
+  private pending: { kind: 'assistant'; text: string } | undefined;
+  private pendingReasoning: ReasoningEntry | undefined;
+
+  reset(): void {
+    this.entries = [];
+    this.pending = undefined;
+    this.pendingReasoning = undefined;
+  }
+
+  private closeReasoning(): void {
+    if (this.pendingReasoning) this.pendingReasoning.closed = !this.thinkingVisible;
+    this.pendingReasoning = undefined;
+  }
+
+  toggleExpanded(): boolean {
+    if (!this.entries.some((e) => e.kind === 'shell')) return false;
+    this.expanded = !this.expanded;
+    return true;
+  }
+
+  toggleReasoning(): boolean {
+    this.thinkingVisible = !this.thinkingVisible;
+    for (const entry of this.entries) {
+      if (entry.kind === 'reasoning') entry.closed = !this.thinkingVisible;
+    }
+    return this.thinkingVisible;
+  }
+
+  appendUser(text: string): void {
+    this.entries.push({ kind: 'user', text });
+  }
+
+  note(content: string, error = false): void {
+    this.entries.push({ kind: 'note', text: content, error });
+  }
+
+  appendSubAgent(agent: string): SubAgentHandle {
+    const entry: SubAgentEntry = {
+      kind: 'subagent',
+      agent,
+      status: 'running',
+      tools: 0,
+      activity: '',
+      result: '',
+      log: [],
+      open: false,
+    };
+    this.entries.push(entry);
+    return {
+      addTool: (label) => {
+        entry.tools += 1;
+        entry.activity = label;
+        entry.log.push(label);
+      },
+      finish: (result) => {
+        entry.status = 'done';
+        entry.activity = '';
+        entry.result = result;
+      },
+      fail: (message) => {
+        entry.status = 'error';
+        entry.activity = '';
+        entry.result = message;
+      },
+    };
+  }
+
+  appendShell(cmd: string): { setOutput: (output: string, error?: boolean) => void } {
+    const entry: Entry = { kind: 'shell', cmd, output: '', error: false };
+    this.entries.push(entry);
+    return {
+      setOutput: (output, error = false) => {
+        entry.output = output;
+        entry.error = error;
+      },
+    };
+  }
+
+  seed(messages: readonly Message[]): void {
+    this.reset();
+    for (const message of messages) {
+      if (message.role === 'system') continue;
+      if (message.role === 'assistant') {
+        const txt = partsToText(message.content);
+        if (txt) this.entries.push({ kind: 'assistant', text: txt });
+        for (const part of message.content) {
+          if (part.type === 'tool_call') this.entries.push({ kind: 'tool_call', name: part.name, input: part.input });
+        }
+      } else if (!isToolResults(message)) {
+        this.entries.push({ kind: 'user', text: partsToText(message.content) });
+      }
+    }
+  }
+
+  applyEvent(event: AgentSessionEvent): void {
+    switch (event.type) {
+      case 'turn_start':
+        this.pending = undefined;
+        this.pendingReasoning = undefined;
+        return;
+      case 'reasoning': {
+        if (!this.pendingReasoning) {
+          this.pendingReasoning = { kind: 'reasoning', text: '', closed: !this.thinkingVisible };
+          this.entries.push(this.pendingReasoning);
+        }
+        this.pendingReasoning.text += event.text;
+        return;
+      }
+      case 'text': {
+        this.closeReasoning();
+        if (!this.pending) {
+          this.pending = { kind: 'assistant', text: '' };
+          this.entries.push(this.pending);
+        }
+        this.pending.text += event.text;
+        return;
+      }
+      case 'tool_call':
+        this.closeReasoning();
+        if (event.name === 'subagent') return;
+        this.entries.push({ kind: 'tool_call', name: event.name, input: event.input });
+        return;
+      case 'message': {
+        const message = event.message;
+        if (message.role === 'assistant') {
+          const txt = partsToText(message.content);
+          if (this.pending) this.pending.text = txt;
+          else if (txt) this.entries.push({ kind: 'assistant', text: txt });
+          this.pending = undefined;
+          this.closeReasoning();
+        }
+        return;
+      }
+      case 'turn_end':
+      case 'done':
+        this.pending = undefined;
+        this.closeReasoning();
+        return;
+    }
+  }
+}
+
+const stringifyArg = (value: unknown): string => {
+  if (value === undefined || value === null) return '';
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) return value.map(stringifyArg).filter(Boolean).join(' ');
+  return JSON.stringify(value) ?? '';
+};
+
+const truncateText = (value: string, max: number): string =>
+  value.length > max ? `${value.slice(0, Math.max(0, max - 1))}…` : value;
+
+export function formatToolArgs(name: string, input: unknown, max = 120): string {
+  if (input === null || typeof input !== 'object') return truncateText(String(input ?? ''), max);
+  const args = input as Record<string, unknown>;
+  if (name === 'edit' || name === 'write' || name === 'read' || name === 'list_dir') {
+    return truncateText(stringifyArg(args.path), max);
+  }
+  if (name === 'bash') return truncateText(stringifyArg(args.cmd), max);
+  if (name === 'subagent') return truncateText(stringifyArg(args.agent), max);
+  return truncateText(Object.values(args).map(stringifyArg).filter(Boolean).join(' '), max);
+}
+
+const fit = (line: string, width: number): string => visibleWidth(line) > width ? truncateToWidth(line, width) : line;
+
+const SPACER: Component = { render: (s) => s.text(0, 0, '') };
+
+const userEntry = (value: string, theme: Theme): Component => ({
+  render: (s) => {
+    if (s.width <= 0) return;
+    const bg = theme.styles.userMessage.bg;
+    if (bg) s.fill({ x: 0, y: 0, width: s.width, height: s.height }, bg);
+    const muted = styleToAnsi(theme.styles.muted);
+    const body = styleToAnsi(theme.styles.userMessage);
+    const innerW = Math.max(1, s.width - PAD - 2 - PAD);
+    const wrapped = value.split('\n').flatMap((line) => wrapText(line, innerW));
+    for (let i = 0; i < wrapped.length; i++) {
+      if (i === 0) s.text(PAD, 0, `${muted}❯${RESET}`);
+      s.text(PAD + 2, i, `${body}${wrapped[i]}${RESET}`);
+    }
+  },
+});
+
+const assistantEntry = (value: string, theme: Theme): Component => ({
+  render: (s) => {
+    if (s.width <= 0) return;
+    const innerW = Math.max(1, s.width - PAD * 2);
+    const lines = renderMarkdown(value || '…', innerW, theme);
+    for (let i = 0; i < lines.length; i++) s.text(PAD, i, fit(lines[i], innerW));
+  },
+});
+
+const leftClick = (event: { type: string; kind?: string; button?: string }): boolean =>
+  event.type === 'mouse' && event.kind === 'press' && event.button === 'left';
+
+const reasoningComponent = (entry: ReasoningEntry, theme: Theme): Component => {
+  const style = styleToAnsi(theme.styles.reasoning);
+  if (entry.closed) {
+    return {
+      handleInput: (event) => {
+        if (leftClick(event)) entry.closed = false;
+      },
+      render: (s) => {
+        if (s.width <= 0) return;
+        s.text(PAD, 0, `${style}[thinking]${RESET}`);
+      },
+    };
+  }
+  return {
+    render: (s) => {
+      if (s.width <= 0) return;
+      const innerW = Math.max(1, s.width - PAD * 2);
+      const wrapped = entry.text.split('\n').flatMap((line) => wrapText(line, innerW));
+      for (let i = 0; i < wrapped.length; i++) s.text(PAD, i, `${style}${fit(wrapped[i], innerW)}${RESET}`);
+    },
+  };
+};
+
+const toolEntry = (name: string, input: unknown, theme: Theme): Component => ({
+  render: (s) => {
+    if (s.width <= 0) return;
+    const muted = styleToAnsi(theme.styles.muted);
+    const args = formatToolArgs(name, input);
+    const line = args ? `→ ${name} ${args}` : `→ ${name}`;
+    s.text(PAD, 0, `${muted}${fit(line, Math.max(1, s.width - PAD * 2))}${RESET}`);
+  },
+});
+
+const noteEntry = (value: string, error: boolean, theme: Theme): Component => ({
+  render: (s) => {
+    if (s.width <= 0) return;
+    const innerW = Math.max(1, s.width - PAD * 2);
+    if (error) {
+      const head = styleToAnsi(theme.styles.errorPrefix);
+      const tail = styleToAnsi(theme.styles.errorLine);
+      s.text(PAD, 0, `${head}! ${RESET}${tail}${fit(value, Math.max(1, innerW - 2))}${RESET}`);
+    } else {
+      s.text(PAD, 0, `${styleToAnsi(theme.styles.muted)}${fit(value, innerW)}${RESET}`);
+    }
+  },
+});
+
+const shellEntry = (cmd: string, output: string, error: boolean, expanded: boolean, theme: Theme): Component => {
+  const innerWidthFor = (w: number) => Math.max(1, w - 2);
+  return {
+    render: (s) => {
+      if (s.width <= 0) return;
+      const bg = error ? theme.colors.surfaceMuted : theme.colors.surface;
+      s.fill({ x: 0, y: 0, width: s.width, height: s.height }, bg);
+      const headerStyle = styleToAnsi({ fg: theme.colors.textMuted });
+      const outputStyle = styleToAnsi({ fg: theme.colors.text });
+      const innerW = innerWidthFor(s.width);
+      s.text(1, 1, `${headerStyle}${fit(cmd, innerW)}${RESET}`);
+      const all = wrapText(output, innerW);
+      const lines = expanded || all.length <= COLLAPSE_LIMIT ? all : all.slice(0, COLLAPSE_LIMIT);
+      const truncated = expanded ? 0 : Math.max(0, all.length - COLLAPSE_LIMIT);
+      for (let i = 0; i < lines.length; i++) s.text(1, 3 + i, `${outputStyle}${lines[i]}${RESET}`);
+      let bottom = 3 + lines.length;
+      if (truncated > 0) {
+        s.text(1, bottom, `${headerStyle}... ${truncated} more lines (ctrl+o)${RESET}`);
+        bottom += 1;
+      }
+      s.text(0, bottom, '');
+    },
+  };
+};
+
+const SUBAGENT_ICON: Record<SubAgentStatus, string> = { running: '◐', done: '✓', error: '✗' };
+
+const subAgentEntry = (entry: SubAgentEntry, theme: Theme): Component => {
+  const iconColor = entry.status === 'done'
+    ? theme.colors.success
+    : entry.status === 'error'
+    ? theme.styles.errorPrefix.fg ?? theme.colors.warning
+    : theme.colors.accent;
+  return {
+    handleInput: (event) => {
+      if (leftClick(event)) entry.open = !entry.open;
+    },
+    render: (s) => {
+      if (s.width <= 0) return;
+      const innerW = Math.max(1, s.width - PAD * 2);
+      const icon = styleToAnsi({ fg: iconColor, bold: true });
+      const name = styleToAnsi({ fg: theme.colors.accent, bold: true });
+      const muted = styleToAnsi(theme.styles.muted);
+      const meta = entry.tools > 0 ? ` · ${entry.tools} tool${entry.tools === 1 ? '' : 's'}` : '';
+      const header = `${icon}${
+        SUBAGENT_ICON[entry.status]
+      }${RESET} ${name}@${entry.agent}${RESET}${muted} ${entry.status}${meta}${RESET}`;
+      s.text(PAD, 0, fit(header, innerW));
+      let row = 1;
+      if (entry.open && entry.log.length > 0) {
+        for (const label of entry.log) {
+          s.text(PAD + 2, row, `${muted}→ ${fit(label, Math.max(1, innerW - 2))}${RESET}`);
+          row += 1;
+        }
+      } else if (entry.status === 'running' && entry.activity) {
+        s.text(PAD + 2, row, `${muted}→ ${fit(entry.activity, Math.max(1, innerW - 2))}${RESET}`);
+        row += 1;
+      }
+      if (entry.result) {
+        const lines = renderMarkdown(entry.result, innerW, theme);
+        const shown = entry.open ? lines : lines.slice(0, COLLAPSE_LIMIT);
+        for (const line of shown) {
+          s.text(PAD, row, fit(line, innerW));
+          row += 1;
+        }
+        const hidden = lines.length - shown.length;
+        if (hidden > 0) {
+          s.text(PAD, row, `${muted}… ${hidden} more lines (click)${RESET}`);
+          row += 1;
+        }
+      }
+      s.text(0, row, '');
+    },
+  };
+};
+
+export function entryComponent(entry: Entry, theme: Theme, expanded: boolean): Component {
+  switch (entry.kind) {
+    case 'user':
+      return userEntry(entry.text, theme);
+    case 'reasoning':
+      return reasoningComponent(entry, theme);
+    case 'assistant':
+      return assistantEntry(entry.text, theme);
+    case 'tool_call':
+      return toolEntry(entry.name, entry.input, theme);
+    case 'shell':
+      return shellEntry(entry.cmd, entry.output || '…', entry.error, expanded, theme);
+    case 'subagent':
+      return subAgentEntry(entry, theme);
+    case 'note':
+      return noteEntry(entry.text, entry.error, theme);
+  }
+}
+
+export function transcriptComponent(model: Transcript, theme: Theme): Component {
+  return {
+    render: (s) => {
+      const children: Component[] = [];
+      for (const entry of model.entries) {
+        children.push(entryComponent(entry, theme, model.expanded));
+        children.push(SPACER);
+      }
+      column(children).render(s);
+    },
+  };
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/bin/mu.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-import '../src/main.ts';

package/prompts/SYSTEM.md

@@ -1,16 +0,0 @@
-You are mu, a terminal coding agent. Be concise, direct, accurate.
-
-## Working style
-- Investigate before editing; don't guess at APIs.
-- Issue independent tool calls in parallel.
-- Ask only when genuinely ambiguous; otherwise proceed.
-- After non-trivial edits, run the project's check command if known (e.g. `bun run check`).
-
-## Output
-- Plain terminal text. Backticks for `paths`, `commands`, `identifiers`.
-- Reference code as `path/to/file.ts:LINE`.
-- No filler. Lead with the result or next action.
-
-## Safety
-- Never run destructive commands (`rm -rf`, force-push, history rewrites) without explicit request.
-- Never commit, amend, or push unless asked.

package/src/app/shutdown.ts

@@ -1,94 +0,0 @@
-import type { PluginRegistry } from 'mu-core';
-
-/**
- * Escape sequences to disable every SGR mouse-tracking mode the TUI may have
- * enabled (or inherited from a stale prior session). Disabling already-off
- * modes is a no-op, so we send all three defensively to avoid leaking mouse
- * tracking into the parent shell after abort.
- *  - 1000 = X10/normal (press+release)         ← what `useScroll` enables
- *  - 1002 = button-event tracking (press+drag) ← legacy, prior versions
- *  - 1003 = any-event tracking (all motion)    ← belt-and-suspenders
- *  - 1006 = SGR-encoded coordinates extension
- */
-const DISABLE_MOUSE_MODE = '\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l';
-
-/** Restore the kitty keyboard protocol stack — symmetric with renderApp's enable. */
-const POP_KITTY_KEYBOARD = '\x1b[<u';
-
-export type ShutdownFn = (code?: number) => Promise<void>;
-
-let registered = false;
-
-/**
- * Install graceful-shutdown handlers and return a `shutdown` function the TUI
- * can invoke directly when the user requests a quit.
- *
- * Coverage:
- *  - terminal close / external kill (SIGHUP, SIGTERM)
- *  - normal Node shutdown via `beforeExit`
- *  - uncaught exceptions / unhandled rejections (best-effort terminal restore)
- *  - explicit quit from `useAbort` (calls the returned `shutdown` directly)
- *
- * SIGINT is intentionally NOT trapped: Ink owns Ctrl+C through the `useInput`
- * hook (`exitOnCtrlC: false` in renderApp) and `useAbort` implements the
- * double-press quit UX, calling the returned function on confirmation.
- *
- * The function is idempotent — concurrent invocations resolve to the same
- * outcome and the handlers fire only once.
- *
- * `getRegistry` is a thunk so the shutdown handle can be created BEFORE the
- * registry (the registry consumes `shutdown` in its plugin context, creating
- * a cycle if both were eager).
- */
-export function registerShutdown(getRegistry: () => PluginRegistry | null): ShutdownFn {
-  let shuttingDown: Promise<void> | null = null;
-
-  const shutdown: ShutdownFn = (code = 0) => {
-    if (shuttingDown) {
-      return shuttingDown;
-    }
-    shuttingDown = (async () => {
-      try {
-        const registry = getRegistry();
-        if (registry) {
-          await registry.shutdown();
-        }
-      } catch (err) {
-        console.error('Shutdown error:', err instanceof Error ? err.message : err);
-      } finally {
-        restoreTerminal();
-        // `process.exit` from inside an `async` function still terminates
-        // synchronously after the current microtask queue drains.
-        process.exit(code);
-      }
-    })();
-    return shuttingDown;
-  };
-
-  if (!registered) {
-    registered = true;
-    process.once('SIGTERM', () => void shutdown(143));
-    process.once('SIGHUP', () => void shutdown(129));
-    process.once('beforeExit', (code) => void shutdown(code));
-    process.once('uncaughtException', (err) => {
-      restoreTerminal();
-      console.error(err);
-      process.exit(1);
-    });
-    process.once('unhandledRejection', (err) => {
-      restoreTerminal();
-      console.error(err);
-      process.exit(1);
-    });
-  }
-
-  return shutdown;
-}
-
-export function restoreTerminal(): void {
-  try {
-    process.stdout.write(`${DISABLE_MOUSE_MODE}${POP_KITTY_KEYBOARD}`);
-  } catch {
-    // stdout may already be closed during teardown — nothing to do.
-  }
-}

package/src/app/startApp.ts

@@ -1,49 +0,0 @@
-import type { PluginRegistry } from 'mu-core';
-import { parseArgs, resolveInitialMessages } from '../cli/args';
-import { handleSubcommand } from '../cli/subcommands';
-import { loadConfig } from '../config/index';
-import { createRegistry } from '../runtime/createRegistry';
-import { checkForUpdatesInBackground } from '../runtime/startupUpdateCheck';
-import { InkUIService } from '../tui/plugins/InkUIService';
-import { registerShutdown } from './shutdown';
-
-async function runApp(): Promise<void> {
-  if (await handleSubcommand()) return;
-
-  const cliArgs = parseArgs();
-  const config = loadConfig(cliArgs.model);
-  const uiService = new InkUIService();
-
-  // Create the shutdown handle BEFORE the registry so we can pass it into the
-  // plugin context. The registry is bound through a thunk, filled in once
-  // construction completes.
-  let registryRef: PluginRegistry | null = null;
-  const shutdown = registerShutdown(() => registryRef);
-
-  const initialMessages = resolveInitialMessages(cliArgs);
-  const { registry, channels } = await createRegistry({
-    cwd: process.cwd(),
-    config,
-    uiService,
-    initialMessages,
-    shutdown,
-  });
-  registryRef = registry;
-
-  // Fire-and-forget npm registry probe — surfaces a toast via uiService.notify
-  // if mu or an installed npm plugin has a newer version. Cached for 24h to
-  // avoid hammering the registry; disable with MU_NO_UPDATE_CHECK=1.
-  void checkForUpdatesInBackground(uiService);
-
-  // The TUI is registered as a `Channel` by `createCodingPlugin`. Starting
-  // it mounts Ink with the same options that were captured at activation
-  // time (config, initialMessages, registry, messageBus, uiService, shutdown).
-  await channels.startAll();
-}
-
-export function startApp(): void {
-  runApp().catch((err) => {
-    console.error(err);
-    process.exit(1);
-  });
-}