mu-coding 0.15.0 → 0.16.1

package/src/cli/args.ts

@@ -1,133 +0,0 @@
-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-core';
-import { getLatestSession, loadSession } from '../sessions/index';
-
-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 <model>        Interactive with specific model
-  mu -c, --continue             Continue most recent session
-  mu --session <path>           Resume a specific session file
-  mu install npm:<package>      Install a plugin from npm
-  mu uninstall npm:<package>    Remove an installed plugin
-  mu update [plugins|self|all]  Update plugins and/or mu (default: all)
-  mu outdated [plugins|self]    List available updates without applying
-  mu -v, --version              Print version and exit
-  mu -h, --help                 Show this help
-
-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
-  ← / →         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);
-}
-
-function printVersion(): never {
-  // Walk up from this file to find mu-coding's package.json. Works whether
-  // the file is loaded from `src/cli/args.ts` (bun --watch) or `dist/cli/args.js`.
-  const here = dirname(fileURLToPath(import.meta.url));
-  const candidates = [join(here, '..', '..', 'package.json'), join(here, '..', 'package.json')];
-  for (const path of candidates) {
-    try {
-      const pkg = JSON.parse(readFileSync(path, 'utf-8'));
-      if (pkg?.name === 'mu-coding') {
-        console.log(`mu ${pkg.version}`);
-        process.exit(0);
-      }
-    } catch {
-      // Try next candidate.
-    }
-  }
-  console.log('mu (version unknown)');
-  process.exit(0);
-}
-
-export function parseArgs(): CliArgs {
-  let parsed: ReturnType<typeof nodeParseArgs>;
-  try {
-    parsed = nodeParseArgs({
-      options: {
-        model: { type: 'string', short: 'm' },
-        continue: { type: 'boolean', short: 'c' },
-        session: { type: 'string' },
-        version: { type: 'boolean', short: 'v' },
-        help: { type: 'boolean', short: 'h' },
-      },
-      // Subcommands like `install`/`uninstall` are routed before parseArgs(),
-      // so we shouldn't see them here. Allow positionals just in case the
-      // user passes stray args (we ignore them rather than erroring).
-      allowPositionals: true,
-      strict: true,
-    });
-  } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
-    console.error('Run `mu --help` for usage.');
-    process.exit(1);
-  }
-
-  if (parsed.values.help) {
-    printHelp();
-  }
-  if (parsed.values.version) {
-    printVersion();
-  }
-
-  return {
-    model: typeof parsed.values.model === 'string' ? parsed.values.model : undefined,
-    continueSession: parsed.values.continue === true,
-    sessionPath: typeof parsed.values.session === 'string' ? parsed.values.session : undefined,
-  };
-}
-
-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/cli/install.ts

