@benzsiangco/jarvis 1.0.0 → 1.1.0

package/src/tools/index.ts

@@ -0,0 +1,436 @@
+// Tool definitions for Jarvis
+import type { Tool, ToolContext, ToolResult } from '../core/types';
+import { execSync, spawn } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, statSync, readdirSync } from 'fs';
+import { resolve, relative, join } from 'path';
+import { glob as globSync } from 'glob';
+import { z } from 'zod';
+
+// Helper to create a tool result
+function success(content: string, metadata?: Record<string, unknown>): ToolResult {
+  return { success: true, content, metadata };
+}
+
+function error(message: string): ToolResult {
+  return { success: false, content: '', error: message };
+}
+
+// Bash tool
+export const bashTool: Tool = {
+  name: 'bash',
+  description: 'Execute a bash/shell command. Use for git, npm, system commands, etc.',
+  parameters: z.object({
+    command: z.string().describe('The command to execute'),
+    workdir: z.string().optional().describe('Working directory for the command'),
+    timeout: z.number().optional().describe('Timeout in milliseconds (default: 120000)'),
+    description: z.string().describe('Brief description of what this command does'),
+  }),
+  async execute(args, context) {
+    const command = args['command'] as string;
+    const workdir = (args['workdir'] as string) || context.workdir;
+    const timeout = (args['timeout'] as number) || 120000;
+
+    try {
+      const result = execSync(command, {
+        cwd: workdir,
+        timeout,
+        encoding: 'utf-8',
+        maxBuffer: 10 * 1024 * 1024,
+        windowsHide: true,
+        shell: process.platform === 'win32' ? 'powershell.exe' : '/bin/bash',
+      });
+      return success(result);
+    } catch (err: unknown) {
+      const execError = err as { stderr?: string; stdout?: string; message?: string };
+      const output = execError.stdout || execError.stderr || execError.message || 'Command failed';
+      return error(output);
+    }
+  },
+};
+
+// Read tool
+export const readTool: Tool = {
+  name: 'read',
+  description: 'Read contents of a file',
+  parameters: z.object({
+    filePath: z.string().describe('Absolute path to the file to read'),
+    offset: z.number().optional().describe('Line number to start reading from (0-based)'),
+    limit: z.number().optional().describe('Number of lines to read (default: 2000)'),
+  }),
+  async execute(args, context) {
+    const filePath = args['filePath'] as string;
+    const offset = (args['offset'] as number) || 0;
+    const limit = (args['limit'] as number) || 2000;
+
+    try {
+      const absolutePath = resolve(context.workdir, filePath);
+      
+      if (!existsSync(absolutePath)) {
+        return error(`File not found: ${filePath}`);
+      }
+
+      const content = readFileSync(absolutePath, 'utf-8');
+      const lines = content.split('\n');
+      const selectedLines = lines.slice(offset, offset + limit);
+      
+      // Add line numbers
+      const numberedLines = selectedLines.map((line, i) => {
+        const lineNum = String(offset + i + 1).padStart(5, ' ');
+        return `${lineNum}| ${line}`;
+      });
+
+      return success(numberedLines.join('\n'), {
+        totalLines: lines.length,
+        readLines: selectedLines.length,
+      });
+    } catch (err: unknown) {
+      return error((err as Error).message);
+    }
+  },
+};
+
+// Write tool
+export const writeTool: Tool = {
+  name: 'write',
+  description: 'Write content to a file (creates or overwrites)',
+  parameters: z.object({
+    filePath: z.string().describe('Absolute path to the file to write'),
+    content: z.string().describe('Content to write to the file'),
+  }),
+  async execute(args, context) {
+    const filePath = args['filePath'] as string;
+    const content = args['content'] as string;
+
+    try {
+      const absolutePath = resolve(context.workdir, filePath);
+      writeFileSync(absolutePath, content, 'utf-8');
+      return success(`Successfully wrote to ${filePath}`);
+    } catch (err: unknown) {
+      return error((err as Error).message);
+    }
+  },
+};
+
+// Edit tool
+export const editTool: Tool = {
+  name: 'edit',
+  description: 'Replace text in a file. oldString must match exactly.',
+  parameters: z.object({
+    filePath: z.string().describe('Absolute path to the file to edit'),
+    oldString: z.string().describe('The text to replace (must match exactly)'),
+    newString: z.string().describe('The replacement text'),
+    replaceAll: z.boolean().optional().describe('Replace all occurrences (default: false)'),
+  }),
+  async execute(args, context) {
+    const filePath = args['filePath'] as string;
+    const oldString = args['oldString'] as string;
+    const newString = args['newString'] as string;
+    const replaceAll = args['replaceAll'] as boolean || false;
+
+    try {
+      const absolutePath = resolve(context.workdir, filePath);
+      
+      if (!existsSync(absolutePath)) {
+        return error(`File not found: ${filePath}`);
+      }
+
+      let content = readFileSync(absolutePath, 'utf-8');
+      
+      if (!content.includes(oldString)) {
+        return error('oldString not found in content');
+      }
+
+      const occurrences = content.split(oldString).length - 1;
+      
+      if (occurrences > 1 && !replaceAll) {
+        return error('oldString found multiple times. Use replaceAll: true or provide more context.');
+      }
+
+      if (replaceAll) {
+        content = content.split(oldString).join(newString);
+      } else {
+        content = content.replace(oldString, newString);
+      }
+
+      writeFileSync(absolutePath, content, 'utf-8');
+      return success(`Successfully edited ${filePath}`, { replacements: replaceAll ? occurrences : 1 });
+    } catch (err: unknown) {
+      return error((err as Error).message);
+    }
+  },
+};
+
+// Glob tool
+export const globTool: Tool = {
+  name: 'glob',
+  description: 'Find files matching a glob pattern',
+  parameters: z.object({
+    pattern: z.string().describe('Glob pattern (e.g., "**/*.ts", "src/**/*.tsx")'),
+    path: z.string().optional().describe('Directory to search in'),
+  }),
+  async execute(args, context) {
+    const pattern = args['pattern'] as string;
+    const searchPath = (args['path'] as string) || context.workdir;
+
+    try {
+      const files = await globSync(pattern, {
+        cwd: searchPath,
+        nodir: true,
+        ignore: ['node_modules/**', '.git/**', 'dist/**'],
+      });
+
+      if (files.length === 0) {
+        return success('No files found matching pattern.');
+      }
+
+      return success(files.join('\n'), { count: files.length });
+    } catch (err: unknown) {
+      return error((err as Error).message);
+    }
+  },
+};
+
+// Grep tool
+export const grepTool: Tool = {
+  name: 'grep',
+  description: 'Search for a regex pattern in files',
+  parameters: z.object({
+    pattern: z.string().describe('Regex pattern to search for'),
+    path: z.string().optional().describe('Directory to search in'),
+    include: z.string().optional().describe('File pattern to include (e.g., "*.ts")'),
+  }),
+  async execute(args, context) {
+    const pattern = args['pattern'] as string;
+    const searchPath = (args['path'] as string) || context.workdir;
+    const include = args['include'] as string || '*';
+
+    try {
+      // Use ripgrep if available, fallback to basic search
+      const rgCommand = `rg --line-number --no-heading "${pattern}" --glob "${include}" --glob "!node_modules" --glob "!.git"`;
+      
+      try {
+        const result = execSync(rgCommand, {
+          cwd: searchPath,
+          encoding: 'utf-8',
+          maxBuffer: 10 * 1024 * 1024,
+        });
+        return success(result);
+      } catch {
+        // Fallback: basic file search
+        const files = await globSync(`**/${include}`, {
+          cwd: searchPath,
+          nodir: true,
+          ignore: ['node_modules/**', '.git/**'],
+        });
+
+        const regex = new RegExp(pattern, 'g');
+        const results: string[] = [];
+
+        for (const file of files.slice(0, 100)) { // Limit files
+          try {
+            const content = readFileSync(join(searchPath, file), 'utf-8');
+            const lines = content.split('\n');
+            
+            lines.forEach((line, i) => {
+              if (regex.test(line)) {
+                results.push(`${file}:${i + 1}:${line.substring(0, 200)}`);
+              }
+              regex.lastIndex = 0; // Reset regex state
+            });
+          } catch {
+            // Skip unreadable files
+          }
+        }
+
+        if (results.length === 0) {
+          return success('No matches found.');
+        }
+
+        return success(results.join('\n'), { count: results.length });
+      }
+    } catch (err: unknown) {
+      return error((err as Error).message);
+    }
+  },
+};
+
+// List tool (directory listing)
+export const listTool: Tool = {
+  name: 'list',
+  description: 'List files and directories in a path',
+  parameters: z.object({
+    path: z.string().describe('Directory path to list'),
+    recursive: z.boolean().optional().describe('List recursively'),
+  }),
+  async execute(args, context) {
+    const dirPath = (args['path'] as string) || context.workdir;
+    const recursive = args['recursive'] as boolean || false;
+
+    try {
+      const absolutePath = resolve(context.workdir, dirPath);
+      
+      if (!existsSync(absolutePath)) {
+        return error(`Directory not found: ${dirPath}`);
+      }
+
+      if (recursive) {
+        const files = await globSync('**/*', {
+          cwd: absolutePath,
+          ignore: ['node_modules/**', '.git/**'],
+        });
+        return success(files.join('\n'), { count: files.length });
+      } else {
+        const entries = readdirSync(absolutePath, { withFileTypes: true });
+        const output = entries.map(e => {
+          const type = e.isDirectory() ? '[D]' : '[F]';
+          return `${type} ${e.name}`;
+        });
+        return success(output.join('\n'), { count: entries.length });
+      }
+    } catch (err: unknown) {
+      return error((err as Error).message);
+    }
+  },
+};
+
+// WebFetch tool
+export const webfetchTool: Tool = {
+  name: 'webfetch',
+  description: 'Fetch content from a URL',
+  parameters: z.object({
+    url: z.string().describe('URL to fetch'),
+    format: z.enum(['text', 'markdown', 'html']).optional().describe('Response format (default: markdown)'),
+    timeout: z.number().optional().describe('Timeout in seconds (max 120)'),
+  }),
+  async execute(args, context) {
+    const url = args['url'] as string;
+    const format = (args['format'] as string) || 'markdown';
+    const timeout = ((args['timeout'] as number) || 30) * 1000;
+
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+      const response = await fetch(url, {
+        headers: {
+          'User-Agent': 'Jarvis-AI/1.0',
+        },
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        return error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      const content = await response.text();
+      
+      // For now, return raw content. In future, add markdown conversion
+      return success(content.substring(0, 50000), {
+        status: response.status,
+        contentType: response.headers.get('content-type'),
+      });
+    } catch (err: unknown) {
+      return error((err as Error).message);
+    }
+  },
+};
+
+// Task tool (spawn subagent)
+export const taskTool: Tool = {
+  name: 'task',
+  description: 'Launch a subagent to handle a complex task',
+  parameters: z.object({
+    description: z.string().describe('Short description of the task (3-5 words)'),
+    prompt: z.string().describe('Detailed instructions for the subagent'),
+    subagent_type: z.string().describe('Type of agent: "general" or "explore"'),
+    session_id: z.string().optional().describe('Existing session to continue'),
+  }),
+  async execute(args, context) {
+    // This will be implemented by the agent executor
+    return success('Task tool placeholder - will be implemented by agent executor');
+  },
+};
+
+// Question tool
+export const questionTool: Tool = {
+  name: 'question',
+  description: 'Ask the user a question to gather preferences or clarify instructions',
+  parameters: z.object({
+    questions: z.array(z.object({
+      question: z.string().describe('The question text'),
+      header: z.string().describe('Short label (max 12 chars)'),
+      options: z.array(z.object({
+        label: z.string(),
+        description: z.string(),
+      })),
+      multiple: z.boolean().optional().describe('Allow multiple selections'),
+    })),
+  }),
+  async execute(args, context) {
+    // This will be handled by the TUI
+    return success('Question tool placeholder - will be handled by TUI');
+  },
+};
+
+// TodoRead tool
+export const todoReadTool: Tool = {
+  name: 'todoread',
+  description: 'Read the current todo list',
+  parameters: z.object({
+    _placeholder: z.boolean().describe('Always pass true'),
+  }),
+  async execute(args, context) {
+    // Todo state is managed by the session
+    return success('TodoRead placeholder - managed by session');
+  },
+};
+
+// TodoWrite tool
+export const todoWriteTool: Tool = {
+  name: 'todowrite',
+  description: 'Create or update the todo list',
+  parameters: z.object({
+    todos: z.array(z.object({
+      id: z.string(),
+      content: z.string(),
+      status: z.enum(['pending', 'in_progress', 'completed', 'cancelled']),
+      priority: z.enum(['high', 'medium', 'low']),
+    })),
+  }),
+  async execute(args, context) {
+    // Todo state is managed by the session
+    return success('TodoWrite placeholder - managed by session');
+  },
+};
+
+// Tool registry
+const tools = new Map<string, Tool>();
+
+export function initializeTools(): void {
+  tools.clear();
+  tools.set('bash', bashTool);
+  tools.set('read', readTool);
+  tools.set('write', writeTool);
+  tools.set('edit', editTool);
+  tools.set('glob', globTool);
+  tools.set('grep', grepTool);
+  tools.set('list', listTool);
+  tools.set('webfetch', webfetchTool);
+  tools.set('task', taskTool);
+  tools.set('question', questionTool);
+  tools.set('todoread', todoReadTool);
+  tools.set('todowrite', todoWriteTool);
+}
+
+export function getTool(name: string): Tool | undefined {
+  return tools.get(name);
+}
+
+export function getAllTools(): Tool[] {
+  return Array.from(tools.values());
+}
+
+// Initialize on module load
+initializeTools();