pelulu-cli 1.0.0

package/src/core/conversation.js

@@ -0,0 +1,57 @@
+/**
+ * Conversation — save/load conversation history
+ */
+import { readFile, writeFile, mkdir, readdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getConfig } from './config.js';
+
+const CONV_DIR = 'conversations';
+
+function getConvDir() {
+  const cfg = getConfig();
+  return join(cfg._root, CONV_DIR);
+}
+
+export async function saveConversation(messages, name) {
+  const dir = getConvDir();
+  await mkdir(dir, { recursive: true });
+  const filename = name || `conv-${Date.now()}.json`;
+  const path = join(dir, filename);
+  await writeFile(path, JSON.stringify({ messages, savedAt: Date.now() }, null, 2));
+  return path;
+}
+
+export async function loadConversation(name) {
+  const path = join(getConvDir(), name);
+  if (!existsSync(path)) throw new Error(`Conversation not found: ${name}`);
+  const data = JSON.parse(await readFile(path, 'utf-8'));
+  return data.messages;
+}
+
+export async function listConversations() {
+  const dir = getConvDir();
+  if (!existsSync(dir)) return [];
+  const files = await readdir(dir);
+  const convs = [];
+  for (const f of files.filter(f => f.endsWith('.json'))) {
+    try {
+      const data = JSON.parse(await readFile(join(dir, f), 'utf-8'));
+      convs.push({
+        name: f,
+        messages: data.messages?.length || 0,
+        savedAt: data.savedAt,
+      });
+    } catch {}
+  }
+  return convs.sort((a, b) => (b.savedAt || 0) - (a.savedAt || 0));
+}
+
+export function formatConversationSummary(messages) {
+  const turns = messages.filter(m => m.role === 'user').length;
+  const toolCalls = messages.filter(m => m.role === 'tool').length;
+  const duration = messages.length > 1
+    ? Math.round((messages[messages.length - 1].ts - messages[0].ts) / 1000)
+    : 0;
+  return `${turns} turns, ${toolCalls} tool calls, ${duration}s`;
+}

package/src/core/diff.js

@@ -0,0 +1,50 @@
+/**
+ * Diff — visual code change display
+ * Shows before/after with colors, like Claude Code's diff view
+ */
+import { COLORS } from './logger.js';
+
+export function showDiff(oldText, newText, filePath) {
+  const oldLines = oldText.split('\n');
+  const newLines = newText.split('\n');
+  const maxLen = Math.max(oldLines.length, newLines.length);
+
+  console.log(`\n${COLORS.bold}📝 Changes: ${filePath || ''}${COLORS.reset}\n`);
+
+  let changes = 0;
+  for (let i = 0; i < maxLen; i++) {
+    const old = oldLines[i];
+    const new_ = newLines[i];
+
+    if (old === new_) {
+      console.log(`${COLORS.gray}  ${String(i + 1).padStart(4)} │ ${old || ''}${COLORS.reset}`);
+    } else {
+      changes++;
+      if (old !== undefined) console.log(`${COLORS.red}- ${String(i + 1).padStart(4)} │ ${old}${COLORS.reset}`);
+      if (new_ !== undefined) console.log(`${COLORS.green}+ ${String(i + 1).padStart(4)} │ ${new_}${COLORS.reset}`);
+    }
+  }
+
+  console.log(`\n${COLORS.dim}  ${changes} line(s) changed${COLORS.reset}\n`);
+  return changes;
+}
+
+export function showPatch(filePath, hunks) {
+  console.log(`\n${COLORS.bold}📝 Patch: ${filePath}${COLORS.reset}\n`);
+  for (const hunk of hunks) {
+    console.log(`${COLORS.cyan}@@ ${hunk.header || ''} @@${COLORS.reset}`);
+    for (const line of hunk.lines) {
+      if (line.startsWith('+')) console.log(`${COLORS.green}${line}${COLORS.reset}`);
+      else if (line.startsWith('-')) console.log(`${COLORS.red}${line}${COLORS.reset}`);
+      else console.log(`${COLORS.gray}${line}${COLORS.reset}`);
+    }
+  }
+  console.log();
+}
+
+export function formatFileChange(action, path, details) {
+  const icons = { created: '✨', modified: '📝', deleted: '🗑️', renamed: '📎' };
+  const icon = icons[action] || '📄';
+  const detailStr = details ? ` ${COLORS.dim}(${details})${COLORS.reset}` : '';
+  return `${icon} ${action}: ${path}${detailStr}`;
+}

