pelulu-cli 1.0.0

package/src/core/session.js

@@ -0,0 +1,46 @@
+/**
+ * SessionState — tracks conversation context, tool history, and working state
+ */
+export class SessionState {
+  constructor() {
+    this.messages = [];
+    this.toolCalls = [];
+    this.startTime = Date.now();
+    this.turnCount = 0;
+    this.cwd = process.cwd();
+  }
+
+  addUserMessage(text) {
+    this.messages.push({ role: 'user', text, ts: Date.now() });
+    this.turnCount++;
+    // Keep last 50 messages
+    if (this.messages.length > 50) this.messages = this.messages.slice(-50);
+  }
+
+  addAiMessage(text) {
+    this.messages.push({ role: 'ai', text, ts: Date.now() });
+  }
+
+  addToolCall(name, args, result) {
+    this.toolCalls.push({ name, args, result: result?.isError ? 'error' : 'ok', ts: Date.now() });
+    // Keep last 100 tool calls
+    if (this.toolCalls.length > 100) this.toolCalls = this.toolCalls.slice(-100);
+  }
+
+  getRecentContext(n = 10) {
+    return this.messages.slice(-n);
+  }
+
+  getStats() {
+    return {
+      uptime: Math.round((Date.now() - this.startTime) / 1000),
+      turns: this.turnCount,
+      messages: this.messages.length,
+      toolCalls: this.toolCalls.length,
+      errors: this.toolCalls.filter(t => t.result === 'error').length,
+    };
+  }
+
+  getCwd() { return this.cwd; }
+  setCwd(path) { this.cwd = path; }
+}

package/src/core/spinner.js

@@ -0,0 +1,60 @@
+/**
+ * Spinner — progress indicator for long operations
+ */
+import { COLORS } from './logger.js';
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+export class Spinner {
+  constructor(text = 'Working...') {
+    this.text = text;
+    this.i = 0;
+    this.timer = null;
+    this.stream = process.stderr;
+  }
+
+  start(text) {
+    if (text) this.text = text;
+    this.i = 0;
+    this.timer = setInterval(() => {
+      this.stream.write(`\r${COLORS.cyan}${FRAMES[this.i % FRAMES.length]}${COLORS.reset} ${this.text}`);
+      this.i++;
+    }, 80);
+    return this;
+  }
+
+  update(text) {
+    this.text = text;
+    return this;
+  }
+
+  stop(finalText) {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.stream.write(`\r${' '.repeat(this.text.length + 4)}\r`);
+    if (finalText) console.log(finalText);
+    return this;
+  }
+
+  success(text) {
+    this.stop(`${COLORS.green}✅ ${text}${COLORS.reset}`);
+  }
+
+  fail(text) {
+    this.stop(`${COLORS.red}❌ ${text}${COLORS.reset}`);
+  }
+}
+
+export async function withSpinner(text, fn) {
+  const spinner = new Spinner(text).start();
+  try {
+    const result = await fn(spinner);
+    spinner.success(text);
+    return result;
+  } catch (e) {
+    spinner.fail(`${text}: ${e.message}`);
+    throw e;
+  }
+}

package/src/core/stats.js

