pelulu-cli 1.0.0 → 1.0.1

package/src/core/formatter.js

@@ -25,35 +25,35 @@ function tryParse(text) {
 }
 
 function formatError(text) {
-  return `${COLORS.red}❌ ${text}${COLORS.reset}`;
+  return `${COLORS.red}[ERR] ${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)`;
+    return `${COLORS.green}[OK]${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 === 'write') return `${COLORS.green}[OK]${COLORS.reset} Written: ${data.path} (${data.written} chars)`;
+  if (action === 'edit') return `${COLORS.green}[OK]${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`;
+    return `${COLORS.green}[OK]${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)}`;
+  if (action === 'exists') return data.exists ? `[OK] ${data.type}: ${data.path}` : `[ERR] Not found: ${data.path}`;
+  if (action === 'delete') return `${COLORS.yellow}[DEL]${COLORS.reset} Deleted: ${data.path}`;
+  return `${COLORS.green}[OK]${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`;
+    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)}`;
+  if (action === 'log') return `${data.commits?.length || 0} commits:\n  ${data.commits?.join('\n  ')}`;
+  if (action === 'commit') return data.committed ? `${COLORS.green}[OK]${COLORS.reset} Committed: ${data.message}` : `[WARN] ${data.reason}`;
+  if (action === 'branch') return data.branches ? `Branches:\n  ${data.branches.join('\n  ')}` : `[OK] ${data.created || data.deleted}`;
+  return `${COLORS.green}[OK]${COLORS.reset} git ${action}: ${JSON.stringify(data)}`;
 }
 
 function formatShellResult(data) {
@@ -65,16 +65,16 @@ function formatShellResult(data) {
 }
 
 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)}`;
+  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'}`;
+  if (action === 'build') return data.success ? `${COLORS.green}[OK] Build OK${COLORS.reset} (${data.type})` : `${COLORS.red}[ERR] Build failed${COLORS.reset} (exit ${data.exitCode})`;
+  if (action === 'test') return data.passed ? `${COLORS.green}[OK] Tests passed${COLORS.reset}` : `${COLORS.red}[ERR] 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);
 }
 

package/src/core/logger.js

@@ -1,7 +1,10 @@
 /**
  * Logger — colored terminal output with levels
+ * Supports Ink mode: when active, logs go through bus instead of console
  */
 let _debug = false;
+let _inkMode = false;
+let _bus = null;
 
 export const COLORS = {
   reset: '\x1b[0m',
@@ -16,10 +19,16 @@ export const COLORS = {
   gray: '\x1b[90m',
 };
 
+export function setInkMode(enabled, bus) {
+  _inkMode = enabled;
+  _bus = bus;
+}
+export function isInkMode() { return _inkMode; }
+
 const ICONS = {
-  ok: '✅', err: '❌', warn: '⚠️', info: 'ℹ️',
-  tool: '🔧', mcp: '🔗', plugin: '🧩', system: '⚙️',
-  user: '👤', ai: '🤖', debug: '🔍', file: '📁',
+  ok: '[OK]', err: '[ERR]', warn: '[WARN]', info: '[i]',
+  tool: '[TOOL]', mcp: '[MCP]', plugin: '[PLUG]', system: '[SYS]',
+  user: '[USER]', ai: '[AI]', debug: '[DBG]', file: '[FILE]',
 };
 
 export function setDebug(enabled) { _debug = enabled; }
@@ -28,6 +37,13 @@ export function debug(msg, data) { log('debug', msg, data); }
 
 export function log(level, msg, data) {
   if (level === 'debug' && !_debug) return;
+
+  // In Ink mode, route logs through bus so they render inside the TUI
+  if (_inkMode && _bus) {
+    _bus.emit('log:message', { level, msg, data });
+    return;
+  }
+
   const icon = ICONS[level] || '';
   const color = {
     ok: COLORS.green, err: COLORS.red, warn: COLORS.yellow,

package/src/core/spinner.js

@@ -39,11 +39,11 @@ export class Spinner {
   }
 
   success(text) {
-    this.stop(`${COLORS.green}✅ ${text}${COLORS.reset}`);
+    this.stop(`${COLORS.green}[OK] ${text}${COLORS.reset}`);
   }
 
   fail(text) {
-    this.stop(`${COLORS.red}❌ ${text}${COLORS.reset}`);
+    this.stop(`${COLORS.red}[ERR] ${text}${COLORS.reset}`);
   }
 }
 

package/src/core/stats.js

@@ -41,9 +41,9 @@ export class Stats {
   formatReport() {
     const s = this.getSummary();
     const lines = [
-      `📊 Session Stats`,
+      `[STATS] Session Stats`,
       `   Uptime: ${s.uptime}s`,
-      `   Tool calls: ${s.total} (${s.success} ✅ / ${s.failed} ❌)`,
+      `   Tool calls: ${s.total} (${s.success} [OK] / ${s.failed} [ERR])`,
       `   Avg duration: ${s.avgDuration}ms`,
     ];
     if (s.topTools.length) {

package/src/core/thinking.js

@@ -6,14 +6,14 @@ import { COLORS } from './logger.js';
 import { bus } from './event-bus.js';
 
 const THINK_STATES = {
-  idle: { icon: '💤', text: 'Idle' },
-  thinking: { icon: '🤔', text: 'Thinking...' },
-  tool_call: { icon: '🔧', text: 'Using tool...' },
-  reading: { icon: '📖', text: 'Reading file...' },
-  writing: { icon: '✏️', text: 'Writing...' },
-  searching: { icon: '🔍', text: 'Searching...' },
-  building: { icon: '🔨', text: 'Building...' },
-  testing: { icon: '🧪', text: 'Testing...' },
+  idle: { icon: '-', text: 'Idle' },
+  thinking: { icon: '..', text: 'Thinking...' },
+  tool_call: { icon: '>>', text: 'Using tool...' },
+  reading: { icon: '..', text: 'Reading file...' },
+  writing: { icon: '..', text: 'Writing...' },
+  searching: { icon: '..', text: 'Searching...' },
+  building: { icon: '..', text: 'Building...' },
+  testing: { icon: '..', text: 'Testing...' },
 };
 
 export class Thinking {

package/src/core/tool-help.js

@@ -99,7 +99,7 @@ export function showToolHelp(toolName) {
     return;
   }
 
-  console.log(`\n${COLORS.bold}📖 ${toolName} — Examples:${COLORS.reset}\n`);
+  console.log(`\n${COLORS.bold}[DOC] ${toolName} — Examples:${COLORS.reset}\n`);
   for (const ex of examples) {
     console.log(`  ${COLORS.cyan}${ex}${COLORS.reset}`);
   }
@@ -108,7 +108,7 @@ export function showToolHelp(toolName) {
 
 export function showAllToolHelp() {
   for (const [tool, examples] of Object.entries(TOOL_EXAMPLES)) {
-    console.log(`\n${COLORS.bold}📖 ${tool}:${COLORS.reset}`);
+    console.log(`\n${COLORS.bold}[DOC] ${tool}:${COLORS.reset}`);
     for (const ex of examples.slice(0, 2)) {
       console.log(`  ${COLORS.cyan}${ex}${COLORS.reset}`);
     }

package/src/core/tool-registry.js

@@ -18,23 +18,19 @@ export class ToolRegistry {
   #tools = new Map();
 
   async loadBuiltins() {
+    const failed = [];
     try {
       const files = await readdir(TOOLS_DIR);
       for (const file of files.filter(f => f.endsWith('.js'))) {
         try {
           const mod = await import(join(TOOLS_DIR, file));
           const tool = mod.default || mod;
-          if (tool?.name && tool?.handler) {
-            this.register(tool);
-            log('tool', `  ${tool.name} — ${tool.description || ''} (${tool.actions?.length || 0} actions)`);
-          }
-        } catch (e) {
-          log('warn', `Tool "${file}" failed: ${e.message}`);
-        }
+          if (tool?.name && tool?.handler) this.register(tool);
+        } catch (e) { failed.push(file); }
       }
-    } catch (e) {
-      log('warn', `Tools dir not found: ${e.message}`);
-    }
+    } catch (e) { /* silent */ }
+    if (failed.length) log('warn', `Failed tools: ${failed.join(', ')}`);
+    return { loaded: this.#tools.size, failed: failed.length };
   }
 
   register(tool) {

package/src/core/update-checker.js

@@ -0,0 +1,125 @@
+/**
+ * Update Checker — compare local version with GitHub releases
+ * Uses: https://api.github.com/repos/venenapro/Pelulu-CLI/releases
+ */
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+
+const GITHUB_RELEASES_URL = 'https://api.github.com/repos/venenapro/Pelulu-CLI/releases';
+const TIMEOUT_MS = 8000;
+
+/**
+ * Parse semver string "1.2.3" → { major, minor, patch }
+ */
+function parseSemver(version) {
+  const clean = version.replace(/^v/i, '');
+  const match = clean.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return { major: +match[1], minor: +match[2], patch: +match[3] };
+}
+
+/**
+ * Compare two semver objects.
+ * Returns: 1 if a > b, -1 if a < b, 0 if equal
+ */
+function compareSemver(a, b) {
+  if (a.major !== b.major) return a.major > b.major ? 1 : -1;
+  if (a.minor !== b.minor) return a.minor > b.minor ? 1 : -1;
+  if (a.patch !== b.patch) return a.patch > b.patch ? 1 : -1;
+  return 0;
+}
+
+/**
+ * Read local version from package.json
+ */
+async function getLocalVersion(root) {
+  try {
+    const raw = await readFile(join(root, 'package.json'), 'utf-8');
+    const pkg = JSON.parse(raw);
+    return pkg.version || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Fetch latest release from GitHub API.
+ * Returns { tag, name, body, url, publishedAt } or null on failure.
+ */
+async function fetchLatestRelease() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+
+  try {
+    const res = await fetch(GITHUB_RELEASES_URL, {
+      signal: controller.signal,
+      headers: {
+        'Accept': 'application/vnd.github+json',
+        'User-Agent': 'Pelulu-CLI',
+      },
+    });
+
+    if (!res.ok) return null;
+
+    const releases = await res.json();
+    if (!Array.isArray(releases) || releases.length === 0) return null;
+
+    // Filter out prerelease/draft, pick latest stable
+    const stable = releases.find(r => !r.prerelease && !r.draft) || releases[0];
+
+    return {
+      tag: stable.tag_name || '',
+      name: stable.name || stable.tag_name || '',
+      body: stable.body || '',
+      url: stable.html_url || '',
+      publishedAt: stable.published_at || '',
+    };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Check for updates.
+ * Returns:
+ *   { available: true, local, remote, release }  — update available
+ *   { available: false, local, remote }           — up to date
+ *   { available: false, error: true, message }    — check failed
+ */
+export async function checkForUpdates(root) {
+  const localVersion = await getLocalVersion(root);
+  if (!localVersion) {
+    return { available: false, error: true, message: 'Could not read local version from package.json' };
+  }
+
+  const release = await fetchLatestRelease();
+  if (!release) {
+    return { available: false, error: true, local: localVersion, message: 'Could not fetch GitHub releases' };
+  }
+
+  const localParsed = parseSemver(localVersion);
+  const remoteParsed = parseSemver(release.tag);
+
+  if (!localParsed || !remoteParsed) {
+    return { available: false, error: true, local: localVersion, remote: release.tag, message: 'Invalid version format' };
+  }
+
+  const cmp = compareSemver(remoteParsed, localParsed);
+
+  if (cmp > 0) {
+    return {
+      available: true,
+      local: localVersion,
+      remote: release.tag.replace(/^v/i, ''),
+      release,
+    };
+  }
+
+  return {
+    available: false,
+    local: localVersion,
+    remote: release.tag.replace(/^v/i, ''),
+  };
+}

package/src/core/wizard.js

@@ -12,7 +12,7 @@ export async function runWizard(root) {
   if (config._wizard_done) return config;
 
   console.log(`\n${COLORS.cyan}╔══════════════════════════════════════╗`);
-  console.log(`║        🐾 Pelulu CLI Setup           ║`);
+  console.log(`║          Pelulu CLI Setup             ║`);
   console.log(`╚══════════════════════════════════════╝${COLORS.reset}\n`);
 
   if (!process.stdin.isTTY) {
@@ -31,23 +31,23 @@ export async function runWizard(root) {
 
   try {
     // Workspace
-    const workspace = await ask('📁 Workspace path?', config.agent?.workspace || '~/coding-agent');
+    const workspace = await ask('[DIR] Workspace path?', config.agent?.workspace || '~/coding-agent');
     config.agent = { ...config.agent, workspace };
 
     // MCP endpoint (optional)
     console.log(`\n${COLORS.dim}MCP Endpoint (optional, for official XiaoZhi MCP):${COLORS.reset}`);
     console.log(`${COLORS.dim}Get from: xiaozhi.me → Configure → Extensions → MCP Endpoint${COLORS.reset}`);
-    const mcpUrl = await ask('🔗 MCP Endpoint URL?', '');
+    const mcpUrl = await ask('[MCP] MCP Endpoint URL?', '');
     if (mcpUrl) config.mcp = { ...config.mcp, endpoint_url: mcpUrl };
 
     // Shell timeout
-    const timeout = await ask('⏱️ Shell timeout (ms)?', String(config.tools?.shell_timeout || 30000));
+    const timeout = await ask('Shell timeout (ms)?', String(config.tools?.shell_timeout || 30000));
     config.tools = { ...config.tools, shell_timeout: parseInt(timeout) || 30000 };
 
     config._wizard_done = true;
     await saveConfig(root, config);
 
-    console.log(`\n${COLORS.green}✅ Configuration saved!${COLORS.reset}\n`);
+    console.log(`\n${COLORS.green}[OK] Configuration saved!${COLORS.reset}\n`);
     return config;
   } finally {
     rl.close();

package/src/core/workspace.js

@@ -82,15 +82,15 @@ export async function detectWorkspace(dir) {
 
 export function formatWorkspace(info) {
   const lines = [
-    `📁 ${info.name} (${info.type})`,
+    `[DIR] ${info.name} (${info.type})`,
     `   Language: ${info.language}`,
     `   Path: ${info.path}`,
   ];
   if (info.version) lines.push(`   Version: ${info.version}`);
   if (info.scripts?.length) lines.push(`   Scripts: ${info.scripts.join(', ')}`);
   if (info.dirs?.length) lines.push(`   Dirs: ${info.dirs.join(', ')}`);
-  if (info.hasGit) lines.push('   Git: ✅');
-  if (info.hasDocker) lines.push('   Docker: ✅');
-  if (info.hasCI) lines.push('   CI: ✅');
+  if (info.hasGit) lines.push('   Git: [OK]');
+  if (info.hasDocker) lines.push('   Docker: [OK]');
+  if (info.hasCI) lines.push('   CI: [OK]');
   return lines.join('\n');
 }

package/src/index.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 /**
- * XiaoZhi Coding Agent — CLI Entry Point
- * Usage: cd my-project && xcode
+ * Pelulu CLI — Entry Point
+ * Ink-based TUI with React components
  */
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
+import chalk from 'chalk';
 import { loadConfig, saveConfig } from './core/config.js';
 import { log, setDebug } from './core/logger.js';
 import { bus } from './core/event-bus.js';
@@ -16,44 +17,70 @@ import { buildSystemPrompt } from './core/system-prompt.js';
 import { buildContext } from './core/context.js';
 import { isDestructive, askConfirmation } from './core/confirm.js';
 import { runWizard } from './core/wizard.js';
+import { handleError } from './core/error-handler.js';
+import { withRetry } from './core/retry.js';
+import { withSpinner } from './core/spinner.js';
+import { Thinking } from './core/thinking.js';
+import { autoFormat } from './core/auto-format.js';
+import { FileTracker } from './core/file-tracker.js';
 import { MqttClient } from './mcp/mqtt-client.js';
+import { MessageSender } from './mcp/message-sender.js';
 import { WssEndpoint } from './mcp/wss-endpoint.js';
 import { PluginManager } from './plugins/manager.js';
-import { REPL } from './repl.js';
+import { checkForUpdates } from './core/update-checker.js';
+import { renderUpdateNotification, renderAsciiBanner } from './tui/renderer.js';
+import { startInkTUI } from './tui/ink-entry.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = join(__dirname, '..');
 
 const args = process.argv.slice(2);
 if (args.includes('--debug')) setDebug(true);
-if (args.includes('--wizard')) { /* force wizard */ }
 const LIST_TOOLS = args.includes('--list-tools');
 
 async function main() {
-  // 1. Load config + wizard
+  // Buffer ALL startup logs for Ink to display inside TUI
+  const startupLogs = [];
+  const origLog = console.log;
+  const bufferLog = (...args) => startupLogs.push(args.join(' '));
+
+  // 1. Load config
   const config = await loadConfig(ROOT);
 
-  // 2. Auto-detect CWD as workspace (like Claude Code, Gemini CLI, etc.)
+  // 2. Check for updates — block if outdated
+  const update = await checkForUpdates(ROOT);
+  if (update.available) {
+    renderUpdateNotification(update);
+    process.exit(1);
+  }
+
+  // 3. Workspace & wizard
   const cwd = process.cwd();
   config.agent = { ...config.agent, workspace: cwd };
-  log('info', `Workspace: ${cwd}`);
-
   if (!config._wizard_done || args.includes('--wizard')) {
     await runWizard(ROOT);
   }
 
-  // 3. Load tools
+  // Show ASCII banner before Ink takes over
+  renderAsciiBanner(config.agent?.version);
+
+  // Redirect console.log to buffer — everything after this goes into Ink
+  console.log = bufferLog;
+
+  // 4. Load tools
   const registry = new ToolRegistry();
-  log('info', 'Loading tools...');
-  await registry.loadBuiltins();
+  const pluginMgr = new PluginManager(registry);
 
-  // 4. Load plugins
-  const plugins = new PluginManager(registry);
-  await plugins.load();
+  const { loaded } = await withSpinner('Loading tools...', async () => {
+    return await registry.loadBuiltins();
+  });
+  await pluginMgr.load();
+  const actions = registry.all().reduce((s, t) => s + (t.actions?.length || 0), 0);
 
   if (LIST_TOOLS) {
+    console.log = origLog;
     const tools = registry.list();
-    console.log('\n🔧 Tools:\n');
+    console.log('\nTools:\n');
     for (const t of tools) console.log(`  ${t.name} — ${t.description} (${t.actions.join(', ')})`);
     console.log(`\n  ${tools.length} tools, ${tools.reduce((s, t) => s + t.actions.length, 0)} actions\n`);
     process.exit(0);
@@ -63,33 +90,35 @@ async function main() {
   const sandbox = new Sandbox();
   const session = new SessionState();
   const stats = new Stats();
+  const thinking = new Thinking();
+  const fileTracker = new FileTracker();
 
   // 6. Build context & system prompt
   const context = await buildContext();
   const systemPrompt = buildSystemPrompt(registry, config);
-  log('info', `Context: ${context.split('\n').length} lines`);
 
   // 7. Connect to XiaoZhi
   const mqtt = new MqttClient(config);
 
   bus.on('activation:required', ({ code }) => {
-    console.log('');
-    console.log(`  ╔═════════════════════════════════════════════╗`);
-    console.log(`  ║  🔐 Kode Aktivasi: ${String(code).padEnd(25)}║`);
-    console.log(`  ║  🌐 https://xiaozhi.me                     ║`);
-    console.log(`  ╚═════════════════════════════════════════════╝`);
-    console.log('');
+    startupLogs.push('');
+    startupLogs.push(`  Kode Aktivasi: ${code}`);
+    startupLogs.push(`  https://xiaozhi.me`);
+    startupLogs.push('');
   });
 
   try {
-    log('info', 'Connecting to XiaoZhi...');
-    await mqtt.connect();
+    await withRetry(() => mqtt.connect(), { maxRetries: 2, delay: 2000 });
   } catch (e) {
-    log('err', `Connection failed: ${e.message}`);
+    console.log = origLog;
+    console.error(chalk.red(`\n  Connection failed: ${e.message}\n`));
     process.exit(1);
   }
 