package/src/core/doctor.js

@@ -0,0 +1,60 @@
+/**
+ * Doctor — diagnostic checks for the coding agent
+ * Like Claude Code's diagnostic/health check
+ */
+import { exec } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getConfig } from './config.js';
+import { COLORS } from './logger.js';
+
+function run(cmd) {
+  return new Promise((resolve) => {
+    exec(cmd, { timeout: 5000 }, (err, stdout) => resolve(!err && stdout?.trim()));
+  });
+}
+
+export async function runDoctor() {
+  const cfg = getConfig();
+  const cwd = cfg.agent?.workspace || process.cwd();
+  const checks = [];
+
+  // Node.js
+  const nodeVer = await run('node --version');
+  checks.push({ name: 'Node.js', ok: !!nodeVer, value: nodeVer || 'not found' });
+
+  // npm
+  const npmVer = await run('npm --version');
+  checks.push({ name: 'npm', ok: !!npmVer, value: npmVer || 'not found' });
+
+  // git
+  const gitVer = await run('git --version');
+  checks.push({ name: 'git', ok: !!gitVer, value: gitVer || 'not found' });
+
+  // Workspace
+  checks.push({ name: 'Workspace', ok: existsSync(cwd), value: cwd });
+
+  // Config
+  checks.push({ name: 'Config', ok: !!cfg, value: cfg._path });
+
+  // Device ID
+  checks.push({ name: 'Device ID', ok: !!cfg.mqtt?.device_id, value: cfg.mqtt?.device_id || 'not set' });
+
+  // MQTT
+  checks.push({ name: 'MQTT endpoint', ok: !!cfg.mqtt?.ota_url, value: cfg.mqtt?.ota_url || 'not set' });
+
+  // Git repo
+  const hasGit = existsSync(join(cwd, '.git'));
+  checks.push({ name: 'Git repo', ok: hasGit, value: hasGit ? 'yes' : 'no' });
+
+  // Print report
+  console.log(`\n${COLORS.bold}🩺 Doctor Report:${COLORS.reset}\n`);
+  let allOk = true;
+  for (const c of checks) {
+    const icon = c.ok ? `${COLORS.green}✅${COLORS.reset}` : `${COLORS.red}❌${COLORS.reset}`;
+    console.log(`  ${icon} ${c.name.padEnd(18)} ${c.value}`);
+    if (!c.ok) allOk = false;
+  }
+  console.log(`\n${allOk ? `${COLORS.green}All checks passed!${COLORS.reset}` : `${COLORS.yellow}Some checks failed.${COLORS.reset}`}\n`);
+  return allOk;
+}

package/src/core/error-handler.js

