pelulu-cli 1.0.0

package/src/tools/diff.js

@@ -0,0 +1,118 @@
+/**
+ * Diff Tool — file comparison (1 MCP tool, 3 actions)
+ * Actions: compare, stats, patch
+ */
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+import { homedir } from 'os';
+import { log } from '../core/logger.js';
+
+const HOME = homedir();
+
+function safe(p) {
+  if (!p) throw new Error('path required');
+  return resolve(p.replace(/^~(?=$|[/\\])/g, HOME));
+}
+
+function diffLines(oldText, newText) {
+  const oldLines = oldText.split('\n');
+  const newLines = newText.split('\n');
+  const changes = [];
+  const maxLen = Math.max(oldLines.length, newLines.length);
+  for (let i = 0; i < maxLen; i++) {
+    if (oldLines[i] !== newLines[i]) {
+      changes.push({ line: i + 1, old: oldLines[i] || null, new: newLines[i] || null });
+    }
+  }
+  return changes;
+}
+
+const ACTIONS = {
+  compare: {
+    required: ['file1', 'file2'],
+    handler: async ({ file1, file2, context }) => {
+      const abs1 = safe(file1);
+      const abs2 = safe(file2);
+      const c1 = await readFile(abs1, 'utf-8');
+      const c2 = await readFile(abs2, 'utf-8');
+      const changes = diffLines(c1, c2);
+      const ctx = context || 3;
+
+      // Build hunks with context
+      const hunks = [];
+      for (const change of changes) {
+        const start = Math.max(0, change.line - ctx - 1);
+        const end = Math.min(Math.max(c1.split('\n').length, c2.split('\n').length), change.line + ctx);
+        const oldSlice = c1.split('\n').slice(start, end);
+        const newSlice = c2.split('\n').slice(start, end);
+        hunks.push({ line: change.line, old: change.old, new: change.new, context: { old: oldSlice, new: newSlice } });
+      }
+
+      return { file1: abs1, file2: abs2, totalChanges: changes.length, hunks: hunks.slice(0, 20) };
+    },
+  },
+
+  stats: {
+    required: ['file1', 'file2'],
+    handler: async ({ file1, file2 }) => {
+      const abs1 = safe(file1);
+      const abs2 = safe(file2);
+      const c1 = await readFile(abs1, 'utf-8');
+      const c2 = await readFile(abs2, 'utf-8');
+      const changes = diffLines(c1, c2);
+      const l1 = c1.split('\n').length;
+      const l2 = c2.split('\n').length;
+      return {
+        file1: abs1, file2: abs2,
+        lines1: l1, lines2: l2,
+        changes: changes.length,
+        identical: changes.length === 0,
+      };
+    },
+  },
+
+  patch: {
+    required: ['file1', 'file2'],
+    handler: async ({ file1, file2 }) => {
+      const abs1 = safe(file1);
+      const abs2 = safe(file2);
+      const c1 = await readFile(abs1, 'utf-8');
+      const c2 = await readFile(abs2, 'utf-8');
+      const changes = diffLines(c1, c2);
+
+      const patch = [`--- ${abs1}`, `+++ ${abs2}`];
+      for (const change of changes.slice(0, 50)) {
+        if (change.old !== null) patch.push(`-${change.old}`);
+        if (change.new !== null) patch.push(`+${change.new}`);
+      }
+
+      return { patch: patch.join('\n'), changes: changes.length };
+    },
+  },
+};
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'diff',
+  description: 'File comparison: compare, stats, patch',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: actionNames },
+      file1: { type: 'string', description: 'First file path' },
+      file2: { type: 'string', description: 'Second file path' },
+      context: { type: 'number', description: 'Context lines (default 3)' },
+    },
+    required: ['action'],
+  },
+  async handler({ action, ...params }) {
+    const a = ACTIONS[action];
+    if (!a) throw new Error(`Unknown action: ${action}`);
+    for (const f of a.required) {
+      if (params[f] === undefined) throw new Error(`Missing required: ${f}`);
+    }
+    return a.handler(params);
+  },
+};

package/src/tools/env.js

