tiger-agent 0.2.0

package/src/agent/skills.js

@@ -0,0 +1,169 @@
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+
+const execFileAsync = promisify(execFile);
+const localClawhubBin = path.resolve(process.cwd(), 'node_modules', '.bin', 'clawhub');
+
+function listSkills(baseDir) {
+  if (!fs.existsSync(baseDir)) return [];
+  return fs
+    .readdirSync(baseDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name)
+    .sort();
+}
+
+function loadSkill(baseDir, skillName) {
+  const skillDir = path.join(baseDir, skillName);
+  const skillFile = path.join(skillDir, 'SKILL.md');
+  if (!fs.existsSync(skillFile)) {
+    throw new Error(`Skill not found: ${skillName}`);
+  }
+  return fs.readFileSync(skillFile, 'utf8');
+}
+
+function isValidSlug(slug) {
+  return /^[a-z0-9][a-z0-9-]*$/.test(String(slug || ''));
+}
+
+async function ensureClawhubCli() {
+  const candidates = ['clawhub'];
+  if (fs.existsSync(localClawhubBin)) {
+    candidates.unshift(localClawhubBin);
+  }
+
+  for (const bin of candidates) {
+    try {
+      const { stdout, stderr } = await execFileAsync(bin, ['--cli-version'], {
+        timeout: 10000,
+        maxBuffer: 256 * 1024
+      });
+      return { ok: true, bin, version: String(stdout || stderr || '').trim() };
+    } catch (err) {
+      // try next candidate
+    }
+  }
+
+  return {
+    ok: false,
+    error:
+      'clawhub CLI is not available. Install it with: npm i -g clawhub or npm i clawhub in this project.'
+  };
+}
+
+async function runClawhub(argv, opts = {}) {
+  const cli = await ensureClawhubCli();
+  if (!cli.ok) return cli;
+  try {
+    const { stdout, stderr } = await execFileAsync(cli.bin, argv, {
+      timeout: Number(opts.timeout || 30000),
+      maxBuffer: Number(opts.maxBuffer || 1024 * 1024)
+    });
+    return {
+      ok: true,
+      bin: cli.bin,
+      version: cli.version,
+      stdout: String(stdout || '').trim(),
+      stderr: String(stderr || '').trim()
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      bin: cli.bin,
+      version: cli.version,
+      error: err.message,
+      stdout: String(err.stdout || '').trim(),
+      stderr: String(err.stderr || '').trim()
+    };
+  }
+}
+
+async function clawhubSearch(args = {}) {
+  const query = String(args.query || '').trim();
+  if (!query) return { ok: false, error: 'Missing query.' };
+
+  const limit = Math.max(1, Math.min(50, Number(args.limit || 10)));
+  const workdir = path.resolve(String(args.workdir || process.cwd()));
+  const dir = String(args.dir || 'skills').trim() || 'skills';
+
+  const argv = ['search', query, '--limit', String(limit), '--no-input', '--workdir', workdir, '--dir', dir];
+  const res = await runClawhub(argv, {
+    timeout: Number(args.timeout_ms || 30000),
+    maxBuffer: 1024 * 1024
+  });
+  if (res.ok) {
+    return {
+      ok: true,
+      bin: res.bin,
+      query,
+      limit,
+      workdir,
+      dir,
+      output: res.stdout,
+      warning: res.stderr
+    };
+  }
+  return {
+    ok: false,
+    bin: res.bin,
+    query,
+    workdir,
+    dir,
+    error: res.error,
+    output: res.stdout || '',
+    warning: res.stderr || ''
+  };
+}
+
+async function clawhubInstall(args = {}) {
+  const slug = String(args.slug || '').trim();
+  if (!slug) return { ok: false, error: 'Missing slug.' };
+  if (!isValidSlug(slug)) {
+    return { ok: false, error: 'Invalid slug format. Use lowercase letters, numbers, and hyphens only.' };
+  }
+
+  const workdir = path.resolve(String(args.workdir || process.cwd()));
+  const dir = String(args.dir || 'skills').trim() || 'skills';
+  const version = String(args.version || '').trim();
+  const force = Boolean(args.force);
+
+  const argv = ['install', slug, '--no-input', '--workdir', workdir, '--dir', dir];
+  if (version) argv.push('--version', version);
+  if (force) argv.push('--force');
+
+  const res = await runClawhub(argv, {
+    timeout: Number(args.timeout_ms || 120000),
+    maxBuffer: 1024 * 1024
+  });
+  if (res.ok) {
+    const skillPath = path.join(workdir, dir, slug, 'SKILL.md');
+    return {
+      ok: true,
+      bin: res.bin,
+      slug,
+      version: version || 'latest',
+      installed_path: skillPath,
+      skill_exists: fs.existsSync(skillPath),
+      output: res.stdout,
+      warning: res.stderr
+    };
+  }
+  return {
+    ok: false,
+    bin: res.bin,
+    slug,
+    version: version || 'latest',
+    error: res.error,
+    output: res.stdout || '',
+    warning: res.stderr || ''
+  };
+}
+
+module.exports = {
+  listSkills,
+  loadSkill,
+  clawhubSearch,
+  clawhubInstall
+};