@@ -0,0 +1,73 @@
+/**
+ * Stats — tool usage analytics and session metrics
+ */
+export class Stats {
+  constructor() {
+    this.toolCalls = [];
+    this.startTime = Date.now();
+    this.errors = [];
+  }
+
+  record(toolName, action, success, duration, error) {
+    this.toolCalls.push({
+      tool: toolName,
+      action,
+      success,
+      duration,
+      ts: Date.now(),
+    });
+    if (!success && error) this.errors.push({ tool: toolName, action, error, ts: Date.now() });
+    // Keep last 500 calls
+    if (this.toolCalls.length > 500) this.toolCalls = this.toolCalls.slice(-500);
+  }
+
+  getSummary() {
+    const total = this.toolCalls.length;
+    const success = this.toolCalls.filter(t => t.success).length;
+    const failed = total - success;
+    const avgDuration = total ? Math.round(this.toolCalls.reduce((s, t) => s + t.duration, 0) / total) : 0;
+    const uptime = Math.round((Date.now() - this.startTime) / 1000);
+
+    // Tool frequency
+    const freq = {};
+    for (const t of this.toolCalls) {
+      freq[t.tool] = (freq[t.tool] || 0) + 1;
+    }
+    const topTools = Object.entries(freq).sort((a, b) => b[1] - a[1]).slice(0, 5);
+
+    return { total, success, failed, avgDuration, uptime, topTools };
+  }
+
+  formatReport() {
+    const s = this.getSummary();
+    const lines = [
+      `📊 Session Stats`,
+      `   Uptime: ${s.uptime}s`,
+      `   Tool calls: ${s.total} (${s.success} ✅ / ${s.failed} ❌)`,
+      `   Avg duration: ${s.avgDuration}ms`,
+    ];
+    if (s.topTools.length) {
+      lines.push('   Top tools:');
+      for (const [tool, count] of s.topTools) {
+        lines.push(`     ${tool}: ${count} calls`);
+      }
+    }
+    if (this.errors.length) {
+      lines.push(`   Recent errors:`);
+      for (const e of this.errors.slice(-3)) {
+        lines.push(`     ${e.tool}.${e.action}: ${e.error.slice(0, 60)}`);
+      }
+    }
+    return lines.join('\n');
+  }
+
+  getToolStats(toolName) {
+    const calls = this.toolCalls.filter(t => t.tool === toolName);
+    return {
+      tool: toolName,
+      calls: calls.length,
+      success: calls.filter(t => t.success).length,
+      avgDuration: calls.length ? Math.round(calls.reduce((s, t) => s + t.duration, 0) / calls.length) : 0,
+    };
+  }
+}

package/src/core/system-prompt.js

@@ -0,0 +1,42 @@
+/**
+ * SystemPrompt — builds context prompt for XiaoZhi LLM
+ * Tells the AI what tools are available and how to use them
+ */
+
+export function buildSystemPrompt(registry, config) {
+  const tools = registry.list();
+  const lines = [
+    `You are ${config.agent?.name || 'a coding agent'} running in Termux/Node.js.`,
+    `You have access to ${tools.length} MCP tools. Use them to help the user.`,
+    '',
+    '## Available Tools',
+    '',
+  ];
+
+  for (const tool of tools) {
+    lines.push(`### ${tool.name}`);
+    lines.push(`${tool.description}`);
+    lines.push(`Actions: ${tool.actions.join(', ')}`);
+    lines.push('');
+  }
+
+  lines.push('## Tool Call Format');
+  lines.push('When you need to use a tool, call it with the action and required parameters.');
+  lines.push('Example: file(action="read", path="./src/index.js")');
+  lines.push('Example: shell(action="exec", command="npm test")');
+  lines.push('Example: git(action="status")');
+  lines.push('');
+
+  lines.push('## Guidelines');
+  lines.push('- Always read files before editing them');
+  lines.push('- Use git status before committing');
+  lines.push('- Run tests after making changes');
+  lines.push('- Be concise in explanations');
+  lines.push('- Show code changes clearly');
+
+  return lines.join('\n');
+}
+
+export function buildToolHint(toolName, action) {
+  return `[Calling ${toolName}.${action}]`;
+}

package/src/core/thinking.js

@@ -0,0 +1,39 @@
+/**
+ * Thinking — AI processing indicator
+ * Shows thinking state like Claude Code's "thinking..." display
+ */
+import { COLORS } from './logger.js';
+import { bus } from './event-bus.js';
+
+const THINK_STATES = {
+  idle: { icon: '💤', text: 'Idle' },
+  thinking: { icon: '🤔', text: 'Thinking...' },
+  tool_call: { icon: '🔧', text: 'Using tool...' },
+  reading: { icon: '📖', text: 'Reading file...' },
+  writing: { icon: '✏️', text: 'Writing...' },
+  searching: { icon: '🔍', text: 'Searching...' },
+  building: { icon: '🔨', text: 'Building...' },
+  testing: { icon: '🧪', text: 'Testing...' },
+};
+
+export class Thinking {
+  constructor() {
+    this.state = 'idle';
+    this.timer = null;
+  }
+
+  set(state) {
+    this.state = state;
+    const info = THINK_STATES[state] || THINK_STATES.idle;
+    bus.emit('thinking', { state, ...info });
+  }
+
+  get() {
+    return THINK_STATES[this.state] || THINK_STATES.idle;
+  }
+
+  format() {
+    const info = this.get();
+    return `${COLORS.dim}${info.icon} ${info.text}${COLORS.reset}`;
+  }
+}

package/src/core/tool-help.js