@@ -1,107 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { canonicalNpmSpecifier, getDataDir, loadConfig, parseBareNpmSpec, saveConfig } from '../config/index';
-
-const INIT_PACKAGE_JSON = JSON.stringify({ private: true, dependencies: {} }, null, 2);
-
-export function ensureDataDir(): string {
-  const dataDir = getDataDir();
-  mkdirSync(dataDir, { recursive: true });
-
-  const pkgPath = join(dataDir, 'package.json');
-  if (!existsSync(pkgPath)) {
-    writeFileSync(pkgPath, INIT_PACKAGE_JSON, 'utf-8');
-  }
-
-  return dataDir;
-}
-
-/**
- * Install an npm package into the mu data dir using `bun add`. Shared by the
- * `mu install` CLI and the runtime auto-installer (pluginLoader). `bare` is
- * the spec without the `npm:` prefix (e.g. `mu-coding-agents`,
- * `@scope/foo@^1.0.0`). When `silent`, stdout is suppressed (used by the
- * runtime path so the TUI isn't garbled at startup).
- */
-export function installNpmPackage(bare: string, options: { silent?: boolean } = {}): void {
-  const dataDir = ensureDataDir();
-  execFileSync('bun', ['add', bare], {
-    cwd: dataDir,
-    stdio: options.silent ? 'pipe' : 'inherit',
-  });
-}
-
-function stripNpmPrefix(specifier: string): string {
-  if (!specifier.startsWith('npm:')) {
-    console.error(`Error: package specifier must start with npm: — got "${specifier}"`);
-    process.exit(1);
-  }
-  return specifier.slice(4);
-}
-
-export async function runInstall(args: string[]): Promise<void> {
-  if (args.length === 0) {
-    console.error('Usage: mu install npm:<package>');
-    process.exit(1);
-  }
-
-  ensureDataDir();
-  const config = loadConfig();
-  const plugins = config.plugins ?? [];
-
-  for (const specifier of args) {
-    const bare = stripNpmPrefix(specifier);
-    const canonical = canonicalNpmSpecifier(bare);
-
-    console.log(`Installing ${bare}...`);
-    try {
-      installNpmPackage(bare);
-    } catch (err) {
-      console.error(`Failed to install ${bare}: ${err instanceof Error ? err.message : err}`);
-      process.exit(1);
-    }
-
-    // Add to plugins if not already present (compare by canonical form so
-    // `npm:foo` and `npm:foo@1.2.3` deduplicate correctly).
-    const existing = plugins.some((p) => (typeof p === 'string' ? p : p.name) === canonical);
-    if (!existing) {
-      plugins.push(canonical);
-    }
-
-    console.log(`✓ ${canonical}`);
-  }
-
-  saveConfig({ plugins });
-}
-
-export async function runUninstall(args: string[]): Promise<void> {
-  if (args.length === 0) {
-    console.error('Usage: mu uninstall npm:<package>');
-    process.exit(1);
-  }
-
-  const dataDir = ensureDataDir();
-  const config = loadConfig();
-  let plugins = config.plugins ?? [];
-
-  for (const specifier of args) {
-    const bare = stripNpmPrefix(specifier);
-    const canonical = canonicalNpmSpecifier(bare);
-    const { name } = parseBareNpmSpec(bare);
-
-    console.log(`Removing ${name}...`);
-    try {
-      execFileSync('bun', ['remove', name], { cwd: dataDir, stdio: 'inherit' });
-    } catch (err) {
-      console.error(`Failed to remove ${name}: ${err instanceof Error ? err.message : err}`);
-      process.exit(1);
-    }
-
-    plugins = plugins.filter((p) => (typeof p === 'string' ? p : p.name) !== canonical);
-
-    console.log(`✓ Removed ${canonical}`);
-  }
-
-  saveConfig({ plugins });
-}

package/src/cli/subcommands.ts

@@ -1,29 +0,0 @@
-import { runInstall, runUninstall } from './install';
-import { runOutdated, runUpdate } from './update';
-
-/**
- * Handle CLI subcommands that run before the TUI.
- * Returns true if a subcommand was handled (caller should exit).
- */
-export async function handleSubcommand(): Promise<boolean> {
-  const sub = process.argv[2];
-
-  switch (sub) {
-    case 'install':
-      await runInstall(process.argv.slice(3));
-      return true;
-    case 'uninstall':
-      await runUninstall(process.argv.slice(3));
-      return true;
-    case 'update':
-    case 'upgrade':
-      await runUpdate(process.argv.slice(3));
-      return true;
-    case 'outdated':
-    case 'ping':
-      await runOutdated(process.argv.slice(3));
-      return true;
-    default:
-      return false;
-  }
-}

package/src/cli/update.ts