@@ -0,0 +1,39 @@
+/**
+ * ErrorHandler — smart error handling with suggestions
+ * Like Claude Code: shows what went wrong + how to fix it
+ */
+import { COLORS } from './logger.js';
+
+const ERROR_SUGGESTIONS = {
+  'ENOENT': (e) => `File not found. Check the path: ${e.path || ''}`,
+  'EACCES': () => 'Permission denied. Check file permissions.',
+  'EISDIR': () => 'Is a directory, not a file. Use "list" action instead.',
+  'ENOTDIR': () => 'Not a directory. Check the path.',
+  'EEXIST': () => 'Already exists. Use "edit" to modify or delete first.',
+  'ETIMEDOUT': () => 'Timed out. Try increasing timeout or check network.',
+  'ECONNREFUSED': () => 'Connection refused. Is the server running?',
+  'ENOTFOUND': () => 'Host not found. Check the URL or DNS.',
+  'MODULE_NOT_FOUND': (e) => `Module not found. Run: npm install`,
+  'SyntaxError': () => 'Syntax error in code. Check brackets, quotes, semicolons.',
+};
+
+export function handleError(error) {
+  const code = error.code || error.constructor?.name || 'UNKNOWN';
+  const suggestion = ERROR_SUGGESTIONS[code]?.(error) || null;
+
+  const lines = [`${COLORS.red}❌ ${error.message}${COLORS.reset}`];
+  if (suggestion) lines.push(`${COLORS.yellow}💡 ${suggestion}${COLORS.reset}`);
+
+  return lines.join('\n');
+}
+
+export function wrapToolError(toolName, action, fn) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (e) {
+      const enhanced = handleError(e);
+      throw new Error(enhanced);
+    }
+  };
+}

package/src/core/event-bus.js

@@ -0,0 +1,43 @@
+/**
+ * EventBus — lightweight pub/sub for decoupled communication
+ */
+import { EventEmitter } from 'events';
+
+class Bus extends EventEmitter {
+  constructor() {
+    super();
+    this.setMaxListeners(50);
+  }
+
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+
+  on(event, fn) {
+    return super.on(event, fn);
+  }
+
+  once(event, fn) {
+    return super.once(event, fn);
+  }
+
+  off(event, fn) {
+    return super.off(event, fn);
+  }
+
+  waitFor(event, timeoutMs = 30000) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.off(event, handler);
+        reject(new Error(`Timeout waiting for "${event}"`));
+      }, timeoutMs);
+      const handler = (...args) => {
+        clearTimeout(timer);
+        resolve(args);
+      };
+      this.once(event, handler);
+    });
+  }
+}
+
+export const bus = new Bus();

package/src/core/file-tracker.js

@@ -0,0 +1,44 @@
+/**
+ * FileTracker — track file changes during session
+ * Shows summary of what was modified, like Claude Code's change tracking
+ */
+import { COLORS } from './logger.js';
+
+export class FileTracker {
+  constructor() {
+    this.changes = new Map(); // path → { action, count, firstTs, lastTs }
+  }
+
+  track(path, action) {
+    const existing = this.changes.get(path);
+    if (existing) {
+      existing.count++;
+      existing.lastTs = Date.now();
+      existing.action = action; // latest action
+    } else {
+      this.changes.set(path, { action, count: 1, firstTs: Date.now(), lastTs: Date.now() });
+    }
+  }
+
+  getChanges() {
+    return [...this.changes.entries()].map(([path, info]) => ({ path, ...info }));
+  }
+
+  getSummary() {
+    const changes = this.getChanges();
+    if (!changes.length) return 'No file changes this session';
+
+    const created = changes.filter(c => c.action === 'created');
+    const modified = changes.filter(c => c.action === 'modified');
+    const deleted = changes.filter(c => c.action === 'deleted');
+
+    const lines = [`${COLORS.bold}📁 File Changes:${COLORS.reset}`];
+    if (created.length) lines.push(`  ${COLORS.green}✨ Created:${COLORS.reset} ${created.map(c => c.path).join(', ')}`);
+    if (modified.length) lines.push(`  ${COLORS.yellow}📝 Modified:${COLORS.reset} ${modified.map(c => `${c.path} (${c.count}x)`).join(', ')}`);
+    if (deleted.length) lines.push(`  ${COLORS.red}🗑️ Deleted:${COLORS.reset} ${deleted.map(c => c.path).join(', ')}`);
+
+    return lines.join('\n');
+  }
+
+  reset() { this.changes.clear(); }
+}

package/src/core/formatter.js

