pelulu-cli 1.0.0

package/src/tools/process.js

@@ -0,0 +1,69 @@
+/**
+ * Process Tool — process management (1 MCP tool, 4 actions)
+ */
+import { exec } from 'child_process';
+import { log } from '../core/logger.js';
+
+function run(cmd) {
+  return new Promise((resolve) => {
+    exec(cmd, { timeout: 10000, maxBuffer: 256 * 1024 }, (_, stdout, stderr) => {
+      resolve({ stdout: stdout?.trim() || '', stderr: stderr?.trim() || '' });
+    });
+  });
+}
+
+const ACTIONS = {
+  async list({ filter }) {
+    const cmd = filter
+      ? `ps aux | grep -i "${filter}" | grep -v grep`
+      : 'ps aux --sort=-%mem | head -20';
+    const r = await run(cmd);
+    return { processes: r.stdout };
+  },
+
+  async info({ pid }) {
+    if (!pid) throw new Error('pid required');
+    const r = await run(`ps -p ${pid} -o pid,ppid,user,%cpu,%mem,vsz,rss,etime,cmd --no-headers`);
+    if (!r.stdout) throw new Error(`Process ${pid} not found`);
+    const parts = r.stdout.trim().split(/\s+/);
+    return { pid: parts[0], ppid: parts[1], user: parts[2], cpu: parts[3], mem: parts[4], vsz: parts[5], rss: parts[6], time: parts[7], cmd: parts.slice(8).join(' ') };
+  },
+
+  async kill({ pid, signal }) {
+    if (!pid) throw new Error('pid required');
+    const sig = signal || 'SIGTERM';
+    try {
+      process.kill(pid, sig);
+      return { pid, signal, killed: true };
+    } catch (e) {
+      throw new Error(`Cannot kill ${pid}: ${e.message}`);
+    }
+  },
+
+  async top({ limit }) {
+    const n = limit || 15;
+    const r = await run(`ps aux --sort=-%cpu | head -${n + 1}`);
+    return { top: r.stdout };
+  },
+};
+
+export default {
+  name: 'process',
+  description: 'Process management: list, info, kill, top',
+  actions: Object.keys(ACTIONS).map(name => ({ name })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: Object.keys(ACTIONS) },
+      pid: { type: 'number', description: 'Process ID' },
+      signal: { type: 'string', description: 'Signal (default SIGTERM)' },
+      filter: { type: 'string', description: 'Filter pattern' },
+      limit: { type: 'number', description: 'Number of processes' },
+    },
+    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/project.js

