mu-coding 0.15.0 → 0.16.1

package/README.md

@@ -1,125 +1,11 @@
-# mu-coding
+# coding-agent
 
-Minimal terminal AI assistant for local models. A TUI chat interface with tool-calling support, built with Ink and React.
+Terminal coding assistant built on `mu-core` + `mu-harness` + `mu-tui`. Uses
+`mu-local-provider` (llama-swap) for inference and `mu-tools` for
+filesystem + shell access. Sessions persist as JSONL under
+`$XDG_DATA_HOME/coding-agent/sessions/`; plugins, skills, agents,
+permissions load from `$XDG_CONFIG_HOME/coding-agent/`.
 
-## Install
-
-```bash
-npm install -g mu-coding
-```
-
-## Usage
-
-```bash
-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
-```
-
-## Configuration
-
-Config files follow XDG conventions:
-
-| Path | Purpose |
-|------|---------|
-| `~/.config/mu/config.json` | Settings (baseUrl, model, maxTokens, temperature) |
-| `~/.config/mu/SYSTEM.md` | System prompt |
-| `~/.local/share/mu/sessions/` | Saved conversation sessions (JSONL) |
-| `~/.cache/mu/repomap/` | Code index cache |
-
-### Example `config.json`
-
-```json
-{
-  "baseUrl": "http://localhost:11434/v1",
-  "model": "qwen2.5",
-  "maxTokens": 4096,
-  "temperature": 0.7,
-  "streamTimeoutMs": 30000
-}
-```
-
-### 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` (or `Ctrl+J`) | New line |
-| `Ctrl+S` | Send message |
-| `Ctrl+C` | Abort / Quit (press twice) |
-| `Esc` | Stop generation (press twice) |
-| `Ctrl+N` | New conversation |
-| `Ctrl+M` | Cycle models |
-| `Ctrl+O` | Model picker |
-| `Ctrl+V` | Paste image from clipboard |
-| `PageUp` / `PageDown` | Scroll |
-| Mouse wheel | Scroll |
-
-## Slash Commands
-
-| Command | Action |
-|---------|--------|
-| `/model` | Select a model |
-| `/sessions` | List project sessions |
-| `/new` | New conversation |
-
-## Features
-
-- Streams responses with live token/s display
-- Multi-turn tool calling (bash, read, write, edit files)
-- 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
-
-## License
-
-MIT
+Run with `pnpm dev` (or `deno run -A --sloppy-imports bin/coding-agent.ts`).
+`coding-agent install <npm:spec | path.ts>` adds a plugin;
+`coding-agent -c` resumes the most recent session.

package/bin/coding-agent.ts