@@ -1,205 +0,0 @@
-/**
- * `mu update` — bring installed plugins (and optionally mu itself) to the
- * latest version published on the npm registry.
- *
- * Plugins live in `~/.local/share/mu/node_modules/<name>` and are listed in
- * `config.plugins` as `npm:<name>` specifiers. Updating them is a thin
- * wrapper around `bun update --latest <name>` against the data dir, which
- * already owns its own `package.json`.
- *
- * mu itself is updated by re-running its global installer. We probe the
- * binary path to detect which manager owns the install (bun, npm, pnpm) and
- * fall back to a generic `npm i -g` instructions message on unknown setups.
- */
-
-import { execFileSync } from 'node:child_process';
-import { realpathSync } from 'node:fs';
-import {
-  listConfiguredNpmPlugins,
-  type NpmRegistryView,
-  PACKAGE_NAME,
-  probePluginSync,
-  probeSelfSync,
-} from '../runtime/updateCheck';
-import { ensureDataDir } from './install';
-
-function printRow(name: string, view: NpmRegistryView | null) {
-  if (!view) {
-    console.log(`  ${name.padEnd(28)} ?       (npm view failed)`);
-    return;
-  }
-  const arrow = view.hasUpdate ? '→' : '=';
-  const tail = view.hasUpdate ? `${view.current} ${arrow} ${view.latest}` : `${view.current} (up to date)`;
-  console.log(`  ${name.padEnd(28)} ${tail}`);
-}
-
-// ─── outdated ────────────────────────────────────────────────────────────────
-
-export async function runOutdated(args: string[]): Promise<void> {
-  const scope = args[0];
-  const wantsPlugins = !scope || scope === 'plugins' || scope === 'all';
-  const wantsSelf = !scope || scope === 'self' || scope === 'mu' || scope === 'all';
-
-  const dataDir = ensureDataDir();
-  let anyUpdate = false;
-
-  if (wantsSelf) {
-    console.log('mu:');
-    const view = probeSelfSync();
-    printRow(PACKAGE_NAME, view);
-    if (view?.hasUpdate) anyUpdate = true;
-  }
-
-  if (wantsPlugins) {
-    const names = listConfiguredNpmPlugins();
-    console.log(`\nplugins (${names.length}):`);
-    if (names.length === 0) {
-      console.log('  (none configured)');
-    } else {
-      for (const name of names) {
-        const view = probePluginSync(name, dataDir);
-        printRow(name, view);
-        if (view?.hasUpdate) anyUpdate = true;
-      }
-    }
-  }
-
-  if (!anyUpdate) {
-    console.log('\nEverything is up to date.');
-  } else {
-    console.log("\nRun 'mu update' to apply.");
-  }
-}
-
-// ─── update plugins ──────────────────────────────────────────────────────────
-
-function updatePlugin(name: string, dataDir: string): boolean {
-  try {
-    execFileSync('bun', ['update', '--latest', name], { cwd: dataDir, stdio: 'inherit' });
-    return true;
-  } catch (err) {
-    console.error(`Failed to update ${name}: ${err instanceof Error ? err.message : err}`);
-    return false;
-  }
-}
-
-export async function runUpdatePlugins(): Promise<{ ok: number; failed: number }> {
-  const dataDir = ensureDataDir();
-  const names = listConfiguredNpmPlugins();
-  if (names.length === 0) {
-    console.log('No npm plugins configured.');
-    return { ok: 0, failed: 0 };
-  }
-  let ok = 0;
-  let failed = 0;
-  for (const name of names) {
-    console.log(`\nUpdating ${name}…`);
-    if (updatePlugin(name, dataDir)) {
-      ok += 1;
-      console.log(`✓ ${name}`);
-    } else {
-      failed += 1;
-    }
-  }
-  return { ok, failed };
-}
-
-// ─── update self ─────────────────────────────────────────────────────────────
-
-interface SelfInstallStrategy {
-  manager: 'bun' | 'npm' | 'pnpm' | 'yarn' | 'unknown';
-  command?: [string, string[]];
-}
-
-/**
- * Best-effort detection of which package manager installed `mu` globally.
- * We resolve the absolute binary path of the running process and look for
- * tell-tale path segments.
- */
-function detectSelfInstall(): SelfInstallStrategy {
-  let bin = process.argv[1] ?? '';
-  try {
-    bin = realpathSync(bin);
-  } catch {
-    // keep raw argv path
-  }
-  const norm = bin.replace(/\\/g, '/');
-
-  if (norm.includes('/.bun/') || norm.includes('/bun/install/')) {
-    return { manager: 'bun', command: ['bun', ['add', '-g', `${PACKAGE_NAME}@latest`]] };
-  }
-  if (norm.includes('/pnpm/')) {
-    return { manager: 'pnpm', command: ['pnpm', ['add', '-g', `${PACKAGE_NAME}@latest`]] };
-  }
-  if (norm.includes('/.yarn/') || norm.includes('/yarn/global/')) {
-    return { manager: 'yarn', command: ['yarn', ['global', 'add', `${PACKAGE_NAME}@latest`]] };
-  }
-  if (norm.includes('/npm/') || norm.includes('node_modules/.bin/mu')) {
-    return { manager: 'npm', command: ['npm', ['i', '-g', `${PACKAGE_NAME}@latest`]] };
-  }
-  return { manager: 'unknown' };
-}
-
-export async function runUpdateSelf(): Promise<boolean> {
-  const view = probeSelfSync();
-  if (view && !view.hasUpdate) {
-    console.log(`mu is already up to date (${view.current}).`);
-    return true;
-  }
-
-  const strategy = detectSelfInstall();
-  if (!strategy.command) {
-    console.log(
-      [
-        'Could not auto-detect how mu was installed.',
-        'Re-install with one of:',
-        `  bun add -g ${PACKAGE_NAME}@latest`,
-        `  npm i -g ${PACKAGE_NAME}@latest`,
-        `  pnpm add -g ${PACKAGE_NAME}@latest`,
-      ].join('\n'),
-    );
-    return false;
-  }
-
-  const [bin, args] = strategy.command;
-  console.log(`Updating mu via ${strategy.manager}…`);
-  console.log(`$ ${bin} ${args.join(' ')}`);
-  try {
-    execFileSync(bin, args, { stdio: 'inherit' });
-    console.log('✓ mu updated. Restart any running mu sessions.');
-    return true;
-  } catch (err) {
-    console.error(`Failed to update mu: ${err instanceof Error ? err.message : err}`);
-    return false;
-  }
-}
-
-// ─── dispatcher ──────────────────────────────────────────────────────────────
-
-export async function runUpdate(args: string[]): Promise<void> {
-  const scope = args[0];
-
-  if (scope === 'plugins') {
-    const { failed } = await runUpdatePlugins();
-    if (failed > 0) process.exit(1);
-    return;
-  }
-
-  if (scope === 'self' || scope === 'mu') {
-    const ok = await runUpdateSelf();
-    if (!ok) process.exit(1);
-    return;
-  }
-
-  if (scope && scope !== 'all') {
-    console.error('Usage: mu update [plugins|self|all]');
-    process.exit(1);
-  }
-
-  // Default: update everything.
-  console.log('=== Updating plugins ===');
-  const pluginRes = await runUpdatePlugins();
-  console.log('\n=== Updating mu ===');
-  const selfOk = await runUpdateSelf();
-  if (pluginRes.failed > 0 || !selfOk) process.exit(1);
-}

