pelulu-cli 1.0.0 → 1.0.3

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,42 @@ 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('');
+    // Display DIRECTLY to console (not buffered) — user must see this!
+    origLog('');
+    origLog(chalk.red('  ╔══════════════════════════════════════════╗'));
+    origLog(chalk.red('  ║') + chalk.bold.white('         ACTIVATION REQUIRED              ') + chalk.red('║'));
+    origLog(chalk.red('  ╠══════════════════════════════════════════╣'));
+    origLog(chalk.red('  ║') + chalk.yellow(`  Code: ${code}`) + ' '.repeat(33 - code.length) + chalk.red('║'));
+    origLog(chalk.red('  ║') + chalk.cyan('  https://xiaozhi.me') + ' '.repeat(23) + chalk.red('║'));
+    origLog(chalk.red('  ╚══════════════════════════════════════════╝'));
+    origLog('');
+    origLog(chalk.gray('  Waiting for activation... (checking every 5s)'));
+    origLog('');
   });
 
   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 +134,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 +168,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 +191,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

@@ -33,9 +33,6 @@ export async function handleActivation(data, otaUrl, deviceId, clientId) {
   const a = data.activation;
   if (!a?.code) return data.mqtt;
 
-  log('warn', `🔐 Activation required`);
-  log('info', `📋 Code: ${a.code}`);
-  log('info', `🌐 https://xiaozhi.me`);
   bus.emit('activation:required', { code: a.code });
 
   const timeout = a.timeout_ms || 120000;
@@ -43,10 +40,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', '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(() => {

package/src/mcp/mqtt-client.js

@@ -111,9 +111,9 @@ export class MqttClient {
     for (const r of responses) {
       if (r.type === 'mcp') { this._send(r); }
       else if (r.type === 'tool_call') {
-        log('tool', `🔧 ${r.name}`);
+        log('tool', r.name);
         this.mcp.executeTool(r.name, r.args)
-          .then(result => { log('tool', result.isError ? '❌' : '✅'); this._send({ type: 'mcp', payload: { jsonrpc: '2.0', id: r.id, result } }); })
+          .then(result => { log('tool', result.isError ? 'failed' : 'done'); this._send({ type: 'mcp', payload: { jsonrpc: '2.0', id: r.id, result } }); })
           .catch(err => { this._send({ type: 'mcp', payload: { jsonrpc: '2.0', id: r.id, result: { content: [{ type: 'text', text: err.message }], isError: true } } }); });
       }
     }
@@ -124,7 +124,7 @@ export class MqttClient {
   }
 
   _onOther(msg) {
-    if (msg.type === 'stt') { log('user', `🎤 "${msg.text}"`); bus.emit('stt', msg.text); }
+    if (msg.type === 'stt') { log('user', `"${msg.text}"`); bus.emit('stt', msg.text); }
     if (msg.type === 'llm' && msg.text) { bus.emit('llm:text', msg.text); }
     if (msg.type === 'tts' && msg.state === 'sentence_start' && msg.text) { bus.emit('tts:sentence', msg.text); }
     if (msg.type === 'goodbye') { this.sessionId = null; this.mcp.reset(); this._helloQueue = []; }
@@ -138,7 +138,7 @@ export class MqttClient {
 
   sendText(text) {
     this._send({ type: 'listen', state: 'detect', text });
-    log('user', `💬 "${text}"`);
+    log('user', `"${text}"`);
     bus.emit('user:text', text);
   }
 

package/src/repl-commands.js

@@ -76,7 +76,7 @@ export async function handleCommand(cmd, arg, ctx) {
     case '/history': {
       const recent = history.slice(-10);
       if (!recent.length) { log('info', 'No history'); break; }
-      console.log(`\n${COLORS.bold}📜 Recent:${COLORS.reset}\n`);
+      console.log(`\n${COLORS.bold}[LOG] Recent:${COLORS.reset}\n`);
       for (const h of recent) console.log(`  ${COLORS.dim}${new Date(h.ts).toLocaleTimeString()}${COLORS.reset} ${h.text.slice(0, 80)}`);
       console.log();
       break;
@@ -84,6 +84,7 @@ export async function handleCommand(cmd, arg, ctx) {
 
     case '/doctor': await runDoctor(); break;
     case '/model': console.log(`\n${formatModelInfo()}\n`); break;
+    case '/keys': return 'keys';
     case '/clear': console.clear(); break;
     default: log('info', `Unknown: ${cmd}. /help`);
   }

package/src/repl.js

@@ -9,6 +9,8 @@ import { formatToolResult } from './core/formatter.js';
 import { parseIntent } from './core/intent.js';
 import { FileTracker } from './core/file-tracker.js';
 import { handleCommand } from './repl-commands.js';
+import { getCompletions } from './core/completion.js';
+import { formatKeybindings } from './core/keybindings.js';
 import {
   renderBanner, renderStatus, renderTools, renderHelp,
   renderToolCall, renderToolResult, renderAiResponse,
@@ -16,19 +18,21 @@ import {
 } from './tui/renderer.js';
 
 export class REPL {
-  constructor(registry, mqtt, stats, session) {
+  constructor(registry, mqtt, stats, session, extras = {}) {
     this.registry = registry;
     this.mqtt = mqtt;
     this.stats = stats;
     this.session = session;
     this.fileTracker = new FileTracker();
+    this.thinking = extras.thinking || null;
+    this.sender = extras.sender || null;
+    this.autoFormat = extras.autoFormat || null;
     this.rl = null;
     this.history = [];
   }
 
   start() {
     const config = getConfig();
-    renderBanner(config, this.registry.all(), this.mqtt.connected);
     this._events();
 
     if (!process.stdin.isTTY) {
@@ -41,6 +45,10 @@ export class REPL {
     this.rl = createInterface({
       input: process.stdin, output: process.stdout,
       prompt: createPrompt(dirName), historySize: 200,
+      completer: (line) => {
+        const hits = getCompletions(line);
+        return [hits.length ? hits : [], line];
+      },
     });
     this.rl.prompt();
     this.rl.on('line', (input) => this._line(input.trim()));
@@ -49,12 +57,15 @@ export class REPL {
 
   _events() {
     bus.on('llm:text', (text) => {
+      if (this.thinking) this.thinking.set('idle');
+      // Clear any thinking indicator line
+      process.stdout.write('\r' + ' '.repeat(60) + '\r');
       renderAiResponse(text);
       if (this.rl) this.rl.prompt();
     });
 
     bus.on('tts:sentence', (text) => {
-      console.log(chalk.dim(`     🔊 ${text}`));
+      // TTS is audio output, no need to display text
     });
 
     bus.on('tool:called', ({ name, result, args }) => {
@@ -63,7 +74,7 @@ export class REPL {
     });
 
     bus.on('ready', () => {
-      console.log(chalk.green('  ✅ XiaoZhi session ready\n'));
+      if (this.rl) this.rl.prompt();
     });
   }
 
@@ -75,7 +86,11 @@ export class REPL {
     const intent = parseIntent(input);
     if (intent.matched) {
       renderUserInput(input);
+      if (this.thinking) this.thinking.set('tool_call');
       const result = await this.registry.call(intent.tool, intent.params);
+      if (this.thinking) this.thinking.set('idle');
+      // Clear thinking indicator
+      process.stdout.write('\r' + ' '.repeat(60) + '\r');
       const formatted = formatToolResult(intent.tool, intent.action, result);
       console.log(`\n${formatted}\n`);
       this.history.push({ role: 'user', text: input, ts: Date.now() });
@@ -86,6 +101,7 @@ export class REPL {
     // Send to XiaoZhi
     renderUserInput(input);
     this.history.push({ role: 'user', text: input, ts: Date.now() });
+    if (this.thinking) this.thinking.set('thinking');
     this.mqtt.sendText(input);
     this.rl?.prompt();
   }
@@ -93,15 +109,19 @@ export class REPL {
   async _cmd(input) {
     const [cmd, ...rest] = input.split(' ');
     const arg = rest.join(' ');
-    const ctx = { registry: this.registry, mqtt: this.mqtt, stats: this.stats, session: this.session, fileTracker: this.fileTracker, history: this.history };
+    const ctx = {
+      registry: this.registry, mqtt: this.mqtt, stats: this.stats,
+      session: this.session, fileTracker: this.fileTracker, history: this.history,
+    };
     const special = await handleCommand(cmd, arg, ctx);
 
     if (special === 'help') renderHelp();
     if (special === 'tools') renderTools(this.registry.list());
+    if (special === 'keys') console.log(formatKeybindings());
     if (special === 'status') {
       const s = this.session.getStats();
       renderStatus({
-        'MQTT': this.mqtt.connected ? '✅ Connected' : '❌ Disconnected',
+        'MQTT': this.mqtt.connected ? '[OK] Connected' : '[ERR] Disconnected',
         'Session': this.mqtt.sessionId || 'none',
         'Tools': `${this.registry.all().length} (${this.registry.all().reduce((s, t) => s + (t.actions?.length || 0), 0)} actions)`,
         'Turns': s.turns,

package/src/tools/config.js

@@ -36,7 +36,7 @@ const ACTIONS = {
       const config = getConfig();
       setNested(config, key, value);
       await saveConfig(config._root, config);
-      log('config', `⚙️ Set ${key} = ${value}`);
+      log('config', `[CFG] Set ${key} = ${value}`);
       return { key, value, saved: true };
     },
   },