@@ -0,0 +1,83 @@
+/**
+ * Formatter — rich output formatting for tool results
+ * Like Claude Code's structured output display
+ */
+import { COLORS } from './logger.js';
+
+export function formatToolResult(toolName, action, result) {
+  if (result.isError) return formatError(result.content?.[0]?.text);
+  const data = tryParse(result.content?.[0]?.text);
+  if (!data) return result.content?.[0]?.text || 'OK';
+
+  switch (toolName) {
+    case 'file': return formatFileResult(action, data);
+    case 'git': return formatGitResult(action, data);
+    case 'shell': return formatShellResult(data);
+    case 'search': return formatSearchResult(action, data);
+    case 'project': return formatProjectResult(action, data);
+    case 'process': return formatProcessResult(data);
+    default: return JSON.stringify(data, null, 2);
+  }
+}
+
+function tryParse(text) {
+  try { return JSON.parse(text); } catch { return null; }
+}
+
+function formatError(text) {
+  return `${COLORS.red}❌ ${text}${COLORS.reset}`;
+}
+
+function formatFileResult(action, data) {
+  if (action === 'read') {
+    const lines = data.content?.split('\n').length || 0;
+    return `${COLORS.green}✅${COLORS.reset} ${data.path} (${lines} lines, ${data.totalSize} chars)`;
+  }
+  if (action === 'write') return `${COLORS.green}✅${COLORS.reset} Written: ${data.path} (${data.written} chars)`;
+  if (action === 'edit') return `${COLORS.green}✅${COLORS.reset} Edited: ${data.path} (${data.occurrences} occurrence(s))`;
+  if (action === 'list') {
+    const dirs = data.items?.filter(i => i.type === 'dir').length || 0;
+    const files = data.items?.filter(i => i.type === 'file').length || 0;
+    return `${COLORS.green}✅${COLORS.reset} ${data.path}: ${dirs} dirs, ${files} files`;
+  }
+  if (action === 'exists') return data.exists ? `✅ ${data.type}: ${data.path}` : `❌ Not found: ${data.path}`;
+  if (action === 'delete') return `${COLORS.yellow}🗑️${COLORS.reset} Deleted: ${data.path}`;
+  return `${COLORS.green}✅${COLORS.reset} ${action}: ${JSON.stringify(data)}`;
+}
+
+function formatGitResult(action, data) {
+  if (action === 'status') {
+    const dirty = data.dirty ? `${COLORS.yellow}dirty${COLORS.reset}` : `${COLORS.green}clean${COLORS.reset}`;
+    return `🌿 ${data.branch} (${dirty}) ${data.changes?.length || 0} changes`;
+  }
+  if (action === 'log') return `📜 ${data.commits?.length || 0} commits:\n  ${data.commits?.join('\n  ')}`;
+  if (action === 'commit') return data.committed ? `${COLORS.green}✅${COLORS.reset} Committed: ${data.message}` : `⚠️ ${data.reason}`;
+  if (action === 'branch') return data.branches ? `🌿 Branches:\n  ${data.branches.join('\n  ')}` : `✅ ${data.created || data.deleted}`;
+  return `${COLORS.green}✅${COLORS.reset} git ${action}: ${JSON.stringify(data)}`;
+}
+
+function formatShellResult(data) {
+  const exit = data.exitCode === 0 ? `${COLORS.green}0${COLORS.reset}` : `${COLORS.red}${data.exitCode}${COLORS.reset}`;
+  let out = `Exit: ${exit}`;
+  if (data.stdout) out += `\n${COLORS.dim}${data.stdout.slice(0, 500)}${COLORS.reset}`;
+  if (data.stderr) out += `\n${COLORS.red}${data.stderr.slice(0, 200)}${COLORS.reset}`;
+  return out;
+}
+
+function formatSearchResult(action, data) {
+  if (action === 'grep') return `🔍 ${data.matches} matches for "${data.pattern}":\n  ${(data.results || []).join('\n  ')}`;
+  if (action === 'find') return `🔍 ${data.matches} files matching "${data.pattern}":\n  ${(data.files || []).join('\n  ')}`;
+  if (action === 'web') return `🌐 ${data.url} (${data.status}):\n${data.body?.slice(0, 500)}`;
+  return JSON.stringify(data, null, 2);
+}
+
+function formatProjectResult(action, data) {
+  if (action === 'build') return data.success ? `${COLORS.green}✅ Build OK${COLORS.reset} (${data.type})` : `${COLORS.red}❌ Build failed${COLORS.reset} (exit ${data.exitCode})`;
+  if (action === 'test') return data.passed ? `${COLORS.green}✅ Tests passed${COLORS.reset}` : `${COLORS.red}❌ Tests failed${COLORS.reset} (exit ${data.exitCode})`;
+  if (action === 'info') return `📁 ${data.name || data.type}: ${data.scripts?.join(', ') || 'no scripts'}`;
+  return JSON.stringify(data, null, 2);
+}
+
+function formatProcessResult(data) {
+  return data.processes || data.top || JSON.stringify(data, null, 2);
+}

