pelulu-cli 1.0.5 → 1.2.0

package/CHANGELOG.md

@@ -0,0 +1,81 @@
+# Changelog
+
+All notable changes to **Pelulu CLI** will be documented in this file.
+
+## [1.1.0] - 2026-07-21
+
+### Fixed
+- **MQTT disconnect loop** — `tools/list` response exceeded 8KB broker limit, now optimized to ~4KB
+- **Agent sends prompt before session ready** — `LLMClient` now waits for MCP handshake + session before sending
+- **Double tool execution** — agent loop no longer re-executes tools already handled by MQTT client
+- **Prompt sent multiple times** — agent loop now sends prompt only once per run
+- **AI responses not in log file** — added `llm:text` and `tts:sentence` event logging
+- **Log files accumulate** — old logs deleted on startup, only latest kept
+- **y/N confirmation prompt flashing** — agent tool calls auto-approved (no more UI glitches)
+- **Version mismatch** — version now read from `package.json` (auto-sync)
+
+### Changed
+- **Statusbar redesigned** — clean minimal layout: `🐱 PELULU ● online  session:xxx  xiaozhi.me`
+- **Tool schema optimization** — `action` enum preserved, first 4 properties sent (under 8KB)
+- **System prompt added to hello message** — tells XiaoZhi to use tools instead of just chatting
+
+## [1.0.5] - 2026-07-20
+
+### Added
+- File logging (`logs/` directory)
+- Char counter on TUI input (70 char limit)
+- Scrollable chat (Shift+Up/Down, PgUp/PgDn)
+
+### Fixed
+- Chat limited to 12 visible lines
+- Progress feedback and timeout handling in agent loop
+
+## [1.0.4] - 2026-07-19
+
+### Changed
+- Update checker uses npm registry instead of GitHub releases
+
+### Fixed
+- Activation code displays directly to console
+
+## [1.0.3] - 2026-07-19
+
+### Fixed
+- Duplicate user messages (Enter key fired onSubmit twice)
+- TTS responses handled as assistant messages
+
+## [1.0.2] - 2026-07-18
+
+### Added
+- Cute ASCII cat banner above CLI header
+- Block CLI when update is available
+
+### Fixed
+- Redirect ALL startup logs into Ink TUI
+- Clean status bar header format
+
+## [1.0.1] - 2026-07-17
+
+### Added
+- OpenHands-style agent system (AgentLoop, AgentController, LLMClient)
+- Auto-completion with Tab key
+- Auto-format for written files
+
+### Changed
+- Replaced readline with Ink React TUI
+
+### Fixed
+- Compact banner text
+- TTY fallback for non-interactive mode
+- Log status as single-line auto-updating text
+
+## [1.0.0] - 2026-07-16
+
+### Added
+- Initial release
+- XiaoZhi AI integration via MQTT
+- MCP tool protocol support
+- 18 built-in tools (file, shell, git, project, network, etc.)
+- Interactive REPL with syntax highlighting
+- Plugin system
+- Workspace detection and context building

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "pelulu-cli",
-  "version": "1.0.5",
+  "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",
   "bin": {
-    "pelulu": "src/index.js"
+    "pelulu-cli": "src/index.js"
   },
   "scripts": {
     "start": "node src/index.js",
     "start:debug": "node src/index.js --debug",
     "start:fallback": "node src/index.js --no-ink",
+    "start:no-agent": "node src/index.js --no-agent",
     "tools": "node src/index.js --list-tools",
     "test": "node src/index.js --test"
   },
@@ -26,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",
@@ -43,5 +44,8 @@
   },
   "engines": {
     "node": ">=18"
+  },
+  "devDependencies": {
+    "ink-testing-library": "^4.0.0"
   }
 }

package/src/agent/agent-controller.js

