pelulu-cli 1.0.5 → 1.1.0

package/src/agent/history-condenser.js

@@ -0,0 +1,202 @@
+/**
+ * HistoryCondenser — Manage long conversations (OpenHands-style)
+ * 
+ * When history gets too long, condense it by:
+ * 1. Summarizing old messages
+ * 2. Keeping recent messages intact
+ * 3. Preserving important context (files read, errors, decisions)
+ */
+import { debug } from '../core/logger.js';
+
+export class HistoryCondenser {
+  #maxMessages;
+  #maxTokens;
+  #condensedHistory = [];
+
+  constructor({ maxMessages = 50, maxTokens = 100000 } = {}) {
+    this.#maxMessages = maxMessages;
+    this.#maxTokens = maxTokens;
+  }
+
+  /**
+   * Check if history needs condensation
+   */
+  needsCondensation(messages) {
+    if (messages.length > this.#maxMessages) return true;
+    const estimatedTokens = this.#estimateTokens(messages);
+    if (estimatedTokens > this.#maxTokens) return true;
+    return false;
+  }
+
+  /**
+   * Condense history to fit within limits
+   * @param {Array} messages - Full message history
+   * @param {object} llm - LLM client for summarization (optional)
+   * @returns {Array} - Condensed messages
+   */
+  async condense(messages, llm = null) {
+    if (!this.needsCondensation(messages)) return messages;
+
+    debug('history', `Condensing ${messages.length} messages`);
+
+    // Strategy 1: Keep first message + last N messages
+    const keepRecent = Math.floor(this.#maxMessages * 0.7);
+    const firstMessage = messages[0];
+    const recentMessages = messages.slice(-keepRecent);
+
+    // Strategy 2: Summarize middle section if LLM available
+    if (llm) {
+      const middleMessages = messages.slice(1, -keepRecent);
+      const summary = await this.#summarize(middleMessages, llm);
+
+      if (summary) {
+        return [
+          firstMessage,
+          { role: 'system', content: `[Previous conversation summary]: ${summary}` },
+          ...recentMessages,
+        ];
+      }
+    }
+
+    // Fallback: Just keep first + recent
+    return [firstMessage, ...recentMessages];
+  }
+
+  /**
+   * Summarize a batch of messages using LLM
+   */
+  async #summarize(messages, llm) {
+    try {
+      const conversation = messages.map(m => {
+        if (m.role === 'user') return `User: ${m.content}`;
+        if (m.role === 'assistant') return `Assistant: ${m.content || '(tool call)'}`;
+        if (m.role === 'tool') return `Tool (${m.name}): ${typeof m.content === 'string' ? m.content.slice(0, 200) : '(result)'}`;
+        return '';
+      }).filter(Boolean).join('\n');
+
+      const response = await llm.chat([
+        { role: 'system', content: 'Summarize this conversation concisely. Focus on: files modified, decisions made, errors encountered, and current task status. Max 200 words.' },
+        { role: 'user', content: conversation },
+      ]);
+
+      let content = response.content;
+      if (Array.isArray(content)) {
+        content = content.filter(c => c.type === 'text').map(c => c.text).join('');
+      }
+
+      return content;
+    } catch (err) {
+      debug('history', `Summarization failed: ${err.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Extract important context from messages
+   * This context is preserved even when messages are condensed
+   */
+  extractImportantContext(messages) {
+    const context = {
+      filesRead: new Set(),
+      filesModified: new Set(),
+      errors: [],
+      decisions: [],
+      toolCalls: [],
+    };
+
+    for (const msg of messages) {
+      // Track file operations
+      if (msg.role === 'tool' && msg.name === 'file') {
+        try {
+          const result = JSON.parse(msg.content);
+          if (result.path) {
+            if (msg.args?.action === 'read') context.filesRead.add(result.path);
+            if (msg.args?.action === 'write' || msg.args?.action === 'edit') {
+              context.filesModified.add(result.path);
+            }
+          }
+        } catch {}
+      }
+
+      // Track errors
+      if (msg.role === 'tool' && msg.content?.includes('error')) {
+        context.errors.push(msg.content.slice(0, 200));
+      }
+
+      // Track tool calls
+      if (msg.role === 'tool') {
+        context.toolCalls.push({
+          name: msg.name,
+          timestamp: msg.timestamp,
+        });
+      }
+    }
+
+    return {
+      filesRead: [...context.filesRead],
+      filesModified: [...context.filesModified],
+      recentErrors: context.errors.slice(-5),
+      totalToolCalls: context.toolCalls.length,
+    };
+  }
+
+  /**
+   * Estimate token count (rough approximation)
+   */
+  #estimateTokens(messages) {
+    let totalChars = 0;
+    for (const msg of messages) {
+      if (typeof msg.content === 'string') {
+        totalChars += msg.content.length;
+      }
+      if (msg.tool_calls) {
+        totalChars += JSON.stringify(msg.tool_calls).length;
+      }
+    }
+    // Rough estimate: ~4 chars per token
+    return Math.ceil(totalChars / 4);
+  }
+
+  /**
+   * Build context summary for condensed history
+   */
+  buildContextSummary(messages) {
+    const context = this.extractImportantContext(messages);
+    const parts = [];
+
+    if (context.filesRead.length > 0) {
+      parts.push(`Files read: ${context.filesRead.join(', ')}`);
+    }
+    if (context.filesModified.length > 0) {
+      parts.push(`Files modified: ${context.filesModified.join(', ')}`);
+    }
+    if (context.recentErrors.length > 0) {
+      parts.push(`Recent errors:\n${context.recentErrors.map(e => `  - ${e}`).join('\n')}`);
+    }
+    parts.push(`Total tool calls: ${context.totalToolCalls}`);
+
+    return parts.join('\n');
+  }
+
+  /**
+   * Get optimal message window for a given token budget
+   */
+  getWindow(messages, tokenBudget) {
+    let currentTokens = 0;
+    let endIndex = messages.length;
+
+    // Walk backwards from the end
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msgTokens = this.#estimateTokens([messages[i]]);
+      if (currentTokens + msgTokens > tokenBudget) break;
+      currentTokens += msgTokens;
+      endIndex = i;
+    }
+
+    // Always include the first message (user's original request)
+    if (endIndex > 1) {
+      return [messages[0], ...messages.slice(endIndex)];
+    }
+    return messages.slice(endIndex);
+  }
+}

package/src/agent/index.js

@@ -0,0 +1,8 @@
+/**
+ * Agent Module — OpenHands-style agent system for Pelulu-CLI
+ */
+export { AgentLoop, AgentState } from './agent-loop.js';
+export { LLMClient } from './llm-client.js';
+export { ContextBuilder } from './context-builder.js';
+export { AgentController } from './agent-controller.js';
+export { buildSystemPrompt, matchMicroagents } from './system-prompt.js';

package/src/agent/llm-client.js

@@ -0,0 +1,50 @@
+/**
+ * LLMClient — XiaoZhi AI MQTT wrapper
+ * 
+ * Sends user messages to XiaoZhi via MQTT.
+ * Response handling is done by AgentLoop via bus events.
+ */
+import { debug } from '../core/logger.js';
+
+const MAX_PROMPT_LEN = 70;
+
+export class LLMClient {
+  #mqtt;
+
+  constructor(mqtt) {
+    this.#mqtt = mqtt;
+  }
+
+  /**
+   * Wait for MCP handshake to complete (tools received + session assigned)
+   */
+  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);
+    });
+  }
+
+  /**
+   * Send prompt to XiaoZhi (waits for MCP handshake first)
+   * Response comes back via llm:text or mcp:tool_call events
+   */
+  async sendPrompt(prompt) {
+    if (prompt.length > MAX_PROMPT_LEN) {
+      debug('llm', `Prompt too long: ${prompt.length} > ${MAX_PROMPT_LEN}`);
+      throw new Error(`Prompt too long (${prompt.length}/${MAX_PROMPT_LEN} chars)`);
+    }
+    await this.#waitForReady();
+    debug('llm', `Sending: ${prompt}`);
+    await this.#mqtt.sendText(prompt);
+  }
+}

package/src/agent/plan-manager.js

@@ -0,0 +1,342 @@
+/**
+ * PlanManager — Task decomposition and execution tracking (OpenHands-style)
+ * 
+ * Breaks complex tasks into steps, tracks progress, handles failures.
+ * The plan is a living document that evolves as the agent works.
+ */
+import { bus } from '../core/event-bus.js';
+import { debug } from '../core/logger.js';
+
+export const StepStatus = {
+  PENDING: 'pending',
+  IN_PROGRESS: 'in_progress',
+  COMPLETED: 'completed',
+  FAILED: 'failed',
+  SKIPPED: 'skipped',
+};
+
+export class PlanStep {
+  constructor({ id, description, status = StepStatus.PENDING, result = null, error = null }) {
+    this.id = id;
+    this.description = description;
+    this.status = status;
+    this.result = result;
+    this.error = error;
+    this.startedAt = null;
+    this.completedAt = null;
+  }
+
+  start() {
+    this.status = StepStatus.IN_PROGRESS;
+    this.startedAt = Date.now();
+  }
+
+  complete(result) {
+    this.status = StepStatus.COMPLETED;
+    this.result = result;
+    this.completedAt = Date.now();
+  }
+
+  fail(error) {
+    this.status = StepStatus.FAILED;
+    this.error = error;
+    this.completedAt = Date.now();
+  }
+
+  skip(reason) {
+    this.status = StepStatus.SKIPPED;
+    this.result = reason;
+    this.completedAt = Date.now();
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      description: this.description,
+      status: this.status,
+      result: this.result,
+      error: this.error,
+      duration: this.completedAt && this.startedAt ? this.completedAt - this.startedAt : null,
+    };
+  }
+}
+
+export class Plan {
+  constructor({ goal, steps = [] }) {
+    this.goal = goal;
+    this.steps = steps.map((s, i) => new PlanStep({ id: i + 1, ...s }));
+    this.createdAt = Date.now();
+    this.updatedAt = Date.now();
+  }
+
+  get currentStep() {
+    return this.steps.find(s => s.status === StepStatus.IN_PROGRESS);
+  }
+
+  get nextPending() {
+    return this.steps.find(s => s.status === StepStatus.PENDING);
+  }
+
+  get progress() {
+    const total = this.steps.length;
+    const completed = this.steps.filter(s => s.status === StepStatus.COMPLETED).length;
+    const failed = this.steps.filter(s => s.status === StepStatus.FAILED).length;
+    return { total, completed, failed, percent: total ? Math.round((completed / total) * 100) : 0 };
+  }
+
+  get isComplete() {
+    return this.steps.every(s =>
+      s.status === StepStatus.COMPLETED ||
+      s.status === StepStatus.FAILED ||
+      s.status === StepStatus.SKIPPED
+    );
+  }
+
+  get hasFailures() {
+    return this.steps.some(s => s.status === StepStatus.FAILED);
+  }
+
+  startStep(id) {
+    const step = this.steps.find(s => s.id === id);
+    if (step) {
+      step.start();
+      this.updatedAt = Date.now();
+      bus.emit('plan:step:start', { step: step.toJSON() });
+    }
+    return step;
+  }
+
+  completeStep(id, result) {
+    const step = this.steps.find(s => s.id === id);
+    if (step) {
+      step.complete(result);
+      this.updatedAt = Date.now();
+      bus.emit('plan:step:complete', { step: step.toJSON(), progress: this.progress });
+    }
+    return step;
+  }
+
+  failStep(id, error) {
+    const step = this.steps.find(s => s.id === id);
+    if (step) {
+      step.fail(error);
+      this.updatedAt = Date.now();
+      bus.emit('plan:step:fail', { step: step.toJSON(), progress: this.progress });
+    }
+    return step;
+  }
+
+  skipStep(id, reason) {
+    const step = this.steps.find(s => s.id === id);
+    if (step) {
+      step.skip(reason);
+      this.updatedAt = Date.now();
+    }
+    return step;
+  }
+
+  /**
+   * Add a new step (plan can be modified during execution)
+   */
+  addStep(description, afterId = null) {
+    const id = this.steps.length + 1;
+    const step = new PlanStep({ id, description });
+    if (afterId) {
+      const idx = this.steps.findIndex(s => s.id === afterId);
+      this.steps.splice(idx + 1, 0, step);
+    } else {
+      this.steps.push(step);
+    }
+    // Re-number steps
+    this.steps.forEach((s, i) => s.id = i + 1);
+    this.updatedAt = Date.now();
+    bus.emit('plan:updated', { plan: this.toJSON() });
+    return step;
+  }
+
+  /**
+   * Remove a pending step
+   */
+  removeStep(id) {
+    const idx = this.steps.findIndex(s => s.id === id && s.status === StepStatus.PENDING);
+    if (idx >= 0) {
+      this.steps.splice(idx, 1);
+      this.steps.forEach((s, i) => s.id = i + 1);
+      this.updatedAt = Date.now();
+    }
+  }
+
+  /**
+   * Format plan as prompt for LLM
+   */
+  toPrompt() {
+    const lines = [`Goal: ${this.goal}`, ''];
+    for (const step of this.steps) {
+      const icon = {
+        [StepStatus.PENDING]: '⬜',
+        [StepStatus.IN_PROGRESS]: '🔄',
+        [StepStatus.COMPLETED]: '✅',
+        [StepStatus.FAILED]: '❌',
+        [StepStatus.SKIPPED]: '⏭️',
+      }[step.status];
+
+      lines.push(`${icon} Step ${step.id}: ${step.description}`);
+      if (step.result && step.status === StepStatus.COMPLETED) {
+        lines.push(`   Result: ${step.result}`);
+      }
+      if (step.error && step.status === StepStatus.FAILED) {
+        lines.push(`   Error: ${step.error}`);
+      }
+    }
+    lines.push('');
+    lines.push(`Progress: ${this.progress.percent}% (${this.progress.completed}/${this.progress.total})`);
+    return lines.join('\n');
+  }
+
+  /**
+   * Format plan for display
+   */
+  toDisplay() {
+    const lines = [`📋 Plan: ${this.goal}`, '─'.repeat(40)];
+    for (const step of this.steps) {
+      const icon = {
+        [StepStatus.PENDING]: '⬜',
+        [StepStatus.IN_PROGRESS]: '🔄',
+        [StepStatus.COMPLETED]: '✅',
+        [StepStatus.FAILED]: '❌',
+        [StepStatus.SKIPPED]: '⏭️',
+      }[step.status];
+      lines.push(`${icon} ${step.id}. ${step.description}`);
+    }
+    lines.push('─'.repeat(40));
+    lines.push(`Progress: ${this.progress.percent}%`);
+    return lines.join('\n');
+  }
+
+  toJSON() {
+    return {
+      goal: this.goal,
+      steps: this.steps.map(s => s.toJSON()),
+      progress: this.progress,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+    };
+  }
+}
+
+export class PlanManager {
+  #currentPlan = null;
+  #history = [];
+
+  get currentPlan() { return this.#currentPlan; }
+  get history() { return [...this.#history]; }
+
+  /**
+   * Create a new plan from a goal
+   */
+  create(goal, steps = []) {
+    if (this.#currentPlan && !this.#currentPlan.isComplete) {
+      this.#history.push(this.#currentPlan);
+    }
+    this.#currentPlan = new Plan({ goal, steps });
+    bus.emit('plan:created', { plan: this.#currentPlan.toJSON() });
+    debug('plan', `Created plan: ${goal} (${steps.length} steps)`);
+    return this.#currentPlan;
+  }
+
+  /**
+   * Let the LLM generate a plan for a task
+   */
+  async generatePlan(task, llm, context) {
+    const prompt = `You are a task planner. Break this task into clear, actionable steps.
+
+Task: ${task}
+
+${context ? `Context:\n${context}` : ''}
+
+Respond with a JSON object:
+{
+  "goal": "Brief description of the overall goal",
+  "steps": [
+    { "description": "Step 1 description" },
+    { "description": "Step 2 description" }
+  ]
+}
+
+Rules:
+- Each step should be a single, clear action
+- Steps should be in logical order
+- Maximum 10 steps
+- Be specific and actionable`;
+
+    try {
+      const response = await llm.chat([
+        { role: 'system', content: 'You are a task planning assistant. Respond only with valid JSON.' },
+        { role: 'user', content: prompt },
+      ]);
+
+      let content = response.content;
+      if (Array.isArray(content)) {
+        content = content.filter(c => c.type === 'text').map(c => c.text).join('');
+      }
+
+      // Parse JSON from response
+      const jsonMatch = content.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const planData = JSON.parse(jsonMatch[0]);
+        return this.create(planData.goal || task, planData.steps || []);
+      }
+    } catch (err) {
+      debug('plan', `Plan generation failed: ${err.message}`);
+    }
+
+    // Fallback: create simple plan
+    return this.create(task, [{ description: task }]);
+  }
+
+  /**
+   * Mark current step as complete and move to next
+   */
+  advanceCurrent(result) {
+    if (!this.#currentPlan) return null;
+    const current = this.#currentPlan.currentStep;
+    if (current) {
+      this.#currentPlan.completeStep(current.id, result);
+    }
+    const next = this.#currentPlan.nextPending;
+    if (next) {
+      this.#currentPlan.startStep(next.id);
+    }
+    return next;
+  }
+
+  /**
+   * Mark current step as failed
+   */
+  failCurrent(error) {
+    if (!this.#currentPlan) return null;
+    const current = this.#currentPlan.currentStep;
+    if (current) {
+      this.#currentPlan.failStep(current.id, error);
+    }
+    return current;
+  }
+
+  /**
+   * Get plan status for display
+   */
+  getStatus() {
+    if (!this.#currentPlan) return 'No active plan';
+    return this.#currentPlan.toDisplay();
+  }
+
+  /**
+   * Clear current plan
+   */
+  clear() {
+    if (this.#currentPlan) {
+      this.#history.push(this.#currentPlan);
+      this.#currentPlan = null;
+    }
+  }
+}

package/src/agent/system-prompt.js

@@ -0,0 +1,41 @@
+/**
+ * SystemPrompt — Minimal system prompt for XiaoZhi
+ * 
+ * XiaoZhi doesn't support system prompts, so this is used
+ * only for agent-internal context tracking.
+ */
+
+/**
+ * Build minimal system prompt (for internal use only, NOT sent to XiaoZhi)
+ */
+export function buildSystemPrompt({ config, context, plan }) {
+  const name = config.agent?.name || 'Pelulu';
+  const parts = [`You are ${name}, a coding agent.`];
+
+  if (context) {
+    // Extract only git branch and project type
+    const branch = context.match(/Branch:\s*(\S+)/)?.[1];
+    const type = context.match(/Type:\s*(\S+)/)?.[1];
+    if (branch || type) {
+      parts.push([branch && `git:${branch}`, type].filter(Boolean).join(' | '));
+    }
+  }
+
+  if (plan) {
+    parts.push(`Plan: ${plan.goal} (${plan.progress?.percent || 0}%)`);
+  }
+
+  return parts.join(' ');
+}
+
+/**
+ * Match microagents based on user input
+ */
+export function matchMicroagents(userInput, allMicroagents) {
+  if (!allMicroagents?.length) return [];
+  const input = userInput.toLowerCase();
+  return allMicroagents.filter(agent => {
+    if (!agent.trigger?.length) return true;
+    return agent.trigger.some(kw => input.includes(kw.toLowerCase()));
+  });
+}