package/src/agent/subAgent.js

@@ -0,0 +1,39 @@
+const { chatCompletion } = require('../llmClient');
+
+async function runSubAgent(task, contextText) {
+  const system = [
+    'You are a focused sub-agent.',
+    'Complete only the assigned task.',
+    'Return concise findings, key facts, and action items.'
+  ].join(' ');
+
+  const message = [
+    `Task: ${task}`,
+    contextText ? `Context:\n${contextText}` : ''
+  ]
+    .filter(Boolean)
+    .join('\n\n');
+
+  const result = await chatCompletion([
+    { role: 'system', content: system },
+    { role: 'user', content: message }
+  ]);
+
+  return result.content || '';
+}
+
+async function runSubAgentBatch(tasks, contextText) {
+  const safeTasks = Array.isArray(tasks) ? tasks : [];
+  const out = await Promise.all(
+    safeTasks.map(async (task) => {
+      const answer = await runSubAgent(task, contextText);
+      return { task, answer };
+    })
+  );
+  return out;
+}
+
+module.exports = {
+  runSubAgent,
+  runSubAgentBatch
+};

package/src/agent/toolbox.js

@@ -0,0 +1,291 @@
+const fs = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const { allowShell } = require('../config');
+const { listSkills, loadSkill, clawhubSearch, clawhubInstall } = require('./skills');
+const { runSubAgentBatch } = require('./subAgent');
+
+const execAsync = promisify(exec);
+const skillsDir = path.resolve('./skills');
+
+function toAbsolutePath(inputPath) {
+  return path.resolve(String(inputPath || '.'));
+}
+
+function listFiles(args = {}) {
+  const target = toAbsolutePath(args.path || '.');
+  const recursive = Boolean(args.recursive);
+  const limit = Number(args.limit || 200);
+  const out = [];
+
+  function walk(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      out.push({
+        path: full,
+        type: entry.isDirectory() ? 'dir' : 'file'
+      });
+      if (out.length >= limit) return;
+      if (recursive && entry.isDirectory()) {
+        walk(full);
+        if (out.length >= limit) return;
+      }
+    }
+  }
+
+  walk(target);
+  return { root: target, items: out, truncated: out.length >= limit };
+}
+
+function readFile(args = {}) {
+  const target = toAbsolutePath(args.path);
+  const maxChars = Number(args.max_chars || 16000);
+  const content = fs.readFileSync(target, 'utf8');
+  return {
+    path: target,
+    content: content.slice(0, maxChars),
+    truncated: content.length > maxChars
+  };
+}
+
+function writeFile(args = {}) {
+  const target = toAbsolutePath(args.path);
+  const append = Boolean(args.append);
+  const content = String(args.content || '');
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  if (append) {
+    fs.appendFileSync(target, content, 'utf8');
+  } else {
+    fs.writeFileSync(target, content, 'utf8');
+  }
+  return { path: target, bytes: Buffer.byteLength(content, 'utf8'), append };
+}
+
+async function runShell(args = {}) {
+  if (!allowShell) {
+    return { ok: false, error: 'Shell tool disabled. Set ALLOW_SHELL=true to enable.' };
+  }
+  const command = String(args.command || '').trim();
+  if (!command) {
+    return { ok: false, error: 'Missing command.' };
+  }
+  const cwd = toAbsolutePath(args.cwd || process.cwd());
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      cwd,
+      timeout: Number(args.timeout_ms || 15000),
+      maxBuffer: 1024 * 1024
+    });
+    return { ok: true, cwd, stdout, stderr };
+  } catch (err) {
+    return {
+      ok: false,
+      cwd,
+      error: err.message,
+      stdout: err.stdout || '',
+      stderr: err.stderr || ''
+    };
+  }
+}
+
+async function runSubAgentsTool(args = {}) {
+  const tasks = Array.isArray(args.tasks) ? args.tasks.map(String) : [];
+  const context = String(args.context || '');
+  const results = await runSubAgentBatch(tasks, context);
+  return { count: results.length, results };
+}
+
+function listSkillsTool() {
+  const skills = listSkills(skillsDir);
+  return { skills, skills_dir: skillsDir };
+}
+
+function loadSkillTool(args = {}) {
+  const skill = String(args.skill || '').trim();
+  if (!skill) return { ok: false, error: 'Missing skill name.' };
+  const content = loadSkill(skillsDir, skill);
+  return { ok: true, skill, content };
+}
+
+async function clawhubSearchTool(args = {}) {
+  return clawhubSearch({
+    query: args.query,
+    limit: args.limit,
+    workdir: args.workdir || process.cwd(),
+    dir: args.dir || 'skills',
+    timeout_ms: args.timeout_ms
+  });
+}
+
+async function clawhubInstallTool(args = {}) {
+  return clawhubInstall({
+    slug: args.slug,
+    version: args.version,
+    force: args.force,
+    workdir: args.workdir || process.cwd(),
+    dir: args.dir || 'skills',
+    timeout_ms: args.timeout_ms
+  });
+}
+
+const tools = [
+  {
+    type: 'function',
+    function: {
+      name: 'list_files',
+      description: 'List files/directories from a path. Supports recursive mode.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' },
+          recursive: { type: 'boolean' },
+          limit: { type: 'integer' }
+        }
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'read_file',
+      description: 'Read text file content from disk.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' },
+          max_chars: { type: 'integer' }
+        },
+        required: ['path']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'write_file',
+      description: 'Write or append text content to a file on disk.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' },
+          content: { type: 'string' },
+          append: { type: 'boolean' }
+        },
+        required: ['path', 'content']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_shell',
+      description: 'Execute shell command on the computer if enabled by ALLOW_SHELL=true.',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string' },
+          cwd: { type: 'string' },
+          timeout_ms: { type: 'integer' }
+        },
+        required: ['command']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'list_skills',
+      description: 'List available local skills.',
+      parameters: { type: 'object', properties: {} }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'load_skill',
+      description: 'Load full SKILL.md content for a specific local skill.',
+      parameters: {
+        type: 'object',
+        properties: {
+          skill: { type: 'string' }
+        },
+        required: ['skill']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'clawhub_search',
+      description: 'Search ClawHub skills using the clawhub CLI.',
+      parameters: {
+        type: 'object',
+        properties: {
+          query: { type: 'string' },
+          limit: { type: 'integer' },
+          workdir: { type: 'string' },
+          dir: { type: 'string' },
+          timeout_ms: { type: 'integer' }
+        },
+        required: ['query']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'clawhub_install',
+      description: 'Install a ClawHub skill by slug into the local skills directory.',
+      parameters: {
+        type: 'object',
+        properties: {
+          slug: { type: 'string' },
+          version: { type: 'string' },
+          force: { type: 'boolean' },
+          workdir: { type: 'string' },
+          dir: { type: 'string' },
+          timeout_ms: { type: 'integer' }
+        },
+        required: ['slug']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'run_sub_agents',
+      description: 'Run multiple focused sub-agents and return all outputs for orchestration.',
+      parameters: {
+        type: 'object',
+        properties: {
+          tasks: {
+            type: 'array',
+            items: { type: 'string' }
+          },
+          context: { type: 'string' }
+        },
+        required: ['tasks']
+      }
+    }
+  }
+];
+
+async function callTool(name, args) {
+  if (name === 'list_files') return listFiles(args);
+  if (name === 'read_file') return readFile(args);
+  if (name === 'write_file') return writeFile(args);
+  if (name === 'run_shell') return runShell(args);
+  if (name === 'list_skills') return listSkillsTool();
+  if (name === 'load_skill') return loadSkillTool(args);
+  if (name === 'clawhub_search') return clawhubSearchTool(args);
+  if (name === 'clawhub_install') return clawhubInstallTool(args);
+  if (name === 'run_sub_agents') return runSubAgentsTool(args);
+  return { ok: false, error: `Unknown tool: ${name}` };
+}
+
+module.exports = {
+  tools,
+  callTool
+};