@@ -0,0 +1,105 @@
+/**
+ * AgentController — Orchestrates the agent system
+ */
+import { AgentLoop } from './agent-loop.js';
+import { LLMClient } from './llm-client.js';
+import { ContextBuilder } from './context-builder.js';
+import { bus } from '../core/event-bus.js';
+import { debug } from '../core/logger.js';
+
+export class AgentController {
+  #loop;
+  #llm;
+  #contextBuilder;
+  #registry;
+  #sandbox;
+  #confirm;
+  #config;
+  #running = false;
+
+  constructor({ registry, mqtt, sandbox, confirm, config }) {
+    this.#registry = registry;
+    this.#sandbox = sandbox;
+    this.#confirm = confirm;
+    this.#config = config;
+    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();
+  }
+
+  get isRunning() { return this.#running; }
+
+  get summary() {
+    return {
+      state: this.#loop.state,
+      iteration: this.#loop.iteration,
+      history: this.#loop.history.length,
+      running: this.#running,
+    };
+  }
+
+  /**
+   * Run agent for a user prompt
+   */
+  async run(userPrompt, options = {}) {
+    // Validate input length
+    const MAX_LEN = 70;
+    if (userPrompt.length > MAX_LEN) {
+      throw new Error(`Input too long (${userPrompt.length}/${MAX_LEN} chars)`);
+    }
+
+    if (this.#running) {
+      this.abort();
+      await new Promise(r => setTimeout(r, 300));
+    }
+
+    this.#running = true;
+    const start = Date.now();
+
+    try {
+      debug('agent', `Running: ${userPrompt}`);
+      
+      const result = await this.#loop.run(userPrompt, {
+        llm: this.#llm,
+        tools: this.#registry,
+        sandbox: this.#sandbox,
+        confirm: this.#confirm,
+      });
+
+      result.duration = Date.now() - start;
+      debug('agent', `Done in ${result.duration}ms: ${result.success}`);
+      return result;
+
+    } finally {
+      this.#running = false;
+    }
+  }
+
+  /**
+   * Abort current run
+   */
+  abort() {
+    this.#loop.abort();
+    this.#running = false;
+    debug('agent', 'Aborted');
+  }
+
+  /**
+   * Get workspace context
+   */
+  async getContext() {
+    return this.#contextBuilder.build();
+  }
+
+  /**
+   * Reset agent state
+   */
+  reset() {
+    this.#running = false;
+  }
+}

package/src/agent/agent-loop.js

@@ -0,0 +1,248 @@
+/**
+ * AgentLoop — Core observe→think→act cycle
+ *
+ * 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';
+
+export const AgentState = {
+  IDLE: 'idle',
+  THINKING: 'thinking',
+  ACTING: 'acting',
+  FINISHED: 'finished',
+  ERROR: 'error',
+};
+
+export class AgentLoop {
+  #state = AgentState.IDLE;
+  #iteration = 0;
+  #maxIterations;
+  #abortController = null;
+  #history = [];
+  #idleTimeoutMs;
+  #quietMs;
+  #postToolGraceMs;
+
+  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; }
+  get iteration() { return this.#iteration; }
+  get history() { return [...this.#history]; }
+
+  #setState(s) {
+    const old = this.#state;
+    this.#state = s;
+    debug('agent', `${old} → ${s}`);
+    bus.emit('agent:state', { from: old, to: s });
+  }
+
+  /**
+   * 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 } = {}) {
+    this.#iteration = 0;
+    this.#abortController = new AbortController();
+    this.#history = [{ role: 'user', content: userPrompt, ts: Date.now() }];
+
+    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 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 };
+    }
+  }
+
+  abort() {
+    this.#abortController?.abort();
+  }
+
+  /**
+   * 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.
+   */
+  #observeTurn(llm, userPrompt) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let buffer = '';
+      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 = () => {
+        clearTimers();
+        bus.off('llm:text', onText);
+        bus.off('tts:sentence', onText);
+        bus.off('mcp:tool_call', onToolCall);
+        bus.off('mcp:tool_result', onToolResult);
+      };
+
+      const finish = (outcome) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        bus.emit('agent:progress', { state: 'done', message: 'Done!' });
+        resolve(outcome);
+      };
+
+      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 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 });
+      };
+
+      // 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'));
+        }, this.#idleTimeoutMs);
+      };
+
+      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);
+      };
+
+      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 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);
+        }
+      };
+
+      this.#abortController.signal.addEventListener('abort', () => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(new Error('AbortError'));
+      }, { once: true });
+
+      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)));
+      });
+    });
+  }
+}