pelulu-cli 1.0.0 → 1.0.3

package/src/tools/diff.js

@@ -6,6 +6,7 @@ import { readFile } from 'fs/promises';
 import { resolve } from 'path';
 import { homedir } from 'os';
 import { log } from '../core/logger.js';
+import { showDiff } from '../core/diff.js';
 
 const HOME = homedir();
 
@@ -50,6 +51,11 @@ const ACTIONS = {
 
       return { file1: abs1, file2: abs2, totalChanges: changes.length, hunks: hunks.slice(0, 20) };
     },
+    format: async ({ file1, file2 }) => {
+      const c1 = await readFile(file1, 'utf-8').catch(() => '');
+      const c2 = await readFile(file2, 'utf-8').catch(() => '');
+      if (c1 && c2) showDiff(c1, c2, file1);
+    },
   },
 
   stats: {

package/src/tools/file.js

@@ -40,7 +40,7 @@ const ACTIONS = {
       const abs = safe(path);
       await mkdir(dirname(abs), { recursive: true });
       await writeFile(abs, content, 'utf-8');
-      log('file', `📝 Written: ${abs} (${content.length} chars)`);
+      log('file', `[EDIT] Written: ${abs} (${content.length} chars)`);
       return { path: abs, written: content.length };
     },
   },
@@ -54,7 +54,7 @@ const ACTIONS = {
       const count = content.split(old_text).length - 1;
       content = content.replace(old_text, new_text);
       await writeFile(abs, content, 'utf-8');
-      log('file', `✏️ Edited: ${abs} (${count} occurrence(s))`);
+      log('file', `[EDIT] Edited: ${abs} (${count} occurrence(s))`);
       return { path: abs, edited: true, occurrences: count };
     },
   },
@@ -80,7 +80,7 @@ const ACTIONS = {
       const abs = safe(path);
       if (!existsSync(abs)) throw new Error(`Not found: ${abs}`);
       await unlink(abs);
-      log('file', `🗑️ Deleted: ${abs}`);
+      log('file', `[DEL] Deleted: ${abs}`);
       return { path: abs, deleted: true };
     },
   },

package/src/tools/git.js

@@ -85,7 +85,7 @@ const ACTIONS = {
       const msg = params.message.replace(/"/g, '\\"');
       const r = await git(`commit -m "${msg}"`, dir);
       if (r.code !== 0 && r.stderr.includes('nothing to commit')) return { committed: false, reason: 'nothing to commit' };
-      log('git', `📝 Committed: ${params.message}`);
+      log('git', `[EDIT] Committed: ${params.message}`);
       return { committed: true, message: params.message, output: r.stdout.slice(-300) };
     },
   },

package/src/tools/network.js