@@ -0,0 +1,58 @@
+/**
+ * Env Tool — environment variable operations (1 MCP tool, 3 actions)
+ */
+const SENSITIVE = ['KEY', 'TOKEN', 'SECRET', 'PASSWORD', 'CREDENTIAL', 'PRIVATE'];
+
+function isSensitive(name) {
+  return SENSITIVE.some(s => name.toUpperCase().includes(s));
+}
+
+function mask(name, value) {
+  if (isSensitive(name)) return '***MASKED***';
+  return value;
+}
+
+const ACTIONS = {
+  async get({ name }) {
+    if (!name) throw new Error('env name required');
+    const value = process.env[name];
+    if (value === undefined) return { name, exists: false };
+    return { name, value: mask(name, value), exists: true };
+  },
+
+  async set({ name, value }) {
+    if (!name) throw new Error('env name required');
+    if (isSensitive(name)) throw new Error('Cannot set sensitive env var via tool');
+    process.env[name] = value || '';
+    return { name, set: true };
+  },
+
+  async list({ filter }) {
+    const vars = {};
+    for (const [k, v] of Object.entries(process.env)) {
+      if (filter && !k.includes(filter.toUpperCase()) && !k.includes(filter)) continue;
+      vars[k] = mask(k, v);
+    }
+    return { count: Object.keys(vars).length, vars };
+  },
+};
+
+export default {
+  name: 'env',
+  description: 'Environment variables: get, set, list',
+  actions: Object.keys(ACTIONS).map(name => ({ name })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: Object.keys(ACTIONS) },
+      name: { type: 'string', description: 'Variable name' },
+      value: { type: 'string', description: 'Value to set' },
+      filter: { type: 'string', description: 'Filter pattern (for list)' },
+    },
+    required: ['action'],
+  },
+  async handler({ action, ...params }) {
+    if (!ACTIONS[action]) throw new Error(`Unknown action: ${action}. Use: ${Object.keys(ACTIONS).join(', ')}`);
+    return ACTIONS[action](params);
+  },
+};

package/src/tools/file.js