@@ -0,0 +1,152 @@
+/**
+ * Project Tool — project lifecycle operations (1 MCP tool, 6 actions)
+ * Actions: init, build, test, lint, deps, info
+ */
+import { exec } from 'child_process';
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { log } from '../core/logger.js';
+import { getConfig } from '../core/config.js';
+
+function run(cmd, cwd, timeout = 120000) {
+  return new Promise((resolve, reject) => {
+    exec(cmd, { cwd, timeout, maxBuffer: 512 * 1024 }, (err, stdout, stderr) => {
+      if (err?.killed) return reject(new Error(`Timed out: ${cmd}`));
+      resolve({ stdout: stdout?.trim() || '', stderr: stderr?.trim() || '', code: err?.code ?? 0 });
+    });
+  });
+}
+
+function cwd(p) { return p || getConfig().agent?.workspace || process.cwd(); }
+
+async function detectProject(dir) {
+  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'],
+  ];
+  for (const [file, type] of checks) {
+    if (existsSync(join(dir, file))) return type;
+  }
+  return 'unknown';
+}
+
+const BUILD_CMD = { node: 'npm run build', python: 'python -m build', go: 'go build ./...', rust: 'cargo build', make: 'make', cmake: 'cmake --build build', java: 'mvn package', gradle: 'gradle build' };
+const TEST_CMD = { node: 'npm test', python: 'pytest', go: 'go test ./...', rust: 'cargo test', make: 'make test', java: 'mvn test', gradle: 'gradle test' };
+const LINT_CMD = { node: 'npx eslint . 2>&1 || true', python: 'ruff check . 2>&1 || true', go: 'golangci-lint run 2>&1 || true', rust: 'cargo clippy 2>&1 || true' };
+const INSTALL_CMD = { node: 'npm install', python: 'pip install -r requirements.txt', go: 'go mod download', rust: 'cargo fetch', java: 'mvn dependency:resolve', gradle: 'gradle dependencies' };
+
+const ACTIONS = {
+  init: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params.path);
+      const type = params.template || await detectProject(dir);
+      const cmds = { node: 'npm init -y', python: 'python -m venv .venv', go: 'go mod init project', rust: 'cargo init' };
+      if (!cmds[type]) throw new Error(`No init for ${type}`);
+      await run(cmds[type], dir);
+      return { initialized: true, type, path: dir };
+    },
+  },
+
+  build: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params.path);
+      const type = await detectProject(dir);
+      const cmd = BUILD_CMD[type];
+      if (!cmd) throw new Error(`No build for ${type}`);
+      log('project', `🔨 Building (${type})...`);
+      const r = await run(cmd, dir);
+      return { success: r.code === 0, type, exitCode: r.code, output: r.stdout.slice(-500) || r.stderr.slice(-500) };
+    },
+  },
+
+  test: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params.path);
+      const type = await detectProject(dir);
+      const cmd = TEST_CMD[type];
+      if (!cmd) throw new Error(`No test for ${type}`);
+      log('project', `🧪 Testing (${type})...`);
+      const r = await run(cmd, dir);
+      return { passed: r.code === 0, type, exitCode: r.code, output: r.stdout.slice(-1000) || r.stderr.slice(-1000) };
+    },
+  },
+
+  lint: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params.path);
+      const type = await detectProject(dir);
+      const cmd = LINT_CMD[type];
+      if (!cmd) throw new Error(`No lint for ${type}`);
+      const r = await run(cmd, dir);
+      return { type, issues: r.stdout.slice(-2000) };
+    },
+  },
+
+  deps: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params.path);
+      const type = await detectProject(dir);
+      if (params.install) {
+        const cmd = INSTALL_CMD[type];
+        if (!cmd) throw new Error(`No install for ${type}`);
+        await run(cmd, dir, 180000);
+        return { installed: true, type };
+      }
+      try {
+        if (type === 'node') {
+          const pkg = JSON.parse(await readFile(join(dir, 'package.json'), 'utf-8'));
+          return { type, dependencies: pkg.dependencies || {}, devDependencies: pkg.devDependencies || {} };
+        }
+        return { type, message: 'Set install=true to install deps' };
+      } catch { return { type, error: 'Could not read project config' }; }
+    },
+  },
+
+  info: {
+    required: [],
+    handler: async (params) => {
+      const dir = cwd(params.path);
+      const type = await detectProject(dir);
+      const info = { type, path: dir };
+      try {
+        if (type === 'node') {
+          const pkg = JSON.parse(await readFile(join(dir, 'package.json'), 'utf-8'));
+          info.name = pkg.name; info.version = pkg.version;
+          info.scripts = Object.keys(pkg.scripts || {});
+          info.deps = Object.keys(pkg.dependencies || {});
+        }
+      } catch {}
+      return info;
+    },
+  },
+};
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'project',
+  description: 'Project lifecycle: init, build, test, lint, deps, info (auto-detects type)',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: actionNames },
+      path: { type: 'string', description: 'Project directory' },
+      template: { type: 'string', description: 'Project type for init' },
+      install: { type: 'boolean', description: 'Install deps' },
+    },
+    required: ['action'],
+  },
+  async handler({ action, ...params }) {
+    const a = ACTIONS[action];
+    if (!a) throw new Error(`Unknown action: ${action}. Use: ${actionNames.join(', ')}`);
+    return a.handler(params);
+  },
+};

package/src/tools/search.js

