mu-coding 0.4.0 → 0.5.0

package/src/main.tsx

@@ -1,147 +0,0 @@
-#!/usr/bin/env bun
-import { readdirSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { join, resolve } from 'node:path';
-import { render } from 'ink';
-import { createBuiltinPlugin, PluginRegistry } from 'mu-agents';
-import { parseArgs, resolveInitialMessages } from './cli';
-import { type AppConfig, getDataDir, getPluginsDir, loadConfig } from './config';
-import { handleSubcommand } from './subcommands';
-import { ChatPanel } from './tui/components/chat/ChatPanel';
-import { InkUIService } from './tui/services/uiService';
-
-function discoverPluginFiles(): string[] {
-  const dir = getPluginsDir();
-  try {
-    return readdirSync(dir)
-      .filter((f) => f.endsWith('.ts'))
-      .map((f) => join(dir, f));
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Resolve an npm: specifier to an absolute path via the data dir's node_modules.
- */
-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(': ');
-}
-
-function resolveNpmPlugin(specifier: string): string {
-  const bare = specifier.slice(4);
-  const dataDir = getDataDir();
-  try {
-    const require = createRequire(resolve(dataDir, 'package.json'));
-    return require.resolve(bare);
-  } catch (err) {
-    throw new Error(`Cannot resolve "${bare}" from ${dataDir}/node_modules — is it installed?`, { cause: err });
-  }
-}
-
-/**
- * Load a plugin by name or path, resolving from this package's context.
- * This allows workspace packages (like mu-pi-compat) to be found even though
- * mu-agents' registry can't resolve them from its own location.
- *
- * Plugins prefixed with npm: are resolved from ~/.local/share/mu/node_modules/.
- */
-async function loadPluginFromHere(
-  registry: PluginRegistry,
-  name: string,
-  pluginConfig?: Record<string, unknown>,
-  uiService?: InkUIService,
-): Promise<void> {
-  try {
-    const target = name.startsWith('npm:') ? resolveNpmPlugin(name) : name;
-    const mod = await import(target);
-    const factory = mod.default ?? mod.createPlugin;
-
-    if (typeof factory === 'function') {
-      const plugin = factory(pluginConfig ?? {});
-      await registry.register(plugin);
-    } else if (typeof mod === 'object' && mod !== null && 'name' in mod) {
-      await registry.register(mod);
-    } else {
-      const exportKeys = Object.keys(mod).join(', ') || '(none)';
-      uiService?.notify(`Plugin "${name}": no plugin export found. Exports: [${exportKeys}]`, 'error');
-    }
-  } catch (err) {
-    // npm: plugins don't fall back — they must resolve from data dir
-    if (name.startsWith('npm:')) {
-      uiService?.notify(formatPluginError(name, err), 'error');
-      return;
-    }
-    // Non-npm plugins fall back to registry loader (for file paths)
-    try {
-      await registry.loadPlugin(name, pluginConfig);
-    } catch (fallbackErr) {
-      uiService?.notify(formatPluginError(name, fallbackErr), 'error');
-    }
-  }
-}
-
-async function createRegistry(cwd: string, config: AppConfig, uiService: InkUIService) {
-  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 configured plugins
-  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;
-
-      // Inject uiService for plugins that accept it (duck typing)
-      const finalConfig = pluginConfig ? { ...pluginConfig, ui: uiService } : { ui: uiService };
-
-      await loadPluginFromHere(registry, name, finalConfig, uiService);
-    }
-  }
-
-  return registry;
-}
-
-async function main() {
-  if (await handleSubcommand()) return;
-
-  const cliArgs = parseArgs();
-  const config = loadConfig(cliArgs.model);
-  const root = process.cwd();
-
-  const uiService = new InkUIService();
-  const registry = await createRegistry(root, config, uiService);
-
-  const initialMessages = resolveInitialMessages(cliArgs);
-
-  render(<ChatPanel config={config} initialMessages={initialMessages} registry={registry} uiService={uiService} />, {
-    exitOnCtrlC: false,
-    kittyKeyboard: { mode: 'enabled' },
-  });
-
-  process.on('exit', () => {
-    registry.shutdown();
-  });
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});

package/src/project.ts

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

@@ -1,95 +0,0 @@
-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 [];
-  }
-}

package/src/tui/commands.ts