package/src/core/intent.js

@@ -0,0 +1,81 @@
+/**
+ * Intent — parse natural language commands for direct tool execution
+ * "read index.js" → file read {path: "index.js"}
+ * "run npm test" → shell exec {command: "npm test"}
+ * "git status" → git status
+ */
+const PATTERNS = [
+  // File operations
+  { re: /^(read|cat|show|open)\s+(.+)/i, tool: 'file', action: 'read', extract: (m) => ({ path: m[2] }) },
+  { re: /^(write|create|make)\s+(?:file\s+)?(.+)/i, tool: 'file', action: 'write', extract: (m) => ({ path: m[2] }) },
+  { re: /^(edit|change|replace)\s+(.+)/i, tool: 'file', action: 'edit', extract: (m) => ({ path: m[2] }) },
+  { re: /^(delete|remove|rm)\s+(.+)/i, tool: 'file', action: 'delete', extract: (m) => ({ path: m[2] }) },
+  { re: /^(list|ls|dir)\s*(.*)/i, tool: 'file', action: 'list', extract: (m) => ({ path: m[2] || '.' }) },
+  { re: /^(mkdir)\s+(.+)/i, tool: 'file', action: 'mkdir', extract: (m) => ({ path: m[2] }) },
+  { re: /^(exists|exist|check)\s+(.+)/i, tool: 'file', action: 'exists', extract: (m) => ({ path: m[2] }) },
+  { re: /^(copy|cp)\s+(\S+)\s+(\S+)/i, tool: 'file', action: 'copy', extract: (m) => ({ from: m[2], to: m[3] }) },
+  { re: /^(move|mv)\s+(\S+)\s+(\S+)/i, tool: 'file', action: 'move', extract: (m) => ({ from: m[2], to: m[3] }) },
+  // Shell
+  { re: /^(run|exec|execute)\s+(.+)/i, tool: 'shell', action: 'exec', extract: (m) => ({ command: m[2] }) },
+  { re: /^\.\/(.+)/i, tool: 'shell', action: 'exec', extract: (m) => ({ command: `./${m[1]}` }) },
+  // Git
+  { re: /^(git)\s+(.+)/i, tool: 'git', action: null, extract: (m) => {
+    const parts = m[2].split(' ');
+    return { action: parts[0], message: parts.slice(1).join(' ') || undefined };
+  }},
+  { re: /^(commit)\s+(.+)/i, tool: 'git', action: 'commit', extract: (m) => ({ message: m[2] }) },
+  { re: /^(push|pull|clone|status|diff|log)\s*(.*)/i, tool: 'git', action: (m) => m[1].toLowerCase(), extract: (m) => ({}) },
+  // Search
+  { re: /^(search|grep|find)\s+(.+)/i, tool: 'search', action: 'grep', extract: (m) => ({ pattern: m[2] }) },
+  { re: /^(where|locate)\s+(.+)/i, tool: 'search', action: 'find', extract: (m) => ({ name: m[2] }) },
+  // Project
+  { re: /^(build|compile)\s*(.*)/i, tool: 'project', action: 'build', extract: () => ({}) },
+  { re: /^(test|check)\s*(.*)/i, tool: 'project', action: 'test', extract: () => ({}) },
+  { re: /^(lint|format|fmt)\s*(.*)/i, tool: 'project', action: 'lint', extract: () => ({}) },
+  { re: /^(install|deps)\s*(.*)/i, tool: 'project', action: 'deps', extract: () => ({ install: true }) },
+  // Process
+  { re: /^(kill)\s+(\d+)/i, tool: 'process', action: 'kill', extract: (m) => ({ pid: parseInt(m[2]) }) },
+  { re: /^(ps|processes|top)\s*(.*)/i, tool: 'process', action: 'list', extract: (m) => ({ filter: m[2] || undefined }) },
+  // Network
+  { re: /^(fetch|curl|http)\s+(.+)/i, tool: 'network', action: 'fetch', extract: (m) => ({ url: m[2] }) },
+  { re: /^(ping)\s+(.+)/i, tool: 'network', action: 'ping', extract: (m) => ({ host: m[2] }) },
+  { re: /^(download)\s+(.+)/i, tool: 'network', action: 'download', extract: (m) => ({ url: m[2] }) },
+  // AI
+  { re: /^(analyze|inspect)\s+(.+)/i, tool: 'ai', action: 'analyze', extract: (m) => ({ path: m[2] }) },
+  { re: /^(summarize|summary)\s+(.+)/i, tool: 'ai', action: 'summarize', extract: (m) => ({ path: m[2] }) },
+  { re: /^(diff)\s+(\S+)\s+(\S+)/i, tool: 'ai', action: 'diff', extract: (m) => ({ file1: m[2], file2: m[3] }) },
+  // Snippet
+  { re: /^(snippet|snip)\s+save\s+(\S+)\s+(.+)/i, tool: 'snippet', action: 'save', extract: (m) => ({ name: m[2], code: m[3] }) },
+  { re: /^(snippet|snip)\s+load\s+(\S+)/i, tool: 'snippet', action: 'load', extract: (m) => ({ name: m[2] }) },
+  { re: /^(snippet|snip)\s+list/i, tool: 'snippet', action: 'list', extract: () => ({}) },
+  // Env
+  { re: /^(env|envvar)\s+(\S+)/i, tool: 'env', action: 'get', extract: (m) => ({ name: m[2] }) },
+  // Template
+  { re: /^(scaffold|scaffold|new project|create project)\s+(\S+)\s+(\S+)/i, tool: 'template', action: 'create', extract: (m) => ({ template: m[2], name: m[3] }) },
+  { re: /^(templates|scaffolds)/i, tool: 'template', action: 'list', extract: () => ({}) },
+  // History
+  { re: /^(history|log|calls)\s*(.*)/i, tool: 'history', action: 'list', extract: (m) => ({ limit: parseInt(m[2]) || 20 }) },
+  // Config
+  { re: /^(config|conf|setting)\s+(get|set|list|reset)\s*(.*)/i, tool: 'config', action: null, extract: (m) => ({ action: m[2], key: m[3] || undefined }) },
+  // Diff
+  { re: /^(diff|compare)\s+(\S+)\s+(\S+)/i, tool: 'diff', action: 'compare', extract: (m) => ({ file1: m[2], file2: m[3] }) },
+  // Watch
+  { re: /^(watch|monitor)\s+(.+)/i, tool: 'watch', action: 'start', extract: (m) => ({ path: m[2] }) },
+  { re: /^(unwatch|stop watching)\s+(.+)/i, tool: 'watch', action: 'stop', extract: (m) => ({ path: m[2] }) },
+];
+
+export function parseIntent(input) {
+  for (const { re, tool, action, extract } of PATTERNS) {
+    const match = input.match(re);
+    if (match) {
+      const params = extract(match);
+      return {
+        matched: true,
+        tool,
+        action: action || params.action,
+        params: { ...params, action: action || params.action },
+      };
+    }
+  }
+  return { matched: false };
+}

