pelulu-cli 1.0.5 → 1.1.0

package/src/agent/agent-loop.js

@@ -0,0 +1,276 @@
+/**
+ * AgentLoop — Core observe→think→act cycle
+ * 
+ * Handles:
+ * - Plain text responses from XiaoZhi (via llm:text)
+ * - MCP tool calls from XiaoZhi (via mcp:tool_call)
+ */
+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 = [];
+
+  constructor({ maxIterations = 50 } = {}) {
+    this.#maxIterations = maxIterations;
+  }
+
+  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 agent loop for a user prompt
+   */
+  async run(userPrompt, { llm, tools, sandbox, confirm }) {
+    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.FINISHED);
+      return { success: false, result: `Max iterations (${this.#maxIterations}) reached`, iterations: this.#iteration };
+
+    } catch (err) {
+      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();
+  }
+
+  /**
+   * Send prompt to XiaoZhi — only once per run
+   */
+  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() {
+    return new Promise((resolve, reject) => {
+      let resolved = false;
+      let buffer = '';
+      let timer = null;
+      let gotToolCall = false;
+
+      const cleanup = () => {
+        if (timer) clearTimeout(timer);
+        bus.off('llm:text', onText);
+        bus.off('mcp:tool_call', onTool);
+      };
+
+      const onText = (text) => {
+        if (resolved || gotToolCall) return;
+        buffer += text;
+        
+        bus.emit('agent:progress', {
+          state: 'receiving',
+          message: `Receiving: ${buffer.length} chars...`,
+        });
+
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(() => {
+          if (!resolved && !gotToolCall && buffer) {
+            resolved = true;
+            cleanup();
+            resolve({ type: 'text', content: buffer.trim() });
+          }
+        }, 2000);
+      };
+
+      const onTool = (data) => {
+        if (resolved) return;
+        gotToolCall = true;
+        resolved = true;
+        cleanup();
+        resolve({ type: 'tool_call', ...data });
+      };
+
+      // Timeout after 60s
+      const timeout = setTimeout(() => {
+        if (!resolved) {
+          resolved = 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 });
+
+      bus.on('llm:text', onText);
+      bus.on('mcp:tool_call', onTool);
+    });
+  }
+
+  /**
+   * 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 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);
+        }
+      };
+
+      // 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);
+
+      bus.on('mcp:tool_result', onResult);
+    });
+  }
+
+  /**
+   * 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/context-builder.js

@@ -0,0 +1,307 @@
+/**
+ * ContextBuilder — Enhanced workspace context (OpenHands-style)
+ * 
+ * Builds rich context about the workspace including:
+ * - Git status and history
+ * - Project type and structure
+ * - Recent files and changes
+ * - Dependencies and configuration
+ * - Runtime environment
+ */
+import { readFile, readdir, stat } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, relative, extname } from 'path';
+import { exec } from 'child_process';
+import { getConfig } from '../core/config.js';
+
+function run(cmd, cwd, timeout = 5000) {
+  return new Promise((resolve) => {
+    exec(cmd, { cwd, timeout, maxBuffer: 256 * 1024 }, (_, stdout) => resolve(stdout?.trim() || ''));
+  });
+}
+
+export class ContextBuilder {
+  #cwd;
+  #cache = new Map();
+  #cacheTTL = 30000; // 30 seconds
+
+  constructor(cwd) {
+    this.#cwd = cwd || getConfig().agent?.workspace || process.cwd();
+  }
+
+  /**
+   * Build full context
+   */
+  async build() {
+    const sections = await Promise.all([
+      this.#buildGitContext(),
+      this.#buildProjectContext(),
+      this.#buildRuntimeContext(),
+      this.#buildFileSystemContext(),
+    ]);
+
+    return sections.filter(Boolean).join('\n\n');
+  }
+
+  /**
+   * Build git context
+   */
+  async #buildGitContext() {
+    if (!existsSync(join(this.#cwd, '.git'))) return null;
+
+    const cacheKey = 'git';
+    const cached = this.#getCache(cacheKey);
+    if (cached) return cached;
+
+    const [branch, status, lastCommits, remotes] = await Promise.all([
+      run('git rev-parse --abbrev-ref HEAD', this.#cwd),
+      run('git status --porcelain', this.#cwd),
+      run('git log --oneline -5', this.#cwd),
+      run('git remote -v', this.#cwd),
+    ]);
+
+    const changes = status.split('\n').filter(Boolean);
+    const changeSummary = changes.length > 0
+      ? `${changes.length} uncommitted change(s):\n${changes.slice(0, 10).map(c => `  ${c}`).join('\n')}${changes.length > 10 ? `\n  ... and ${changes.length - 10} more` : ''}`
+      : 'Clean working tree';
+
+    const sections = [
+      `## Git`,
+      `Branch: ${branch}`,
+      changeSummary,
+    ];
+
+    if (lastCommits) {
+      sections.push(`Recent commits:\n${lastCommits}`);
+    }
+
+    if (remotes) {
+      const uniqueRemotes = [...new Set(remotes.split('\n').map(r => r.split('\t')[0]).filter(Boolean))];
+      if (uniqueRemotes.length > 0) {
+        sections.push(`Remotes: ${uniqueRemotes.join(', ')}`);
+      }
+    }
+
+    const result = sections.join('\n');
+    this.#setCache(cacheKey, result);
+    return result;
+  }
+
+  /**
+   * Build project context
+   */
+  async #buildProjectContext() {
+    const cacheKey = 'project';
+    const cached = this.#getCache(cacheKey);
+    if (cached) return cached;
+
+    const type = await this.#detectProjectType();
+    const sections = [`## Project`, `Type: ${type}`];
+
+    // Package.json (Node.js)
+    if (type === 'node' || existsSync(join(this.#cwd, 'package.json'))) {
+      try {
+        const pkg = JSON.parse(await readFile(join(this.#cwd, 'package.json'), 'utf-8'));
+        if (pkg.name) sections.push(`Name: ${pkg.name}@${pkg.version || '?'}`);
+        if (pkg.scripts) {
+          const scripts = Object.keys(pkg.scripts);
+          sections.push(`Scripts: ${scripts.slice(0, 10).join(', ')}${scripts.length > 10 ? '...' : ''}`);
+        }
+        if (pkg.dependencies) {
+          const deps = Object.keys(pkg.dependencies);
+          sections.push(`Dependencies: ${deps.length} (${deps.slice(0, 5).join(', ')}${deps.length > 5 ? '...' : ''})`);
+        }
+      } catch {}
+    }
+
+    // pyproject.toml (Python)
+    if (existsSync(join(this.#cwd, 'pyproject.toml'))) {
+      try {
+        const content = await readFile(join(this.#cwd, 'pyproject.toml'), 'utf-8');
+        const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
+        if (nameMatch) sections.push(`Name: ${nameMatch[1]}`);
+      } catch {}
+    }
+
+    // README
+    if (existsSync(join(this.#cwd, 'README.md'))) {
+      try {
+        const readme = await readFile(join(this.#cwd, 'README.md'), 'utf-8');
+        const firstPara = readme.split('\n\n').find(p => p.trim() && !p.startsWith('#'));
+        if (firstPara) {
+          sections.push(`Description: ${firstPara.trim().slice(0, 200)}`);
+        }
+      } catch {}
+    }
+
+    const result = sections.join('\n');
+    this.#setCache(cacheKey, result);
+    return result;
+  }
+
+  /**
+   * Build runtime context
+   */
+  async #buildRuntimeContext() {
+    const [nodeVer, npmVer, osInfo] = await Promise.all([
+      run('node --version', this.#cwd),
+      run('npm --version', this.#cwd),
+      run('uname -a', this.#cwd),
+    ]);
+
+    return [
+      `## Runtime`,
+      `Node: ${nodeVer}`,
+      `npm: ${npmVer}`,
+      `OS: ${osInfo}`,
+      `Working Directory: ${this.#cwd}`,
+    ].join('\n');
+  }
+
+  /**
+   * Build file system context (recent files, structure)
+   */
+  async #buildFileSystemContext() {
+    const cacheKey = 'filesystem';
+    const cached = this.#getCache(cacheKey);
+    if (cached) return cached;
+
+    const sections = ['## Workspace Structure'];
+
+    // Get top-level directory listing
+    try {
+      const entries = await readdir(this.#cwd, { withFileTypes: true });
+      const dirs = entries.filter(e => e.isDirectory() && !e.name.startsWith('.')).map(e => e.name);
+      const files = entries.filter(e => e.isFile()).map(e => e.name);
+
+      if (dirs.length > 0) {
+        sections.push(`Directories: ${dirs.slice(0, 15).join(', ')}${dirs.length > 15 ? '...' : ''}`);
+      }
+      if (files.length > 0) {
+        sections.push(`Files: ${files.slice(0, 15).join(', ')}${files.length > 15 ? '...' : ''}`);
+      }
+    } catch {}
+
+    // Recently modified files (via git)
+    if (existsSync(join(this.#cwd, '.git'))) {
+      const recentFiles = await run('git diff --name-only -10', this.#cwd);
+      if (recentFiles) {
+        sections.push(`Recently modified:\n${recentFiles}`);
+      }
+    }
+
+    const result = sections.join('\n');
+    this.#setCache(cacheKey, result);
+    return result;
+  }
+
+  /**
+   * Detect project type
+   */
+  async #detectProjectType() {
+    const checks = [
+      ['package.json', 'node'],
+      ['requirements.txt', 'python'],
+      ['pyproject.toml', 'python'],
+      ['Cargo.toml', 'rust'],
+      ['go.mod', 'go'],
+      ['CMakeLists.txt', 'cmake'],
+      ['Makefile', 'make'],
+      ['pom.xml', 'java'],
+      ['build.gradle', 'gradle'],
+      ['Gemfile', 'ruby'],
+      ['mix.exs', 'elixir'],
+      ['composer.json', 'php'],
+    ];
+
+    for (const [file, type] of checks) {
+      if (existsSync(join(this.#cwd, file))) return type;
+    }
+
+    // Check for common file types
+    try {
+      const files = await readdir(this.#cwd);
+      const exts = files.map(f => extname(f).toLowerCase());
+      if (exts.includes('.py')) return 'python';
+      if (exts.includes('.js') || exts.includes('.ts')) return 'node';
+      if (exts.includes('.rs')) return 'rust';
+      if (exts.includes('.go')) return 'go';
+    } catch {}
+
+    return 'unknown';
+  }
+
+  /**
+   * Get file tree for a specific directory
+   */
+  async getFileTree(dir, maxDepth = 3, currentDepth = 0) {
+    if (currentDepth >= maxDepth) return [];
+
+    const entries = [];
+    try {
+      const items = await readdir(dir, { withFileTypes: true });
+      for (const item of items) {
+        if (item.name.startsWith('.') || item.name === 'node_modules') continue;
+
+        const fullPath = join(dir, item.name);
+        const relPath = relative(this.#cwd, fullPath);
+
+        if (item.isDirectory()) {
+          entries.push({ path: relPath, type: 'dir' });
+          const children = await this.getFileTree(fullPath, maxDepth, currentDepth + 1);
+          entries.push(...children);
+        } else {
+          const s = await stat(fullPath).catch(() => null);
+          entries.push({ path: relPath, type: 'file', size: s?.size || 0 });
+        }
+      }
+    } catch {}
+
+    return entries;
+  }
+
+  /**
+   * Read a specific file with context
+   */
+  async readFileWithContext(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    const ext = extname(filePath).slice(1);
+    const lines = content.split('\n');
+
+    return {
+      path: filePath,
+      content,
+      lines: lines.length,
+      language: this.#detectLanguage(ext),
+      size: content.length,
+    };
+  }
+
+  #detectLanguage(ext) {
+    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';
+  }
+
+  // Simple cache
+  #getCache(key) {
+    const entry = this.#cache.get(key);
+    if (entry && Date.now() - entry.time < this.#cacheTTL) return entry.value;
+    return null;
+  }
+
+  #setCache(key, value) {
+    this.#cache.set(key, { value, time: Date.now() });
+  }
+
+  clearCache() {
+    this.#cache.clear();
+  }
+}