pelulu-cli 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pelulu-cli",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "CLI coding agent powered by XiaoZhi AI — a tiny Chinese LLM that lives in ESP32 chips",
   "type": "module",
   "main": "src/index.js",
@@ -27,13 +27,13 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/chaerulchas/Pelulu-CLI.git"
+    "url": "git+https://github.com/venenapro/Pelulu-CLI.git"
   },
   "bugs": {
-    "url": "https://github.com/chaerulchas/Pelulu-CLI/issues"
+    "url": "https://github.com/venenapro/Pelulu-CLI/issues"
   },
-  "homepage": "https://github.com/chaerulchas/Pelulu-CLI#readme",
-  "author": "chaerulchas",
+  "homepage": "https://github.com/venenapro/Pelulu-CLI#readme",
+  "author": "venenapro",
   "license": "MIT",
   "dependencies": {
     "chalk": "^5.3.0",
@@ -44,5 +44,8 @@
   },
   "engines": {
     "node": ">=18"
+  },
+  "devDependencies": {
+    "ink-testing-library": "^4.0.0"
   }
 }

package/src/agent/agent-controller.js

@@ -22,7 +22,12 @@ export class AgentController {
     this.#sandbox = sandbox;
     this.#confirm = confirm;
     this.#config = config;
-    this.#loop = new AgentLoop({ maxIterations: config.agent?.max_iterations || 50 });
+    this.#loop = new AgentLoop({
+      maxIterations: config.agent?.max_iterations || 50,
+      idleTimeoutMs: config.agent?.response_idle_ms || 45000,
+      quietMs: config.agent?.reply_quiet_ms || 2500,
+      postToolGraceMs: config.agent?.post_tool_grace_ms || 9000,
+    });
     this.#llm = new LLMClient(mqtt);
     this.#contextBuilder = new ContextBuilder();
   }

package/src/agent/agent-loop.js

@@ -1,9 +1,17 @@
 /**
  * AgentLoop — Core observe→think→act cycle
- * 
- * Handles:
- * - Plain text responses from XiaoZhi (via llm:text)
- * - MCP tool calls from XiaoZhi (via mcp:tool_call)
+ *
+ * Handles the THREE ways XiaoZhi actually talks back:
+ * - Spoken replies via `tts:sentence`  ← this is the PRIMARY reply channel
+ * - Plain text replies via `llm:text`  ← rarely used, but supported
+ * - MCP tool calls via `mcp:tool_call`
+ *
+ * Turn completion is activity-aware: the loop treats text/speech/tool events as
+ * liveness and only considers the turn finished after a short quiet period, so
+ * multi-step builds (write several files, then a spoken "done") no longer look
+ * like a timeout. Previously the loop ignored `tts:sentence` entirely, so after
+ * a tool ran it waited out the full timeout and reported "XiaoZhi not
+ * responding" even though XiaoZhi had already answered by voice.
  */
 import { bus } from '../core/event-bus.js';
 import { debug } from '../core/logger.js';
