pelulu-cli 1.0.5 → 1.1.0

package/src/core/logger.js

@@ -1,10 +1,18 @@
 /**
- * Logger — colored terminal output with levels
+ * Logger — colored terminal output with levels + file logging
  * Supports Ink mode: when active, logs go through bus instead of console
  */
+import { writeFile, mkdir, appendFile, readdir, unlink } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+
 let _debug = false;
 let _inkMode = false;
 let _bus = null;
+let _logFile = null;
+let _logQueue = [];
+let _logTimer = null;
 
 export const COLORS = {
   reset: '\x1b[0m',
@@ -35,9 +43,82 @@ export function setDebug(enabled) { _debug = enabled; }
 export function isDebug() { return _debug; }
 export function debug(msg, data) { log('debug', msg, data); }
 
+/**
+ * Initialize file logging
+ * Deletes old logs, keeps only the latest one
+ */
+export async function initFileLog(root, appName = 'pelulu') {
+  const logDir = join(root, 'logs');
+  await mkdir(logDir, { recursive: true });
+
+  // Delete old log files
+  try {
+    const files = await readdir(logDir);
+    for (const f of files) {
+      if (f.endsWith('.log')) {
+        await unlink(join(logDir, f)).catch(() => {});
+      }
+    }
+  } catch {}
+
+  const now = new Date();
+  const date = now.toISOString().slice(0, 10);
+  const time = now.toISOString().slice(11, 19).replace(/:/g, '-');
+  _logFile = join(logDir, `${appName}-${date}_${time}.log`);
+  
+  // Write header
+  const header = `═══════════════════════════════════════\n` +
+    `${appName} Log\n` +
+    `Started: ${now.toISOString()}\n` +
+    `═══════════════════════════════════════\n\n`;
+  await writeFile(_logFile, header, 'utf-8');
+  return _logFile;
+}
+
+/**
+ * Write log entry to file
+ */
+function writeToFile(level, msg, data) {
+  if (!_logFile) return;
+  
+  const ts = new Date().toISOString().slice(11, 23);
+  const icon = ICONS[level] || '';
+  let line = `${ts} ${icon} ${msg}`;
+  if (data && _debug) line += ` ${JSON.stringify(data)}`;
+  line += '\n';
+  
+  _logQueue.push(line);
+  _flushSoon();
+}
+
+/**
+ * Write raw text to log file (for AI responses, chat messages)
+ */
+export function writeRawToLog(text) {
+  if (!_logFile || !text) return;
+  const ts = new Date().toISOString().slice(11, 23);
+  _logQueue.push(`${ts} ${text}\n`);
+  _flushSoon();
+}
+
+function _flushSoon() {
+  if (_logTimer) return;
+  _logTimer = setTimeout(async () => {
+    const batch = _logQueue.join('');
+    _logQueue = [];
+    _logTimer = null;
+    try {
+      await appendFile(_logFile, batch, 'utf-8');
+    } catch {}
+  }, 500);
+}
+
 export function log(level, msg, data) {
   if (level === 'debug' && !_debug) return;
 
+  // Write to file
+  writeToFile(level, msg, data);
+
   // In Ink mode, route logs through bus so they render inside the TUI
   if (_inkMode && _bus) {
     _bus.emit('log:message', { level, msg, data });
@@ -56,6 +137,30 @@ export function log(level, msg, data) {
   if (data && _debug) console.log(`${COLORS.gray}${JSON.stringify(data, null, 2)}${COLORS.reset}`);
 }
 
+/**
+ * Flush pending logs to file
+ */
+export async function flushLogs() {
+  if (_logTimer) {
+    clearTimeout(_logTimer);
+    _logTimer = null;
+  }
+  if (_logQueue.length > 0 && _logFile) {
+    const batch = _logQueue.join('');
+    _logQueue = [];
+    try {
+      await appendFile(_logFile, batch, 'utf-8');
+    } catch {}
+  }
+}
+
+/**
+ * Get log file path
+ */
+export function getLogFile() {
+  return _logFile;
+}
+
 export function table(rows) {
   if (!rows.length) return;
   const keys = Object.keys(rows[0]);

package/src/core/system-prompt.js

@@ -1,13 +1,22 @@
 /**
  * SystemPrompt — builds context prompt for XiaoZhi LLM
- * Tells the AI what tools are available and how to use them
+ * 
+ * Now supports both legacy mode and OpenHands-style agent mode.
+ * The agent mode provides richer context and tool descriptions.
  */
 
+// Re-export from agent module for backward compatibility
+export { buildSystemPrompt as buildAgentSystemPrompt } from '../agent/system-prompt.js';
+
+/**
+ * Legacy system prompt (for direct XiaoZhi MQTT mode)
+ */
 export function buildSystemPrompt(registry, config) {
   const tools = registry.list();
+  const agentName = config.agent?.name || 'Pelulu';
   const lines = [
-    `You are ${config.agent?.name || 'a coding agent'} running in Termux/Node.js.`,
-    `You have access to ${tools.length} MCP tools. Use them to help the user.`,
+    `You are ${agentName}, an AI coding agent running in Termux/Node.js.`,
+    `You have access to ${tools.length} tools. Use them to help the user.`,
     '',
     '## Available Tools',
     '',
@@ -16,15 +25,21 @@ export function buildSystemPrompt(registry, config) {
   for (const tool of tools) {
     lines.push(`### ${tool.name}`);
     lines.push(`${tool.description}`);
-    lines.push(`Actions: ${tool.actions.join(', ')}`);
+    if (tool.actions && tool.actions.length > 0) {
+      lines.push(`Actions: ${tool.actions.map(a => typeof a === 'string' ? a : a.name).join(', ')}`);
+    }
     lines.push('');
   }
 
   lines.push('## Tool Call Format');
-  lines.push('When you need to use a tool, call it with the action and required parameters.');
-  lines.push('Example: file(action="read", path="./src/index.js")');
-  lines.push('Example: shell(action="exec", command="npm test")');
-  lines.push('Example: git(action="status")');
+  lines.push('When you need to use a tool, respond with a JSON object:');
+  lines.push('```json');
+  lines.push('{"tool": "tool_name", "action": "action_name", "param1": "value1", ...}');
+  lines.push('```');
+  lines.push('');
+  lines.push('Example: {"tool": "file", "action": "read", "path": "./src/index.js"}');
+  lines.push('Example: {"tool": "shell", "action": "exec", "command": "npm test"}');
+  lines.push('Example: {"tool": "git", "action": "status"}');
   lines.push('');
 
   lines.push('## Guidelines');
@@ -33,6 +48,7 @@ export function buildSystemPrompt(registry, config) {
   lines.push('- Run tests after making changes');
   lines.push('- Be concise in explanations');
   lines.push('- Show code changes clearly');
+  lines.push('- When done, call: {"tool": "finish", "result": "summary of what was done"}');
 
   return lines.join('\n');
 }

package/src/core/tool-registry.js

@@ -51,11 +51,19 @@ export class ToolRegistry {
   }
 
   toMcpTools() {
-    return this.all().map(t => ({
-      name: t.name,
-      description: t.description,
-      inputSchema: t.inputSchema || { type: 'object', properties: {} },
-    }));
+    return this.all().map(t => {
+      const schema = t.inputSchema || { type: 'object', properties: {} };
+      const compact = { type: 'object', properties: {} };
+      // Send all properties with type + enum only (no descriptions)
+      if (schema.properties) {
+        for (const [k, v] of Object.entries(schema.properties)) {
+          const prop = { type: v.type };
+          if (v.enum) prop.enum = v.enum;
+          compact.properties[k] = prop;
+        }
+      }
+      return { name: t.name, description: t.description, inputSchema: compact };
+    });
   }
 
   async call(name, args = {}) {

package/src/index.js

@@ -2,18 +2,24 @@
 /**
  * Pelulu CLI — Entry Point
  * Ink-based TUI with React components
+ * 
+ * Now with OpenHands-style agent capabilities:
+ * - Agent Loop (observe→think→act)
+ * - Plan Management
+ * - Enhanced Context
+ * - History Condensation
  */
 import { dirname, join } from 'path';
+import { readFile } from 'fs/promises';
 import { fileURLToPath } from 'url';
 import chalk from 'chalk';
 import { loadConfig, saveConfig } from './core/config.js';
-import { log, setDebug } from './core/logger.js';
+import { log, setDebug, debug, setInkMode, initFileLog, flushLogs, getLogFile, writeRawToLog } from './core/logger.js';
 import { bus } from './core/event-bus.js';
 import { ToolRegistry } from './core/tool-registry.js';
 import { Sandbox } from './core/sandbox.js';
 import { SessionState } from './core/session.js';
 import { Stats } from './core/stats.js';
-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';
@@ -28,15 +34,19 @@ import { MessageSender } from './mcp/message-sender.js';
 import { WssEndpoint } from './mcp/wss-endpoint.js';
 import { PluginManager } from './plugins/manager.js';
 import { checkForUpdates } from './core/update-checker.js';
-import { renderUpdateNotification, renderAsciiBanner } from './tui/renderer.js';
+import { renderUpdateNotification, renderPostUpdate, renderAsciiBanner } from './tui/renderer.js';
 import { startInkTUI } from './tui/ink-entry.js';
 
+// Import new agent system
+import { AgentController } from './agent/agent-controller.js';
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = join(__dirname, '..');
 
 const args = process.argv.slice(2);
 if (args.includes('--debug')) setDebug(true);
 const LIST_TOOLS = args.includes('--list-tools');
+const NO_AGENT = args.includes('--no-agent');
 
 async function main() {
   // Buffer ALL startup logs for Ink to display inside TUI
@@ -47,11 +57,32 @@ async function main() {
   // 1. Load config
   const config = await loadConfig(ROOT);
 
-  // 2. Check for updates — block if outdated
+  // 1b. Initialize file logging (deletes old logs, keeps only latest)
+  const appName = config.agent?.name?.toLowerCase().replace(/\s+/g, '-') || 'pelulu';
+  const logFile = await initFileLog(ROOT, appName);
+  debug('init', `Log file: ${logFile}`);
+
+  // 1c. Enable Ink mode early — route ALL logs through bus (no console.log leak)
+  if (process.stdin.isTTY) {
+    setInkMode(true, bus);
+  }
+
+  // 2. Auto-update — silently install latest if outdated
   const update = await checkForUpdates(ROOT);
   if (update.available) {
-    renderUpdateNotification(update);
-    process.exit(1);
+    const pkgName = await (async () => {
+      try { return JSON.parse(await readFile(join(ROOT, 'package.json'), 'utf-8')).name; } catch { return 'pelulu-cli'; }
+    })();
+    try {
+      const { execSync } = await import('child_process');
+      execSync(`npm install -g ${pkgName}@latest`, { stdio: 'ignore' });
+      renderPostUpdate(pkgName, update.remote);
+      process.exit(0);
+    } catch (e) {
+      console.error(chalk.red(`  ✗ Update failed: ${e.message}`));
+      console.log(chalk.gray(`  Run manually: npm install -g ${pkgName}@latest`));
+      process.exit(1);
+    }
   }
 
   // 3. Workspace & wizard
@@ -61,8 +92,11 @@ async function main() {
     await runWizard(ROOT);
   }
 
-  // Show ASCII banner before Ink takes over
-  renderAsciiBanner(config.agent?.version);
+  // Banner is now a React component inside Ink TUI (AsciiBanner)
+  // Only render console banner for fallback REPL (non-TTY)
+  if (!process.stdin.isTTY) {
+    await renderAsciiBanner();
+  }
 
   // Redirect console.log to buffer — everything after this goes into Ink
   console.log = bufferLog;
@@ -95,7 +129,6 @@ async function main() {
 
   // 6. Build context & system prompt
   const context = await buildContext();
-  const systemPrompt = buildSystemPrompt(registry, config);
 
   // 7. Connect to XiaoZhi
   const mqtt = new MqttClient(config);
@@ -125,14 +158,27 @@ async function main() {
   // 8. Message sender
   const sender = new MessageSender(mqtt);
 
-  // 9. Register MCP tool handler
+  // 9. Initialize Agent Controller (OpenHands-style)
+  let agentController = null;
+  if (!NO_AGENT) {
+    agentController = new AgentController({
+      registry,
+      mqtt,
+      sandbox,
+      confirm: { isDestructive, ask: askConfirmation },
+      config,
+    });
+
+    startupLogs.push(chalk.green('  ✓ Agent system initialized'));
+    startupLogs.push(chalk.gray(`    - Max iterations: ${config.agent?.max_iterations || 50}`));
+    startupLogs.push(chalk.gray(`    - Max input: 70 chars`));
+    startupLogs.push(chalk.gray(`    - Log: ${getLogFile()}`));
+  }
+
+  // 10. Register MCP tool handler (for XiaoZhi direct tool calls)
+  // Agent calls are auto-approved — XiaoZhi controls the flow, no y/N prompts
   mqtt.registerToolHandler(
     async (name, args) => {
-      const destructive = isDestructive(name, args);
-      if (destructive.destructive) {
-        const ok = await askConfirmation(name, args, destructive);
-        if (!ok) return { isError: true, content: [{ type: 'text', text: 'Cancelled by user' }] };
-      }
       sandbox.validate(name, args);
 
       thinking.set('tool_call');
@@ -158,7 +204,7 @@ async function main() {
     () => registry.toMcpTools()
   );
 
-  // 10. Optional WSS endpoint
+  // 11. Optional WSS endpoint
   let wss = null;
   if (config.mcp?.endpoint_url) {
     wss = new WssEndpoint(config.mcp.endpoint_url, () => registry.toMcpTools(), async (name, args) => {
@@ -168,25 +214,39 @@ async function main() {
     wss.start();
   }
 
-  // 11. Track conversation
-  bus.on('user:text', (text) => session.addUserMessage(text));
-  bus.on('llm:text', (text) => session.addAiMessage(text));
+  // 12. Track conversation + log AI responses
+  bus.on('user:text', (text) => {
+    session.addUserMessage(text);
+    writeRawToLog(`[USER] ${text}`);
+  });
+  bus.on('llm:text', (text) => {
+    session.addAiMessage(text);
+    writeRawToLog(`[AI] ${text}`);
+  });
+  bus.on('tts:sentence', (text) => {
+    writeRawToLog(`[AI-TTS] ${text}`);
+  });
 
-  // 12. Save config
+  // 13. Save config
   await saveConfig(ROOT, config);
 
-  // 13. Start Ink TUI
+  // 14. Start Ink TUI
   const { unmount, waitUntilExit } = startInkTUI({
     registry, mqtt, stats, session, bus, config,
-    extras: { fileTracker, thinking, sender, autoFormat, startupLogs },
+    extras: {
+      fileTracker, thinking, sender, autoFormat, startupLogs,
+      agentController, // Pass agent controller to TUI
+    },
   });
 
   // Graceful shutdown
   const shutdown = async () => {
     unmount();
+    if (agentController) agentController.abort();
     if (wss) wss.stop();
     await registry.shutdown();
     mqtt.disconnect();
+    await flushLogs();
     process.exit(0);
   };
   process.on('SIGINT', shutdown);

package/src/mcp/mcp-handler.js

@@ -43,7 +43,7 @@ export class McpHandler {
           result: {
             protocolVersion: PROTOCOL_VERSION,
             capabilities: { tools: {} },
-            serverInfo: { name: 'coding-agent', version: '1.0.0' },
+            serverInfo: { name: 'shellulu', version: '1.0.0' },
           },
         },
       });
@@ -61,7 +61,7 @@ export class McpHandler {
       const tools = (this.#toolsFn?.() || []).map(t => {
         const safeName = this._sanitize(t.name);
         this.#nameMap.set(safeName, t.name);
-        return { name: safeName, description: t.description, inputSchema: t.inputSchema || { type: 'object', properties: {} } };
+        return this._optimizeTool({ name: safeName, description: t.description, inputSchema: t.inputSchema || { type: 'object', properties: {} } });
       });
       responses.push({ type: 'mcp', payload: { jsonrpc: '2.0', id: p.id, result: { tools } } });
       log('mcp', `Sent ${tools.length} tools`);
@@ -89,4 +89,31 @@ export class McpHandler {
   _sanitize(name) {
     return String(name).replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
   }
+
+  /**
+   * Optimize tool definition to stay under 8KB MQTT broker limit
+   * - Keep descriptions (truncated to 200 chars)
+   * - Keep enum values (critical for XiaoZhi to know valid actions)
+   * - Keep required fields (critical for XiaoZhi to know what's mandatory)
+   */
+  _optimizeTool(tool) {
+    const optimized = {
+      name: tool.name,
+      description: tool.description?.slice(0, 100) || '',
+      inputSchema: { type: 'object', properties: {} }
+    };
+
+    // Keep first 4 properties only (to stay under 8KB MQTT limit)
+    // action + first 3 params — enough for XiaoZhi to understand the tool
+    if (tool.inputSchema?.properties) {
+      const entries = Object.entries(tool.inputSchema.properties);
+      for (const [key, val] of entries.slice(0, 4)) {
+        const prop = { type: val.type };
+        if (val.enum) prop.enum = val.enum;
+        optimized.inputSchema.properties[key] = prop;
+      }
+    }
+
+    return optimized;
+  }
 }

package/src/mcp/mqtt-client.js

@@ -50,10 +50,11 @@ export class MqttClient {
         clientId: this.mqttCfg.client_id,
         username: this.mqttCfg.username,
         password: this.mqttCfg.password,
-        keepalive: 240,
+        keepalive: 60,
         reconnectPeriod: 5000,
         connectTimeout: 10000,
         clean: true,
+        protocolVersion: 4, // MQTT v3.1.1
       });
 
       this.client.on('connect', () => {
@@ -82,6 +83,7 @@ export class MqttClient {
       type: 'hello', version: 3, transport: 'udp',
       features: { mcp: true },
       audio_params: { format: 'opus', sample_rate: 16000, channels: 1, frame_duration: 60 },
+      system_prompt: 'You are a coding assistant. When the user asks to create, write, or edit files, you MUST use the file tool with appropriate action (write/edit/mkdir). Always use tools to complete tasks. Do not just describe what to do — actually do it using the tools.',
     }));
   }
 
@@ -112,9 +114,19 @@ export class MqttClient {
       if (r.type === 'mcp') { this._send(r); }
       else if (r.type === 'tool_call') {
         log('tool', r.name);
+        // Emit tool call event so agent can track it
+        bus.emit('mcp:tool_call', { name: r.name, args: r.args, id: r.id });
         this.mcp.executeTool(r.name, r.args)
-          .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 } } }); });
+          .then(result => {
+            log('tool', result.isError ? 'failed' : 'done');
+            this._send({ type: 'mcp', payload: { jsonrpc: '2.0', id: r.id, result } });
+            // Emit tool result event
+            bus.emit('mcp:tool_result', { name: r.name, args: r.args, result, id: r.id });
+          })
+          .catch(err => {
+            this._send({ type: 'mcp', payload: { jsonrpc: '2.0', id: r.id, result: { content: [{ type: 'text', text: err.message }], isError: true } } });
+            bus.emit('mcp:tool_result', { name: r.name, args: r.args, result: { isError: true, content: [{ type: 'text', text: err.message }] }, id: r.id });
+          });
       }
     }
     if (this.mcp.toolsReceived && this._helloQueue.length) {

package/src/tools/agent.js

@@ -0,0 +1,80 @@
+/**
+ * Agent Tool — Expose agent capabilities (1 MCP tool, 5 actions)
+ * Actions: run, status, abort, reset, context
+ */
+import { bus } from '../core/event-bus.js';
+
+let agentController = null;
+
+export function setAgentController(controller) {
+  agentController = controller;
+}
+
+const ACTIONS = {
+  run: {
+    required: ['task'],
+    handler: async ({ task }) => {
+      if (!agentController) throw new Error('Agent not initialized');
+      const result = await agentController.run(task, { generatePlan: false });
+      return { success: result.success, result: result.result, iterations: result.iterations };
+    },
+  },
+
+  status: {
+    required: [],
+    handler: async () => {
+      if (!agentController) throw new Error('Agent not initialized');
+      return agentController.summary;
+    },
+  },
+
+  abort: {
+    required: [],
+    handler: async () => {
+      if (!agentController) throw new Error('Agent not initialized');
+      agentController.abort();
+      return { aborted: true };
+    },
+  },
+
+  reset: {
+    required: [],
+    handler: async () => {
+      if (!agentController) throw new Error('Agent not initialized');
+      agentController.reset();
+      return { reset: true };
+    },
+  },
+
+  context: {
+    required: [],
+    handler: async () => {
+      if (!agentController) throw new Error('Agent not initialized');
+      return { context: await agentController.getContext() };
+    },
+  },
+};
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'agent',
+  description: 'Agent: run task, status, abort, reset, context',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string' },
+      task: { type: 'string' },
+    },
+    required: ['action'],
+  },
+  async handler({ action, ...params }) {
+    const a = ACTIONS[action];
+    if (!a) throw new Error(`Unknown: ${action}. Use: ${actionNames.join(', ')}`);
+    for (const f of a.required) {
+      if (params[f] === undefined) throw new Error(`Missing: ${f}`);
+    }
+    return a.handler(params);
+  },
+};