@@ -0,0 +1,117 @@
+/**
+ * ToolHelp — detailed help for each tool with examples
+ */
+import { COLORS } from './logger.js';
+
+const TOOL_EXAMPLES = {
+  ai: [
+    '/call ai analyze {"path":"./src/index.js"}',
+    '/call ai summarize {"path":"./src/index.js"}',
+    '/call ai diff {"file1":"./old.js","file2":"./new.js"}',
+  ],
+  env: [
+    '/call env get {"name":"HOME"}',
+    '/call env list {"filter":"NODE"}',
+  ],
+  snippet: [
+    '/call snippet save {"name":"hello","code":"console.log(1)","language":"js"}',
+    '/call snippet load {"name":"hello"}',
+    '/call snippet list',
+  ],
+  template: [
+    '/call template list',
+    '/call template create {"template":"node-basic","name":"my-app"}',
+    '/call template info {"template":"python-basic"}',
+  ],
+  config: [
+    '/call config list',
+    '/call config get {"key":"tools.shell_timeout"}',
+    '/call config set {"key":"tools.shell_timeout","value":"60000"}',
+  ],
+  diff: [
+    '/call diff compare {"file1":"./old.js","file2":"./new.js"}',
+    '/call diff stats {"file1":"./a.txt","file2":"./b.txt"}',
+    '/call diff patch {"file1":"./a.py","file2":"./b.py"}',
+  ],
+  watch: [
+    '/call watch start {"path":"./src"}',
+    '/call watch stop {"path":"./src"}',
+    '/call watch status',
+  ],
+  file: [
+    '/call file read {"path":"./src/index.js"}',
+    '/call file write {"path":"./test.js","content":"console.log(1)"}',
+    '/call file edit {"path":"./src/index.js","old_text":"foo","new_text":"bar"}',
+    '/call file list {"path":".","recursive":true}',
+    '/call file exists {"path":"./package.json"}',
+  ],
+  shell: [
+    '/call shell exec {"command":"npm test"}',
+    '/call shell exec {"command":"ls -la","timeout":5000}',
+    '/call shell ps {"filter":"node"}',
+    '/call shell kill {"pid":1234}',
+  ],
+  git: [
+    '/call git status',
+    '/call git diff {"staged":true}',
+    '/call git log {"limit":5}',
+    '/call git commit {"message":"fix: bug"}',
+    '/call git push',
+  ],
+  search: [
+    '/call search grep {"pattern":"TODO","path":"./src"}',
+    '/call search find {"name":"*.js","path":"./src"}',
+    '/call search web {"url":"https://example.com"}',
+  ],
+  project: [
+    '/call project info',
+    '/call project build',
+    '/call project test',
+    '/call project lint',
+    '/call project deps {"install":true}',
+  ],
+  process: [
+    '/call process list',
+    '/call process top {"limit":10}',
+    '/call process info {"pid":1234}',
+  ],
+  network: [
+    '/call network fetch {"url":"https://api.github.com"}',
+    '/call network download {"url":"https://example.com/file.zip","path":"./file.zip"}',
+    '/call network ping {"host":"google.com"}',
+  ],
+  env: [
+    '/call env get {"name":"HOME"}',
+    '/call env list {"filter":"NODE"}',
+  ],
+  ai: [
+    '/call ai analyze {"path":"./src/index.js"}',
+    '/call ai summarize {"path":"./src/index.js"}',
+    '/call ai diff {"file1":"./old.js","file2":"./new.js"}',
+  ],
+};
+
+export function showToolHelp(toolName) {
+  const examples = TOOL_EXAMPLES[toolName];
+  if (!examples) {
+    console.log(`${COLORS.yellow}No help for: ${toolName}${COLORS.reset}`);
+    console.log(`Available: ${Object.keys(TOOL_EXAMPLES).join(', ')}`);
+    return;
+  }
+
+  console.log(`\n${COLORS.bold}📖 ${toolName} — Examples:${COLORS.reset}\n`);
+  for (const ex of examples) {
+    console.log(`  ${COLORS.cyan}${ex}${COLORS.reset}`);
+  }
+  console.log();
+}
+
+export function showAllToolHelp() {
+  for (const [tool, examples] of Object.entries(TOOL_EXAMPLES)) {
+    console.log(`\n${COLORS.bold}📖 ${tool}:${COLORS.reset}`);
+    for (const ex of examples.slice(0, 2)) {
+      console.log(`  ${COLORS.cyan}${ex}${COLORS.reset}`);
+    }
+  }
+  console.log();
+}

package/src/core/tool-registry.js