-  // 8. Register MCP tool handler
+  // 8. Message sender
+  const sender = new MessageSender(mqtt);
+
+  // 9. Register MCP tool handler
   mqtt.registerToolHandler(
     async (name, args) => {
       const destructive = isDestructive(name, args);
@@ -98,24 +127,31 @@ async function main() {
         if (!ok) return { isError: true, content: [{ type: 'text', text: 'Cancelled by user' }] };
       }
       sandbox.validate(name, args);
+
+      thinking.set('tool_call');
       const start = Date.now();
-      log('tool', `🔧 ${name} → ${args.action || '-'}`);
       try {
         const result = await registry.call(name, args);
         stats.record(name, args.action, !result.isError, Date.now() - start);
         session.addToolCall(name, args, result);
-        log('tool', result.isError ? `❌ ${result.content?.[0]?.text}` : `✅ OK`);
+
+        if (name === 'file' && (args.action === 'write' || args.action === 'edit') && args.path) {
+          autoFormat(args.path).catch(() => {});
+        }
+
+        thinking.set('idle');
         bus.emit('tool:called', { name, result, args });
         return result;
       } catch (e) {
         stats.record(name, args.action, false, Date.now() - start, e.message);
-        throw e;
+        thinking.set('idle');
+        throw new Error(handleError(e));
       }
     },
     () => registry.toMcpTools()
   );
 