@@ -0,0 +1,177 @@
+/**
+ * File Tool — consolidated file operations (1 MCP tool, 9 actions)
+ * Actions: read, write, edit, list, delete, mkdir, copy, move, exists
+ */
+import { readFile, writeFile, readdir, stat, mkdir, unlink, rename, copyFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve, join, dirname } from 'path';
+import { homedir } from 'os';
+import { log } from '../core/logger.js';
+
+const HOME = homedir();
+
+function safe(p) {
+  if (!p) throw new Error('path is required');
+  const abs = resolve(p.replace(/^~(?=$|[/\\])/g, HOME));
+  const allowed = [HOME, process.cwd()];
+  if (!allowed.some(prefix => abs.startsWith(prefix))) throw new Error(`Access denied: ${abs}`);
+  return abs;
+}
+
+async function statOrNull(p) {
+  try { return await stat(p); } catch { return null; }
+}
+
+const ACTIONS = {
+  read: {
+    required: ['path'],
+    handler: async ({ path, offset, limit }) => {
+      const abs = safe(path);
+      const content = await readFile(abs, 'utf-8');
+      const start = offset || 0;
+      const end = limit ? start + limit : content.length;
+      return { path: abs, content: content.slice(start, end), totalSize: content.length };
+    },
+  },
+
+  write: {
+    required: ['path', 'content'],
+    handler: async ({ path, content }) => {
+      const abs = safe(path);
+      await mkdir(dirname(abs), { recursive: true });
+      await writeFile(abs, content, 'utf-8');
+      log('file', `📝 Written: ${abs} (${content.length} chars)`);
+      return { path: abs, written: content.length };
+    },
+  },
+
+  edit: {
+    required: ['path', 'old_text', 'new_text'],
+    handler: async ({ path, old_text, new_text }) => {
+      const abs = safe(path);
+      let content = await readFile(abs, 'utf-8');
+      if (!content.includes(old_text)) throw new Error(`old_text not found in ${abs}`);
+      const count = content.split(old_text).length - 1;
+      content = content.replace(old_text, new_text);
+      await writeFile(abs, content, 'utf-8');
+      log('file', `✏️ Edited: ${abs} (${count} occurrence(s))`);
+      return { path: abs, edited: true, occurrences: count };
+    },
+  },
+
+  list: {
+    required: [],
+    handler: async ({ path, recursive }) => {
+      const dir = safe(path || HOME);
+      if (recursive) return { path: dir, items: await _listRecursive(dir, dir) };
+      const entries = await readdir(dir, { withFileTypes: true });
+      const items = await Promise.all(entries.map(async e => {
+        const fp = join(dir, e.name);
+        const s = await statOrNull(fp);
+        return { name: e.name, type: e.isDirectory() ? 'dir' : 'file', size: s?.size || 0 };
+      }));
+      return { path: dir, count: items.length, items };
+    },
+  },
+
+  delete: {
+    required: ['path'],
+    handler: async ({ path }) => {
+      const abs = safe(path);
+      if (!existsSync(abs)) throw new Error(`Not found: ${abs}`);
+      await unlink(abs);
+      log('file', `🗑️ Deleted: ${abs}`);
+      return { path: abs, deleted: true };
+    },
+  },
+
+  mkdir: {
+    required: ['path'],
+    handler: async ({ path }) => {
+      const abs = safe(path);
+      await mkdir(abs, { recursive: true });
+      return { path: abs, created: true };
+    },
+  },
+
+  copy: {
+    required: ['from', 'to'],
+    handler: async ({ from, to }) => {
+      const absFrom = safe(from);
+      const absTo = safe(to);
+      await mkdir(dirname(absTo), { recursive: true });
+      await copyFile(absFrom, absTo);
+      return { from: absFrom, to: absTo, copied: true };
+    },
+  },
+
+  move: {
+    required: ['from', 'to'],
+    handler: async ({ from, to }) => {
+      const absFrom = safe(from);
+      const absTo = safe(to);
+      await mkdir(dirname(absTo), { recursive: true });
+      await rename(absFrom, absTo);
+      return { from: absFrom, to: absTo, moved: true };
+    },
+  },
+
+  exists: {
+    required: ['path'],
+    handler: async ({ path }) => {
+      const abs = safe(path);
+      if (!existsSync(abs)) return { exists: false, path: abs };
+      const s = await stat(abs);
+      return { exists: true, path: abs, type: s.isDirectory() ? 'dir' : 'file', size: s.size };
+    },
+  },
+};
+
+async function _listRecursive(base, dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const items = [];
+  for (const e of entries) {
+    const fp = join(dir, e.name);
+    const rel = fp.slice(base.length + 1);
+    if (e.isDirectory()) {
+      items.push({ name: rel, type: 'dir' });
+      items.push(...(await _listRecursive(base, fp)));
+    } else {
+      const s = await statOrNull(fp);
+      items.push({ name: rel, type: 'file', size: s?.size || 0 });
+    }
+  }
+  return items;
+}
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'file',
+  description: 'File operations: read, write, edit, list, delete, mkdir, copy, move, exists',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: actionNames, description: 'Action to perform' },
+      path: { type: 'string', description: 'File or directory path' },
+      content: { type: 'string', description: 'Content to write' },
+      old_text: { type: 'string', description: 'Exact text to find (for edit)' },
+      new_text: { type: 'string', description: 'Replacement text (for edit)' },
+      from: { type: 'string', description: 'Source path (for copy/move)' },
+      to: { type: 'string', description: 'Destination path (for copy/move)' },
+      offset: { type: 'number', description: 'Read start offset (chars)' },
+      limit: { type: 'number', description: 'Read max chars' },
+      recursive: { type: 'boolean', description: 'Recursive list' },
+    },
+    required: ['action'],
+  },
+  async handler({ action, ...params }) {
+    const a = ACTIONS[action];
+    if (!a) throw new Error(`Unknown action: ${action}. Use: ${actionNames.join(', ')}`);
+    for (const field of a.required) {
+      if (params[field] === undefined) throw new Error(`Missing required field: ${field}`);
+    }
+    return a.handler(params);
+  },
+};

package/src/tools/git.js