package/src/config/index.test.ts

@@ -1,77 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
-import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-// Important: stub XDG_CONFIG_HOME *before* importing './index' so the module
-// captures the test paths in its top-level constants. Bun resolves dynamic
-// imports per-call, so we use `await import` inside each test.
-let tmpRoot: string;
-let configPath: string;
-let originalConfigHome: string | undefined;
-
-beforeAll(() => {
-  tmpRoot = mkdtempSync(join(tmpdir(), 'mu-config-'));
-  originalConfigHome = process.env.XDG_CONFIG_HOME;
-  process.env.XDG_CONFIG_HOME = tmpRoot;
-  mkdirSync(join(tmpRoot, 'mu'), { recursive: true });
-  configPath = join(tmpRoot, 'mu', 'config.json');
-});
-
-afterAll(() => {
-  if (originalConfigHome === undefined) {
-    delete process.env.XDG_CONFIG_HOME;
-  } else {
-    process.env.XDG_CONFIG_HOME = originalConfigHome;
-  }
-});
-
-describe('saveConfig', () => {
-  it('preserves unknown keys in config.json', async () => {
-    const { saveConfig } = await import('./index');
-
-    // Seed with a custom key the loader doesn't know about.
-    writeFileSync(configPath, JSON.stringify({ baseUrl: 'http://x', customKey: 42 }, null, 2));
-
-    saveConfig({ model: 'qwen' });
-
-    const persisted = JSON.parse(readFileSync(configPath, 'utf-8'));
-    expect(persisted.customKey).toBe(42);
-    expect(persisted.model).toBe('qwen');
-    expect(persisted.baseUrl).toBe('http://x');
-  });
-
-  it('removes a key when explicitly set to undefined', async () => {
-    const { saveConfig } = await import('./index');
-    writeFileSync(configPath, JSON.stringify({ model: 'before' }));
-    saveConfig({ model: undefined });
-    const persisted = JSON.parse(readFileSync(configPath, 'utf-8'));
-    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();
-  });
-});