package/src/core/keybindings.js

@@ -0,0 +1,29 @@
+/**
+ * Keybindings — keyboard shortcuts for the REPL
+ * Inspired by Claude Code's keyboard shortcuts
+ */
+export const KEYBINDINGS = {
+  'Ctrl+C': 'Cancel current input / Exit',
+  'Ctrl+D': 'Exit (EOF)',
+  'Ctrl+L': 'Clear screen',
+  'Ctrl+U': 'Clear line',
+  'Ctrl+K': 'Delete to end of line',
+  'Ctrl+A': 'Move to start of line',
+  'Ctrl+E': 'Move to end of line',
+  'Up/Down': 'Navigate history',
+  'Tab': 'Auto-complete (planned)',
+};
+
+export function setupKeybindings(rl) {
+  // readline handles most of these automatically
+  // Custom bindings can be added here
+  return rl;
+}
+
+export function formatKeybindings() {
+  const lines = ['⌨️ Keyboard Shortcuts:'];
+  for (const [key, desc] of Object.entries(KEYBINDINGS)) {
+    lines.push(`  ${key.padEnd(15)} ${desc}`);
+  }
+  return lines.join('\n');
+}

package/src/core/logger.js

@@ -0,0 +1,67 @@
+/**
+ * Logger — colored terminal output with levels
+ */
+let _debug = false;
+
+export const COLORS = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+};
+
+const ICONS = {
+  ok: '✅', err: '❌', warn: '⚠️', info: 'ℹ️',
+  tool: '🔧', mcp: '🔗', plugin: '🧩', system: '⚙️',
+  user: '👤', ai: '🤖', debug: '🔍', file: '📁',
+};
+
+export function setDebug(enabled) { _debug = enabled; }
+export function isDebug() { return _debug; }
+export function debug(msg, data) { log('debug', msg, data); }
+
+export function log(level, msg, data) {
+  if (level === 'debug' && !_debug) return;
+  const icon = ICONS[level] || '';
+  const color = {
+    ok: COLORS.green, err: COLORS.red, warn: COLORS.yellow,
+    info: COLORS.blue, tool: COLORS.cyan, mcp: COLORS.magenta,
+    debug: COLORS.gray, user: COLORS.bold, ai: COLORS.green,
+  }[level] || '';
+
+  const prefix = `${color}${icon} ${COLORS.reset}`;
+  console.log(`${prefix}${msg}`);
+  if (data && _debug) console.log(`${COLORS.gray}${JSON.stringify(data, null, 2)}${COLORS.reset}`);
+}
+
+export function table(rows) {
+  if (!rows.length) return;
+  const keys = Object.keys(rows[0]);
+  const widths = keys.map(k => Math.max(k.length, ...rows.map(r => String(r[k] ?? '').length)));
+  const sep = widths.map(w => '─'.repeat(w + 2)).join('┼');
+  console.log(keys.map((k, i) => k.padEnd(widths[i])).join(' │ '));
+  console.log(sep);
+  for (const row of rows) {
+    console.log(keys.map((k, i) => String(row[k] ?? '').padEnd(widths[i])).join(' │ '));
+  }
+}
+
+export function banner(title, lines = []) {
+  const width = Math.max(title.length + 4, ...lines.map(l => l.length + 4), 40);
+  const pad = (s) => `  ${s}${' '.repeat(width - s.length - 2)}  `;
+  console.log('');
+  console.log(`${COLORS.cyan}╔${'═'.repeat(width)}╗`);
+  console.log(`║${COLORS.bold}${pad(title)}${COLORS.cyan}║`);
+  if (lines.length) {
+    console.log(`╠${'═'.repeat(width)}╣`);
+    for (const line of lines) console.log(`║${COLORS.reset}${pad(line)}${COLORS.cyan}║`);
+  }
+  console.log(`╚${'═'.repeat(width)}╝${COLORS.reset}`);
+  console.log('');
+}

