mu-coding 0.1.0

package/README.md

@@ -0,0 +1,81 @@
+# mu-coding
+
+Minimal terminal AI assistant for local models. A TUI chat interface with tool-calling support, built with Ink and React.
+
+## Install
+
+```bash
+npm install -g mu-coding
+```
+
+## Usage
+
+```bash
+mu                    # Start interactive chat
+mu -p "prompt"        # Single-shot prompt, then exit
+mu -m model -p "p"    # Single-shot with specific model
+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
+}
+```
+
+## Keyboard Shortcuts
+
+| Key | Action |
+|-----|--------|
+| `Enter` | Send message |
+| `Shift+Enter` | 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 |
+| `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)
+- Code indexing via `mu-repomap` plugin (auto-loaded)
+- Image attachment support
+- Session persistence and resume
+- Mouse wheel scrolling
+
+## License
+
+MIT

package/bin/mu.js

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

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "mu-coding",
+  "version": "0.1.0",
+  "description": "Minimal terminal AI assistant for local models",
+  "type": "module",
+  "bin": {
+    "mu": "./bin/mu.js"
+  },
+  "scripts": {
+    "dev": "bun --watch bin/mu.js",
+    "start": "bun bin/mu.js"
+  },
+  "dependencies": {
+    "ink": "^7.0.1",
+    "mu-agents": "0.1.0",
+    "mu-provider": "0.1.0",
+    "react": "^19.2.5"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,90 @@
+import type { ChatMessage } from 'mu-provider';
+import { getLatestSession, loadSession } from './session';
+
+interface CliArgs {
+  model?: string;
+  prompt?: string;
+  continueSession?: boolean;
+  sessionPath?: string;
+}
+
+function printHelp(): never {
+  console.log(`mu — minimal terminal AI assistant
+
+Usage:
+  mu                  Start interactive chat
+  mu -p "prompt"      Single-shot prompt, then exit
+  mu -m model -p "p"  Single-shot with specific model
+  mu -m model         Interactive with specific model
+  mu -c               Continue most recent session
+  mu --session <path> Resume a specific session file
+
+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);
+}
+
+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 === '-p' && args[i + 1]) {
+      result.prompt = 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 === '-h' || arg === '--help') {
+      printHelp();
+    } else if (!(result.prompt || arg.startsWith('-'))) {
+      result.prompt = arg;
+    }
+  }
+
+  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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,116 @@
+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');
+}

package/src/diff.ts

@@ -0,0 +1,81 @@
+// Lightweight diff for edit_file tool output.
+// Uses prefix/suffix matching — sufficient for small, localized edits.
+
+export interface DiffLine {
+  type: 'context' | 'old' | 'new';
+  value: string;
+}
+
+export interface DiffResult {
+  lines: DiffLine[];
+  totalOldLines: number;
+  totalNewLines: number;
+}
+
+const CONTEXT_LINES = 3;
+const MAX_LINES = 500;
+
+export function computeDiff(oldText: string, newText: string): DiffResult {
+  const oldLines = oldText.split('\n');
+  const newLines = newText.split('\n');
+
+  if (oldLines.length > MAX_LINES || newLines.length > MAX_LINES) {
+    return { lines: [], totalOldLines: oldLines.length, totalNewLines: newLines.length };
+  }
+
+  // Find common prefix
+  let prefixLen = 0;
+  const minLen = Math.min(oldLines.length, newLines.length);
+  while (prefixLen < minLen && oldLines[prefixLen] === newLines[prefixLen]) {
+    prefixLen++;
+  }
+
+  // Find common suffix (don't overlap with prefix)
+  let suffixLen = 0;
+  const maxSuffix = Math.min(oldLines.length - prefixLen, newLines.length - prefixLen);
+  while (
+    suffixLen < maxSuffix &&
+    oldLines[oldLines.length - 1 - suffixLen] === newLines[newLines.length - 1 - suffixLen]
+  ) {
+    suffixLen++;
+  }
+
+  const result: DiffLine[] = [];
+
+  // Context from prefix (last N lines)
+  const ctxStart = Math.max(0, prefixLen - CONTEXT_LINES);
+  for (let i = ctxStart; i < prefixLen; i++) {
+    result.push({ type: 'context', value: oldLines[i] });
+  }
+
+  // Removed lines
+  for (let i = prefixLen; i < oldLines.length - suffixLen; i++) {
+    result.push({ type: 'old', value: oldLines[i] });
+  }
+
+  // Added lines
+  for (let i = prefixLen; i < newLines.length - suffixLen; i++) {
+    result.push({ type: 'new', value: newLines[i] });
+  }
+
+  // Context from suffix (first N lines)
+  const ctxEnd = Math.min(suffixLen, CONTEXT_LINES);
+  for (let i = 0; i < ctxEnd; i++) {
+    const idx = oldLines.length - suffixLen + i;
+    result.push({ type: 'context', value: oldLines[idx] });
+  }
+
+  return { lines: result, totalOldLines: oldLines.length, totalNewLines: newLines.length };
+}
+
+export function renderDiff(diff: DiffResult, maxLines: number): { lines: string[]; truncated: boolean } {
+  const result: string[] = [];
+  const capped = diff.lines.slice(0, maxLines);
+
+  for (const line of capped) {
+    const prefix = line.type === 'old' ? '-' : line.type === 'new' ? '+' : ' ';
+    result.push(`${prefix} ${line.value}`);
+  }
+
+  return { lines: result, truncated: diff.lines.length > maxLines };
+}

package/src/main.tsx