@@ -25,7 +25,7 @@ function httpGet(url, maxChars = 5000) {
 const ACTIONS = {
   async fetch({ url, method, body, headers }) {
     if (!url) throw new Error('url required');
-    log('network', `🌐 ${method || 'GET'} ${url}`);
+    log('network', `[WEB] ${method || 'GET'} ${url}`);
     const result = await httpGet(url);
     return { url, status: result.status, body: result.body.slice(0, 5000) };
   },

package/src/tools/project.js

@@ -57,7 +57,7 @@ const ACTIONS = {
       const type = await detectProject(dir);
       const cmd = BUILD_CMD[type];
       if (!cmd) throw new Error(`No build for ${type}`);
-      log('project', `🔨 Building (${type})...`);
+      log('project', `[BUILD] Building (${type})...`);
       const r = await run(cmd, dir);
       return { success: r.code === 0, type, exitCode: r.code, output: r.stdout.slice(-500) || r.stderr.slice(-500) };
     },
@@ -70,7 +70,7 @@ const ACTIONS = {
       const type = await detectProject(dir);
       const cmd = TEST_CMD[type];
       if (!cmd) throw new Error(`No test for ${type}`);
-      log('project', `🧪 Testing (${type})...`);
+      log('project', `[TEST] Testing (${type})...`);
       const r = await run(cmd, dir);
       return { passed: r.code === 0, type, exitCode: r.code, output: r.stdout.slice(-1000) || r.stderr.slice(-1000) };
     },

package/src/tools/search.js

@@ -34,7 +34,7 @@ const ACTIONS = {
     required: ['pattern'],
     handler: async ({ pattern, path, ignoreCase, include, context }) => {
       if (!pattern) throw new Error('pattern required');
-      log('search', `🔍 grep: ${pattern}`);
+      log('search', `[FIND] grep: ${pattern}`);
       const flags = ignoreCase ? '-rn' : '-rn';
       const ic = ignoreCase ? 'i' : '';
       const inc = include ? `--include="*.${include}"` : '';
@@ -49,7 +49,7 @@ const ACTIONS = {
   find: {
     required: ['name'],
     handler: async ({ name, path, type }) => {
-      log('search', `🔍 find: ${name}`);
+      log('search', `[FIND] find: ${name}`);
       const t = type ? `-type ${type}` : '';
       const cmd = `find "${path || '.'}" ${t} -name "${name}" 2>/dev/null | head -50`;
       const r = await runCmd(cmd);
@@ -60,7 +60,7 @@ const ACTIONS = {
   web: {
     required: ['url'],
     handler: async ({ url, maxChars }) => {
-      log('search', `🌐 fetch: ${url}`);
+      log('search', `[WEB] fetch: ${url}`);
       const r = await httpGet(url, maxChars || 8000);
       return { url, status: r.status, body: r.body.slice(0, maxChars || 8000), length: r.body.length };
     },

package/src/tools/shell.js

@@ -26,7 +26,7 @@ const ACTIONS = {
   exec: {
     required: ['command'],
     handler: async ({ command, timeout }) => {
-      log('shell', `⚙️ $ ${command}`);
+      log('shell', `[CFG] $ ${command}`);
       const result = await run(command, timeout);
       const maxLen = getConfig().tools?.max_output || 10000;
       return { stdout: result.stdout.slice(0, maxLen), stderr: result.stderr.slice(0, 2000), exitCode: result.code };
@@ -36,7 +36,7 @@ const ACTIONS = {
   bg: {
     required: ['command'],
     handler: async ({ command }) => {
-      log('shell', `⚙️ [bg] $ ${command}`);
+      log('shell', `[CFG] [bg] $ ${command}`);
       const child = spawn('bash', ['-c', command], { detached: true, stdio: 'ignore' });
       child.unref();
       return { pid: child.pid, background: true, command };

package/src/tools/template.js

@@ -71,7 +71,7 @@ const ACTIONS = {
       for (const [file, content] of Object.entries(files)) {
         await writeFile(join(dir, file), content);
       }
-      log('template', `📁 Created ${template}: ${dir}`);
+      log('template', `[DIR] Created ${template}: ${dir}`);
       return { created: true, template, path: dir, files: Object.keys(files) };
     },
   },

package/src/tools/watch.js

@@ -26,7 +26,7 @@ const ACTIONS = {
       const watcher = fsWatch(abs, { recursive: recursive !== false }, (eventType, filename) => {
         if (filter && !filename.includes(filter)) return;
         const event = { type: eventType, file: filename, path: abs, ts: Date.now() };
-        log('watch', `📁 ${eventType}: ${filename}`);
+        log('watch', `[DIR] ${eventType}: ${filename}`);
         bus.emit('file:change', event);
       });
 

package/src/tui/completable-input.js

@@ -0,0 +1,127 @@
+/**
+ * CompletableInput — TextInput with Tab auto-completion
+ * Wraps ink-text-input and adds completion support
+ */
+import React, { useState, useCallback } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { getCompletions } from '../core/completion.js';
+
+export function CompletableInput({ onSubmit, placeholder }) {
+  const [value, setValue] = useState('');
+  const [completions, setCompletions] = useState([]);
+  const [completionIndex, setCompletionIndex] = useState(0);
+  const [showCompletions, setShowCompletions] = useState(false);
+
+  // Handle Tab for completion
+  useInput((input, key) => {
+    if (key.tab) {
+      if (!showCompletions) {
+        // First Tab: show completions
+        const hits = getCompletions(value);
+        if (hits.length > 0) {
+          setCompletions(hits);
+          setCompletionIndex(0);
+          setShowCompletions(true);
+          // Auto-fill first match
+          if (hits.length === 1) {
+            setValue(hits[0] + ' ');
+            setShowCompletions(false);
+          } else {
+            setValue(hits[0]);
+          }
+        }
+      } else {
+        // Subsequent Tab: cycle through completions
+        const next = (completionIndex + 1) % completions.length;
+        setCompletionIndex(next);
+        setValue(completions[next]);
+      }
+    } else if (key.escape) {
+      // Escape: hide completions
+      setShowCompletions(false);
+      setCompletions([]);
+      setCompletionIndex(0);
+    } else if (key.return) {
+      // Enter: handled by TextInput onSubmit, do nothing here
+      setShowCompletions(false);
+      setCompletions([]);
+    } else {
+      // Any other key: reset completions
+      if (showCompletions) {
+        setShowCompletions(false);
+        setCompletions([]);
+        setCompletionIndex(0);
+      }
+    }
+  });
+
+  // Update value from TextInput (but not on Tab/Enter which are handled above)
+  const handleChange = useCallback((val) => {
+    setValue(val);
+    // Live completion hints
+    if (val.length > 0) {
+      const hits = getCompletions(val);
+      if (hits.length > 0 && hits[0] !== val) {
+        setCompletions(hits);
+        setShowCompletions(true);
+        setCompletionIndex(0);
+      } else {
+        setShowCompletions(false);
+      }
+    } else {
+      setShowCompletions(false);
+    }
+  }, []);
+
+  // Handle TextInput submit (Enter key)
+  const handleSubmit = useCallback((val) => {
+    const trimmed = val.trim();
+    if (trimmed) {
+      onSubmit(trimmed);
+      setValue('');
+    }
+    setShowCompletions(false);
+    setCompletions([]);
+  }, [onSubmit]);
+
+  return React.createElement(Box, { flexDirection: 'column', width: '100%' },
+    // Completion suggestions
+    showCompletions && completions.length > 1
+      ? React.createElement(Box, {
+          paddingLeft: 2, paddingBottom: 0,
+          flexDirection: 'row', flexWrap: 'wrap', gap: 1,
+        },
+        completions.slice(0, 8).map((c, i) =>
+          React.createElement(Text, {
+            key: c,
+            color: i === completionIndex ? 'cyan' : 'dim',
+            bold: i === completionIndex,
+            dimColor: i !== completionIndex,
+          },
+            i === completionIndex ? `[${c}]` : ` ${c} `
+          )
+        ),
+      )
+      : null,
+
+    // Input line
+    React.createElement(Box, { paddingX: 1 },
+      React.createElement(Text, { color: 'cyan' }, '> '),
+      React.createElement(TextInput, {
+        value,
+        onChange: handleChange,
+        onSubmit: handleSubmit,
+        placeholder: placeholder || 'type a message...',
+        // Don't show cursor when we have a completion suggestion
+        showCursor: !showCompletions || completions.length <= 1,
+      }),
+      // Show ghost completion (the remaining part of the suggested completion)
+      showCompletions && completions.length > 0 && value.length > 0
+        ? React.createElement(Text, { dimColor: true },
+            completions[completionIndex]?.slice(value.length) || ''
+          )
+        : null,
+    ),
+  );
+}

package/src/tui/ink-app.js

@@ -0,0 +1,324 @@
+/**
+ * Ink App — Main Pelulu TUI Application
+ * Full React component with message list, input, status, thinking
+ */
+import React, { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import { Box, Text, useApp, useInput, useStdin } from 'ink';
+import {
+  StatusBar, MessageBubble, ThinkingIndicator,
+} from './ink-components.js';
+import { CompletableInput } from './completable-input.js';
+import { setInkMode } from '../core/logger.js';
+
+export function createApp({ registry, mqtt, stats, session, bus, config, extras }) {
+  return function App() {
+    const { exit } = useApp();
+    const { isRawModeSupported } = useStdin();
+    const [messages, setMessages] = useState([]);
+    const [thinking, setThinking] = useState('idle');
+    const [connected, setConnected] = useState(mqtt.connected);
+    const [sessionId, setSessionId] = useState(mqtt.sessionId);
+    // Show last startup log as initial log line
+    const _startupLogs = extras?.startupLogs || [];
+    const _lastStartup = _startupLogs.length
+      ? _startupLogs[_startupLogs.length - 1].replace(/\x1b\[[0-9;]*m/g, '')
+      : '';
+    const [logLine, setLogLine] = useState(_lastStartup);
+    const logTimer = useRef(null);
+    const maxMessages = 200;
+    const [scrollOffset, setScrollOffset] = useState(0); // 0 = bottom, N = scrolled up N messages
+    const scrollOffsetRef = useRef(0);
+
+    // Calculate how many rows are available for messages
+    const getAvailableRows = useCallback(() => {
+      const termRows = process.stdout.rows || 24;
+      // status bar (3) + log line (1) + input box (3) + padding (2) + thinking (1) = ~10
+      return Math.max(5, termRows - 10);
+    }, []);
+
+    // ─── Enable Ink mode for logger ──────────────────
+    useEffect(() => {
+      setInkMode(true, bus);
+      return () => {
+        setInkMode(false, null);
+        if (logTimer.current) clearTimeout(logTimer.current);
+      };
+    }, []);
+
+    // ─── Bus Events ───────────────────────────────────
+    useEffect(() => {
+      const onLlmText = (text) => {
+        setThinking('idle');
+        // Strip emojis to check if there's real content
+        const clean = text.replace(/\p{Emoji_Presentation}/gu, '').replace(/\p{Extended_Pictographic}/gu, '').trim();
+        if (!clean) return; // skip emoji-only LLM responses (TTS will carry the real text)
+        setMessages(prev => [...prev.slice(-maxMessages), {
+          id: Date.now().toString(), role: 'assistant', content: text,
+        }]);
+      };
+
+      const onToolCalled = ({ name, result, args }) => {
+        setMessages(prev => [...prev.slice(-maxMessages), {
+          id: `tool-${Date.now()}`, role: 'tool',
+          toolName: name, action: args?.action,
+          detail: args?.path || args?.command || args?.pattern || '',
+        }, {
+          id: `result-${Date.now()}`, role: 'tool',
+          toolName: '', action: '',
+          detail: result.isError
+            ? `x ${result.content?.[0]?.text || 'error'}`
+            : 'v OK',
+        }]);
+      };
+
+      const onThinking = ({ state }) => setThinking(state);
+      const onReady = () => {
+        setConnected(true);
+        setSessionId(mqtt.sessionId);
+      };
+      const onDisconnect = () => {
+        setConnected(false);
+        setSessionId(null);
+      };
+
+      // Single log line that updates in place
+      const onLogMessage = ({ level, msg }) => {
+        const LABELS = { ok: 'OK', err: 'ERR', warn: 'WARN', info: 'i', tool: 'TOOL', mcp: 'MCP', user: 'USER', ai: 'AI' };
+        const label = LABELS[level] || level.toUpperCase();
+        setLogLine(`[${label}] ${msg}`);
+        // Auto-hide after 4s of no new logs
+        if (logTimer.current) clearTimeout(logTimer.current);
+        logTimer.current = setTimeout(() => setLogLine(''), 4000);
+      };
+
+      // XiaoZhi sends responses as TTS sentences, not LLM text
+      // Accumulate TTS sentences and display as assistant message
+      let ttsBuffer = '';
+      let ttsTimer = null;
+
+      const onTtsSentence = (text) => {
+        ttsBuffer += text;
+        setThinking('idle');
+        // Debounce: wait for all TTS sentences to arrive, then display
+        if (ttsTimer) clearTimeout(ttsTimer);
+        ttsTimer = setTimeout(() => {
+          if (ttsBuffer) {
+            setMessages(prev => {
+              const next = [...prev.slice(-maxMessages), {
+                id: Date.now().toString(), role: 'assistant', content: ttsBuffer,
+              }];
+              // Auto-scroll to bottom on new AI response
+              setScrollOffset(0);
+              scrollOffsetRef.current = 0;
+              return next;
+            });
+            ttsBuffer = '';
+          }
+        }, 500);
+      };
+
+      bus.on('llm:text', onLlmText);
+      bus.on('tts:sentence', onTtsSentence);
+      bus.on('tool:called', onToolCalled);
+      bus.on('thinking', onThinking);
+      bus.on('ready', onReady);
+      bus.on('mqtt:error', onDisconnect);
+      bus.on('log:message', onLogMessage);
+
+      return () => {
+        bus.off('llm:text', onLlmText);
+        bus.off('tts:sentence', onTtsSentence);
+        bus.off('tool:called', onToolCalled);
+        bus.off('thinking', onThinking);
+        bus.off('ready', onReady);
+        bus.off('mqtt:error', onDisconnect);
+        bus.off('log:message', onLogMessage);
+        if (ttsTimer) clearTimeout(ttsTimer);
+      };
+    }, []);
+
+    // ─── Keyboard shortcuts ─────────────────────────
+    useInput((input, key) => {
+      if (key.ctrl && input === 'c') exit();
+
+      // Scroll: Shift+Up / Shift+Down / PageUp / PageDown
+      if (key.shift && key.upArrow) {
+        setScrollOffset(prev => {
+          const next = Math.min(prev + 5, messages.length - 1);
+          scrollOffsetRef.current = next;
+          return next;
+        });
+      } else if (key.shift && key.downArrow) {
+        setScrollOffset(prev => {
+          const next = Math.max(0, prev - 5);
+          scrollOffsetRef.current = next;
+          return next;
+        });
+      } else if (key.pageUp) {
+        setScrollOffset(prev => {
+          const next = Math.min(prev + 20, messages.length - 1);
+          scrollOffsetRef.current = next;
+          return next;
+        });
+      } else if (key.pageDown) {
+        setScrollOffset(prev => {
+          const next = Math.max(0, prev - 20);
+          scrollOffsetRef.current = next;
+          return next;
+        });
+      }
+    });
+
+    // ─── Handle Submit ────────────────────────────────
+    const handleSubmit = useCallback(async (text) => {
+      // Add user message
+      setMessages(prev => [...prev.slice(-maxMessages), {
+        id: `user-${Date.now()}`, role: 'user', content: text,
+      }]);
+
+      // Slash commands
+      if (text.startsWith('/')) {
+        const [cmd, ...rest] = text.split(' ');
+        const arg = rest.join(' ');
+        const ctx = { registry, mqtt, stats, session, fileTracker: extras.fileTracker, history: [] };
+
+        if (cmd === '/quit' || cmd === '/exit') {
+          exit();
+          return;
+        }
+        if (cmd === '/clear') {
+          setMessages([]);
+          setScrollOffset(0);
+          scrollOffsetRef.current = 0;
+          return;
+        }
+        if (cmd === '/status') {
+          const s = session.getStats();
+          setMessages(prev => [...prev, {
+            id: `sys-${Date.now()}`, role: 'system',
+            content: `mqtt: ${mqtt.connected ? 'on' : 'off'} | session: ${mqtt.sessionId || '-'} | tools: ${registry.all().length} | turns: ${s.turns} | calls: ${s.toolCalls}`,
+          }]);
+          return;
+        }
+        if (cmd === '/tools') {
+          const tools = registry.list();
+          const lines = tools.map(t => `  ${t.name} (${t.actions?.length || 0})`).join('\n');
+          setMessages(prev => [...prev, {
+            id: `sys-${Date.now()}`, role: 'system', content: `tools:\n${lines}`,
+          }]);
+          return;
+        }
+
+        // Try repl-commands handler
+        try {
+          const { handleCommand } = await import('../repl-commands.js');
+          const special = await handleCommand(cmd, arg, ctx);
+          if (special === 'help') {
+            setMessages(prev => [...prev, {
+              id: `sys-${Date.now()}`, role: 'system',
+              content: '/tools /status /stats /clear /quit /call <tool> <action> /keys',
+            }]);
+          }
+        } catch {}
+        return;
+      }
+
+      // Intent parsing (natural language shortcuts)
+      try {
+        const { parseIntent } = await import('../core/intent.js');
+        const intent = parseIntent(text);
+        if (intent.matched) {
+          setThinking('tool_call');
+          const result = await registry.call(intent.tool, intent.params);
+          setThinking('idle');
+          const { formatToolResult } = await import('../core/formatter.js');
+          const formatted = formatToolResult(intent.tool, intent.action, result);
+          setMessages(prev => [...prev.slice(-maxMessages), {
+            id: `tool-${Date.now()}`, role: 'tool',
+            toolName: intent.tool, action: intent.action,
+            detail: '',
+          }, {
+            id: `result-${Date.now()}`, role: 'assistant', content: formatted,
+          }]);
+          return;
+        }
+      } catch {}
+
+      // Send to XiaoZhi
+      setThinking('thinking');
+      mqtt.sendText(text);
+    }, [registry, mqtt, stats, session]);
+
+    // ─── Render ───────────────────────────────────────
+    const tools = registry.all();
+    const actions = tools.reduce((s, t) => s + (t.actions?.length || 0), 0);
+
+    // Calculate visible messages (scrollable window)
+    const availableRows = getAvailableRows();
+    const totalMessages = messages.length;
+    const endIdx = totalMessages - scrollOffset;
+    const startIdx = Math.max(0, endIdx - availableRows);
+    const visibleMessages = messages.slice(startIdx, endIdx);
+    const canScrollUp = scrollOffset < totalMessages - 1;
+    const canScrollDown = scrollOffset > 0;
+
+    return React.createElement(Box, {
+      flexDirection: 'column', width: '100%',
+    },
+      // Top: Status bar
+      React.createElement(StatusBar, {
+        connected, session: sessionId,
+        version: config?.agent?.version,
+      }),
+
+      // Log status line (single line, auto-updating, auto-hiding)
+      logLine
+        ? React.createElement(Box, { paddingLeft: 1 },
+            React.createElement(Text, { dimColor: true, color: 'gray' }, logLine),
+          )
+        : null,
+
+      // Scroll indicator (only when scrolled up)
+      canScrollUp
+        ? React.createElement(Box, { paddingLeft: 2 },
+            React.createElement(Text, { dimColor: true, color: 'yellow' },
+              `[${totalMessages - endIdx} more above | Shift+Up/Down or PgUp/PgDn to scroll]`
+            ),
+          )
+        : null,
+
+      // Middle: Messages (scrollable window)
+      React.createElement(Box, {
+        flexDirection: 'column', paddingY: 1,
+      },
+        totalMessages === 0
+          ? React.createElement(Box, { paddingLeft: 2 },
+              React.createElement(Text, { dimColor: true },
+                'type a message to get started. tab for autocomplete. /help for commands.'
+              ),
+            )
+          : visibleMessages.map((msg) =>
+              React.createElement(MessageBubble, { key: msg.id, message: msg })
+            ),
+        canScrollDown
+          ? React.createElement(Box, { paddingLeft: 2 },
+              React.createElement(Text, { dimColor: true, color: 'yellow' },
+                `[${scrollOffset} more below | Shift+Down or PgDn to scroll to bottom]`
+              ),
+            )
+          : null,
+        React.createElement(ThinkingIndicator, { state: thinking }),
+      ),
+
+      // Bottom: Input
+      React.createElement(Box, {
+        borderStyle: 'single', borderColor: 'cyan', paddingX: 0,
+      },
+        React.createElement(CompletableInput, {
+          onSubmit: handleSubmit,
+          placeholder: 'type a message or /help ...',
+        }),
+      ),
+    );
+  };
+}