@@ -1,33 +0,0 @@
-import type { CommandContext, SlashCommand as PluginSlashCommand } from 'mu-agents';
-
-export interface SlashCommand {
-  name: string;
-  description: string;
-  action?: string;
-  execute?: (args: string) => Promise<string | undefined>;
-}
-
-const BUILTIN_COMMANDS: SlashCommand[] = [
-  { name: '/model', description: 'Select a model', action: 'model' },
-  { name: '/sessions', description: 'List project sessions', action: 'sessions' },
-  { name: '/new', description: 'New conversation', action: 'new' },
-];
-
-export function matchCommands(input: string, pluginCommands: PluginSlashCommand[] = []): SlashCommand[] {
-  if (!input.startsWith('/')) {
-    return [];
-  }
-  const q = input.toLowerCase();
-
-  const fromPlugins: SlashCommand[] = pluginCommands.map((pc) => ({
-    name: `/${pc.name}`,
-    description: pc.description,
-    execute: (args: string) => {
-      const ctx: CommandContext = { messages: [], cwd: process.cwd(), config: {} as CommandContext['config'] };
-      return pc.execute(args, ctx);
-    },
-  }));
-
-  const all = [...BUILTIN_COMMANDS, ...fromPlugins];
-  return all.filter((cmd) => cmd.name.startsWith(q));
-}

package/src/tui/components/chatLayout.tsx

@@ -1,192 +0,0 @@
-import type { DOMElement } from 'ink';
-import { Box, Text } from 'ink';
-import type { StatusSegment } from 'mu-agents';
-import type { ChatMessage } from 'mu-provider';
-import type React from 'react';
-import { useSpinner } from '../hooks/useUI';
-import type { StreamState } from '../useChatSession';
-import { MessageItem } from './messages/messageItem';
-import { StreamingOutput } from './messages/streamingOutput';
-import { Dropdown } from './ui/dropdown';
-import { Modal } from './ui/modal';
-
-function Scrollbar({
-  viewHeight,
-  contentHeight,
-  scrollOffset,
-}: {
-  viewHeight: number;
-  contentHeight: number;
-  scrollOffset: number;
-}) {
-  if (contentHeight <= viewHeight || viewHeight < 1) {
-    return null;
-  }
-  const maxScroll = contentHeight - viewHeight;
-  const ratio = scrollOffset / maxScroll;
-  const thumbSize = Math.max(1, Math.round((viewHeight / contentHeight) * viewHeight));
-  const thumbPos = Math.round(ratio * (viewHeight - thumbSize));
-
-  const track = Array.from({ length: viewHeight }, (_, i) => (i >= thumbPos && i < thumbPos + thumbSize ? '┃' : '│'));
-
-  return (
-    <Box flexDirection="column" flexShrink={0} width={1}>
-      <Text>{track.join('')}</Text>
-    </Box>
-  );
-}
-
-export function StatusBar({
-  streaming,
-  abortWarning,
-  quitWarning,
-  error,
-  modelError,
-  totalTokens,
-  tokensPerSecond,
-  pluginStatus,
-}: {
-  streaming: boolean;
-  abortWarning: boolean;
-  quitWarning: boolean;
-  error: string | null;
-  modelError: string | null;
-  totalTokens: number;
-  tokensPerSecond: number;
-  pluginStatus?: StatusSegment[];
-}) {
-  const spinner = useSpinner(streaming);
-  const segments: Array<{ text: string; color?: string; dim?: boolean }> = [];
-  if (streaming) {
-    segments.push({ text: `${spinner} generating`, color: 'yellow' });
-  }
-  if (tokensPerSecond > 0) {
-    segments.push({ text: `${tokensPerSecond} tok/s`, dim: true });
-  }
-  if (abortWarning) {
-    segments.push({ text: 'Esc again to stop', color: 'yellow' });
-  } else if (quitWarning) {
-    segments.push({ text: 'Ctrl+C again to quit', color: 'yellow' });
-  } else if (streaming) {
-    segments.push({ text: 'Esc to stop', dim: true });
-  }
-  if (error) {
-    segments.push({ text: '⚠ error', color: 'red' });
-  }
-  if (modelError) {
-    segments.push({ text: `⚠ ${modelError}`, color: 'red' });
-  }
-
-  if (totalTokens > 0) {
-    segments.push({ text: `${formatTokens(totalTokens)} tokens`, dim: true });
-  }
-  if (pluginStatus) {
-    segments.push(...pluginStatus);
-  }
-
-  return (
-    <Box flexShrink={0} paddingX={1} marginY={1}>
-      <Box justifyContent="flex-end" flexGrow={1}>
-        {segments.map((seg, i) => (
-          // biome-ignore lint/suspicious/noArrayIndexKey: positional static list
-          <Box key={i}>
-            {i > 0 && <Text dimColor={true}> · </Text>}
-            <Text color={seg.color} dimColor={seg.dim}>
-              {seg.text}
-            </Text>
-          </Box>
-        ))}
-      </Box>
-    </Box>
-  );
-}
-
-function formatTokens(tokens: number): string {
-  if (tokens >= 1_000_000) {
-    return `${(tokens / 1_000_000).toFixed(1)}M`;
-  }
-  if (tokens >= 1_000) {
-    return `${(tokens / 1_000).toFixed(1)}k`;
-  }
-  return String(tokens);
-}
-
-interface PickerItem {
-  label: string;
-  value: string;
-  description?: string;
-}
-
-export function PickerModal({
-  visible,
-  title,
-  items,
-  placeholder,
-  emptyMessage,
-  onSelect,
-  onCancel,
-}: {
-  visible: boolean;
-  title: string;
-  items: PickerItem[];
-  placeholder: string;
-  emptyMessage?: string;
-  onSelect: (value: string) => void;
-  onCancel?: () => void;
-}) {
-  return (
-    <Modal visible={visible} title={title}>
-      {items.length === 0 && emptyMessage ? (
-        <Text dimColor={true} italic={true}>
-          {emptyMessage}
-        </Text>
-      ) : (
-        <Dropdown
-          items={items}
-          placeholder={placeholder}
-          isActive={visible}
-          onSelect={(item) => onSelect(item.value)}
-          onCancel={onCancel}
-        />
-      )}
-    </Modal>
-  );
-}
-
-export function MessageView({
-  viewRef,
-  contentRef,
-  messages,
-  streaming,
-  stream,
-  error,
-  scrollOffset,
-  viewHeight,
-  contentHeight,
-}: {
-  viewRef: React.RefObject<DOMElement | null>;
-  contentRef: React.RefObject<DOMElement | null>;
-  messages: ChatMessage[];
-  streaming: boolean;
-  stream: StreamState;
-  error: string | null;
-  scrollOffset: number;
-  viewHeight: number;
-  contentHeight: number;
-}) {
-  return (
-    <Box flexGrow={1} overflow="hidden">
-      <Box ref={viewRef} flexDirection="column" flexGrow={1} paddingX={1} overflow="hidden">
-        <Box ref={contentRef} flexDirection="column" flexShrink={0} marginTop={-scrollOffset}>
-          {messages.map((msg, i) => (
-            // biome-ignore lint/suspicious/noArrayIndexKey: messages have no stable id
-            <MessageItem key={i} msg={msg} messages={messages} index={i} />
-          ))}
-          {streaming && <StreamingOutput currentText={stream.text} currentReasoning={stream.reasoning} />}
-          {error && <Text color="red">Error: {error}</Text>}
-        </Box>
-      </Box>
-      <Scrollbar viewHeight={viewHeight} contentHeight={contentHeight} scrollOffset={scrollOffset} />
-    </Box>
-  );
-}