@@ -0,0 +1,80 @@
+#!/usr/bin/env bun
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { render } from 'ink';
+import { createBuiltinPlugin, PluginRegistry } from 'mu-agents';
+import { parseArgs, resolveInitialMessages } from './cli';
+import { type AppConfig, getPluginsDir, loadConfig } from './config';
+import { runSingleShot } from './singleShot';
+import { ChatPanel } from './tui/components/chat/ChatPanel';
+
+function discoverPluginFiles(): string[] {
+  const dir = getPluginsDir();
+  try {
+    return readdirSync(dir)
+      .filter((f) => f.endsWith('.ts'))
+      .map((f) => join(dir, f));
+  } catch {
+    return [];
+  }
+}
+
+async function createRegistry(cwd: string, config: AppConfig) {
+  const registry = new PluginRegistry({ cwd, config: {} });
+
+  // Register built-in tools (read, write, edit, bash)
+  await registry.register(createBuiltinPlugin());
+
+  // Auto-load .ts plugin files from ~/.config/mu/plugins/
+  for (const filePath of discoverPluginFiles()) {
+    await registry.loadPlugin(filePath);
+  }
+
+  // Load npm package plugins from config
+  if (config.plugins?.length) {
+    for (const entry of config.plugins) {
+      const name = typeof entry === 'string' ? entry : entry.name;
+      const pluginConfig = typeof entry === 'string' ? undefined : entry.config;
+      await registry.loadPlugin(name, pluginConfig);
+    }
+  }
+
+  return registry;
+}
+
+async function main() {
+  const cliArgs = parseArgs();
+  const config = loadConfig(cliArgs.model);
+  const root = process.cwd();
+
+  const registry = await createRegistry(root, config);
+
+  if (cliArgs.prompt) {
+    try {
+      await runSingleShot(cliArgs.prompt, config, registry);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : 'Unknown error';
+      console.error(`Error: ${msg}`);
+      process.exit(1);
+    } finally {
+      await registry.shutdown();
+    }
+    return;
+  }
+
+  const initialMessages = resolveInitialMessages(cliArgs);
+
+  render(<ChatPanel config={config} initialMessages={initialMessages} registry={registry} />, {
+    exitOnCtrlC: false,
+    kittyKeyboard: { mode: 'enabled' },
+  });
+
+  process.on('exit', () => {
+    registry.shutdown();
+  });
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/project.ts

@@ -0,0 +1,32 @@
+import { execSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+
+function findGitRoot(from: string): string | null {
+  try {
+    const root = execSync('git rev-parse --show-toplevel', {
+      cwd: from,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    return root || null;
+  } catch {
+    return null;
+  }
+}
+
+function getProjectRoot(): string {
+  const cwd = process.cwd();
+  return findGitRoot(cwd) ?? cwd;
+}
+
+export function getProjectId(): string {
+  const root = getProjectRoot();
+  const hash = createHash('sha256').update(root).digest('hex').slice(0, 12);
+  const name = root.split('/').pop() || 'unknown';
+  return `${name}-${hash}`;
+}
+
+export function getProjectName(): string {
+  const root = getProjectRoot();
+  return root.split('/').pop() || root;
+}

package/src/session.ts

@@ -0,0 +1,95 @@
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ChatMessage } from 'mu-provider';
+import { getDataDir } from './config';
+import { getProjectId, getProjectName } from './project';
+
+function getProjectSessionsDir(): string {
+  return join(getDataDir(), 'sessions', getProjectId());
+}
+
+function getSortedSessionFiles(): string[] {
+  try {
+    const dir = getProjectSessionsDir();
+    return readdirSync(dir)
+      .filter((f) => f.endsWith('.jsonl'))
+      .sort()
+      .reverse();
+  } catch {
+    return [];
+  }
+}
+
+export interface SessionInfo {
+  path: string;
+  name: string;
+  date: Date;
+  messageCount: number;
+  preview: string;
+  project: string;
+}
+
+export function generateSessionPath(): string {
+  const dir = getProjectSessionsDir();
+  mkdirSync(dir, { recursive: true });
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  return join(dir, `${ts}.jsonl`);
+}
+
+export function saveSession(path: string, messages: ChatMessage[]): void {
+  writeFileSync(path, `${messages.map((m) => JSON.stringify(m)).join('\n')}\n`, 'utf-8');
+}
+
+export function loadSession(path: string): ChatMessage[] {
+  try {
+    const content = readFileSync(path, 'utf-8').trim();
+    if (!content) {
+      return [];
+    }
+    return content
+      .split('\n')
+      .map((line) => {
+        try {
+          return JSON.parse(line) as ChatMessage;
+        } catch {
+          return null;
+        }
+      })
+      .filter((msg): msg is ChatMessage => msg !== null);
+  } catch {
+    return [];
+  }
+}
+
+export function getLatestSession(): string | null {
+  const files = getSortedSessionFiles();
+  return files.length ? join(getProjectSessionsDir(), files[0]) : null;
+}
+
+export function listSessions(): SessionInfo[] {
+  try {
+    const dir = getProjectSessionsDir();
+    mkdirSync(dir, { recursive: true });
+    const files = getSortedSessionFiles();
+    const project = getProjectName();
+
+    return files.map((file) => {
+      const path = join(dir, file);
+      const stat = statSync(path);
+      const messages = loadSession(path);
+      const firstUserMsg = messages.find((m) => m.role === 'user');
+      const preview = firstUserMsg ? firstUserMsg.content.slice(0, 80).replace(/\n/g, ' ') : '(empty)';
+
+      return {
+        path,
+        name: file.replace('.jsonl', ''),
+        date: stat.mtime,
+        messageCount: messages.length,
+        preview,
+        project,
+      };
+    });
+  } catch {
+    return [];
+  }
+}