@@ -0,0 +1,100 @@
+/**
+ * Search Tool — consolidated search operations (1 MCP tool, 3 actions)
+ * Actions: grep, find, web
+ */
+import { exec } from 'child_process';
+import https from 'https';
+import http from 'http';
+import { log } from '../core/logger.js';
+
+function runCmd(cmd, timeout = 10000) {
+  return new Promise((resolve) => {
+    exec(cmd, { timeout, maxBuffer: 256 * 1024 }, (_, stdout, stderr) => {
+      resolve({ stdout: stdout?.trim() || '', stderr: stderr?.trim() || '' });
+    });
+  });
+}
+
+function httpGet(url, maxChars = 8000) {
+  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, body: d }));
+    }).on('error', reject);
+  });
+}
+
+const ACTIONS = {
+  grep: {
+    required: ['pattern'],
+    handler: async ({ pattern, path, ignoreCase, include, context }) => {
+      if (!pattern) throw new Error('pattern required');
+      log('search', `🔍 grep: ${pattern}`);
+      const flags = ignoreCase ? '-rn' : '-rn';
+      const ic = ignoreCase ? 'i' : '';
+      const inc = include ? `--include="*.${include}"` : '';
+      const ctx = context ? `-C ${context}` : '';
+      const cmd = `grep ${flags}${ic} ${inc} ${ctx} "${pattern}" "${path || '.'}" 2>/dev/null | head -100`;
+      const r = await runCmd(cmd);
+      const lines = r.stdout.split('\n').filter(Boolean);
+      return { pattern, matches: lines.length, results: lines };
+    },
+  },
+
+  find: {
+    required: ['name'],
+    handler: async ({ name, path, type }) => {
+      log('search', `🔍 find: ${name}`);
+      const t = type ? `-type ${type}` : '';
+      const cmd = `find "${path || '.'}" ${t} -name "${name}" 2>/dev/null | head -50`;
+      const r = await runCmd(cmd);
+      return { pattern: name, matches: r.stdout.split('\n').filter(Boolean).length, files: r.stdout.split('\n').filter(Boolean) };
+    },
+  },
+
+  web: {
+    required: ['url'],
+    handler: async ({ url, maxChars }) => {
+      log('search', `🌐 fetch: ${url}`);
+      const r = await httpGet(url, maxChars || 8000);
+      return { url, status: r.status, body: r.body.slice(0, maxChars || 8000), length: r.body.length };
+    },
+  },
+};
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'search',
+  description: 'Search: grep (text in files), find (files by name), web (fetch URL content)',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: actionNames },
+      pattern: { type: 'string', description: 'Search pattern (for grep/find)' },
+      path: { type: 'string', description: 'Directory or URL' },
+      name: { type: 'string', description: 'Filename glob (for find)' },
+      type: { type: 'string', description: 'File type: f=file, d=dir' },
+      ignoreCase: { type: 'boolean' },
+      include: { type: 'string', description: 'Extension filter for grep' },
+      context: { type: 'number', description: 'Context lines for grep' },
+      url: { type: 'string', description: 'URL to fetch' },
+      maxChars: { type: 'number', description: 'Max response chars' },
+    },
+    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/shell.js