package/src/tui/useChatSession.ts

@@ -1,155 +0,0 @@
-import { type AgentEvent, type PluginRegistry, runAgent } from 'mu-agents';
-import type { ChatMessage, ProviderConfig } from 'mu-provider';
-import { useCallback, useRef, useState } from 'react';
-import { generateSessionPath, loadSession, saveSession } from '../session';
-import type { AttachmentState } from './useChatUI';
-
-export interface StreamState {
-  text: string;
-  reasoning: string;
-  totalTokens: number;
-  tps: number;
-}
-
-const EMPTY_STREAM: StreamState = { text: '', reasoning: '', totalTokens: 0, tps: 0 };
-
-export interface ChatSessionState {
-  messages: ChatMessage[];
-  streaming: boolean;
-  error: string | null;
-  stream: StreamState;
-  inputHistory: string[];
-  onSend: (text: string) => Promise<void>;
-  onNew: () => void;
-  onLoadSession: (path: string) => void;
-}
-
-interface SessionDeps {
-  config: ProviderConfig;
-  currentModel: string;
-  attachment: AttachmentState;
-  controllerRef: React.RefObject<AbortController | null>;
-  initialMessages?: ChatMessage[];
-  registry: PluginRegistry;
-}
-
-function applyEvent(prev: StreamState, event: AgentEvent, tps: number): StreamState {
-  switch (event.type) {
-    case 'content':
-      return { ...prev, text: event.text, tps };
-    case 'reasoning':
-      return { ...prev, reasoning: event.text, tps };
-    case 'usage':
-      return { ...prev, totalTokens: prev.totalTokens + event.totalTokens };
-    case 'turn_end':
-      return { ...prev, text: '', reasoning: '' };
-    default:
-      return prev;
-  }
-}
-
-async function consumeAgent(
-  events: AsyncGenerator<AgentEvent>,
-  onStream: (updater: (prev: StreamState) => StreamState) => void,
-  onMessages: (messages: ChatMessage[]) => void,
-): Promise<ChatMessage[] | null> {
-  let final: ChatMessage[] | null = null;
-  const start = Date.now();
-  let tokenCount = 0;
-
-  for await (const event of events) {
-    if (event.type === 'content' || event.type === 'reasoning') {
-      tokenCount++;
-      const elapsed = (Date.now() - start) / 1000;
-      const tps = elapsed > 0.5 ? Math.round(tokenCount / elapsed) : 0;
-      onStream((prev) => applyEvent(prev, event, tps));
-    } else if (event.type === 'messages') {
-      final = event.messages;
-      onMessages(event.messages);
-    } else {
-      onStream((prev) => applyEvent(prev, event, 0));
-    }
-  }
-  return final;
-}
-
-export function useChatSession(deps: SessionDeps): ChatSessionState {
-  const { config, currentModel, attachment, controllerRef, initialMessages, registry } = deps;
-  const [messages, setMessages] = useState<ChatMessage[]>(initialMessages ?? []);
-  const [streaming, setStreaming] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const [stream, setStream] = useState<StreamState>(EMPTY_STREAM);
-  const [inputHistory, setInputHistory] = useState<string[]>(
-    initialMessages?.filter((m) => m.role === 'user').map((m) => m.content) ?? [],
-  );
-  const sessionPathRef = useRef(generateSessionPath());
-
-  const reset = useCallback(() => {
-    setStream(EMPTY_STREAM);
-    setError(null);
-  }, []);
-
-  const onSend = useCallback(
-    async (text: string) => {
-      if (streaming) {
-        return;
-      }
-      const userMsg: ChatMessage = {
-        role: 'user',
-        content: text,
-        ...(attachment.attachment ? { images: [attachment.attachment] } : {}),
-      };
-      setMessages((prev) => [...prev, userMsg]);
-      setInputHistory((prev) => [...prev, text]);
-      reset();
-      setStreaming(true);
-      attachment.clear();
-
-      const controller = new AbortController();
-      controllerRef.current = controller;
-
-      try {
-        const final = await consumeAgent(
-          runAgent([...messages, userMsg], config, currentModel, controller.signal, registry),
-          setStream,
-          setMessages,
-        );
-        if (final) {
-          saveSession(sessionPathRef.current, final);
-        }
-      } catch (err) {
-        if (!(err instanceof Error && err.name === 'AbortError')) {
-          setError(err instanceof Error ? err.message : 'Unknown error');
-        }
-      } finally {
-        setStreaming(false);
-        controllerRef.current = null;
-        if (!controller.signal.aborted) {
-          setStream((s) => ({ ...s, text: '', reasoning: '' }));
-        }
-      }
-    },
-    [streaming, messages, config, currentModel, attachment, controllerRef, reset, registry],
-  );
-
-  const onNew = useCallback(() => {
-    setMessages([]);
-    reset();
-    sessionPathRef.current = generateSessionPath();
-    attachment.clear();
-  }, [attachment, reset]);
-
-  const onLoadSession = useCallback(
-    (path: string) => {
-      const msgs = loadSession(path);
-      if (msgs.length > 0) {
-        setMessages(msgs);
-        sessionPathRef.current = path;
-        reset();
-      }
-    },
-    [reset],
-  );
-
-  return { messages, streaming, error, stream, inputHistory, onSend, onNew, onLoadSession };
-}

