pelulu-cli 1.0.0

package/src/mcp/wss-endpoint.js

@@ -0,0 +1,133 @@
+/**
+ * WssEndpoint — official XiaoZhi MCP endpoint (WSS)
+ * Alternative to MQTT-based tool serving
+ * Reference: https://github.com/78/mcp-calculator/blob/main/mcp_pipe.py
+ */
+import WebSocket from 'ws';
+import { log, debug } from '../core/logger.js';
+
+const INITIAL_BACKOFF = 1000;
+const MAX_BACKOFF = 60000;
+const HEARTBEAT_INTERVAL = 25000;
+
+export class WssEndpoint {
+  constructor(url, getTools, callTool) {
+    this.url = url;
+    this.getTools = getTools;
+    this.callTool = callTool;
+    this.ws = null;
+    this.backoff = INITIAL_BACKOFF;
+    this.closed = false;
+    this.nameMap = new Map();
+    this._heartbeat = null;
+    this._reconnectTimer = null;
+  }
+
+  start() {
+    if (!this.url) { debug('WSS endpoint: no URL'); return; }
+    this.closed = false;
+    this._connect();
+  }
+
+  _connect() {
+    const safe = this.url.replace(/token=[^&]+/i, 'token=***');
+    log('mcp', `WSS connecting: ${safe}`);
+
+    this.ws = new WebSocket(this.url);
+
+    this.ws.on('open', () => {
+      this.backoff = INITIAL_BACKOFF;
+      this.nameMap.clear();
+      log('ok', 'WSS connected');
+      this._startHeartbeat();
+    });
+
+    this.ws.on('message', (data) => this._onMessage(data));
+
+    this.ws.on('close', (code) => {
+      log('warn', `WSS closed (${code})`);
+      this._stopHeartbeat();
+      this.nameMap.clear();
+      if (!this.closed) this._reconnect();
+    });
+
+    this.ws.on('error', (e) => debug(`WSS error: ${e.message}`));
+  }
+
+  _startHeartbeat() {
+    this._stopHeartbeat();
+    this._heartbeat = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        try { this.ws.ping(); } catch {}
+      }
+    }, HEARTBEAT_INTERVAL);
+  }
+
+  _stopHeartbeat() {
+    if (this._heartbeat) { clearInterval(this._heartbeat); this._heartbeat = null; }
+  }
+
+  _reconnect() {
+    if (this.closed || this._reconnectTimer) return;
+    const delay = this.backoff;
+    this._reconnectTimer = setTimeout(() => {
+      this._reconnectTimer = null;
+      this.backoff = Math.min(this.backoff * 2, MAX_BACKOFF);
+      this._connect();
+    }, delay);
+  }
+
+  _send(obj) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(obj));
+    }
+  }
+
+  async _onMessage(data) {
+    let msg;
+    try { msg = JSON.parse(data.toString()); } catch { return; }
+
+    const { id, method } = msg;
+
+    if (method === 'initialize') {
+      this._send({ jsonrpc: '2.0', id, result: {
+        protocolVersion: '2024-11-05', capabilities: { tools: {} },
+        serverInfo: { name: 'coding-agent', version: '1.0.0' },
+      }});
+    }
+
+    if (method === 'notifications/initialized') log('mcp', 'WSS initialized ✓');
+
+    if (method === 'tools/list') {
+      this.nameMap.clear();
+      const tools = this.getTools().map(t => {
+        const name = t.name.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+        this.nameMap.set(name, t.name);
+        return { name, description: t.description, inputSchema: t.inputSchema || { type: 'object', properties: {} } };
+      });
+      this._send({ jsonrpc: '2.0', id, result: { tools } });
+      log('mcp', `WSS sent ${tools.length} tools`);
+    }
+
+    if (method === 'tools/call') {
+      const name = this.nameMap.get(msg.params?.name) || msg.params?.name;
+      try {
+        const result = await this.callTool(name, msg.params?.arguments || {});
+        this._send({ jsonrpc: '2.0', id, result: { content: result.content || [{ type: 'text', text: 'OK' }], isError: !!result.isError } });
+      } catch (e) {
+        this._send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: e.message }], isError: true } });
+      }
+    }
+
+    if (method === 'ping') this._send({ jsonrpc: '2.0', id, result: {} });
+  }
+
+  isConnected() { return this.ws?.readyState === WebSocket.OPEN; }
+
+  stop() {
+    this.closed = true;
+    this._stopHeartbeat();
+    if (this._reconnectTimer) { clearTimeout(this._reconnectTimer); this._reconnectTimer = null; }
+    if (this.ws) { try { this.ws.close(); } catch {} this.ws = null; }
+  }
+}

