mu-coding 0.15.0 → 0.16.1

package/src/runtime/pluginLoader.ts

@@ -1,153 +0,0 @@
-import { readdirSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { join, resolve } from 'node:path';
-import type { Plugin, PluginRegistry } from 'mu-core';
-import { installNpmPackage } from '../cli/install';
-import { getDataDir, getPluginsDir, parseBareNpmSpec } from '../config/index';
-import type { InkUIService } from '../tui/plugins/InkUIService';
-
-export function discoverPluginFiles(): string[] {
-  const dir = getPluginsDir();
-  try {
-    return readdirSync(dir)
-      .filter((f) => f.endsWith('.ts'))
-      .map((f) => join(dir, f));
-  } catch {
-    return [];
-  }
-}
-
-function formatPluginError(name: string, err: unknown): string {
-  const parts: string[] = [`Plugin "${name}" failed`];
-  let current: unknown = err;
-  while (current) {
-    if (current instanceof Error) {
-      parts.push(current.message);
-      current = current.cause;
-    } else {
-      parts.push(String(current));
-      break;
-    }
-  }
-  return parts.join(': ');
-}
-
-/**
- * Resolve an `npm:<spec>` plugin specifier to an absolute path on disk.
- *
- * If the package isn't installed yet, runs `bun add <spec>` against the mu
- * data dir and retries — so users can list a plugin in `config.plugins`
- * without having to invoke `mu install` first.
- *
- * `uiService` is optional: when provided, surface "Installing …" / failure
- * messages through the TUI; otherwise fall back to stderr so the host's
- * boot log still shows what happened.
- */
-async function resolveNpmPlugin(specifier: string, uiService?: InkUIService): Promise<string> {
-  const bare = specifier.slice(4);
-  const { name } = parseBareNpmSpec(bare);
-  const dataDir = getDataDir();
-  const require = createRequire(resolve(dataDir, 'package.json'));
-
-  try {
-    return require.resolve(name);
-  } catch (_firstErr) {
-    const installMsg = `Installing ${name}…`;
-    if (uiService) uiService.notify(installMsg, 'info');
-    else console.error(`[mu] ${installMsg}`);
-
-    try {
-      installNpmPackage(bare, { silent: true });
-    } catch (installErr) {
-      throw new Error(`Failed to auto-install "${name}" into ${dataDir}/node_modules`, { cause: installErr });
-    }
-
-    try {
-      return require.resolve(name);
-    } catch (retryErr) {
-      throw new Error(
-        `Auto-installed "${name}" but cannot resolve it from ${dataDir}/node_modules — install may have failed silently`,
-        { cause: retryErr },
-      );
-    }
-  }
-}
-
-function isPluginShape(value: unknown): value is Plugin {
-  return typeof value === 'object' && value !== null && 'name' in value && typeof (value as Plugin).name === 'string';
-}
-
-/**
- * Extract a plugin from a loaded module. Tries (in order):
- *   1. `module.default` as a factory function
- *   2. `module.createPlugin` as a factory function
- *   3. `module.default` as a Plugin object
- *   4. `module` as a Plugin object
- *
- * Returns `null` if no plugin shape matches; the caller should report this
- * with the list of available exports for debugging.
- */
-function extractPlugin(mod: Record<string, unknown>, pluginConfig: Record<string, unknown>): Plugin | null {
-  const factory = (mod.default ?? mod.createPlugin) as unknown;
-  if (typeof factory === 'function') {
-    const result = (factory as (cfg: Record<string, unknown>) => unknown)(pluginConfig);
-    return isPluginShape(result) ? result : null;
-  }
-  if (isPluginShape(mod.default)) {
-    return mod.default;
-  }
-  if (isPluginShape(mod)) {
-    return mod;
-  }
-  return null;
-}
-
-/**
- * Loader variant that *resolves* (imports + extracts) a plugin without
- * registering it. Used by hosts driving `startMu({ resolvePlugin })`. Errors
- * surface via `uiService` (or are swallowed when omitted) so the host's
- * boot log behaviour matches `loadConfiguredPlugin`.
- */
-export async function resolveConfiguredPlugin(
-  name: string,
-  pluginConfig?: Record<string, unknown>,
-  uiService?: InkUIService,
-): Promise<Plugin | null> {
-  const config = pluginConfig ?? {};
-  let target: string;
-  try {
-    target = name.startsWith('npm:') ? await resolveNpmPlugin(name, uiService) : name;
-  } catch (err) {
-    uiService?.notify(formatPluginError(name, err), 'error');
-    return null;
-  }
-  let mod: Record<string, unknown>;
-  try {
-    mod = (await import(target)) as Record<string, unknown>;
-  } catch (err) {
-    uiService?.notify(formatPluginError(name, err), 'error');
-    return null;
-  }
-  const plugin = extractPlugin(mod, config);
-  if (!plugin) {
-    const exportKeys = Object.keys(mod).join(', ') || '(none)';
-    uiService?.notify(`Plugin "${name}": no plugin export found. Exports: [${exportKeys}]`, 'error');
-    return null;
-  }
-  return plugin;
-}
-
-export async function loadConfiguredPlugin(
-  registry: PluginRegistry,
-  name: string,
-  pluginConfig?: Record<string, unknown>,
-  uiService?: InkUIService,
-): Promise<void> {
-  const plugin = await resolveConfiguredPlugin(name, pluginConfig, uiService);
-  if (!plugin) return;
-  try {
-    await registry.register(plugin);
-  } catch (err) {
-    uiService?.notify(formatPluginError(name, err), 'error');
-  }
-}

package/src/runtime/startupUpdateCheck.ts

@@ -1,163 +0,0 @@
-/**
- * Startup update check — fires off `npm view` probes in the background after
- * the TUI is up, then surfaces a toast through `uiService.notify` when mu or
- * any installed npm plugin has a newer version on the registry.
- *
- * Design constraints:
- *  - Must never block startup. Caller fire-and-forgets the returned promise.
- *  - Must never crash the host on network / DNS errors. Every probe is wrapped.
- *  - Must not hammer npm on every boot. Results are cached in
- *    `<cacheDir>/update-check.json` for `CACHE_TTL_MS` (1h).
- *  - Disable with `MU_NO_UPDATE_CHECK=1` (kill switch for offline / CI / tests).
- *
- * Toasts are routed through the existing `InkUIService.notify` queue, which
- * buffers messages emitted before any toast listener attaches — so even if
- * the probe finishes before the TUI mounts (rare; see fast `npm view` runs)
- * the alert still surfaces.
- */
-
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { getCacheDir, getDataDir } from '../config/index';
-import type { InkUIService } from '../tui/plugins/InkUIService';
-import {
-  listConfiguredNpmPlugins,
-  type NpmRegistryView,
-  PACKAGE_NAME,
-  probePluginAsync,
-  probeSelfAsync,
-} from './updateCheck';
-
-const CACHE_TTL_MS = 60 * 60 * 1000; // 1 h
-const CACHE_FILENAME = 'update-check.json';
-
-interface CacheShape {
-  ts: number;
-  results: Record<string, NpmRegistryView | null>;
-}
-
-function cachePath(): string {
-  return join(getCacheDir(), CACHE_FILENAME);
-}
-
-function readCache(): CacheShape | null {
-  try {
-    const raw = readFileSync(cachePath(), 'utf-8');
-    const parsed = JSON.parse(raw) as CacheShape;
-    if (typeof parsed?.ts !== 'number' || typeof parsed?.results !== 'object') return null;
-    if (Date.now() - parsed.ts > CACHE_TTL_MS) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-
-function writeCache(cache: CacheShape): void {
-  try {
-    mkdirSync(getCacheDir(), { recursive: true });
-    writeFileSync(cachePath(), JSON.stringify(cache), 'utf-8');
-  } catch {
-    // Cache writes are best-effort; ignore disk errors.
-  }
-}
-
-/**
- * Discard the cached probe result. Called after a `/update` so the next
- * boot re-probes against fresh registry data instead of replaying the
- * pre-update state from cache.
- */
-export function invalidateUpdateCheckCache(): void {
-  try {
-    rmSync(cachePath(), { force: true });
-  } catch {
-    // best-effort
-  }
-}
-
-function isDisabled(): boolean {
-  const v = process.env.MU_NO_UPDATE_CHECK;
-  return v === '1' || v === 'true' || v === 'yes';
-}
-
-interface ProbeOutcome {
-  self: NpmRegistryView | null;
-  plugins: Map<string, NpmRegistryView | null>;
-}
-
-async function runProbes(): Promise<ProbeOutcome> {
-  const dataDir = getDataDir();
-  const pluginNames = listConfiguredNpmPlugins();
-
-  const [self, ...plugins] = await Promise.all([
-    probeSelfAsync().catch(() => null),
-    ...pluginNames.map((name) => probePluginAsync(name, dataDir).catch(() => null)),
-  ]);
-
-  const pluginMap = new Map<string, NpmRegistryView | null>();
-  pluginNames.forEach((name, i) => {
-    pluginMap.set(name, plugins[i] ?? null);
-  });
-
-  return { self, plugins: pluginMap };
-}
-
-function outcomeFromCache(cache: CacheShape, pluginNames: string[]): ProbeOutcome {
-  const self = cache.results[PACKAGE_NAME] ?? null;
-  const plugins = new Map<string, NpmRegistryView | null>();
-  for (const name of pluginNames) {
-    plugins.set(name, cache.results[name] ?? null);
-  }
-  return { self, plugins };
-}
-
-function outcomeToCache(outcome: ProbeOutcome): CacheShape {
-  const results: Record<string, NpmRegistryView | null> = {};
-  results[PACKAGE_NAME] = outcome.self;
-  for (const [name, view] of outcome.plugins) {
-    results[name] = view;
-  }
-  return { ts: Date.now(), results };
-}
-
-function notifyOutcome(outcome: ProbeOutcome, ui: InkUIService): void {
-  const stale: string[] = [];
-  if (outcome.self?.hasUpdate) {
-    stale.push(`mu ${outcome.self.current} → ${outcome.self.latest}`);
-  }
-  for (const [name, view] of outcome.plugins) {
-    if (view?.hasUpdate) {
-      stale.push(`${name} ${view.current} → ${view.latest}`);
-    }
-  }
-  if (stale.length === 0) return;
-
-  const header = stale.length === 1 ? 'Update available' : `${stale.length} updates available`;
-  const body = stale.join(', ');
-  ui.notify(`${header}: ${body}. Run \`mu update\` to apply.`, 'info');
-}
-
-/**
- * Background entry point. Resolves once the probe (or cache lookup) has
- * completed and any toast has been emitted. Callers should fire-and-forget.
- */
-export async function checkForUpdatesInBackground(ui: InkUIService): Promise<void> {
-  if (isDisabled()) return;
-
-  const pluginNames = listConfiguredNpmPlugins();
-
-  const cached = readCache();
-  if (cached) {
-    notifyOutcome(outcomeFromCache(cached, pluginNames), ui);
-    return;
-  }
-
-  let outcome: ProbeOutcome;
-  try {
-    outcome = await runProbes();
-  } catch {
-    return;
-  }
-
-  writeCache(outcomeToCache(outcome));
-  notifyOutcome(outcome, ui);
-}

package/src/runtime/updateCheck.ts

@@ -1,136 +0,0 @@
-/**
- * Shared "is there a newer version?" probes used by both the `mu update` /
- * `mu outdated` CLI subcommands (synchronous, blocking) and the in-TUI
- * startup alert (asynchronous, cached). Pure & side-effect free except for
- * the actual `npm view` exec — no toast / IO concerns live here.
- */
-
-import { execFile, execFileSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { promisify } from 'node:util';
-import { loadConfig, parseBareNpmSpec } from '../config/index';
-
-const execFileAsync = promisify(execFile);
-
-export const PACKAGE_NAME = 'mu-coding';
-
-export interface NpmRegistryView {
-  current: string;
-  latest: string;
-  hasUpdate: boolean;
-}
-
-export function npmViewLatestSync(name: string): string | undefined {
-  try {
-    const out = execFileSync('npm', ['view', name, 'version'], {
-      stdio: ['ignore', 'pipe', 'ignore'],
-      encoding: 'utf-8',
-    });
-    return out.trim() || undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-export async function npmViewLatest(name: string, timeoutMs = 8000): Promise<string | undefined> {
-  try {
-    const { stdout } = await execFileAsync('npm', ['view', name, 'version'], {
-      timeout: timeoutMs,
-      encoding: 'utf-8',
-    });
-    return stdout.trim() || undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-export function readInstalledVersion(name: string, cwd: string): string | undefined {
-  try {
-    const path = join(cwd, 'node_modules', name, 'package.json');
-    const pkg = JSON.parse(readFileSync(path, 'utf-8'));
-    return typeof pkg.version === 'string' ? pkg.version : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-export function readSelfVersion(): string | undefined {
-  const here = dirname(fileURLToPath(import.meta.url));
-  const candidates = [
-    join(here, '..', '..', 'package.json'),
-    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 === PACKAGE_NAME && typeof pkg.version === 'string') return pkg.version;
-    } catch {
-      // try next
-    }
-  }
-  return undefined;
-}
-
-export function listConfiguredNpmPlugins(): string[] {
-  const config = loadConfig();
-  const out: string[] = [];
-  for (const entry of config.plugins ?? []) {
-    const spec = typeof entry === 'string' ? entry : entry.name;
-    if (!spec.startsWith('npm:')) continue;
-    const { name } = parseBareNpmSpec(spec.slice(4));
-    out.push(name);
-  }
-  return out;
-}
-
-/**
- * Best-effort "is `latest` newer than `current`?". Splits on `.+-` and
- * compares numeric segments left-to-right. Returns `true` when `current` is
- * unknown so a missing local install reads as "needs install / update".
- */
-export function isVersionNewer(current: string | undefined, latest: string): boolean {
-  if (!current) return true;
-  if (current === latest) return false;
-  const cur = current.split(/[.+-]/).map((p) => Number.parseInt(p, 10));
-  const lat = latest.split(/[.+-]/).map((p) => Number.parseInt(p, 10));
-  const len = Math.max(cur.length, lat.length);
-  for (let i = 0; i < len; i++) {
-    const a = cur[i];
-    const b = lat[i];
-    if (Number.isNaN(a ?? Number.NaN) || Number.isNaN(b ?? Number.NaN)) return current !== latest;
-    if ((a ?? 0) < (b ?? 0)) return true;
-    if ((a ?? 0) > (b ?? 0)) return false;
-  }
-  return false;
-}
-
-export function probePluginSync(name: string, dataDir: string): NpmRegistryView | null {
-  const latest = npmViewLatestSync(name);
-  if (!latest) return null;
-  const current = readInstalledVersion(name, dataDir);
-  return { current: current ?? '(not installed)', latest, hasUpdate: isVersionNewer(current, latest) };
-}
-
-export function probeSelfSync(): NpmRegistryView | null {
-  const latest = npmViewLatestSync(PACKAGE_NAME);
-  if (!latest) return null;
-  const current = readSelfVersion();
-  return { current: current ?? '(unknown)', latest, hasUpdate: isVersionNewer(current, latest) };
-}
-
-export async function probePluginAsync(name: string, dataDir: string): Promise<NpmRegistryView | null> {
-  const latest = await npmViewLatest(name);
-  if (!latest) return null;
-  const current = readInstalledVersion(name, dataDir);
-  return { current: current ?? '(not installed)', latest, hasUpdate: isVersionNewer(current, latest) };
-}
-
-export async function probeSelfAsync(): Promise<NpmRegistryView | null> {
-  const latest = await npmViewLatest(PACKAGE_NAME);
-  if (!latest) return null;
-  const current = readSelfVersion();
-  return { current: current ?? '(unknown)', latest, hasUpdate: isVersionNewer(current, latest) };
-}

package/src/sessions/index.test.ts

@@ -1,66 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
-import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { clearSessionCache, listSessionsAsync, loadSession, saveSession } from './index';
-
-let tmpRoot: string;
-let originalDataHome: string | undefined;
-
-beforeAll(() => {
-  tmpRoot = mkdtempSync(join(tmpdir(), 'mu-sessions-'));
-  originalDataHome = process.env.XDG_DATA_HOME;
-  process.env.XDG_DATA_HOME = tmpRoot;
-});
-
-afterAll(() => {
-  if (originalDataHome === undefined) {
-    delete process.env.XDG_DATA_HOME;
-  } else {
-    process.env.XDG_DATA_HOME = originalDataHome;
-  }
-  clearSessionCache();
-});
-
-describe('saveSession / loadSession', () => {
-  it('round-trips messages as JSONL', async () => {
-    const path = join(tmpRoot, 'roundtrip.jsonl');
-    const messages = [
-      { role: 'user' as const, content: 'hi' },
-      { role: 'assistant' as const, content: 'hello' },
-    ];
-    await saveSession(path, messages);
-
-    const raw = readFileSync(path, 'utf-8');
-    expect(raw.split('\n').filter(Boolean)).toHaveLength(2);
-
-    const loaded = loadSession(path);
-    expect(loaded).toEqual(messages);
-  });
-
-  it('returns [] for missing files', () => {
-    expect(loadSession(join(tmpRoot, 'does-not-exist.jsonl'))).toEqual([]);
-  });
-
-  it('skips malformed JSONL lines', () => {
-    const path = join(tmpRoot, 'partial.jsonl');
-    writeFileSync(path, '{"role":"user","content":"ok"}\n{not json}\n{"role":"assistant","content":"yo"}\n');
-    const loaded = loadSession(path);
-    expect(loaded).toHaveLength(2);
-    expect(loaded[0].role).toBe('user');
-    expect(loaded[1].role).toBe('assistant');
-  });
-
-  it('writes empty content for empty arrays', async () => {
-    const path = join(tmpRoot, 'empty.jsonl');
-    await saveSession(path, []);
-    expect(readFileSync(path, 'utf-8')).toBe('');
-  });
-});
-
-describe('listSessionsAsync', () => {
-  it('returns [] when no project sessions exist', async () => {
-    const list = await listSessionsAsync();
-    expect(Array.isArray(list)).toBe(true);
-  });
-});

package/src/sessions/index.ts

@@ -1,183 +0,0 @@
-import { createReadStream, mkdirSync, readdirSync, readFileSync } from 'node:fs';
-import { stat, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { createInterface } from 'node:readline';
-import type { ChatMessage } from 'mu-core';
-import { getDataDir } from '../config/index';
-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`);
-}
-
-/**
- * Persist `messages` as JSONL. Async to avoid blocking the event loop on
- * large sessions; callers should `await` to apply backpressure.
- */
-export async function saveSession(path: string, messages: ChatMessage[]): Promise<void> {
-  const content = messages.length > 0 ? `${messages.map((m) => JSON.stringify(m)).join('\n')}\n` : '';
-  await writeFile(path, content, '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 [];
-  }
-}
-
-interface SessionPeek {
-  messageCount: number;
-  preview: string;
-}
-
-const PREVIEW_LENGTH = 80;
-const NO_USER_PREVIEW = '(no user message)';
-const EMPTY_PEEK: SessionPeek = { messageCount: 0, preview: '(empty)' };
-
-/**
- * In-memory cache of session metadata, keyed by absolute path. Entries are
- * invalidated when the file's mtime changes (a fresh `saveSession` after a
- * new message bumps mtime). Lifetime is the process — no on-disk index.
- */
-const peekCache = new Map<string, { mtimeMs: number; peek: SessionPeek }>();
-
-function extractUserPreview(line: string): string | null {
-  try {
-    const msg = JSON.parse(line) as ChatMessage;
-    if (msg && msg.role === 'user' && typeof msg.content === 'string') {
-      return msg.content.slice(0, PREVIEW_LENGTH).replace(/\n/g, ' ');
-    }
-  } catch {
-    // Skip malformed lines.
-  }
-  return null;
-}
-
-/**
- * Stream a session file line-by-line so memory use is bounded regardless of
- * file size, and we can stop expensive `JSON.parse` work as soon as we've
- * captured the first user message.
- */
-async function peekSessionStreaming(path: string): Promise<SessionPeek> {
-  return new Promise((resolve) => {
-    const stream = createReadStream(path, { encoding: 'utf-8', highWaterMark: 64 * 1024 });
-    const rl = createInterface({ input: stream });
-    let messageCount = 0;
-    let preview: string | null = null;
-
-    const finish = (): void => {
-      resolve({ messageCount, preview: preview ?? NO_USER_PREVIEW });
-    };
-
-    rl.on('line', (line) => {
-      if (!line) return;
-      messageCount++;
-      if (preview !== null) return;
-      preview = extractUserPreview(line);
-    });
-    rl.on('close', finish);
-    stream.on('error', () => resolve(EMPTY_PEEK));
-  });
-}
-
-async function peekSessionCached(path: string, mtimeMs: number): Promise<SessionPeek> {
-  const cached = peekCache.get(path);
-  if (cached && cached.mtimeMs === mtimeMs) {
-    return cached.peek;
-  }
-  const peek = await peekSessionStreaming(path);
-  peekCache.set(path, { mtimeMs, peek });
-  return peek;
-}
-
-/** Test/maintenance helper — drop the in-memory peek cache. */
-export function clearSessionCache(): void {
-  peekCache.clear();
-}
-
-export function getLatestSession(): string | null {
-  const files = getSortedSessionFiles();
-  return files.length ? join(getProjectSessionsDir(), files[0]) : null;
-}
-
-/**
- * Resolve session metadata for the picker. Each file is peeked concurrently
- * (typically just a few hundred bytes per file), and successive picker opens
- * hit the in-memory cache keyed by mtime.
- */
-export async function listSessionsAsync(): Promise<SessionInfo[]> {
-  let dir: string;
-  try {
-    dir = getProjectSessionsDir();
-    mkdirSync(dir, { recursive: true });
-  } catch {
-    return [];
-  }
-  const files = getSortedSessionFiles();
-  const project = getProjectName();
-
-  const results = await Promise.all(
-    files.map(async (file) => {
-      const path = join(dir, file);
-      try {
-        const fileStat = await stat(path);
-        const peek = await peekSessionCached(path, fileStat.mtimeMs);
-        return {
-          path,
-          name: file.replace('.jsonl', ''),
-          date: fileStat.mtime,
-          messageCount: peek.messageCount,
-          preview: peek.preview,
-          project,
-        } satisfies SessionInfo;
-      } catch {
-        return null;
-      }
-    }),
-  );
-
-  return results.filter((s): s is SessionInfo => s !== null);
-}