package/src/tui/useChatUI.ts

@@ -1,51 +0,0 @@
-import type { ImageAttachment } from 'mu-provider';
-import { useCallback, useState } from 'react';
-import { readClipboardImage } from '../clipboard';
-
-export interface AttachmentState {
-  attachment: ImageAttachment | null;
-  attachmentError: string | null;
-  onPaste: () => void;
-  clear: () => void;
-}
-
-export function useAttachment(): AttachmentState {
-  const [attachment, setAttachment] = useState<ImageAttachment | null>(null);
-  const [attachmentError, setAttachmentError] = useState<string | null>(null);
-
-  const onPaste = useCallback(() => {
-    const img = readClipboardImage();
-    if (img) {
-      setAttachment(img);
-      setAttachmentError(null);
-      return;
-    }
-    setAttachmentError('No image on clipboard');
-    setTimeout(() => setAttachmentError(null), 3000);
-  }, []);
-
-  const clear = useCallback(() => {
-    setAttachment(null);
-    setAttachmentError(null);
-  }, []);
-
-  return { attachment, attachmentError, onPaste, clear };
-}
-
-export interface TogglesState {
-  showModelPicker: boolean;
-  showSessionPicker: boolean;
-  onTogglePicker: () => void;
-  onToggleSessionPicker: () => void;
-}
-
-export function useToggles(): TogglesState {
-  const [showModelPicker, setShowModelPicker] = useState(false);
-  const [showSessionPicker, setShowSessionPicker] = useState(false);
-  return {
-    showModelPicker,
-    showSessionPicker,
-    onTogglePicker: useCallback(() => setShowModelPicker((p) => !p), []),
-    onToggleSessionPicker: useCallback(() => setShowSessionPicker((p) => !p), []),
-  };
-}