package/src/plugins/manager.js

@@ -0,0 +1,72 @@
+/**
+ * PluginManager — loads external plugins from plugins/ directory
+ *
+ * Plugin structure:
+ *   export default { name, description, version, init?, tools?, shutdown? }
+ *   tools: [{ name, description, inputSchema, handler }]
+ */
+import { readdir } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { log, debug } from '../core/logger.js';
+import { bus } from '../core/event-bus.js';
+import { getConfig } from '../core/config.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PLUGINS_DIR = join(__dirname);
+
+export class PluginManager {
+  #plugins = new Map();
+  #registry = null;
+
+  constructor(registry) {
+    this.#registry = registry;
+  }
+
+  async load() {
+    const config = getConfig();
+    const disabled = new Set(config.plugins?.disabled || []);
+
+    try {
+      const files = await readdir(PLUGINS_DIR);
+      for (const file of files.filter(f => f.endsWith('.js') && f !== 'manager.js')) {
+        const name = file.replace('.js', '');
+        if (disabled.has(name)) { debug(`Plugin "${name}" disabled`); continue; }
+
+        try {
+          const mod = await import(join(PLUGINS_DIR, file));
+          const plugin = mod.default || mod;
+          if (!plugin?.name) continue;
+
+          if (plugin.init) await plugin.init({ bus, config });
+          if (plugin.tools) {
+            for (const tool of plugin.tools) {
+              this.#registry.register(tool);
+            }
+          }
+          this.#plugins.set(plugin.name, plugin);
+          log('plugin', `  ${plugin.name} v${plugin.version || '?'} — ${plugin.description || ''}`);
+        } catch (e) {
+          log('warn', `Plugin "${name}" failed: ${e.message}`);
+        }
+      }
+    } catch (e) {
+      debug(`Plugins dir scan: ${e.message}`);
+    }
+
+    log('info', `${this.#plugins.size} plugins loaded`);
+  }
+
+  list() {
+    return [...this.#plugins.values()].map(p => ({
+      name: p.name, version: p.version || '-', description: p.description || '-',
+    }));
+  }
+
+  async shutdown() {
+    for (const [name, p] of this.#plugins) {
+      try { if (p.shutdown) await p.shutdown(); } catch (e) { debug(`Plugin "${name}" shutdown error: ${e.message}`); }
+    }
+    this.#plugins.clear();
+  }
+}

package/src/repl-commands.js