-  // 9. Optional WSS endpoint
+  // 10. Optional WSS endpoint
   let wss = null;
   if (config.mcp?.endpoint_url) {
     wss = new WssEndpoint(config.mcp.endpoint_url, () => registry.toMcpTools(), async (name, args) => {
@@ -125,19 +161,22 @@ async function main() {
     wss.start();
   }
 
-  // 10. Track conversation
+  // 11. Track conversation
   bus.on('user:text', (text) => session.addUserMessage(text));
   bus.on('llm:text', (text) => session.addAiMessage(text));
 
-  // 11. Save config & start REPL
+  // 12. Save config
   await saveConfig(ROOT, config);
-  const repl = new REPL(registry, mqtt, stats, session);
-  repl.start();
+
+  // 13. Start Ink TUI
+  const { unmount, waitUntilExit } = startInkTUI({
+    registry, mqtt, stats, session, bus, config,
+    extras: { fileTracker, thinking, sender, autoFormat, startupLogs },
+  });
 
   // Graceful shutdown
   const shutdown = async () => {
-    log('info', 'Shutting down...');
-    console.log(stats.formatReport());
+    unmount();
     if (wss) wss.stop();
     await registry.shutdown();
     mqtt.disconnect();
@@ -145,6 +184,12 @@ async function main() {
   };
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
+
+  await waitUntilExit();
+  await shutdown();
 }
 
-main().catch(e => { log('err', `Fatal: ${e.message}`); process.exit(1); });
+main().catch(e => {
+  console.error(chalk.red(`\n  Fatal: ${handleError(e)}\n`));
+  process.exit(1);
+});

package/src/mcp/activation.js

@@ -35,7 +35,7 @@ export async function handleActivation(data, otaUrl, deviceId, clientId) {
 
   log('warn', `🔐 Activation required`);
   log('info', `📋 Code: ${a.code}`);
-  log('info', `🌐 https://xiaozhi.me`);
+  log('info', `[WEB] https://xiaozhi.me`);
   bus.emit('activation:required', { code: a.code });
 
   const timeout = a.timeout_ms || 120000;
@@ -43,10 +43,10 @@ export async function handleActivation(data, otaUrl, deviceId, clientId) {
 
   while (Date.now() - start < timeout) {
     await new Promise(r => setTimeout(r, 5000));
-    log('info', '⏳ Checking activation...');
+    log('info', '[...] Checking activation...');
     const poll = await fetchOtaConfig(otaUrl, deviceId, clientId);
     if (!poll.activation?.code && poll.mqtt) {
-      log('ok', '✅ Activated!');
+      log('ok', '[OK] Activated!');
       return poll.mqtt;
     }
   }

package/src/mcp/message-sender.js

@@ -70,7 +70,7 @@ export class MessageSender {
   async _waitForReady() {
     if (this.mqtt.mcp.toolsReceived) return;
 
-    log('info', '⏳ Waiting for MCP handshake...');
+    log('info', '[...] Waiting for MCP handshake...');
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => reject(new Error('MCP handshake timeout')), 30000);
       const check = setInterval(() => {