@@ -0,0 +1,82 @@
+/**
+ * ToolRegistry — central registry for consolidated MCP tools
+ *
+ * Pattern: Each tool has name, description, inputSchema with "action" enum.
+ * Handler receives { action, ...params } and routes to the action handler.
+ *
+ * This keeps us well under XiaoZhi's 32 MCP tool limit.
+ */
+import { readdir } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { log, debug } from './logger.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TOOLS_DIR = join(__dirname, '..', 'tools');
+
+export class ToolRegistry {
+  #tools = new Map();
+
+  async loadBuiltins() {
+    try {
+      const files = await readdir(TOOLS_DIR);
+      for (const file of files.filter(f => f.endsWith('.js'))) {
+        try {
+          const mod = await import(join(TOOLS_DIR, file));
+          const tool = mod.default || mod;
+          if (tool?.name && tool?.handler) {
+            this.register(tool);
+            log('tool', `  ${tool.name} — ${tool.description || ''} (${tool.actions?.length || 0} actions)`);
+          }
+        } catch (e) {
+          log('warn', `Tool "${file}" failed: ${e.message}`);
+        }
+      }
+    } catch (e) {
+      log('warn', `Tools dir not found: ${e.message}`);
+    }
+  }
+
+  register(tool) {
+    if (!tool.name || !tool.handler) throw new Error('Tool needs name + handler');
+    this.#tools.set(tool.name, tool);
+  }
+
+  get(name) { return this.#tools.get(name); }
+
+  all() { return [...this.#tools.values()]; }
+
+  list() {
+    return this.all().map(t => ({
+      name: t.name,
+      description: t.description,
+      actions: t.actions?.map(a => a.name) || [],
+    }));
+  }
+
+  toMcpTools() {
+    return this.all().map(t => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema || { type: 'object', properties: {} },
+    }));
+  }
+
+  async call(name, args = {}) {
+    const tool = this.#tools.get(name);
+    if (!tool) return { isError: true, content: [{ type: 'text', text: `Unknown tool: ${name}` }] };
+    try {
+      const result = await tool.handler(args);
+      return { isError: false, content: [{ type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result) }] };
+    } catch (e) {
+      return { isError: true, content: [{ type: 'text', text: e.message }] };
+    }
+  }
+
+  async shutdown() {
+    for (const tool of this.#tools.values()) {
+      if (tool.shutdown) await tool.shutdown();
+    }
+    this.#tools.clear();
+  }
+}

package/src/core/wizard.js

@@ -0,0 +1,55 @@
+/**
+ * Wizard — first-run configuration wizard
+ */
+import { createInterface } from 'readline';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getConfig, saveConfig } from './config.js';
+import { COLORS } from './logger.js';
+
+export async function runWizard(root) {
+  const config = getConfig();
+  if (config._wizard_done) return config;
+
+  console.log(`\n${COLORS.cyan}╔══════════════════════════════════════╗`);
+  console.log(`║        🐾 Pelulu CLI Setup           ║`);
+  console.log(`╚══════════════════════════════════════╝${COLORS.reset}\n`);
+
+  if (!process.stdin.isTTY) {
+    console.log(`${COLORS.yellow}Non-interactive mode. Using defaults.${COLORS.reset}`);
+    config._wizard_done = true;
+    await saveConfig(root, config);
+    return config;
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q, def) => new Promise((resolve) => {
+    rl.question(`${q}${def ? ` ${COLORS.dim}[${def}]${COLORS.reset}` : ''}: `, (a) => {
+      resolve(a.trim() || def);
+    });
+  });
+
+  try {
+    // Workspace
+    const workspace = await ask('📁 Workspace path?', config.agent?.workspace || '~/coding-agent');
+    config.agent = { ...config.agent, workspace };
+
+    // MCP endpoint (optional)
+    console.log(`\n${COLORS.dim}MCP Endpoint (optional, for official XiaoZhi MCP):${COLORS.reset}`);
+    console.log(`${COLORS.dim}Get from: xiaozhi.me → Configure → Extensions → MCP Endpoint${COLORS.reset}`);
+    const mcpUrl = await ask('🔗 MCP Endpoint URL?', '');
+    if (mcpUrl) config.mcp = { ...config.mcp, endpoint_url: mcpUrl };
+
+    // Shell timeout
+    const timeout = await ask('⏱️ Shell timeout (ms)?', String(config.tools?.shell_timeout || 30000));
+    config.tools = { ...config.tools, shell_timeout: parseInt(timeout) || 30000 };
+
+    config._wizard_done = true;
+    await saveConfig(root, config);
+
+    console.log(`\n${COLORS.green}✅ Configuration saved!${COLORS.reset}\n`);
+    return config;
+  } finally {
+    rl.close();
+  }
+}