@@ -0,0 +1,166 @@
+/**
+ * Git Tool — consolidated git operations (1 MCP tool, 10 actions)
+ * Actions: init, clone, status, diff, log, add, commit, push, pull, branch
+ */
+import { exec } from 'child_process';
+import { log } from '../core/logger.js';
+import { getConfig } from '../core/config.js';
+
+function git(cmd, cwd) {
+  return new Promise((resolve, reject) => {
+    exec(`git ${cmd}`, { cwd, timeout: 30000, maxBuffer: 512 * 1024 }, (err, stdout, stderr) => {
+      if (err?.killed) return reject(new Error('Git timed out'));
+      resolve({ stdout: stdout?.trim() || '', stderr: stderr?.trim() || '', code: err?.code ?? 0 });
+    });
+  });
+}
+
+function cwd(params) { return params?.cwd || getConfig().agent?.workspace || process.cwd(); }
+
+const ACTIONS = {
+  init: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params);
+      await git('init', dir);
+      return { initialized: true, path: dir };
+    },
+  },
+
+  clone: {
+    required: ['url'],
+    handler: async ({ url, path, branch }) => {
+      const cmd = `clone${branch ? ` -b ${branch}` : ''} "${url}"${path ? ` "${path}"` : ''}`;
+      await git(cmd);
+      return { cloned: true, url, path: path || url.split('/').pop()?.replace('.git', '') };
+    },
+  },
+
+  status: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params);
+      const r = await git('status --porcelain', dir);
+      const branch = await git('rev-parse --abbrev-ref HEAD', dir);
+      return { branch: branch.stdout, dirty: !!r.stdout, changes: r.stdout.split('\n').filter(Boolean) };
+    },
+  },
+
+  diff: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params);
+      const staged = params.staged ? ' --staged' : '';
+      const file = params.file ? ` -- "${params.file}"` : '';
+      const r = await git(`diff${staged} --stat${file}`, dir);
+      const detail = await git(`diff${staged}${file}`, dir);
+      return { summary: r.stdout || 'No changes', detail: detail.stdout?.slice(0, 5000) || '' };
+    },
+  },
+
+  log: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params);
+      const n = params.limit || 10;
+      const r = await git(`log --oneline -${n}`, dir);
+      return { commits: r.stdout.split('\n').filter(Boolean) };
+    },
+  },
+
+  add: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params);
+      const files = params.files || '.';
+      await git(`add ${files}`, dir);
+      return { added: files };
+    },
+  },
+
+  commit: {
+    required: ['message'],
+    handler: async (params) => {
+      const dir = cwd(params);
+      const msg = params.message.replace(/"/g, '\\"');
+      const r = await git(`commit -m "${msg}"`, dir);
+      if (r.code !== 0 && r.stderr.includes('nothing to commit')) return { committed: false, reason: 'nothing to commit' };
+      log('git', `📝 Committed: ${params.message}`);
+      return { committed: true, message: params.message, output: r.stdout.slice(-300) };
+    },
+  },
+
+  push: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params);
+      const remote = params.remote || '';
+      const branch = params.branch || '';
+      const r = await git(`push ${remote} ${branch}`.trim(), dir);
+      return { pushed: true, output: r.stdout.slice(-300) || r.stderr.slice(-300) };
+    },
+  },
+
+  pull: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params);
+      const remote = params.remote || '';
+      const branch = params.branch || '';
+      const r = await git(`pull ${remote} ${branch}`.trim(), dir);
+      return { pulled: true, output: r.stdout.slice(-300) };
+    },
+  },
+
+  branch: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params);
+      if (params.delete && params.name) {
+        await git(`branch -d ${params.name}`, dir);
+        return { deleted: params.name };
+      }
+      if (params.name) {
+        await git(`branch ${params.name}`, dir);
+        return { created: params.name };
+      }
+      const r = await git('branch -a', dir);
+      return { branches: r.stdout.split('\n').filter(Boolean) };
+    },
+  },
+};
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'git',
+  description: 'Git operations: init, clone, status, diff, log, add, commit, push, pull, branch',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: actionNames },
+      cwd: { type: 'string', description: 'Working directory' },
+      url: { type: 'string', description: 'Repo URL (for clone)' },
+      path: { type: 'string', description: 'Target path' },
+      branch: { type: 'string', description: 'Branch name' },
+      message: { type: 'string', description: 'Commit message' },
+      files: { type: 'string', description: 'Files to add' },
+      remote: { type: 'string', description: 'Remote name' },
+      limit: { type: 'number', description: 'Log limit' },
+      staged: { type: 'boolean', description: 'Staged diff' },
+      file: { type: 'string', description: 'Specific file for diff' },
+      name: { type: 'string', description: 'Branch name' },
+      delete: { type: 'boolean', description: 'Delete branch' },
+    },
+    required: ['action'],
+  },
+  async handler({ action, ...params }) {
+    const a = ACTIONS[action];
+    if (!a) throw new Error(`Unknown action: ${action}. Use: ${actionNames.join(', ')}`);
+    for (const field of a.required) {
+      if (params[field] === undefined) throw new Error(`Missing required: ${field}`);
+    }
+    return a.handler(params);
+  },
+};

package/src/tools/history.js