@@ -0,0 +1,95 @@
+#!/usr/bin/env -S deno run -A
+import process from 'node:process';
+import { join } from 'node:path';
+import { createHarness, loadAgents } from 'mu-harness';
+import { createLocalProvider, listLocalModels } from 'mu-local-provider';
+import { createMuTools } from 'mu-tools';
+import { getConfigPath, loadConfig, loadState, xdgDirs } from '../src/config';
+import { installPlugin, loadPlugins, uninstallPlugin } from '../src/plugins';
+import { buildSystemPrompt } from '../src/systemPrompt';
+import { runApp } from '../src/main';
+
+const normalizeModel = (model?: string): string | undefined => {
+  if (!model) return undefined;
+  return model.includes('/') ? model : `local/${model}`;
+};
+
+async function run(): Promise<void> {
+  const args = process.argv.slice(2);
+  const [cmd, arg] = args;
+
+  if (cmd === 'install') {
+    if (!arg) throw new Error('usage: mu install <npm:spec | jsr:spec | ./path.ts>');
+    installPlugin(arg);
+    return;
+  }
+  if (cmd === 'uninstall') {
+    if (!arg) throw new Error('usage: mu uninstall <spec>');
+    uninstallPlugin(arg);
+    return;
+  }
+
+  const wantContinue = args.includes('-c') || args.includes('--continue');
+
+  const config = loadConfig();
+  const state = loadState();
+
+  if (!config.baseUrl) {
+    throw new Error(
+      `Missing baseUrl in config. Create ${getConfigPath()} with { "kind": "llama-swap", "baseUrl": "http://..." }`,
+    );
+  }
+
+  const xdg = xdgDirs();
+  const cwd = process.cwd();
+  const projectLocal = join(cwd, '.mu');
+  const providerConfig = { kind: config.kind, baseUrl: config.baseUrl, apiKey: config.apiKey };
+
+  let initialRef = normalizeModel(state.model);
+  if (!initialRef) {
+    try {
+      const models = await listLocalModels(providerConfig);
+      initialRef = models[0] ? `local/${models[0].id}` : 'local/default';
+    } catch {
+      initialRef = 'local/default';
+    }
+  }
+
+  const plugins = await loadPlugins(config.plugins);
+
+  const diskAgents = await loadAgents(join(xdg.configHome, 'mu', 'agents'));
+  const projectAgents = await loadAgents(join(projectLocal, 'agents'));
+  const promptAgents = [...projectAgents, ...diskAgents, ...plugins.flatMap((p) => p.agents ?? [])];
+
+  const harness = await createHarness({
+    hostName: 'mu',
+    xdg,
+    cwd,
+    providers: { local: createLocalProvider(providerConfig) },
+    model: initialRef,
+    tools: createMuTools({ getCwd: () => cwd }),
+    plugins,
+    agents: projectAgents,
+    system: buildSystemPrompt(promptAgents),
+  });
+
+  let session;
+  if (wantContinue) {
+    const recent = await harness.sessions.list({ cwd });
+    if (recent[0]) {
+      session = await harness.sessions.open(recent[0].id);
+    } else {
+      process.stderr.write('[mu] no previous session to resume; starting a new one\n');
+      session = harness.sessions.create();
+    }
+  } else {
+    session = harness.sessions.create();
+  }
+
+  await runApp({ harness, session, providerConfig, state });
+}
+
+run().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -1,32 +1,21 @@
 {
   "name": "mu-coding",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "Minimal terminal AI assistant for local models",
   "type": "module",
   "bin": {
-    "mu": "./bin/mu.js"
+    "mu": "./bin/coding-agent.ts"
   },
-  "exports": {
-    ".": "./src/plugin.ts",
-    "./config": "./src/config/index.ts",
-    "./tools": "./src/runtime/codingTools/index.ts",
-    "./loader": "./src/runtime/pluginLoader.ts"
-  },
-  "files": [
-    "bin",
-    "prompts",
-    "src"
-  ],
   "scripts": {
-    "dev": "bun --watch bin/mu.js",
-    "start": "bun bin/mu.js",
-    "test": "bun test"
+    "dev": "NODE_ENV=development deno run -A --sloppy-imports bin/coding-agent.ts",
+    "dev:tui-debug": "MU_TUI_DEBUG_LOG=/tmp/mu-tui.log NODE_ENV=development deno run -A --sloppy-imports bin/coding-agent.ts",
+    "start": "deno run -A --sloppy-imports bin/coding-agent.ts"
   },
   "dependencies": {
-    "ink": "^7.0.1",
-    "mu-agents": "0.15.0",
-    "mu-core": "0.15.0",
-    "mu-openai-provider": "0.15.0",
-    "react": "^19.2.5"
+    "mu-core": "workspace:*",
+    "mu-harness": "workspace:*",
+    "mu-local-provider": "workspace:*",
+    "mu-tools": "workspace:*",
+    "mu-tui": "workspace:*"
   }
 }

package/src/config.ts

