mu-coding 0.5.0 → 0.8.0

package/README.md

@@ -40,16 +40,61 @@ Config files follow XDG conventions:
 }
 ```
 
+### Theming
+
+The `theme` field selects the UI palette. Either name a built-in preset:
+
+```json
+{ "theme": "solarized-dark" }
+```
+
+Built-in presets: `dark` (default), `light`, `solarized-dark`, `monochrome`.
+
+Or pass an object to override individual leaves on top of a preset:
+
+```json
+{
+  "theme": {
+    "preset": "dark",
+    "input":  { "background": "#1e1e2e", "cursor": "#f5c2e7" },
+    "user":   { "border": "magenta" },
+    "common": { "accent": "#89dceb" }
+  }
+}
+```
+
+Color values accept Ink's named colors (`red`, `green`, `cyan`, `yellow`,
+`magenta`, `blue`, `white`, `black`, `gray`) or hex strings (`#1a1a1a`).
+
+Sections available: `input`, `user`, `assistant`, `tool`, `reasoning`,
+`modal`, `toast`, `dropdown`, `dialog`, `diff`, `status`, `common`. See
+`src/tui/theme/types.ts` for the full leaf list.
+
 ## Keyboard Shortcuts
 
+### Input editing
+
+| Key | Action |
+|-----|--------|
+| `←` / `→` | Move cursor one character |
+| `Ctrl+←` / `Ctrl+→` (or `Alt+←/→`) | Move cursor by word |
+| `Home` / `End` (or `Ctrl+A` / `Ctrl+E`) | Jump to start / end of line |
+| `↑` / `↓` | Move cursor between lines (multi-line buffer); navigate history at edges |
+| `Backspace` | Delete char before cursor |
+| `Delete` | Delete char under cursor |
+| `Ctrl+W` | Delete previous word |
+| `Ctrl+U` | Delete from start of line to cursor |
+| `Ctrl+K` | Delete from cursor to end of line |
+
+### Submission & app
+
 | Key | Action |
 |-----|--------|
 | `Enter` | Send message |
-| `Shift+Enter` | New line |
+| `Shift+Enter` (or `Ctrl+J`) | New line |
 | `Ctrl+S` | Send message |
 | `Ctrl+C` | Abort / Quit (press twice) |
 | `Esc` | Stop generation (press twice) |
-| `↑` / `↓` | Navigate input history |
 | `Ctrl+N` | New conversation |
 | `Ctrl+M` | Cycle models |
 | `Ctrl+O` | Model picker |
@@ -69,7 +114,8 @@ Config files follow XDG conventions:
 
 - Streams responses with live token/s display
 - Multi-turn tool calling (bash, read, write, edit files)
-- Code indexing via `mu-repomap` plugin (auto-loaded)
+- Optional code indexing via the `mu-repomap` plugin (enable via `config.plugins`)
+- Optional default agents (build/plan/explore/review) via `mu-coding-agents` (enable via `config.plugins`)
 - Image attachment support
 - Session persistence and resume
 - Mouse wheel scrolling

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "mu-coding",
-  "version": "0.5.0",
+  "version": "0.8.0",
   "description": "Minimal terminal AI assistant for local models",
   "type": "module",
   "bin": {
     "mu": "./bin/mu.js"
   },
   "exports": {
-    "./config": "./src/config/index.ts"
+    ".": "./src/plugin.ts",
+    "./config": "./src/config/index.ts",
+    "./tools": "./src/runtime/codingTools/index.ts",
+    "./loader": "./src/runtime/pluginLoader.ts"
   },
   "files": [
     "bin",
+    "prompts",
     "src"
   ],
   "scripts": {
@@ -20,8 +24,9 @@
   },
   "dependencies": {
     "ink": "^7.0.1",
-    "mu-agents": "0.5.0",
-    "mu-provider": "0.5.0",
+    "mu-agents": "0.8.0",
+    "mu-core": "0.8.0",
+    "mu-openai-provider": "0.8.0",
     "react": "^19.2.5"
   }
 }

package/prompts/SYSTEM.md