@@ -0,0 +1,91 @@
+/**
+ * Shell Tool — consolidated shell operations (1 MCP tool, 4 actions)
+ * Actions: exec, bg, ps, kill
+ */
+import { exec, spawn } from 'child_process';
+import { log } from '../core/logger.js';
+import { getConfig } from '../core/config.js';
+
+const BLOCKED = [/rm\s+-rf\s+\//, /mkfs/, /dd\s+if=.*of=\/dev/, /chmod\s+777\s+\//];
+
+function isBlocked(cmd) { return BLOCKED.some(re => re.test(cmd)); }
+
+function run(cmd, timeout) {
+  return new Promise((resolve, reject) => {
+    if (isBlocked(cmd)) return reject(new Error('Blocked: dangerous command'));
+    const cfg = getConfig();
+    const t = timeout || cfg.tools?.shell_timeout || 30000;
+    exec(cmd, { timeout: t, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err?.killed) return reject(new Error(`Timed out after ${t}ms`));
+      resolve({ stdout: stdout?.trim() || '', stderr: stderr?.trim() || '', code: err?.code ?? 0 });
+    });
+  });
+}
+
+const ACTIONS = {
+  exec: {
+    required: ['command'],
+    handler: async ({ command, timeout }) => {
+      log('shell', `⚙️ $ ${command}`);
+      const result = await run(command, timeout);
+      const maxLen = getConfig().tools?.max_output || 10000;
+      return { stdout: result.stdout.slice(0, maxLen), stderr: result.stderr.slice(0, 2000), exitCode: result.code };
+    },
+  },
+
+  bg: {
+    required: ['command'],
+    handler: async ({ command }) => {
+      log('shell', `⚙️ [bg] $ ${command}`);
+      const child = spawn('bash', ['-c', command], { detached: true, stdio: 'ignore' });
+      child.unref();
+      return { pid: child.pid, background: true, command };
+    },
+  },
+
+  ps: {
+    required: [],
+    handler: async ({ filter }) => {
+      const cmd = filter ? `ps aux | grep -i "${filter}" | grep -v grep` : 'ps aux --sort=-%cpu | head -20';
+      const result = await run(cmd);
+      return { processes: result.stdout };
+    },
+  },
+
+  kill: {
+    required: ['pid'],
+    handler: async ({ pid, signal }) => {
+      const sig = signal || 'SIGTERM';
+      process.kill(pid, sig);
+      return { pid, signal: sig, killed: true };
+    },
+  },
+};
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'shell',
+  description: 'Shell operations: exec (run command), bg (background process), ps (list), kill',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: actionNames },
+      command: { type: 'string', description: 'Shell command' },
+      timeout: { type: 'number', description: 'Timeout ms' },
+      filter: { type: 'string', description: 'Process filter' },
+      pid: { type: 'number', description: 'Process ID' },
+      signal: { type: 'string', description: 'Signal (default SIGTERM)' },
+    },
+    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/snippet.js

@@ -0,0 +1,95 @@
+/**
+ * Snippet Tool — save and reuse code snippets (1 MCP tool, 4 actions)
+ * Actions: save, load, list, delete
+ */
+import { readFile, writeFile, mkdir, readdir, unlink } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getConfig } from '../core/config.js';
+import { log } from '../core/logger.js';
+
+function snippetDir() {
+  return join(getConfig()._root, 'snippets');
+}
+
+function snippetPath(name) {
+  return join(snippetDir(), `${name}.json`);
+}
+
+const ACTIONS = {
+  save: {
+    required: ['name', 'code'],
+    handler: async ({ name, code, language, description }) => {
+      const dir = snippetDir();
+      await mkdir(dir, { recursive: true });
+      const data = { name, code, language: language || 'unknown', description: description || '', savedAt: Date.now() };
+      await writeFile(snippetPath(name), JSON.stringify(data, null, 2));
+      log('snippet', `💾 Saved: ${name}`);
+      return { saved: true, name, path: snippetPath(name) };
+    },
+  },
+
+  load: {
+    required: ['name'],
+    handler: async ({ name }) => {
+      const path = snippetPath(name);
+      if (!existsSync(path)) throw new Error(`Snippet not found: ${name}`);
+      const data = JSON.parse(await readFile(path, 'utf-8'));
+      return data;
+    },
+  },
+
+  list: {
+    required: [],
+    handler: async () => {
+      const dir = snippetDir();
+      if (!existsSync(dir)) return { snippets: [] };
+      const files = await readdir(dir);
+      const snippets = [];
+      for (const f of files.filter(f => f.endsWith('.json'))) {
+        try {
+          const data = JSON.parse(await readFile(join(dir, f), 'utf-8'));
+          snippets.push({ name: data.name, language: data.language, description: data.description });
+        } catch {}
+      }
+      return { count: snippets.length, snippets };
+    },
+  },
+
+  delete: {
+    required: ['name'],
+    handler: async ({ name }) => {
+      const path = snippetPath(name);
+      if (!existsSync(path)) throw new Error(`Snippet not found: ${name}`);
+      await unlink(path);
+      return { deleted: true, name };
+    },
+  },
+};
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'snippet',
+  description: 'Code snippets: save, load, list, delete',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: actionNames },
+      name: { type: 'string', description: 'Snippet name' },
+      code: { type: 'string', description: 'Code content' },
+      language: { type: 'string', description: 'Programming language' },
+      description: { type: 'string', description: 'Snippet description' },
+    },
+    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/template.js