package/src/core/workspace.js

@@ -0,0 +1,96 @@
+/**
+ * Workspace — auto-detect project type, structure, and capabilities
+ */
+import { readFile, readdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, basename } from 'path';
+import { getConfig } from './config.js';
+
+const PROJECT_TYPES = {
+  'package.json': { type: 'node', lang: 'javascript/typescript' },
+  'requirements.txt': { type: 'python', lang: 'python' },
+  'pyproject.toml': { type: 'python', lang: 'python' },
+  'Cargo.toml': { type: 'rust', lang: 'rust' },
+  'go.mod': { type: 'go', lang: 'go' },
+  'CMakeLists.txt': { type: 'cmake', lang: 'c/c++' },
+  'Makefile': { type: 'make', lang: 'varies' },
+  'pom.xml': { type: 'maven', lang: 'java' },
+  'build.gradle': { type: 'gradle', lang: 'java/kotlin' },
+  'Gemfile': { type: 'ruby', lang: 'ruby' },
+  'composer.json': { type: 'composer', lang: 'php' },
+};
+
+export async function detectWorkspace(dir) {
+  const cwd = dir || getConfig().agent?.workspace || process.cwd();
+  const info = {
+    path: cwd,
+    name: basename(cwd),
+    type: 'unknown',
+    language: 'unknown',
+    files: [],
+    structure: {},
+  };
+
+  // Detect project type
+  for (const [file, meta] of Object.entries(PROJECT_TYPES)) {
+    if (existsSync(join(cwd, file))) {
+      info.type = meta.type;
+      info.language = meta.lang;
+      info.marker = file;
+      break;
+    }
+  }
+
+  // Read key config files
+  if (info.type === 'node') {
+    try {
+      const pkg = JSON.parse(await readFile(join(cwd, 'package.json'), 'utf-8'));
+      info.name = pkg.name || info.name;
+      info.version = pkg.version;
+      info.scripts = Object.keys(pkg.scripts || {});
+      info.dependencies = Object.keys(pkg.dependencies || {});
+      info.devDependencies = Object.keys(pkg.devDependencies || {});
+      info.moduleType = pkg.type || 'commonjs';
+    } catch {}
+  }
+
+  if (info.type === 'python') {
+    try {
+      if (existsSync(join(cwd, 'pyproject.toml'))) {
+        const content = await readFile(join(cwd, 'pyproject.toml'), 'utf-8');
+        const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
+        if (nameMatch) info.name = nameMatch[1];
+      }
+    } catch {}
+  }
+
+  // Detect common directories
+  const commonDirs = ['src', 'lib', 'test', 'tests', 'spec', 'docs', 'public', 'dist', 'build', 'bin'];
+  try {
+    const entries = await readdir(cwd, { withFileTypes: true });
+    info.dirs = entries.filter(e => e.isDirectory() && commonDirs.includes(e.name)).map(e => e.name);
+    info.files = entries.filter(e => e.isFile()).map(e => e.name).slice(0, 30);
+  } catch {}
+
+  // Detect git
+  info.hasGit = existsSync(join(cwd, '.git'));
+  info.hasDocker = existsSync(join(cwd, 'Dockerfile')) || existsSync(join(cwd, 'docker-compose.yml'));
+  info.hasCI = existsSync(join(cwd, '.github')) || existsSync(join(cwd, '.gitlab-ci.yml'));
+
+  return info;
+}
+
+export function formatWorkspace(info) {
+  const lines = [
+    `📁 ${info.name} (${info.type})`,
+    `   Language: ${info.language}`,
+    `   Path: ${info.path}`,
+  ];
+  if (info.version) lines.push(`   Version: ${info.version}`);
+  if (info.scripts?.length) lines.push(`   Scripts: ${info.scripts.join(', ')}`);
+  if (info.dirs?.length) lines.push(`   Dirs: ${info.dirs.join(', ')}`);
+  if (info.hasGit) lines.push('   Git: ✅');
+  if (info.hasDocker) lines.push('   Docker: ✅');
+  if (info.hasCI) lines.push('   CI: ✅');
+  return lines.join('\n');
+}