@@ -0,0 +1,16 @@
+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,4 +1,4 @@
-import type { PluginRegistry } from 'mu-agents';
+import type { PluginRegistry } from 'mu-core';
 
 /**
  * Escape sequences to disable every SGR mouse-tracking mode the TUI may have

package/src/app/startApp.ts

@@ -1,10 +1,9 @@
-import type { PluginRegistry } from 'mu-agents';
+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 { InkUIService } from '../tui/plugins/InkUIService';
-import { renderApp } from '../tui/renderApp';
 import { registerShutdown } from './shutdown';
 
 async function runApp(): Promise<void> {
@@ -20,16 +19,20 @@ async function runApp(): Promise<void> {
   let registryRef: PluginRegistry | null = null;
   const shutdown = registerShutdown(() => registryRef);
 
-  const registry = await createRegistry({ cwd: process.cwd(), config, uiService, shutdown });
-  registryRef = registry;
-
-  renderApp({
+  const initialMessages = resolveInitialMessages(cliArgs);
+  const { registry, channels } = await createRegistry({
+    cwd: process.cwd(),
     config,
-    initialMessages: resolveInitialMessages(cliArgs),
-    registry,
     uiService,
+    initialMessages,
     shutdown,
   });
+  registryRef = registry;
+
+  // 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 {

package/src/cli/args.ts

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parseArgs as nodeParseArgs } from 'node:util';
-import type { ChatMessage } from 'mu-provider';
+import type { ChatMessage } from 'mu-core';
 import { getLatestSession, loadSession } from '../sessions/index';
 
 interface CliArgs {
@@ -31,16 +31,19 @@ Config (XDG):
   ~/.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`);
+  Ctrl+C        Abort / Quit (press twice)
+  Esc           Stop generation (press twice while streaming)
+  Enter         Send message
+  Shift+Enter   New line
+  Ctrl+S        Send message
+  ← / →         Move cursor (Ctrl/Alt+arrow: by word)
+  Home/End      Start/end of line (or Ctrl+A / Ctrl+E)
+  ↑ / ↓         Move between lines; navigate history at edges
+  Backspace/Del Delete around cursor (Ctrl+W word, Ctrl+U/K line)
+  Ctrl+N        New conversation
+  Ctrl+M        Cycle models
+  Ctrl+O        Model picker
+  Ctrl+V        Paste image from clipboard`);
   process.exit(0);
 }
 

package/src/config/index.test.ts

@@ -49,3 +49,29 @@ describe('saveConfig', () => {
     expect('model' in persisted).toBe(false);
   });
 });
+
+describe('loadConfig theme', () => {
+  it('reads the theme field from config.json', async () => {
+    const { loadConfig } = await import('./index');
+    writeFileSync(
+      configPath,
+      JSON.stringify({ baseUrl: 'http://x', theme: { preset: 'light', input: { cursor: '#abcdef' } } }),
+    );
+    const cfg = loadConfig();
+    expect(cfg.theme).toEqual({ preset: 'light', input: { cursor: '#abcdef' } });
+  });
+
+  it('accepts a preset name string', async () => {
+    const { loadConfig } = await import('./index');
+    writeFileSync(configPath, JSON.stringify({ baseUrl: 'http://x', theme: 'solarized-dark' }));
+    const cfg = loadConfig();
+    expect(cfg.theme).toBe('solarized-dark');
+  });
+
+  it('omits theme when not present', async () => {
+    const { loadConfig } = await import('./index');
+    writeFileSync(configPath, JSON.stringify({ baseUrl: 'http://x' }));
+    const cfg = loadConfig();
+    expect(cfg.theme).toBeUndefined();
+  });
+});

package/src/config/index.ts

@@ -1,7 +1,9 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
-import type { ProviderConfig } from 'mu-provider';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { ProviderConfig } from 'mu-core';
+import type { ThemeConfig } from '../tui/theme/types';
 
 // ─── XDG Path Helpers ─────────────────────────────────────────────────────────
 //
@@ -9,9 +11,6 @@ import type { ProviderConfig } from 'mu-provider';
 // "where do mu's files live?" question end-to-end (config.json, SYSTEM.md,
 // sessions, plugin caches). Resolved lazily so tests can stub the env after
 // module import; production callers pay only one `process.env` lookup per call.
-//
-// Other workspace packages (e.g. `mu-pi-compat`) import these via the
-// `mu-coding/config` subpath export — see `mu-coding/package.json`.
 
 const HOME = homedir();
 
@@ -73,6 +72,11 @@ export function canonicalNpmSpecifier(bare: string): string {
 
 export interface AppConfig extends ProviderConfig {
   plugins?: Array<string | { name: string; config?: Record<string, unknown> }>;
+  /**
+   * Optional per-leaf overrides on top of the built-in theme. See
+   * `tui/theme/types.ts` for the available sections and color leaves.
+   */
+  theme?: ThemeConfig;
 }
 
 /**
@@ -87,8 +91,8 @@ const CONFIG_FILE_KEYS = [
   'maxTokens',
   'temperature',
   'streamTimeoutMs',
-  'systemPrompt',
   'plugins',
+  'theme',
 ] as const;
 
 function configPath(): string {
@@ -99,6 +103,19 @@ function systemPromptPath(): string {
   return join(getConfigDir(), 'SYSTEM.md');
 }
 
+/**
+ * Path to the SYSTEM.md bundled with mu-coding. Used as the lowest-priority
+ * fallback when no user override is configured. Resolved from this module's
+ * location so it works both from `src/` (dev via bun) and any compiled layout
+ * that preserves the `prompts/` sibling of `src/` or `dist/`.
+ */
+function bundledSystemPromptPath(): string {
+  const here = dirname(fileURLToPath(import.meta.url));
+  // src/config/index.ts → ../../prompts/SYSTEM.md
+  // dist/config/index.js → ../../prompts/SYSTEM.md
+  return join(here, '..', '..', 'prompts', 'SYSTEM.md');
+}
+
 function tryRead(path: string): string | undefined {
   try {
     return readFileSync(path, 'utf-8').trim() || undefined;
@@ -146,8 +163,9 @@ export function loadConfig(cliModel?: string): AppConfig {
     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(systemPromptPath()),
+    systemPrompt: tryRead(systemPromptPath()) || tryRead(bundledSystemPromptPath()),
     plugins: file.plugins,
+    theme: file.theme,
   };
 
   if (!existsSync(path)) {

package/src/plugin.ts

@@ -0,0 +1,96 @@
+/**
+ * mu-coding plugin — packages the TUI channel + coding tools into a single
+ * plugin. The standalone `mu` binary uses this as its primary surface
+ * (registered by `createRegistry`) and any generic host (Arya, future web
+ * app) can opt in to the coding tools by including it in its plugin list.
+ *
+ * The factory takes a `CodingPluginConfig` rather than reading values from
+ * `PluginContext` because the TUI layer needs the **concrete**
+ * `PluginRegistry` (it subscribes to renderer / shortcut / status changes
+ * via methods that are not part of the read-only `PluginRegistryView`).
+ * `ctx.registry` only exposes the View; the host wires the concrete
+ * registry in after constructing it.
+ */
+
+import type { ApprovalGateway } from 'mu-agents';
+import type { ChatMessage, Plugin, PluginContext, PluginRegistry } from 'mu-core';
+import type { ShutdownFn } from './app/shutdown';
+import type { AppConfig } from './config/index';
+import { createCodingToolsPlugin } from './runtime/codingTools/index';
+import type { HostMessageBus } from './runtime/messageBus';
+import { createTuiChannel } from './tui/channel/tuiChannel';
+import { createInkApprovalChannel } from './tui/plugins/InkApprovalChannel';
+import type { InkUIService } from './tui/plugins/InkUIService';
+
+export interface CodingPluginConfig {
+  appConfig: AppConfig;
+  initialMessages?: ChatMessage[];
+  messageBus: HostMessageBus;
+  uiService: InkUIService;
+  shutdown: ShutdownFn;
+  /**
+   * Concrete `PluginRegistry` instance used by the TUI to subscribe to
+   * renderers / shortcuts / status segments. Required because `ctx.registry`
+   * (the read-only View) does not expose those subscription methods.
+   */
+  registry: PluginRegistry;
+}
+
+interface AgentPluginShape {
+  approvalGateway?: ApprovalGateway;
+}
+
+export function createCodingPlugin(config: CodingPluginConfig): Plugin {
+  // Coding tools are an inner plugin; we delegate via the registered tools
+  // list rather than a recursive register call so a single Plugin object
+  // is returned (matches the SDK's expected factory shape).
+  const inner = createCodingToolsPlugin();
+
+  // Captured at activation time so deactivate can clean up both registrations.
+  let unregisterTuiChannel: (() => void) | null = null;
+  let unregisterApprovalChannel: (() => void) | null = null;
+
+  return {
+    name: 'mu-coding',
+    version: '0.5.0',
+    tools: inner.tools,
+    systemPrompt: inner.systemPrompt,
+    activate(ctx: PluginContext) {
+      // Forward inner plugin's activate (captures cwd for tool path resolution).
+      inner.activate?.(ctx);
+
+      // Register the TUI channel so other code can stop it gracefully via
+      // ctx.channels.stopAll(). The TUI subscribes to the concrete registry
+      // (passed in via config), not the narrow context-exposed view.
+      unregisterTuiChannel =
+        ctx.channels?.register(
+          createTuiChannel({
+            config: config.appConfig,
+            initialMessages: config.initialMessages,
+            registry: config.registry,
+            messageBus: config.messageBus,
+            uiService: config.uiService,
+            shutdown: config.shutdown,
+          }),
+        ) ?? null;
+
+      // Register the Ink approval channel against mu-agents' gateway, when
+      // mu-agents is present. We use `ctx.getPlugin` to look it up loosely
+      // so coding still works in setups that disabled the agent plugin.
+      const agentPlugin = ctx.getPlugin?.<Plugin & AgentPluginShape>('mu-agents');
+      if (agentPlugin?.approvalGateway) {
+        unregisterApprovalChannel = agentPlugin.approvalGateway.registerChannel(
+          'tui',
+          createInkApprovalChannel(config.uiService),
+        );
+      }
+    },
+    deactivate() {
+      unregisterApprovalChannel?.();
+      unregisterApprovalChannel = null;
+      unregisterTuiChannel?.();
+      unregisterTuiChannel = null;
+      inner.deactivate?.();
+    },
+  };
+}

package/src/runtime/codingTools/bash.ts

@@ -0,0 +1,114 @@
+import { spawn } from 'node:child_process';
+import type { PluginTool, ToolExecutorResult } from 'mu-core';
+
+function executeBash(command: string, cwd: string, signal?: AbortSignal): Promise<ToolExecutorResult> {
+  return new Promise((resolve) => {
+    const proc = spawn('bash', ['-c', command], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true,
+      cwd,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data: Buffer) => {
+      try {
+        stdout += data.toString('utf-8');
+      } catch {
+        // skip binary data
+      }
+    });
+    proc.stderr.on('data', (data: Buffer) => {
+      try {
+        stderr += data.toString('utf-8');
+      } catch {
+        // skip binary data
+      }
+    });
+
+    const onAbort = () => {
+      const pid = proc.pid;
+      if (pid) {
+        try {
+          process.kill(-pid, 'SIGTERM');
+        } catch {
+          proc.kill('SIGTERM');
+        }
+        setTimeout(() => {
+          if (!proc.killed) {
+            try {
+              process.kill(-pid, 'SIGKILL');
+            } catch {
+              proc.kill('SIGKILL');
+            }
+          }
+        }, 500);
+      }
+    };
+
+    if (signal) {
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+
+    proc.on('close', (code) => {
+      signal?.removeEventListener('abort', onAbort);
+      const output = [stdout, stderr]
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .join('\n');
+      if (signal?.aborted) {
+        resolve({ content: 'Aborted', error: true });
+        return;
+      }
+      if (code !== 0 && !output) {
+        resolve({ content: `Error: Process exited with code ${code}`, error: true });
+        return;
+      }
+      // Non-zero exit with output: treat as error so the LLM sees it as such,
+      // but preserve stdout/stderr in the content.
+      resolve({ content: output || '(no output)', error: code !== 0 });
+    });
+
+    proc.on('error', (err) => {
+      signal?.removeEventListener('abort', onAbort);
+      resolve({ content: `Error: ${err.message}`, error: true });
+    });
+  });
+}
+
+export function createBashTool(getCwd: () => string): PluginTool {
+  return {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'bash',
+        description:
+          'Run a shell command via bash in the project cwd. Returns stdout+stderr; non-zero exit is an error.',
+        parameters: {
+          type: 'object',
+          properties: {
+            cmd: { type: 'string' },
+          },
+          required: ['cmd'],
+          additionalProperties: false,
+        },
+      },
+    },
+    display: {
+      verb: 'running',
+      kind: 'shell',
+      fields: { command: 'cmd' },
+    },
+    permission: {
+      matchKey: (args) => args.cmd as string | undefined,
+    },
+    execute(args, signal) {
+      return executeBash(args.cmd as string, getCwd(), signal);
+    },
+  };
+}

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

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import type { PluginTool, ToolExecutorResult } from 'mu-core';
+import { sanitizePath } from './utils';
+
+export function createEditFileTool(getCwd: () => string): PluginTool {
+  return {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'edit',
+        description: 'Replace an exact substring in an existing file.',
+        parameters: {
+          type: 'object',
+          properties: {
+            path: { type: 'string' },
+            from: {
+              type: 'string',
+              description:
+                'Must occur exactly once in the file \u2014 include surrounding context to disambiguate. Whitespace must match exactly.',
+            },
+            to: { type: 'string' },
+          },
+          required: ['path', 'from', 'to'],
+          additionalProperties: false,
+        },
+      },
+    },
+    display: {
+      verb: 'editing',
+      kind: 'diff',
+      fields: { path: 'path', from: 'from', to: 'to' },
+    },
+    permission: {
+      matchKey: (args) => args.path as string | undefined,
+    },
+    execute(args): ToolExecutorResult {
+      const path = sanitizePath(args.path as string, getCwd());
+      const oldString = args.from as string;
+      const newString = args.to as string;
+
+      if (!existsSync(path)) {
+        return { content: `Error: File not found: ${path}`, error: true };
+      }
+      try {
+        const content = readFileSync(path, 'utf-8');
+        const count = content.split(oldString).length - 1;
+        if (count === 0) {
+          return { content: 'Error: "from" not found in file', error: true };
+        }
+        if (count > 1) {
+          return { content: `Error: "from" found ${count} times, must be unique`, error: true };
+        }
+        writeFileSync(path, content.replace(oldString, newString), 'utf-8');
+        return { content: `File edited: ${path}` };
+      } catch (err) {
+        return { content: `Error: ${err instanceof Error ? err.message : 'Unknown error'}`, error: true };
+      }
+    },
+  };
+}