@@ -0,0 +1,113 @@
+/**
+ * Template Tool — project scaffolding templates (1 MCP tool, 3 actions)
+ * Actions: list, create, info
+ */
+import { writeFile, mkdir, readdir, readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getConfig } from '../core/config.js';
+import { log } from '../core/logger.js';
+
+const TEMPLATES = {
+  'node-basic': {
+    name: 'Node.js Basic',
+    description: 'Basic Node.js project with package.json',
+    files: {
+      'package.json': '{\n  "name": "{{name}}",\n  "version": "1.0.0",\n  "type": "module",\n  "main": "index.js",\n  "scripts": {\n    "start": "node index.js",\n    "test": "echo \\"No tests\\""\n  }\n}',
+      'index.js': '// {{name}}\nconsole.log("Hello!");\n',
+      '.gitignore': 'node_modules/\n.env\n*.log\n',
+      'README.md': '# {{name}}\n\nA new project.\n',
+    },
+  },
+  'python-basic': {
+    name: 'Python Basic',
+    description: 'Basic Python project with venv',
+    files: {
+      'main.py': '# {{name}}\n\ndef main():\n    print("Hello!")\n\nif __name__ == "__main__":\n    main()\n',
+      'requirements.txt': '',
+      '.gitignore': '__pycache__/\n.venv/\n*.pyc\n.env\n',
+      'README.md': '# {{name}}\n\nA new Python project.\n',
+    },
+  },
+  'go-basic': {
+    name: 'Go Basic',
+    description: 'Basic Go project',
+    files: {
+      'main.go': 'package main\n\nimport "fmt"\n\nfunc main() {\n\tfmt.Println("Hello!")\n}\n',
+      'go.mod': 'module {{name}}\n\ngo 1.21\n',
+      '.gitignore': '{{name}}\n*.exe\n',
+      'README.md': '# {{name}}\n\nA new Go project.\n',
+    },
+  },
+};
+
+function applyTemplate(template, vars) {
+  let content = TEMPLATES[template].files;
+  const result = {};
+  for (const [file, tpl] of Object.entries(content)) {
+    result[file] = tpl.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] || key);
+  }
+  return result;
+}
+
+const ACTIONS = {
+  list: {
+    required: [],
+    handler: async () => {
+      const templates = Object.entries(TEMPLATES).map(([id, t]) => ({
+        id, name: t.name, description: t.description, files: Object.keys(t.files).length,
+      }));
+      return { count: templates.length, templates };
+    },
+  },
+
+  create: {
+    required: ['template', 'name'],
+    handler: async ({ template, name, path }) => {
+      if (!TEMPLATES[template]) throw new Error(`Unknown template: ${template}. Use: ${Object.keys(TEMPLATES).join(', ')}`);
+      const dir = path || join(getConfig().agent?.workspace || process.cwd(), name);
+      await mkdir(dir, { recursive: true });
+      const files = applyTemplate(template, { name });
+      for (const [file, content] of Object.entries(files)) {
+        await writeFile(join(dir, file), content);
+      }
+      log('template', `📁 Created ${template}: ${dir}`);
+      return { created: true, template, path: dir, files: Object.keys(files) };
+    },
+  },
+
+  info: {
+    required: ['template'],
+    handler: async ({ template }) => {
+      if (!TEMPLATES[template]) throw new Error(`Unknown template: ${template}`);
+      const t = TEMPLATES[template];
+      return { id: template, name: t.name, description: t.description, files: Object.keys(t.files) };
+    },
+  },
+};
+
+const actionNames = Object.keys(ACTIONS);
+
+export default {
+  name: 'template',
+  description: 'Project templates: list, create, info',
+  actions: actionNames.map(name => ({ name, required: ACTIONS[name].required })),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: actionNames },
+      template: { type: 'string', description: 'Template ID' },
+      name: { type: 'string', description: 'Project name' },
+      path: { type: 'string', description: 'Target directory' },
+    },
+    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);
+  },
+};