@@ -0,0 +1,122 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import process from 'node:process';
+import type { XdgDirs } from 'mu-harness';
+
+const HOST = 'mu';
+
+const env = (name: string): string | undefined => {
+  const value = process.env[name];
+  return value && value.length > 0 ? value : undefined;
+};
+
+export function xdgDirs(): XdgDirs {
+  const home = homedir();
+  return {
+    configHome: env('XDG_CONFIG_HOME') ?? join(home, '.config'),
+    dataHome: env('XDG_DATA_HOME') ?? join(home, '.local', 'share'),
+    stateHome: env('XDG_STATE_HOME') ?? join(home, '.local', 'state'),
+  };
+}
+
+const xdg = xdgDirs();
+const configDir = join(xdg.configHome, HOST);
+const stateDir = join(xdg.stateHome, HOST);
+
+export const paths = {
+  configFile: join(configDir, 'config.json'),
+  stateFile: join(stateDir, 'state.json'),
+  historyFile: join(stateDir, 'history.json'),
+};
+
+export interface CodingAgentConfig {
+  kind?: string;
+  baseUrl?: string;
+  apiKey?: string;
+  plugins?: string[];
+  provider?: string;
+}
+
+export interface CodingAgentState {
+  model?: string;
+  thinkingVisible?: boolean;
+  theme?: string;
+}
+
+const readJson = (path: string): Record<string, unknown> => {
+  try {
+    const raw = readFileSync(path, 'utf-8');
+    const parsed = JSON.parse(raw);
+    return typeof parsed === 'object' && parsed !== null ? parsed as Record<string, unknown> : {};
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[coding-agent] failed to read ${path}: ${msg}\n`);
+    }
+    return {};
+  }
+};
+
+const writeJson = (path: string, value: unknown): void => {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+};
+
+export function getConfigPath(): string {
+  return paths.configFile;
+}
+
+export function loadConfig(): CodingAgentConfig {
+  const obj = readJson(paths.configFile);
+  const out: CodingAgentConfig = {};
+  if (typeof obj.kind === 'string') out.kind = obj.kind;
+  if (typeof obj.baseUrl === 'string') out.baseUrl = obj.baseUrl;
+  if (typeof obj.apiKey === 'string') out.apiKey = obj.apiKey;
+  if (typeof obj.provider === 'string') out.provider = obj.provider;
+  if (Array.isArray(obj.plugins) && obj.plugins.every((p) => typeof p === 'string')) {
+    out.plugins = obj.plugins as string[];
+  }
+  return out;
+}
+
+export function saveConfig(config: CodingAgentConfig): void {
+  writeJson(paths.configFile, config);
+}
+
+export function loadState(): CodingAgentState {
+  const obj = readJson(paths.stateFile);
+  const out: CodingAgentState = {};
+  if (typeof obj.model === 'string') out.model = obj.model;
+  if (typeof obj.thinkingVisible === 'boolean') out.thinkingVisible = obj.thinkingVisible;
+  if (typeof obj.theme === 'string') out.theme = obj.theme;
+  return out;
+}
+
+export function saveState(state: CodingAgentState): void {
+  try {
+    writeJson(paths.stateFile, state);
+  } catch {
+  }
+}
+
+const HISTORY_MAX = 500;
+
+export function loadHistory(): string[] {
+  const obj = readJson(paths.historyFile);
+  const entries = (obj as { entries?: unknown }).entries;
+  if (Array.isArray(entries)) return entries.filter((e): e is string => typeof e === 'string');
+  return [];
+}
+
+export function appendHistory(entry: string): void {
+  if (!entry.trim()) return;
+  const entries = loadHistory();
+  if (entries[entries.length - 1] === entry) return;
+  entries.push(entry);
+  const trimmed = entries.slice(-HISTORY_MAX);
+  try {
+    writeJson(paths.historyFile, { entries: trimmed });
+  } catch {
+  }
+}

package/src/harness.test.ts

@@ -0,0 +1,159 @@
+import { expect } from '@std/expect';
+import { describe, it } from '@std/testing/bdd';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { Message, Provider, StreamEvent, Tool } from 'mu-core';
+import { type AgentSessionEvent, createHarness, type XdgDirs } from 'mu-harness';
+import { createMuTools } from 'mu-tools';
+
+const tempXdg = (): { xdg: XdgDirs; dir: string } => {
+  const dir = mkdtempSync(join(tmpdir(), 'mu-smoke-'));
+  return { dir, xdg: { configHome: join(dir, 'config'), dataHome: join(dir, 'data'), stateHome: join(dir, 'state') } };
+};
+
+const stubProvider = (parts: StreamEvent[]): Provider => ({
+  async *stream() {
+    for (const part of parts) yield part;
+  },
+});
+
+describe('coding-agent harness wiring', () => {
+  it('runs a streamed turn via a created session', async () => {
+    const { dir, xdg } = tempXdg();
+    const harness = await createHarness({
+      hostName: 'mu-test',
+      xdg,
+      providers: { local: stubProvider([{ type: 'text', text: 'Hello ' }, { type: 'text', text: 'world' }]) },
+      model: 'local/test-model',
+      tools: createMuTools(),
+      system: 'You are a test.',
+      title: false,
+    });
+
+    try {
+      const session = harness.sessions.create();
+      const events: AgentSessionEvent[] = [];
+      session.subscribe((event) => events.push(event));
+
+      await session.send('hi');
+
+      const types = events.map((e) => e.type);
+      expect(types[0]).toBe('turn_start');
+      expect(types).toContain('text');
+      expect(types[types.length - 1]).toBe('turn_end');
+
+      const assistant = session.messages.find((m) => m.role === 'assistant');
+      const assistantText = assistant?.content.map((p) => (p.type === 'text' ? p.text : '')).join('');
+      expect(assistantText).toBe('Hello world');
+    } finally {
+      harness.close();
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('exposes the provider usage events via the session', async () => {
+    const { dir, xdg } = tempXdg();
+    const harness = await createHarness({
+      hostName: 'mu-test',
+      xdg,
+      providers: {
+        local: stubProvider([
+          { type: 'text', text: 'ok' },
+          { type: 'usage', usage: { input: 1200, output: 50, total: 1250, contextWindow: 32768 } },
+        ]),
+      },
+      model: 'local/test-model',
+      tools: createMuTools(),
+      system: 'You are a test.',
+      title: false,
+    });
+
+    try {
+      const session = harness.sessions.create();
+      const usageEvents: { input?: number; total?: number; contextWindow?: number }[] = [];
+      session.subscribe((event) => {
+        if (event.type === 'usage') usageEvents.push(event.usage);
+      });
+
+      await session.send('hi');
+
+      expect(usageEvents.length).toBe(1);
+      expect(usageEvents[0].total).toBe(1250);
+      expect(usageEvents[0].contextWindow).toBe(32768);
+      const assistant = session.messages.find((m) => m.role === 'assistant');
+      expect(assistant?.content).toEqual([{ type: 'text', text: 'ok' }]);
+    } finally {
+      harness.close();
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('adds the per-tool prompts to the system message sent to the model', async () => {
+    const { dir, xdg } = tempXdg();
+    let captured: Message[] = [];
+    const provider: Provider = {
+      async *stream(req) {
+        captured = req.messages;
+        yield { type: 'text', text: 'ok' };
+      },
+    };
+    const tool: Tool = {
+      name: 'demo',
+      description: 'demo tool',
+      prompt: 'DEMO_TOOL_PROMPT',
+      parameters: { type: 'object' },
+      run: () => Promise.resolve([{ type: 'text', text: 'x' }]),
+    };
+    const harness = await createHarness({
+      hostName: 'mu-test',
+      xdg,
+      providers: { local: provider },
+      model: 'local/test-model',
+      tools: [tool],
+      system: 'BASE_SYS',
+      title: false,
+    });
+
+    try {
+      await harness.sessions.create().send('hi');
+      const system = captured.find((m) => m.role === 'system');
+      const text = system?.content.map((p) => (p.type === 'text' ? p.text : '')).join('') ?? '';
+      expect(text).toContain('BASE_SYS');
+      expect(text).toContain('DEMO_TOOL_PROMPT');
+    } finally {
+      harness.close();
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('switches model and forks a session preserving the prior history', async () => {
+    const { dir, xdg } = tempXdg();
+    const harness = await createHarness({
+      hostName: 'mu-test',
+      xdg,
+      providers: { local: stubProvider([{ type: 'text', text: 'ok' }]) },
+      model: 'local/model-a',
+      tools: createMuTools(),
+      system: 'You are a test.',
+      title: false,
+    });
+
+    try {
+      const session = harness.sessions.create();
+      await session.send('first');
+      expect(harness.models.selected).toBe('local/model-a');
+
+      harness.models.select('local/model-b');
+      const forked = await harness.sessions.fork(session.id, session.messages.length - 1);
+      expect(forked.id).not.toBe(session.id);
+      const userTexts = forked.messages
+        .filter((m) => m.role === 'user')
+        .map((m) => m.content.map((p) => (p.type === 'text' ? p.text : '')).join(''));
+      expect(userTexts).toContain('first');
+    } finally {
+      harness.close();
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/main.ts

@@ -1,4 +1,54 @@
-#!/usr/bin/env bun
-import { startApp } from './app/startApp';
+import process from 'node:process';
+import type { AgentSession, Harness } from 'mu-harness';
+import { listLocalModels } from 'mu-local-provider';
+import { type CodingAgentState, saveState } from './config';
+import { ChatApp, type ChatHost } from './ui/ChatApp';
 
-startApp();
+export interface RunAppOptions {
+  harness: Harness;
+  session: AgentSession;
+  providerConfig: { kind?: string; baseUrl?: string; apiKey?: string };
+  state: CodingAgentState;
+}
+
+export async function runApp(opts: RunAppOptions): Promise<void> {
+  const { harness, providerConfig, state } = opts;
+
+  const host: ChatHost = {
+    session: opts.session,
+    cwd: harness.cwd,
+    createSession: () => harness.sessions.create(),
+    forkSession: (id, upToIndex) => harness.sessions.fork(id, upToIndex),
+    selectModel: (ref) => {
+      harness.models.select(ref);
+      state.model = ref;
+      saveState(state);
+    },
+    modelRef: () => harness.models.selected,
+    listModels: () => listLocalModels(providerConfig),
+    agentNames: () => harness.agents.list().map((agent) => agent.name).filter((name) => name !== 'title'),
+    subAgents: harness.subAgents,
+    dispatchSubAgent: (agent, task, parentId) => harness.dispatchSubAgent(agent, task, parentId),
+    initialTheme: state.theme ?? 'dark',
+    saveTheme: (name) => {
+      state.theme = name;
+      saveState(state);
+    },
+    initialThinking: state.thinkingVisible ?? false,
+    saveThinking: (visible) => {
+      state.thinkingVisible = visible;
+      saveState(state);
+    },
+    onExit: (code) => {
+      harness.close();
+      process.exit(code);
+    },
+  };
+
+  const app = new ChatApp(host);
+
+  process.on('SIGINT', () => void app.stop().then(() => process.exit(130)));
+  process.on('SIGTERM', () => void app.stop().then(() => process.exit(143)));
+
+  await app.start();
+}

package/src/plugins.ts

@@ -0,0 +1,49 @@
+import process from 'node:process';
+import type { Plugin } from 'mu-harness';
+import { loadConfig, saveConfig } from './config';
+
+const isPlugin = (value: unknown): value is Plugin =>
+  typeof value === 'object' && value !== null && typeof (value as { name?: unknown }).name === 'string';
+
+export async function loadPlugins(specs: string[] = []): Promise<Plugin[]> {
+  const plugins: Plugin[] = [];
+  for (const spec of specs) {
+    try {
+      const mod = await import(spec) as Record<string, unknown>;
+      const candidate = mod.default ?? mod.plugin ?? mod;
+      if (isPlugin(candidate)) {
+        plugins.push(candidate);
+      } else {
+        process.stderr.write(`[mu] plugin "${spec}" has no valid default export (expected { name, ... })\n`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[mu] failed to load plugin "${spec}": ${msg}\n`);
+    }
+  }
+  return plugins;
+}
+
+export function installPlugin(spec: string): void {
+  const config = loadConfig();
+  const plugins = config.plugins ?? [];
+  if (plugins.includes(spec)) {
+    process.stdout.write(`[mu] plugin already registered: ${spec}\n`);
+    return;
+  }
+  config.plugins = [...plugins, spec];
+  saveConfig(config);
+  process.stdout.write(`[mu] registered plugin: ${spec}\n`);
+}
+
+export function uninstallPlugin(spec: string): void {
+  const config = loadConfig();
+  const plugins = config.plugins ?? [];
+  if (!plugins.includes(spec)) {
+    process.stderr.write(`[mu] plugin not registered: ${spec}\n`);
+    return;
+  }
+  config.plugins = plugins.filter((p) => p !== spec);
+  saveConfig(config);
+  process.stdout.write(`[mu] unregistered plugin: ${spec}\n`);
+}

package/src/systemPrompt.ts

@@ -0,0 +1,22 @@
+import type { Agent } from 'mu-harness';
+
+const BASE = `You are mu, a terminal coding assistant operating inside the user's project directory.
+
+Guidelines:
+- Be concise. The user is in a terminal; avoid filler and long preambles.
+- Inspect before you act: read the relevant files and run commands to confirm assumptions instead of guessing.
+- After changing code, run the project's checks/tests when feasible and report the real outcome.
+- Never invent file paths, APIs, or command output. If a command fails, say so with the error.
+- Use GitHub-flavored Markdown in replies; reference code as path:line.`;
+
+export function buildSystemPrompt(agents: Agent[]): string {
+  const usable = agents.filter((agent) => agent.name !== 'title');
+  if (usable.length === 0) return BASE;
+  const list = usable
+    .map((agent) => `- ${agent.name}: ${agent.description || 'no description'}`)
+    .join('\n');
+  return `${BASE}
+
+Available sub-agents (delegate with the \`subagent\` tool):
+${list}`;
+}