mu-coding 0.2.0 → 0.5.0

package/src/main.tsx

@@ -1,161 +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 { runSingleShot } from './singleShot';
-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);
-
-  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} 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/singleShot.ts

@@ -1,42 +0,0 @@
-import type { PluginRegistry } from 'mu-agents';
-import type { ChatMessage, ProviderConfig } from 'mu-provider';
-import { listModels, streamChat } from 'mu-provider';
-
-export async function runSingleShot(prompt: string, config: ProviderConfig, registry: PluginRegistry): Promise<void> {
-  const messages: ChatMessage[] = [{ role: 'user', content: prompt }];
-
-  let resolvedModel = config.model;
-  if (!resolvedModel) {
-    const models = await listModels(config.baseUrl);
-    if (models.length === 0) {
-      console.error('Error: no models available at', config.baseUrl);
-      process.exit(1);
-    }
-    resolvedModel = models[0].id;
-  }
-
-  const toolDefinitions = registry.getToolDefinitions();
-
-  let tokens = 0;
-  let hasToolCalls = false;
-  process.stdout.write('mu: ');
-  for await (const chunk of streamChat(messages, config, resolvedModel, {
-    onUsage: (usage) => {
-      tokens = usage.totalTokens;
-    },
-    tools: toolDefinitions,
-  })) {
-    if (chunk.type === 'content') {
-      process.stdout.write(chunk.text);
-    } else if (chunk.type === 'tool_call') {
-      hasToolCalls = true;
-    }
-  }
-  if (hasToolCalls) {
-    process.stderr.write('\n[tool calls made — use interactive mode for tool execution]\n');
-  }
-  process.stdout.write('\n');
-  if (tokens > 0) {
-    process.stderr.write(`(${tokens} tokens)\n`);
-  }
-}

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>
-  );
-}