@@ -0,0 +1,64 @@
+/**
+ * History Tool — tool call history and session info (1 MCP tool, 3 actions)
+ * Actions: list, clear, stats
+ */
+import { log } from '../core/logger.js';
+
+// Shared history store (injected via init)
+let _history = [];
+
+export function setHistoryStore(history) { _history = history; }
+
+const ACTIONS = {
+  list: {
+    required: [],
+    handler: async ({ limit }) => {
+      const n = limit || 20;
+      const recent = _history.slice(-n);
+      return { count: recent.length, total: _history.length, calls: recent };
+    },
+  },
+
+  clear: {
+    required: [],
+    handler: async () => {
+      const count = _history.length;
+      _history.length = 0;
+      return { cleared: count };
+    },
+  },
+
+  stats: {
+    required: [],
+    handler: async () => {
+      const freq = {};
+      for (const h of _history) {
+        const key = `${h.tool}.${h.action || '-'}`;
+        freq[key] = (freq[key] || 0) + 1;
+      }
+      const top = Object.entries(freq).sort((a, b) => b[1] - a[1]).slice(0, 10);
+      return { total: _history.length, topTools: top.map(([name, count]) => ({ name, count })) };
+    },
+  },
+};
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'history',
+  description: 'Tool call history: list, clear, stats',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: actionNames },
+      limit: { type: 'number', description: 'Number of recent calls to show' },
+    },
+    required: ['action'],
+  },
+  async handler({ action, ...params }) {
+    const a = ACTIONS[action];
+    if (!a) throw new Error(`Unknown action: ${action}`);
+    return a.handler(params);
+  },
+};

package/src/tools/network.js

@@ -0,0 +1,87 @@
+/**
+ * Network Tool — network operations (1 MCP tool, 3 actions)
+ */
+import https from 'https';
+import http from 'http';
+import { exec } from 'child_process';
+import { createWriteStream } from 'fs';
+import { pipeline } from 'stream/promises';
+import { log } from '../core/logger.js';
+
+function httpGet(url, maxChars = 5000) {
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith('https') ? https : http;
+    client.get(url, { timeout: 15000, headers: { 'User-Agent': 'coding-agent/1.0' } }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return httpGet(res.headers.location, maxChars).then(resolve, reject);
+      }
+      let d = '';
+      res.on('data', c => { if (d.length < maxChars) d += c; });
+      res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body: d }));
+    }).on('error', reject);
+  });
+}
+
+const ACTIONS = {
+  async fetch({ url, method, body, headers }) {
+    if (!url) throw new Error('url required');
+    log('network', `🌐 ${method || 'GET'} ${url}`);
+    const result = await httpGet(url);
+    return { url, status: result.status, body: result.body.slice(0, 5000) };
+  },
+
+  async download({ url, path }) {
+    if (!url || !path) throw new Error('url and path required');
+    log('network', `📥 Downloading: ${url}`);
+    const client = url.startsWith('https') ? https : http;
+    return new Promise((resolve, reject) => {
+      client.get(url, { timeout: 30000, headers: { 'User-Agent': 'coding-agent/1.0' } }, async (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          try { resolve(await ACTIONS.download({ url: res.headers.location, path })); } catch (e) { reject(e); }
+          return;
+        }
+        if (res.statusCode !== 200) return reject(new Error(`HTTP ${res.statusCode}`));
+        const ws = createWriteStream(path);
+        try {
+          await pipeline(res, ws);
+          resolve({ downloaded: true, path, url });
+        } catch (e) { reject(e); }
+      }).on('error', reject);
+    });
+  },
+
+  async ping({ host, count }) {
+    if (!host) throw new Error('host required');
+    const n = count || 3;
+    const r = await new Promise((resolve) => {
+      exec(`ping -c ${n} "${host}"`, { timeout: 15000 }, (_, stdout, stderr) => {
+        resolve({ stdout: stdout?.trim() || '', stderr: stderr?.trim() || '' });
+      });
+    });
+    return { host, result: r.stdout || r.stderr };
+  },
+};
+
+export default {
+  name: 'network',
+  description: 'Network operations: fetch (HTTP request), download (save file), ping',
+  actions: Object.keys(ACTIONS).map(name => ({ name })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: Object.keys(ACTIONS) },
+      url: { type: 'string', description: 'URL' },
+      method: { type: 'string', description: 'HTTP method' },
+      body: { type: 'string', description: 'Request body' },
+      headers: { type: 'object', description: 'Request headers' },
+      path: { type: 'string', description: 'Save path (for download)' },
+      host: { type: 'string', description: 'Host to ping' },
+      count: { type: 'number', description: 'Ping count' },
+    },
+    required: ['action'],
+  },
+  async handler({ action, ...params }) {
+    if (!ACTIONS[action]) throw new Error(`Unknown action: ${action}. Use: ${Object.keys(ACTIONS).join(', ')}`);
+    return ACTIONS[action](params);
+  },
+};