package/src/runtime/codingTools/index.ts

@@ -0,0 +1,39 @@
+/**
+ * mu-coding's filesystem + shell tools, packaged as a plugin. Replaces the
+ * legacy `createBuiltinPlugin` that lived in mu-core. Tools declare a
+ * `permission.matchKey` so agent definitions can authorise them via globs.
+ */
+
+import type { Plugin } from 'mu-core';
+import { createBashTool } from './bash';
+import { createEditFileTool } from './edit-file';
+import { createReadFileTool } from './read-file';
+import { createWriteFileTool } from './write-file';
+
+export function createCodingToolsPlugin(): Plugin {
+  let pluginCwd: string | undefined;
+  const getCwd = (): string => pluginCwd ?? process.cwd();
+
+  return {
+    name: 'mu-coding-tools',
+    version: '0.5.0',
+    tools: [
+      createReadFileTool(getCwd),
+      createWriteFileTool(getCwd),
+      createEditFileTool(getCwd),
+      createBashTool(getCwd),
+    ],
+    systemPrompt: [
+      'File & shell tools:',
+      '- Prefer `read` over `cat`/`sed`; pass `start`/`end` for large files.',
+      '- Use `edit` for surgical changes; include enough context in `from` to be unique. One `edit` call per change site.',
+      '- Use `write` only for new files or full rewrites.',
+      '- Use `bash` for ops without a dedicated tool (ls, rg, build, tests). Avoid using it to read or rewrite files.',
+    ].join('\n'),
+    activate(ctx) {
+      pluginCwd = ctx.cwd;
+    },
+  };
+}
+
+export { createBashTool, createEditFileTool, createReadFileTool, createWriteFileTool };