@@ -0,0 +1,91 @@
+/**
+ * REPL Commands — slash command handlers
+ * Extracted from repl.js to keep it under 200 lines
+ */
+import { log, COLORS } from './core/logger.js';
+import { getConfig } from './core/config.js';
+import { detectWorkspace, formatWorkspace } from './core/workspace.js';
+import { saveConversation, listConversations, loadConversation } from './core/conversation.js';
+import { formatToolResult } from './core/formatter.js';
+import { showToolHelp, showAllToolHelp } from './core/tool-help.js';
+import { runDoctor } from './core/doctor.js';
+import { formatModelInfo } from './core/model-info.js';
+
+export async function handleCommand(cmd, arg, ctx) {
+  const { registry, mqtt, stats, session, fileTracker, history } = ctx;
+
+  switch (cmd) {
+    case '/quit': case '/exit':
+      console.log(stats.formatReport());
+      console.log(fileTracker.getSummary());
+      await registry.shutdown();
+      mqtt.disconnect();
+      process.exit(0);
+
+    case '/help':
+      if (arg) showToolHelp(arg);
+      else return 'help';
+      break;
+
+    case '/tools': return 'tools';
+    case '/status': return 'status';
+    case '/stats': console.log(`\n${stats.formatReport()}\n`); break;
+    case '/workspace':
+      try { console.log(`\n${formatWorkspace(await detectWorkspace())}\n`); }
+      catch (e) { log('err', e.message); }
+      break;
+
+    case '/files': console.log(`\n${fileTracker.getSummary()}\n`); break;
+
+    case '/call': {
+      if (!arg) { log('warn', 'Usage: /call <tool> <action> [params]'); break; }
+      const parts = arg.split(' ');
+      const toolName = parts[0];
+      let args = {};
+      if (parts.length > 1) {
+        try { args = JSON.parse(parts.slice(1).join(' ')); }
+        catch { args = { action: parts[1], path: parts.slice(2).join(' ') || undefined }; }
+      }
+      const result = await registry.call(toolName, args);
+      console.log(`\n${formatToolResult(toolName, args.action, result)}\n`);
+      break;
+    }
+
+    case '/conv': {
+      const [sub, ...rest] = (arg || '').split(' ');
+      const name = rest.join(' ');
+      try {
+        if (sub === 'save') { const p = await saveConversation(history, name || undefined); log('ok', `Saved: ${p}`); }
+        else if (sub === 'list') {
+          const convs = await listConversations();
+          if (!convs.length) { log('info', 'No saved conversations'); break; }
+          console.log(`\n${COLORS.bold}💾 Conversations:${COLORS.reset}\n`);
+          for (const c of convs) console.log(`  ${c.name} (${c.messages} msgs)`);
+          console.log();
+        } else if (sub === 'load') {
+          if (!name) { log('warn', 'Usage: /conv load <name>'); break; }
+          const msgs = await loadConversation(name);
+          history.length = 0;
+          history.push(...msgs);
+          log('ok', `Loaded ${msgs.length} messages`);
+        } else { log('info', 'Usage: /conv save|list|load [name]'); }
+      } catch (e) { log('err', e.message); }
+      break;
+    }
+
+    case '/history': {
+      const recent = history.slice(-10);
+      if (!recent.length) { log('info', 'No history'); break; }
+      console.log(`\n${COLORS.bold}📜 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;
+    }
+
+    case '/doctor': await runDoctor(); break;
+    case '/model': console.log(`\n${formatModelInfo()}\n`); break;
+    case '/clear': console.clear(); break;
+    default: log('info', `Unknown: ${cmd}. /help`);
+  }
+  return null;
+}

package/src/repl.js

@@ -0,0 +1,115 @@
+/**
+ * REPL — interactive CLI with rich TUI
+ */
+import { createInterface } from 'readline';
+import chalk from 'chalk';
+import { bus } from './core/event-bus.js';
+import { getConfig } from './core/config.js';
+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 {
+  renderBanner, renderStatus, renderTools, renderHelp,
+  renderToolCall, renderToolResult, renderAiResponse,
+  renderUserInput, createPrompt,
+} from './tui/renderer.js';
+
+export class REPL {
+  constructor(registry, mqtt, stats, session) {
+    this.registry = registry;
+    this.mqtt = mqtt;
+    this.stats = stats;
+    this.session = session;
+    this.fileTracker = new FileTracker();
+    this.rl = null;
+    this.history = [];
+  }
+
+  start() {
+    const config = getConfig();
+    renderBanner(config, this.registry.all(), this.mqtt.connected);
+    this._events();
+
+    if (!process.stdin.isTTY) {
+      console.log(chalk.gray('  Non-interactive mode. Agent running in background.'));
+      process.stdin.resume();
+      return;
+    }
+
+    const dirName = process.cwd().split('/').pop() || process.cwd();
+    this.rl = createInterface({
+      input: process.stdin, output: process.stdout,
+      prompt: createPrompt(dirName), historySize: 200,
+    });
+    this.rl.prompt();
+    this.rl.on('line', (input) => this._line(input.trim()));
+    this.rl.on('close', () => { console.log(chalk.gray('\n  Goodbye! 👋\n')); process.exit(0); });
+  }
+
+  _events() {
+    bus.on('llm:text', (text) => {
+      renderAiResponse(text);
+      if (this.rl) this.rl.prompt();
+    });
+
+    bus.on('tts:sentence', (text) => {
+      console.log(chalk.dim(`     🔊 ${text}`));
+    });
+
+    bus.on('tool:called', ({ name, result, args }) => {
+      renderToolCall(name, args?.action, args);
+      renderToolResult(!result.isError, result.content?.[0]?.text);
+    });
+
+    bus.on('ready', () => {
+      console.log(chalk.green('  ✅ XiaoZhi session ready\n'));
+    });
+  }
+
+  async _line(input) {
+    if (!input) return this.rl?.prompt();
+    if (input.startsWith('/')) return this._cmd(input);
+
+    // Try intent parsing
+    const intent = parseIntent(input);
+    if (intent.matched) {
+      renderUserInput(input);
+      const result = await this.registry.call(intent.tool, intent.params);
+      const formatted = formatToolResult(intent.tool, intent.action, result);
+      console.log(`\n${formatted}\n`);
+      this.history.push({ role: 'user', text: input, ts: Date.now() });
+      this.rl?.prompt();
+      return;
+    }
+
+    // Send to XiaoZhi
+    renderUserInput(input);
+    this.history.push({ role: 'user', text: input, ts: Date.now() });
+    this.mqtt.sendText(input);
+    this.rl?.prompt();
+  }
+
+  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 special = await handleCommand(cmd, arg, ctx);
+
+    if (special === 'help') renderHelp();
+    if (special === 'tools') renderTools(this.registry.list());
+    if (special === 'status') {
+      const s = this.session.getStats();
+      renderStatus({
+        'MQTT': this.mqtt.connected ? '✅ Connected' : '❌ 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,
+        'Tool Calls': `${s.toolCalls} (${s.errors} errors)`,
+        'Uptime': `${s.uptime}s`,
+        'Workspace': process.cwd(),
+      });
+    }
+    this.rl?.prompt();
+  }
+}

package/src/tools/ai.js

@@ -0,0 +1,128 @@
+/**
+ * AI Tool — code analysis helpers (1 MCP tool, 5 actions)
+ * These are LOCAL helpers — the heavy lifting is done by XiaoZhi LLM via MQTT.
+ */
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+import { homedir } from 'os';
+
+const HOME = homedir();
+
+function safePath(p) {
+  return resolve(p.replace(/^~(?=$|[/\\])/g, HOME));
+}
+
+function detectLanguage(file) {
+  const ext = file.split('.').pop()?.toLowerCase();
+  const map = {
+    js: 'javascript', mjs: 'javascript', jsx: 'javascript', ts: 'typescript',
+    tsx: 'typescript', py: 'python', rb: 'ruby', go: 'go', rs: 'rust',
+    java: 'java', c: 'c', cpp: 'cpp', h: 'c', hpp: 'cpp',
+    sh: 'shell', bash: 'shell', zsh: 'shell',
+    json: 'json', yaml: 'yaml', yml: 'yaml', toml: 'toml',
+    md: 'markdown', html: 'html', css: 'css', sql: 'sql',
+  };
+  return map[ext] || 'unknown';
+}
+
+function analyzeCode(content, lang) {
+  const lines = content.split('\n');
+  const stats = {
+    totalLines: lines.length,
+    blankLines: lines.filter(l => !l.trim()).length,
+    commentLines: lines.filter(l => {
+      const t = l.trim();
+      return t.startsWith('//') || t.startsWith('#') || t.startsWith('/*') || t.startsWith('*');
+    }).length,
+    language: lang,
+  };
+  stats.codeLines = stats.totalLines - stats.blankLines - stats.commentLines;
+
+  // Detect functions/classes
+  const functions = [];
+  const classes = [];
+  for (const line of lines) {
+    const fnMatch = line.match(/(?:function|def|fn|func|async\s+function)\s+(\w+)/);
+    if (fnMatch) functions.push(fnMatch[1]);
+    const clsMatch = line.match(/(?:class|struct|interface)\s+(\w+)/);
+    if (clsMatch) classes.push(clsMatch[1]);
+  }
+
+  return { ...stats, functions: functions.slice(0, 20), classes: classes.slice(0, 10) };
+}
+
+const ACTIONS = {
+  async explain({ path, code, language }) {
+    const lang = language || (path ? detectLanguage(path) : 'unknown');
+    return {
+      language: lang,
+      hint: 'To get a full explanation, send this code to XiaoZhi with: "Explain this code: <code>"',
+      metadata: path ? { file: path } : null,
+    };
+  },
+
+  async analyze({ path }) {
+    if (!path) throw new Error('path required');
+    const abs = safePath(path);
+    const content = await readFile(abs, 'utf-8');
+    const lang = detectLanguage(abs);
+    return { file: abs, ...analyzeCode(content, lang) };
+  },
+
+  async detectLanguage({ path }) {
+    if (!path) throw new Error('path required');
+    return { file: path, language: detectLanguage(path) };
+  },
+
+  async summarize({ path }) {
+    if (!path) throw new Error('path required');
+    const abs = safePath(path);
+    const content = await readFile(abs, 'utf-8');
+    const lang = detectLanguage(abs);
+    const analysis = analyzeCode(content, lang);
+    const firstLine = content.split('\n').find(l => l.trim() && !l.trim().startsWith('#!'));
+    return {
+      file: abs,
+      language: lang,
+      summary: `${analysis.totalLines} lines, ${analysis.functions.length} functions, ${analysis.classes.length} classes`,
+      firstLine: firstLine?.trim().slice(0, 100),
+      stats: analysis,
+    };
+  },
+
+  async diff({ file1, file2 }) {
+    if (!file1 || !file2) throw new Error('file1 and file2 required');
+    const c1 = (await readFile(safePath(file1), 'utf-8')).split('\n');
+    const c2 = (await readFile(safePath(file2), 'utf-8')).split('\n');
+    const changes = [];
+    const maxLen = Math.max(c1.length, c2.length);
+    for (let i = 0; i < maxLen; i++) {
+      if (c1[i] !== c2[i]) {
+        changes.push({ line: i + 1, file1: c1[i] || '(EOF)', file2: c2[i] || '(EOF)' });
+      }
+    }
+    return { file1, file2, differences: changes.length, changes: changes.slice(0, 50) };
+  },
+};
+
+export default {
+  name: 'ai',
+  description: 'Code analysis: explain, analyze, detectLanguage, summarize, diff (local helpers)',
+  actions: Object.keys(ACTIONS).map(name => ({ name })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: Object.keys(ACTIONS) },
+      path: { type: 'string', description: 'File path' },
+      code: { type: 'string', description: 'Code snippet' },
+      language: { type: 'string', description: 'Programming language' },
+      file1: { type: 'string', description: 'First file (for diff)' },
+      file2: { type: 'string', description: 'Second file (for diff)' },
+    },
+    required: ['action'],
+  },
+  async handler({ action, ...params }) {
+    if (!ACTIONS[action]) throw new Error(`Unknown action: ${action}. Use: ${Object.keys(ACTIONS).join(', ')}`);
+    return ACTIONS[action](params);
+  },
+};

package/src/tools/config.js

@@ -0,0 +1,87 @@
+/**
+ * Config Tool — runtime configuration management (1 MCP tool, 4 actions)
+ * Actions: get, set, list, reset
+ */
+import { getConfig, saveConfig } from '../core/config.js';
+import { log } from '../core/logger.js';
+
+const EDITABLE = ['tools.shell_timeout', 'tools.max_output', 'tools.auto_format', 'agent.workspace'];
+
+function getNested(obj, path) {
+  return path.split('.').reduce((o, k) => o?.[k], obj);
+}
+
+function setNested(obj, path, value) {
+  const keys = path.split('.');
+  const last = keys.pop();
+  const target = keys.reduce((o, k) => o[k] = o[k] || {}, obj);
+  target[last] = value;
+}
+
+const ACTIONS = {
+  get: {
+    required: ['key'],
+    handler: async ({ key }) => {
+      const config = getConfig();
+      const value = getNested(config, key);
+      if (value === undefined) throw new Error(`Config key not found: ${key}`);
+      return { key, value };
+    },
+  },
+
+  set: {
+    required: ['key', 'value'],
+    handler: async ({ key, value }) => {
+      if (!EDITABLE.includes(key)) throw new Error(`Cannot edit: ${key}. Editable: ${EDITABLE.join(', ')}`);
+      const config = getConfig();
+      setNested(config, key, value);
+      await saveConfig(config._root, config);
+      log('config', `⚙️ Set ${key} = ${value}`);
+      return { key, value, saved: true };
+    },
+  },
+
+  list: {
+    required: [],
+    handler: async () => {
+      const config = getConfig();
+      const { _root, _path, ...clean } = config;
+      return { config: clean, editable: EDITABLE };
+    },
+  },
+
+  reset: {
+    required: [],
+    handler: async () => {
+      const config = getConfig();
+      config.tools = { shell_timeout: 30000, max_output: 10000 };
+      await saveConfig(config._root, config);
+      return { reset: true };
+    },
+  },
+};
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'config',
+  description: 'Runtime config: get, set, list, reset',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: actionNames },
+      key: { type: 'string', description: 'Config key (dot notation)' },
+      value: { type: 'string', description: 'Value to set' },
+    },
+    required: ['action'],
+  },
+  async handler({ action, ...params }) {
+    const a = ACTIONS[action];
+    if (!a) throw new Error(`Unknown action: ${action}`);
+    for (const f of a.required) {
+      if (params[f] === undefined) throw new Error(`Missing required: ${f}`);
+    }
+    return a.handler(params);
+  },
+};