pelulu-cli 1.0.5 → 1.2.0

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()));
+  });
+}

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 },

package/src/core/http-client.js

@@ -0,0 +1,285 @@
+/**
+ * Shared HTTP engine for all tools.
+ *
+ * Why this exists: previously every tool re-implemented raw http.request with
+ * subtle differences and NONE of them decompressed responses. Real-world
+ * servers (Cloudflare, nginx gzip, brotli via CDNs) return compressed bodies,
+ * so body-based detection silently failed everywhere. This module centralizes:
+ *   - transparent gzip / deflate / br decompression
+ *   - accurate wall-clock timing (duration_ms) for time-based detection
+ *   - real redirect following with a recorded chain + loop protection
+ *   - bounded retries with backoff for transient network errors
+ *   - a global concurrency limiter so batch scans don't self-DoS the target
+ *   - a hard body-size cap to stay memory-safe on huge responses
+ */
+import https from 'https';
+import http from 'http';
+import zlib from 'zlib';
+import { URL } from 'url';
+
+export const DEFAULT_UA =
+  'Mozilla/5.0 (Linux; Android 13) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Mobile Safari/537.36';
+
+const DEFAULT_TIMEOUT = 15000;
+const DEFAULT_MAX_BODY = 2 * 1024 * 1024; // 2 MB
+const DEFAULT_MAX_REDIRECTS = 5;
+const DEFAULT_RETRIES = 1;
+
+// ---------------------------------------------------------------------------
+// Global concurrency limiter (shared across every tool in the process).
+// Keeps aggressive batch scanning from opening hundreds of sockets at once.
+// ---------------------------------------------------------------------------
+let MAX_CONCURRENCY = 8;
+let active = 0;
+const queue = [];
+
+export function setMaxConcurrency(n) {
+  MAX_CONCURRENCY = Math.max(1, n | 0);
+}
+
+function acquire() {
+  if (active < MAX_CONCURRENCY) {
+    active++;
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => queue.push(resolve));
+}
+
+function release() {
+  active--;
+  const next = queue.shift();
+  if (next) {
+    active++;
+    next();
+  }
+}
+
+function decompress(buffer, encoding) {
+  if (!buffer || buffer.length === 0) return '';
+  try {
+    const enc = (encoding || '').toLowerCase();
+    if (enc.includes('br')) return zlib.brotliDecompressSync(buffer).toString('utf8');
+    if (enc.includes('gzip')) return zlib.gunzipSync(buffer).toString('utf8');
+    if (enc.includes('deflate')) {
+      try {
+        return zlib.inflateSync(buffer).toString('utf8');
+      } catch {
+        return zlib.inflateRawSync(buffer).toString('utf8');
+      }
+    }
+  } catch {
+    // Corrupt / partial compressed stream — fall back to raw bytes.
+  }
+  return buffer.toString('utf8');
+}
+
+function normalizeHeaders(raw) {
+  const out = {};
+  for (const [k, v] of Object.entries(raw || {})) {
+    out[k.toLowerCase()] = Array.isArray(v) ? v.join(', ') : v;
+  }
+  return out;
+}
+
+/** Return set-cookie always as an array (Node gives array or string). */
+function rawSetCookies(headers) {
+  const sc = headers['set-cookie'];
+  if (!sc) return [];
+  return Array.isArray(sc) ? sc : [sc];
+}
+
+function singleRequest(rawUrl, opts) {
+  const {
+    method = 'GET',
+    headers = {},
+    body = null,
+    timeout = DEFAULT_TIMEOUT,
+    maxBody = DEFAULT_MAX_BODY,
+  } = opts;
+
+  return new Promise((resolve, reject) => {
+    let parsed;
+    try {
+      parsed = new URL(rawUrl);
+    } catch {
+      return reject(new Error(`Invalid URL: ${rawUrl}`));
+    }
+    const lib = parsed.protocol === 'https:' ? https : http;
+
+    const outHeaders = {
+      'User-Agent': DEFAULT_UA,
+      'Accept': '*/*',
+      'Accept-Encoding': 'gzip, deflate, br',
+      'Connection': 'close',
+      ...headers,
+    };
+    if (body && !outHeaders['Content-Length'] && !outHeaders['content-length']) {
+      outHeaders['Content-Length'] = Buffer.byteLength(body);
+    }
+
+    const reqOpts = {
+      protocol: parsed.protocol,
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method: method.toUpperCase(),
+      headers: outHeaders,
+      timeout,
+      rejectUnauthorized: false,
+    };
+
+    const start = Date.now();
+    const req = lib.request(reqOpts, (res) => {
+      const chunks = [];
+      let size = 0;
+      let truncated = false;
+      res.on('data', (c) => {
+        size += c.length;
+        if (size <= maxBody) chunks.push(c);
+        else truncated = true;
+      });
+      res.on('end', () => {
+        const headersLower = normalizeHeaders(res.headers);
+        const buf = Buffer.concat(chunks);
+        const decoded = decompress(buf, headersLower['content-encoding']);
+        resolve({
+          status: res.statusCode,
+          headers: headersLower,
+          setCookies: rawSetCookies(headersLower),
+          body: decoded,
+          bytes: size,
+          truncated,
+          duration_ms: Date.now() - start,
+          url: rawUrl,
+          finalUrl: rawUrl,
+          location: headersLower['location'] || null,
+        });
+      });
+      res.on('error', reject);
+    });
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error(`Timeout after ${timeout}ms`));
+    });
+    if (body && ['POST', 'PUT', 'PATCH', 'DELETE'].includes(reqOpts.method)) req.write(body);
+    req.end();
+  });
+}
+
+/**
+ * Perform an HTTP request with retries, redirect following and decompression.
+ *
+ * @param {string} url
+ * @param {object} [options]
+ * @param {string} [options.method='GET']
+ * @param {object} [options.headers]
+ * @param {string} [options.body]
+ * @param {number} [options.timeout=15000]
+ * @param {boolean} [options.followRedirects=false]
+ * @param {number} [options.maxRedirects=5]
+ * @param {number} [options.retries=1]
+ * @param {number} [options.maxBody]
+ * @returns {Promise<object>} normalized response with duration_ms, redirectChain, etc.
+ */
+export async function request(url, options = {}) {
+  const {
+    followRedirects = false,
+    maxRedirects = DEFAULT_MAX_REDIRECTS,
+    retries = DEFAULT_RETRIES,
+  } = options;
+
+  await acquire();
+  try {
+    let attempt = 0;
+    let lastErr;
+    let res;
+    // Retry loop for transient failures (ECONNRESET / timeouts / etc).
+    while (attempt <= retries) {
+      try {
+        res = await singleRequest(url, options);
+        break;
+      } catch (err) {
+        lastErr = err;
+        attempt++;
+        if (attempt > retries) throw lastErr;
+        await new Promise((r) => setTimeout(r, 150 * attempt));
+      }
+    }
+
+    const redirectChain = [];
+    const visited = new Set([url]);
+    let current = res;
+    let hops = 0;
+    let currentUrl = url;
+    while (
+      followRedirects &&
+      current.status >= 300 &&
+      current.status < 400 &&
+      current.location &&
+      hops < maxRedirects
+    ) {
+      let nextUrl;
+      try {
+        nextUrl = new URL(current.location, currentUrl).href;
+      } catch {
+        break;
+      }
+      redirectChain.push({ status: current.status, from: currentUrl, to: nextUrl });
+      if (visited.has(nextUrl)) break; // loop guard: already fetched this absolute URL
+      visited.add(nextUrl);
+      // Per RFC, 303 (and commonly 301/302) downgrade to GET without a body.
+      const nextMethod = [301, 302, 303].includes(current.status) ? 'GET' : options.method || 'GET';
+      const nextBody = nextMethod === 'GET' ? null : options.body;
+      current = await singleRequest(nextUrl, { ...options, method: nextMethod, body: nextBody });
+      currentUrl = nextUrl;
+      hops++;
+    }
+
+    current.redirectChain = redirectChain;
+    current.finalUrl = currentUrl;
+    current.requestedUrl = url;
+    return current;
+  } finally {
+    release();
+  }
+}
+
+/** Convenience GET. */
+export function get(url, options = {}) {
+  return request(url, { ...options, method: 'GET' });
+}
+
+/**
+ * Run an async mapper over items with bounded parallelism.
+ * (The global limiter also applies, but this keeps result ordering + batching.)
+ */
+export async function mapLimit(items, limit, mapper) {
+  const results = new Array(items.length);
+  let idx = 0;
+  const workers = new Array(Math.min(limit, items.length || 1)).fill(0).map(async () => {
+    while (idx < items.length) {
+      const i = idx++;
+      try {
+        results[i] = await mapper(items[i], i);
+      } catch (err) {
+        results[i] = { __error: err?.message || String(err) };
+      }
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+/** Parse a "key:value|key:value" header string into an object. */
+export function parseHeaderString(headerStr) {
+  const headers = {};
+  if (!headerStr) return headers;
+  for (const pair of headerStr.split('|')) {
+    const idx = pair.indexOf(':');
+    if (idx > 0) headers[pair.slice(0, idx).trim()] = pair.slice(idx + 1).trim();
+  }
+  return headers;
+}
+
+export default { request, get, mapLimit, setMaxConcurrency, parseHeaderString, DEFAULT_UA };