@@ -22,9 +30,21 @@ export class AgentLoop {
   #maxIterations;
   #abortController = null;
   #history = [];
+  #idleTimeoutMs;
+  #quietMs;
+  #postToolGraceMs;
 
-  constructor({ maxIterations = 50 } = {}) {
+  constructor({ maxIterations = 50, idleTimeoutMs = 45000, quietMs = 2500, postToolGraceMs = 9000 } = {}) {
     this.#maxIterations = maxIterations;
+    // Hard cap: reject only if NOTHING at all (text, speech, tool) arrives for
+    // this long. Reset on every event, so long multi-tool turns stay alive.
+    this.#idleTimeoutMs = idleTimeoutMs;
+    // A spoken/text reply is considered complete after this much silence.
+    this.#quietMs = quietMs;
+    // After the last tool result, how long to wait for XiaoZhi to either run
+    // another tool or speak before concluding the turn as "tools done, no
+    // verbal reply". Keeps a silent voice model from hanging the whole turn.
+    this.#postToolGraceMs = postToolGraceMs;
   }
 
   get state() { return this.#state; }
@@ -39,106 +59,35 @@ export class AgentLoop {
   }
 
   /**
-   * Run agent loop for a user prompt
+   * Run one user turn.
+   *
+   * IMPORTANT — architecture: XiaoZhi is the MCP *client* and drives its own
+   * server-side think→act loop. Our CLI is the MCP *server*: `mqtt-client.js`
+   * already receives each `tools/call`, executes it, and returns the result to
+   * XiaoZhi automatically. So this loop must NOT drive tool execution or wait
+   * for tools in lock-step. It is a single, persistent OBSERVER of the whole
+   * turn's event stream. Oscillating between "wait for text" and "wait for tool
+   * result" phases (the old design) meant the final `tts:sentence` reply landed
+   * in a gap where nothing was listening — which is exactly why the turn hung
+   * and reported "XiaoZhi not responding" after files were read.
    */
-  async run(userPrompt, { llm, tools, sandbox, confirm }) {
+  async run(userPrompt, { llm } = {}) {
     this.#iteration = 0;
     this.#abortController = new AbortController();
     this.#history = [{ role: 'user', content: userPrompt, ts: Date.now() }];
-    this._promptSent = false;
 
-    try {
-      // Send prompt only once at the start
-      await this.#sendOnce(llm);
-
-      while (this.#iteration < this.#maxIterations) {
-        this.#iteration++;
-        this.#setState(AgentState.THINKING);
-
-        // Emit progress
-        bus.emit('agent:progress', {
-          iteration: this.#iteration,
-          maxIterations: this.#maxIterations,
-          state: 'thinking',
-          message: `Thinking... (iteration ${this.#iteration})`,
-        });
-
-        if (this.#abortController.signal.aborted) {
-          this.#setState(AgentState.FINISHED);
-          return { success: true, result: 'Aborted', iterations: this.#iteration };
-        }
-
-        // Wait for response (text or tool call) — does NOT send prompt again
-        let response;
-        try {
-          response = await this.#waitForResponse();
-        } catch (err) {
-          if (err.message.includes('Timeout')) {
-            bus.emit('agent:progress', {
-              iteration: this.#iteration,
-              state: 'timeout',
-              message: 'XiaoZhi not responding, retrying...',
-            });
-            try {
-              response = await this.#waitForResponse();
-            } catch (err2) {
-              this.#setState(AgentState.FINISHED);
-              return { success: false, result: 'Timeout: XiaoZhi did not respond after 2 attempts', iterations: this.#iteration };
-            }
-          } else {
-            throw err;
-          }
-        }
-
-        if (!response) {
-          this.#setState(AgentState.FINISHED);
-          return { success: false, result: 'No response', iterations: this.#iteration };
-        }
-
-        // Handle text response (final answer)
-        if (response.type === 'text') {
-          this.#history.push({ role: 'assistant', content: response.content, ts: Date.now() });
-          this.#setState(AgentState.FINISHED);
-          bus.emit('agent:progress', {
-            iteration: this.#iteration,
-            state: 'done',
-            message: 'Done!',
-          });
-          return { success: true, result: response.content, iterations: this.#iteration };
-        }
-
-        // Handle tool call — wait for MQTT client to execute it, don't double-execute
-        if (response.type === 'tool_call') {
-          this.#setState(AgentState.ACTING);
-          
-          bus.emit('agent:progress', {
-            iteration: this.#iteration,
-            state: 'tool',
-            tool: response.name,
-            action: response.args?.action,
-            message: `Executing ${response.name}.${response.args?.action || ''}...`,
-          });
-
-          // Wait for the tool result from MQTT client (already executed there)
-          const result = await this.#waitForToolResult(response);
-          
-          this.#history.push({ role: 'tool', name: response.name, content: JSON.stringify(result), ts: Date.now() });
-          
-          bus.emit('agent:progress', {
-            iteration: this.#iteration,
-            state: 'tool_done',
-            tool: response.name,
-            message: `${response.name} done, waiting for next response...`,
-          });
-
-          debug('agent', `Tool done, waiting for next response...`);
-        }
-      }
+    this.#setState(AgentState.THINKING);
+    bus.emit('agent:progress', { state: 'thinking', message: 'Thinking...' });
 
+    try {
+      const outcome = await this.#observeTurn(llm, userPrompt);
       this.#setState(AgentState.FINISHED);
-      return { success: false, result: `Max iterations (${this.#maxIterations}) reached`, iterations: this.#iteration };
-
+      return outcome;
     } catch (err) {
+      if (err.message === 'AbortError') {
+        this.#setState(AgentState.FINISHED);
+        return { success: true, result: 'Aborted', iterations: this.#iteration };
+      }
       this.#setState(AgentState.ERROR);
       bus.emit('agent:error', { error: err.message, iteration: this.#iteration });
       return { success: false, result: `Error: ${err.message}`, iterations: this.#iteration };
@@ -150,127 +99,150 @@ export class AgentLoop {
   }
 
   /**
-   * Send prompt to XiaoZhi — only once per run
+   * Observe a full turn with ONE set of listeners that stay attached from the
+   * moment the prompt is sent until the turn settles. Nothing is ever missed
+   * between tool calls.
+   *
+   * Completion rules (whichever fires first):
+   *   - Spoken/text reply settles: buffer got text, then went quiet for
+   *     #quietMs, and no tool call is in flight → success with the reply.
+   *   - Tools finished silently: XiaoZhi ran tools and produced no verbal
+   *     reply within #postToolGraceMs of the last result → success, reported
+   *     as the tool activity (prevents the long hang the user was seeing).
+   *   - Hard idle: absolutely nothing (text, speech, tool call, tool result)
+   *     for #idleTimeoutMs → treated as a stalled turn.
    */
-  async #sendOnce(llm) {
-    if (this._promptSent) return;
-    this._promptSent = true;
-    debug('agent', `Sending prompt: ${this.#history[0].content}`);
-    await llm.sendPrompt(this.#history[0].content);
-  }
-
-  /**
-   * Wait for response from XiaoZhi (text or MCP tool call)
-   * Does NOT send prompt — that's done once in #sendOnce
-   */
-  #waitForResponse() {
+  #observeTurn(llm, userPrompt) {
     return new Promise((resolve, reject) => {
-      let resolved = false;
+      let settled = false;
       let buffer = '';
-      let timer = null;
-      let gotToolCall = false;
-
+      let pendingTools = 0;   // tool calls started but not yet resulted
+      let toolsRun = 0;       // total tool calls seen this turn
+      let lastTool = null;    // name of the most recent tool
+      let quietTimer = null;  // fires when a verbal reply goes quiet
+      let graceTimer = null;  // fires when tools finish with no verbal reply
+      let idleTimer = null;   // hard "nothing at all is happening" cap
+
+      const clearTimers = () => {
+        clearTimeout(quietTimer); clearTimeout(graceTimer); clearTimeout(idleTimer);
+      };
       const cleanup = () => {
-        if (timer) clearTimeout(timer);
+        clearTimers();
         bus.off('llm:text', onText);
-        bus.off('mcp:tool_call', onTool);
+        bus.off('tts:sentence', onText);
+        bus.off('mcp:tool_call', onToolCall);
+        bus.off('mcp:tool_result', onToolResult);
       };
 
-      const onText = (text) => {
-        if (resolved || gotToolCall) return;
-        buffer += text;
-        
-        bus.emit('agent:progress', {
-          state: 'receiving',
-          message: `Receiving: ${buffer.length} chars...`,
-        });
+      const finish = (outcome) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        bus.emit('agent:progress', { state: 'done', message: 'Done!' });
+        resolve(outcome);
+      };
 
-        if (timer) clearTimeout(timer);
-        timer = setTimeout(() => {
-          if (!resolved && !gotToolCall && buffer) {
-            resolved = true;
-            cleanup();
-            resolve({ type: 'text', content: buffer.trim() });
-          }
-        }, 2000);
+      const finishWithText = () => {
+        if (pendingTools > 0) return; // a tool is still running; not done yet
+        const content = buffer.trim();
+        if (!content) return;
+        this.#history.push({ role: 'assistant', content, ts: Date.now() });
+        finish({ success: true, result: content, iterations: this.#iteration });
       };
 
-      const onTool = (data) => {
-        if (resolved) return;
-        gotToolCall = true;
-        resolved = true;
-        cleanup();
-        resolve({ type: 'tool_call', ...data });
+      const finishSilentTools = () => {
+        if (settled || pendingTools > 0 || buffer.trim()) return;
+        const summary = `Completed ${toolsRun} tool ${toolsRun === 1 ? 'action' : 'actions'}${lastTool ? ` (last: ${lastTool})` : ''}.`;
+        this.#history.push({ role: 'assistant', content: summary, ts: Date.now() });
+        finish({ success: true, result: summary, iterations: this.#iteration });
       };
 
-      // Timeout after 60s
-      const timeout = setTimeout(() => {
-        if (!resolved) {
-          resolved = true;
+      // Reset the hard idle cap on every sign of life.
+      const armIdle = () => {
+        clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+          if (settled) return;
+          if (buffer.trim()) { finishWithText(); return; }
+          if (toolsRun > 0) { finishSilentTools(); return; }
+          settled = true;
           cleanup();
           reject(new Error('Timeout: XiaoZhi not responding'));
-        }
-      }, 60000);
-
-      // Abort handler
-      this.#abortController.signal.addEventListener('abort', () => {
-        if (!resolved) {
-          resolved = true;
-          cleanup();
-          clearTimeout(timeout);
-          reject(new Error('AbortError'));
-        }
-      }, { once: true });
+        }, this.#idleTimeoutMs);
+      };
 
-      bus.on('llm:text', onText);
-      bus.on('mcp:tool_call', onTool);
-    });
-  }
+      const onText = (text) => {
+        if (settled || typeof text !== 'string') return;
+        buffer += (buffer ? ' ' : '') + text;
+        clearTimeout(graceTimer); // a verbal reply supersedes the silent-tool path
+        armIdle();
+        bus.emit('agent:progress', { state: 'receiving', message: `Receiving ${buffer.length} chars...` });
+        clearTimeout(quietTimer);
+        quietTimer = setTimeout(finishWithText, this.#quietMs);
+      };
 
-  /**
-   * Wait for tool result from MQTT client (avoids double-execution)
-   * Falls back to direct execution if MQTT doesn't respond in time
-   */
-  #waitForToolResult(call) {
-    return new Promise((resolve) => {
-      let resolved = false;
+      const onToolCall = ({ name, args }) => {
+        if (settled) return;
+        pendingTools++;
+        toolsRun++;
+        lastTool = name;
+        this.#iteration++;
+        this.#setState(AgentState.ACTING);
+        // Text spoken BEFORE a tool call is just "thinking out loud" filler
+        // (e.g. "% file...") — the real answer is what XiaoZhi says after the
+        // tools finish. Drop the filler so the final result is clean.
+        buffer = '';
+        clearTimeout(quietTimer); // don't finish text while a tool is running
+        clearTimeout(graceTimer);
+        armIdle();
+        bus.emit('agent:progress', {
+          state: 'tool', tool: name, action: args?.action,
+          iteration: this.#iteration,
+          message: `Running ${name}${args?.action ? '.' + args.action : ''}...`,
+        });
+      };
 
-      const onResult = ({ name, args, result }) => {
-        if (resolved) return;
-        if (name === call.name && args?.action === call.args?.action) {
-          resolved = true;
-          bus.off('mcp:tool_result', onResult);
-          clearTimeout(fallbackTimer);
-          debug('agent', `Got tool result from MQTT: ${name}`);
-          resolve(result);
+      const onToolResult = ({ name, result }) => {
+        if (settled) return;
+        if (pendingTools > 0) pendingTools--;
+        this.#history.push({ role: 'tool', name, content: JSON.stringify(result), ts: Date.now() });
+        this.#setState(AgentState.THINKING);
+        armIdle();
+        bus.emit('agent:progress', {
+          state: 'tool_done', tool: name,
+          message: `${name} done${result?.isError ? ' (error)' : ''}, waiting for next step...`,
+        });
+        if (pendingTools === 0) {
+          // All in-flight tools are done. Give XiaoZhi a grace window to either
+          // fire another tool call or speak a final reply. If it stays silent,
+          // conclude the turn instead of hanging until the idle timeout.
+          clearTimeout(graceTimer);
+          graceTimer = setTimeout(finishSilentTools, this.#postToolGraceMs);
         }
       };
 
-      // Fallback: if MQTT doesn't respond in 10s, execute directly
-      const fallbackTimer = setTimeout(async () => {
-        if (resolved) return;
-        resolved = true;
-        bus.off('mcp:tool_result', onResult);
-        debug('agent', `Tool result timeout, executing directly: ${call.name}`);
-        try {
-          const result = await this.#execToolDirect(call);
-          resolve(result);
-        } catch (err) {
-          resolve({ isError: true, content: [{ type: 'text', text: err.message }] });
-        }
-      }, 10000);
+      this.#abortController.signal.addEventListener('abort', () => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(new Error('AbortError'));
+      }, { once: true });
 
-      bus.on('mcp:tool_result', onResult);
+      bus.on('llm:text', onText);
+      bus.on('tts:sentence', onText);
+      bus.on('mcp:tool_call', onToolCall);
+      bus.on('mcp:tool_result', onToolResult);
+
+      armIdle();
+
+      // Send the prompt exactly once, after listeners are attached so we never
+      // miss an immediate reply.
+      debug('agent', `Sending prompt: ${userPrompt}`);
+      Promise.resolve(llm?.sendPrompt(userPrompt)).catch((err) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      });
     });
   }
-
-  /**
-   * Direct tool execution (fallback only)
-   */
-  async #execToolDirect(call) {
-    return { isError: true, content: [{ type: 'text', text: 'Tool execution via MQTT timed out' }] };
-  }
-
-  // Tool execution removed — handled by MQTT client
-  // Agent loop only waits for results via mcp:tool_result events
 }

package/src/agent/llm-client.js

@@ -20,18 +20,12 @@ export class LLMClient {
    */
   async #waitForReady() {
     if (this.#mqtt.mcp?.toolsReceived && this.#mqtt.sessionId) return;
-    debug('llm', 'Waiting for MCP handshake...');
-    await new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => reject(new Error('MCP handshake timeout')), 30000);
-      const check = setInterval(() => {
-        if (this.#mqtt.mcp?.toolsReceived && this.#mqtt.sessionId) {
-          clearInterval(check);
-          clearTimeout(timeout);
-          debug('llm', 'MCP ready');
-          resolve();
-        }
-      }, 200);
-    });
+    debug('llm', 'Session not ready — re-establishing...');
+    // Actively re-send hello to recover from an idle `goodbye`, rather than
+    // polling for a session that will never come back on its own.
+    const ok = await this.#mqtt.ensureSession(30000);
+    if (!ok) throw new Error('MCP handshake timeout');
+    debug('llm', 'MCP ready');
   }
 
   /**

package/src/core/config.js

@@ -30,7 +30,7 @@ let _config = null;
 export async function loadConfig(root) {
   const path = join(root, CONFIG_FILE);
   const defaults = {
-    agent: { name: 'Pelulu CLI', version: '1.0.0', workspace: '~/Pelulu-CLI' },
+    agent: { name: 'Pelulu CLI', version: '1.1.0', workspace: '~/Pelulu-CLI' },
     mqtt: { ota_url: 'https://api.tenclass.net/xiaozhi/ota/', keepalive: 240 },
     mcp: { endpoint_url: '' },
     tools: { shell_timeout: 30000, max_output: 10000, auto_format: true },