package/src/core/model-info.js

@@ -0,0 +1,26 @@
+/**
+ * ModelInfo — display and manage AI model information
+ */
+import { COLORS } from './logger.js';
+
+export function getModelInfo() {
+  return {
+    name: 'XiaoZhi',
+    provider: 'Tenclass',
+    protocol: 'MQTT + MCP',
+    features: ['text', 'voice', 'tool_use', 'mcp'],
+    maxTools: 32,
+  };
+}
+
+export function formatModelInfo() {
+  const info = getModelInfo();
+  return [
+    `${COLORS.bold}🧠 Model:${COLORS.reset}`,
+    `  Name:     ${info.name}`,
+    `  Provider: ${info.provider}`,
+    `  Protocol: ${info.protocol}`,
+    `  Features: ${info.features.join(', ')}`,
+    `  Max Tools: ${info.maxTools}`,
+  ].join('\n');
+}

package/src/core/retry.js

@@ -0,0 +1,26 @@
+/**
+ * Retry — retry logic for transient failures
+ */
+import { debug } from './logger.js';
+
+export async function withRetry(fn, { maxRetries = 2, delay = 1000, backoff = 2 } = {}) {
+  let lastError;
+  for (let i = 0; i <= maxRetries; i++) {
+    try {
+      return await fn();
+    } catch (e) {
+      lastError = e;
+      if (i < maxRetries) {
+        const wait = delay * Math.pow(backoff, i);
+        debug(`Retry ${i + 1}/${maxRetries} after ${wait}ms: ${e.message}`);
+        await new Promise(r => setTimeout(r, wait));
+      }
+    }
+  }
+  throw lastError;
+}
+
+export function isRetryable(error) {
+  const retryable = ['ETIMEDOUT', 'ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'EAI_AGAIN'];
+  return retryable.includes(error.code) || error.message?.includes('timeout');
+}

package/src/core/sandbox.js

@@ -0,0 +1,54 @@
+/**
+ * Sandbox — safety layer for tool execution
+ * Validates inputs, blocks dangerous operations, rate limits
+ */
+import { resolve } from 'path';
+import { homedir } from 'os';
+
+const HOME = homedir();
+const DANGEROUS_PATTERNS = [
+  /rm\s+-rf\s+\/$/i, /rm\s+-rf\s+\/[^a-z]/i, /rm\s+-rf\s+\/\s/i,
+  /mkfs/i, /dd\s+if=.*of=\/dev/i,
+  />\s*\/dev\/sd/i, /chmod\s+000/i, /shutdown/i, /reboot/i,
+];
+const RATE_LIMIT_WINDOW = 1000; // 1 second
+const MAX_CALLS_PER_WINDOW = 10;
+
+export class Sandbox {
+  #callTimes = [];
+
+  validate(toolName, args) {
+    // Rate limiting
+    const now = Date.now();
+    this.#callTimes = this.#callTimes.filter(t => now - t < RATE_LIMIT_WINDOW);
+    if (this.#callTimes.length >= MAX_CALLS_PER_WINDOW) {
+      throw new Error('Rate limit exceeded. Slow down.');
+    }
+    this.#callTimes.push(now);
+
+    // Validate shell commands
+    if (toolName === 'shell' && args.command) {
+      for (const pattern of DANGEROUS_PATTERNS) {
+        if (pattern.test(args.command)) {
+          throw new Error(`Blocked dangerous command: ${args.command}`);
+        }
+      }
+    }
+
+    // Validate file paths
+    if (args.path) {
+      const abs = resolve(args.path.replace(/^~(?=$|[/\\])/g, HOME));
+      const blocked = ['/etc/shadow', '/etc/passwd', '/etc/sudoers', '/proc', '/sys'];
+      if (blocked.some(p => abs.startsWith(p))) {
+        throw new Error(`Access denied: ${abs}`);
+      }
+    }
+
+    // Validate git commit messages
+    if (toolName === 'git' && args.action === 'commit' && !args.message) {
+      throw new Error('Commit message required');
+    }
+
+    return true;
+  }
+}