grokcodecli 0.1.0

package/src/tools/edit.ts

@@ -0,0 +1,73 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { ToolResult } from './registry.js';
+
+export interface EditToolParams {
+  file_path: string;
+  old_string: string;
+  new_string: string;
+  replace_all?: boolean;
+}
+
+export async function editTool(params: EditToolParams): Promise<ToolResult> {
+  try {
+    const filePath = path.resolve(params.file_path);
+
+    // Read existing content
+    let content: string;
+    try {
+      content = await fs.readFile(filePath, 'utf-8');
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException;
+      if (err.code === 'ENOENT') {
+        return { success: false, output: '', error: `File not found: ${params.file_path}` };
+      }
+      throw error;
+    }
+
+    // Check if old_string exists
+    if (!content.includes(params.old_string)) {
+      return {
+        success: false,
+        output: '',
+        error: `String not found in file. Make sure the old_string matches exactly including whitespace.`,
+      };
+    }
+
+    // Check for uniqueness if not replace_all
+    if (!params.replace_all) {
+      const occurrences = content.split(params.old_string).length - 1;
+      if (occurrences > 1) {
+        return {
+          success: false,
+          output: '',
+          error: `Found ${occurrences} occurrences of the string. Use replace_all: true to replace all, or provide a more specific string.`,
+        };
+      }
+    }
+
+    // Perform replacement
+    let newContent: string;
+    let replacements: number;
+
+    if (params.replace_all) {
+      const parts = content.split(params.old_string);
+      replacements = parts.length - 1;
+      newContent = parts.join(params.new_string);
+    } else {
+      newContent = content.replace(params.old_string, params.new_string);
+      replacements = 1;
+    }
+
+    // Write back
+    await fs.writeFile(filePath, newContent, 'utf-8');
+
+    return {
+      success: true,
+      output: `File edited successfully: ${filePath} (${replacements} replacement${replacements > 1 ? 's' : ''})`,
+    };
+  } catch (error) {
+    const err = error as Error;
+    return { success: false, output: '', error: `Error editing file: ${err.message}` };
+  }
+}

package/src/tools/glob.ts

@@ -0,0 +1,49 @@
+import { glob } from 'glob';
+import * as path from 'path';
+import { ToolResult } from './registry.js';
+
+export interface GlobToolParams {
+  pattern: string;
+  path?: string;
+}
+
+export async function globTool(params: GlobToolParams): Promise<ToolResult> {
+  try {
+    const cwd = params.path ? path.resolve(params.path) : process.cwd();
+
+    const matches = await glob(params.pattern, {
+      cwd,
+      nodir: true,
+      absolute: false,
+      ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**'],
+    });
+
+    if (matches.length === 0) {
+      return {
+        success: true,
+        output: 'No files found matching the pattern.',
+      };
+    }
+
+    // Sort by path
+    matches.sort();
+
+    // Limit output to prevent overwhelming responses
+    const maxResults = 100;
+    const limited = matches.slice(0, maxResults);
+    const remaining = matches.length - maxResults;
+
+    let output = limited.join('\n');
+    if (remaining > 0) {
+      output += `\n\n... and ${remaining} more files`;
+    }
+
+    return {
+      success: true,
+      output: `Found ${matches.length} file(s):\n${output}`,
+    };
+  } catch (error) {
+    const err = error as Error;
+    return { success: false, output: '', error: `Glob error: ${err.message}` };
+  }
+}

package/src/tools/grep.ts

@@ -0,0 +1,96 @@
+import { spawn } from 'child_process';
+import { ToolResult } from './registry.js';
+
+export interface GrepToolParams {
+  pattern: string;
+  path?: string;
+  include?: string;
+}
+
+export async function grepTool(params: GrepToolParams): Promise<ToolResult> {
+  return new Promise((resolve) => {
+    const args = [
+      '--color=never',
+      '-r',
+      '-n',
+      '-H',
+      '--include=*.{ts,tsx,js,jsx,json,md,py,go,rs,java,kt,swift,c,cpp,h,hpp,css,scss,html,xml,yaml,yml,toml}',
+    ];
+
+    if (params.include) {
+      args.push(`--include=${params.include}`);
+    }
+
+    // Exclude common directories
+    args.push('--exclude-dir=node_modules');
+    args.push('--exclude-dir=.git');
+    args.push('--exclude-dir=dist');
+    args.push('--exclude-dir=build');
+    args.push('--exclude-dir=.next');
+
+    args.push('-E'); // Extended regex
+    args.push(params.pattern);
+    args.push(params.path || '.');
+
+    const child = spawn('grep', args, {
+      cwd: process.cwd(),
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      // grep returns 1 if no matches, which is not an error
+      if (code === 1 && !stderr) {
+        resolve({
+          success: true,
+          output: 'No matches found.',
+        });
+        return;
+      }
+
+      if (code !== 0 && code !== 1) {
+        resolve({
+          success: false,
+          output: '',
+          error: stderr || `grep exited with code ${code}`,
+        });
+        return;
+      }
+
+      // Limit output
+      const lines = stdout.trim().split('\n').filter(Boolean);
+      const maxResults = 50;
+
+      if (lines.length > maxResults) {
+        const output = lines.slice(0, maxResults).join('\n');
+        resolve({
+          success: true,
+          output: `Found ${lines.length} matches (showing first ${maxResults}):\n${output}`,
+        });
+      } else {
+        resolve({
+          success: true,
+          output: lines.length > 0 ? `Found ${lines.length} match(es):\n${stdout.trim()}` : 'No matches found.',
+        });
+      }
+    });
+
+    child.on('error', (error) => {
+      // Fall back to ripgrep if grep is not available
+      resolve({
+        success: false,
+        output: '',
+        error: `grep error: ${error.message}`,
+      });
+    });
+  });
+}

package/src/tools/read.ts

@@ -0,0 +1,116 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { ToolResult } from './registry.js';
+import { validatePath } from '../utils/security.js';
+import chalk from 'chalk';
+
+export interface ReadToolParams {
+  file_path: string;
+  offset?: number;
+  limit?: number;
+}
+
+// Maximum file size to read (10MB)
+const MAX_FILE_SIZE = 10 * 1024 * 1024;
+
+// Maximum lines to return
+const MAX_LINES = 2000;
+
+export async function readTool(params: ReadToolParams): Promise<ToolResult> {
+  try {
+    const filePath = path.resolve(params.file_path);
+
+    // Security validation
+    const security = validatePath(filePath);
+    if (!security.allowed) {
+      return {
+        success: false,
+        output: '',
+        error: `Security: ${security.reason}`,
+      };
+    }
+
+    // Check file stats first
+    let stats;
+    try {
+      stats = await fs.stat(filePath);
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException;
+      if (err.code === 'ENOENT') {
+        return { success: false, output: '', error: `File not found: ${params.file_path}` };
+      }
+      throw error;
+    }
+
+    if (stats.isDirectory()) {
+      return { success: false, output: '', error: `Path is a directory: ${params.file_path}` };
+    }
+
+    if (stats.size > MAX_FILE_SIZE) {
+      return {
+        success: false,
+        output: '',
+        error: `File too large (${(stats.size / 1024 / 1024).toFixed(1)}MB). Maximum is ${MAX_FILE_SIZE / 1024 / 1024}MB. Use offset/limit to read portions.`,
+      };
+    }
+
+    // Read the file
+    const content = await fs.readFile(filePath, 'utf-8');
+
+    // Handle binary files
+    if (content.includes('\0')) {
+      return {
+        success: false,
+        output: '',
+        error: 'File appears to be binary. Cannot display binary content.',
+      };
+    }
+
+    const lines = content.split('\n');
+    const totalLines = lines.length;
+
+    const offset = Math.max(0, (params.offset ?? 1) - 1);
+    const limit = Math.min(params.limit ?? MAX_LINES, MAX_LINES);
+
+    const selectedLines = lines.slice(offset, offset + limit);
+
+    // Format with line numbers like cat -n
+    const padding = String(totalLines).length;
+    const output = selectedLines
+      .map((line, i) => {
+        const lineNum = offset + i + 1;
+        // Truncate very long lines
+        const displayLine = line.length > 2000 ? line.slice(0, 2000) + '...' : line;
+        return `${String(lineNum).padStart(padding)}${chalk.gray('│')} ${displayLine}`;
+      })
+      .join('\n');
+
+    // Add metadata
+    let header = '';
+    if (offset > 0 || selectedLines.length < totalLines) {
+      header = chalk.gray(`Showing lines ${offset + 1}-${offset + selectedLines.length} of ${totalLines}\n`);
+    }
+
+    // Security warning if applicable
+    if (security.severity === 'medium') {
+      header = chalk.yellow(`⚠️ ${security.suggestion}\n`) + header;
+    }
+
+    return {
+      success: true,
+      output: header + (output || '(empty file)'),
+    };
+  } catch (error) {
+    const err = error as NodeJS.ErrnoException;
+    if (err.code === 'ENOENT') {
+      return { success: false, output: '', error: `File not found: ${params.file_path}` };
+    }
+    if (err.code === 'EACCES') {
+      return { success: false, output: '', error: `Permission denied: ${params.file_path}` };
+    }
+    if (err.code === 'EISDIR') {
+      return { success: false, output: '', error: `Path is a directory: ${params.file_path}` };
+    }
+    return { success: false, output: '', error: `Error reading file: ${err.message}` };
+  }
+}

package/src/tools/registry.ts

@@ -0,0 +1,248 @@
+import { Tool } from '../grok/client.js';
+import { readTool, ReadToolParams } from './read.js';
+import { writeTool, WriteToolParams } from './write.js';
+import { editTool, EditToolParams } from './edit.js';
+import { bashTool, BashToolParams } from './bash.js';
+import { globTool, GlobToolParams } from './glob.js';
+import { grepTool, GrepToolParams } from './grep.js';
+import { webFetchTool, WebFetchToolParams } from './webfetch.js';
+import { webSearchTool, WebSearchToolParams } from './websearch.js';
+
+export type ToolParams =
+  | { name: 'Read'; params: ReadToolParams }
+  | { name: 'Write'; params: WriteToolParams }
+  | { name: 'Edit'; params: EditToolParams }
+  | { name: 'Bash'; params: BashToolParams }
+  | { name: 'Glob'; params: GlobToolParams }
+  | { name: 'Grep'; params: GrepToolParams }
+  | { name: 'WebFetch'; params: WebFetchToolParams }
+  | { name: 'WebSearch'; params: WebSearchToolParams };
+
+export interface ToolResult {
+  success: boolean;
+  output: string;
+  error?: string;
+}
+
+export const allTools: Tool[] = [
+  {
+    type: 'function',
+    function: {
+      name: 'Read',
+      description: 'Read the contents of a file. Returns the file content with line numbers.',
+      parameters: {
+        type: 'object',
+        properties: {
+          file_path: {
+            type: 'string',
+            description: 'The absolute or relative path to the file to read',
+          },
+          offset: {
+            type: 'number',
+            description: 'Line number to start reading from (1-based)',
+          },
+          limit: {
+            type: 'number',
+            description: 'Maximum number of lines to read',
+          },
+        },
+        required: ['file_path'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'Write',
+      description: 'Write content to a file. Creates the file if it doesn\'t exist, overwrites if it does.',
+      parameters: {
+        type: 'object',
+        properties: {
+          file_path: {
+            type: 'string',
+            description: 'The absolute or relative path to the file to write',
+          },
+          content: {
+            type: 'string',
+            description: 'The content to write to the file',
+          },
+        },
+        required: ['file_path', 'content'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'Edit',
+      description: 'Edit a file by replacing a specific string with a new string.',
+      parameters: {
+        type: 'object',
+        properties: {
+          file_path: {
+            type: 'string',
+            description: 'The absolute or relative path to the file to edit',
+          },
+          old_string: {
+            type: 'string',
+            description: 'The exact string to find and replace',
+          },
+          new_string: {
+            type: 'string',
+            description: 'The string to replace it with',
+          },
+          replace_all: {
+            type: 'boolean',
+            description: 'Replace all occurrences (default: false)',
+          },
+        },
+        required: ['file_path', 'old_string', 'new_string'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'Bash',
+      description: 'Execute a bash command. Use for terminal operations, git commands, npm, etc.',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: {
+            type: 'string',
+            description: 'The bash command to execute',
+          },
+          timeout: {
+            type: 'number',
+            description: 'Timeout in milliseconds (default: 120000)',
+          },
+        },
+        required: ['command'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'Glob',
+      description: 'Find files matching a glob pattern.',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: {
+            type: 'string',
+            description: 'The glob pattern to match (e.g., "**/*.ts", "src/**/*.js")',
+          },
+          path: {
+            type: 'string',
+            description: 'The directory to search in (default: current directory)',
+          },
+        },
+        required: ['pattern'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'Grep',
+      description: 'Search for a pattern in files using regex.',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: {
+            type: 'string',
+            description: 'The regex pattern to search for',
+          },
+          path: {
+            type: 'string',
+            description: 'The file or directory to search in',
+          },
+          include: {
+            type: 'string',
+            description: 'Glob pattern for files to include (e.g., "*.ts")',
+          },
+        },
+        required: ['pattern'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'WebFetch',
+      description: 'Fetch content from a URL. Returns the response body as text. HTML is converted to readable text.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: {
+            type: 'string',
+            description: 'The URL to fetch',
+          },
+          method: {
+            type: 'string',
+            enum: ['GET', 'POST', 'PUT', 'DELETE'],
+            description: 'HTTP method (default: GET)',
+          },
+          headers: {
+            type: 'object',
+            description: 'Additional HTTP headers',
+          },
+          body: {
+            type: 'string',
+            description: 'Request body for POST/PUT requests',
+          },
+          timeout: {
+            type: 'number',
+            description: 'Timeout in milliseconds (default: 30000)',
+          },
+        },
+        required: ['url'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'WebSearch',
+      description: 'Search the web for information. Returns search results with titles, URLs, and snippets. Use this to find current information, documentation, tutorials, or any web content.',
+      parameters: {
+        type: 'object',
+        properties: {
+          query: {
+            type: 'string',
+            description: 'The search query',
+          },
+          num_results: {
+            type: 'number',
+            description: 'Number of results to return (default: 10, max: 20)',
+          },
+        },
+        required: ['query'],
+      },
+    },
+  },
+];
+
+export async function executeTool(name: string, params: Record<string, unknown>): Promise<ToolResult> {
+  switch (name) {
+    case 'Read':
+      return readTool(params as unknown as ReadToolParams);
+    case 'Write':
+      return writeTool(params as unknown as WriteToolParams);
+    case 'Edit':
+      return editTool(params as unknown as EditToolParams);
+    case 'Bash':
+      return bashTool(params as unknown as BashToolParams);
+    case 'Glob':
+      return globTool(params as unknown as GlobToolParams);
+    case 'Grep':
+      return grepTool(params as unknown as GrepToolParams);
+    case 'WebFetch':
+      return webFetchTool(params as unknown as WebFetchToolParams);
+    case 'WebSearch':
+      return webSearchTool(params as unknown as WebSearchToolParams);
+    default:
+      return { success: false, output: '', error: `Unknown tool: ${name}` };
+  }
+}

package/src/tools/webfetch.ts

@@ -0,0 +1,127 @@
+import { ToolResult } from './registry.js';
+
+export interface WebFetchToolParams {
+  url: string;
+  method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+  headers?: Record<string, string>;
+  body?: string;
+  timeout?: number;
+}
+
+// Simple HTML to text converter
+function htmlToText(html: string): string {
+  return html
+    // Remove script and style tags with content
+    .replace(/<script[\s\S]*?<\/script>/gi, '')
+    .replace(/<style[\s\S]*?<\/style>/gi, '')
+    // Convert block elements to newlines
+    .replace(/<\/(p|div|h[1-6]|li|tr|br)>/gi, '\n')
+    .replace(/<(br|hr)\s*\/?>/gi, '\n')
+    // Remove remaining tags
+    .replace(/<[^>]+>/g, '')
+    // Decode common HTML entities
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&apos;/g, "'")
+    // Clean up whitespace
+    .replace(/\n\s*\n/g, '\n\n')
+    .replace(/[ \t]+/g, ' ')
+    .trim();
+}
+
+export async function webFetchTool(params: WebFetchToolParams): Promise<ToolResult> {
+  const { url, method = 'GET', headers = {}, body, timeout = 30000 } = params;
+
+  // Validate URL
+  let parsedUrl: URL;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    return {
+      success: false,
+      output: '',
+      error: `Invalid URL: ${url}`,
+    };
+  }
+
+  // Only allow http/https
+  if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+    return {
+      success: false,
+      output: '',
+      error: `Unsupported protocol: ${parsedUrl.protocol}`,
+    };
+  }
+
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    const response = await fetch(url, {
+      method,
+      headers: {
+        'User-Agent': 'GrokCodeCLI/1.0',
+        ...headers,
+      },
+      body: body && method !== 'GET' ? body : undefined,
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    const contentType = response.headers.get('content-type') || '';
+    let content: string;
+
+    if (contentType.includes('application/json')) {
+      const json = await response.json();
+      content = JSON.stringify(json, null, 2);
+    } else if (contentType.includes('text/html')) {
+      const html = await response.text();
+      content = htmlToText(html);
+    } else {
+      content = await response.text();
+    }
+
+    // Truncate very long responses
+    const maxLength = 50000;
+    if (content.length > maxLength) {
+      content = content.slice(0, maxLength) + '\n\n... (truncated)';
+    }
+
+    const statusInfo = `Status: ${response.status} ${response.statusText}`;
+    const headerInfo = `Content-Type: ${contentType}`;
+
+    if (!response.ok) {
+      return {
+        success: false,
+        output: content,
+        error: `HTTP ${response.status}: ${response.statusText}`,
+      };
+    }
+
+    return {
+      success: true,
+      output: `${statusInfo}\n${headerInfo}\n\n${content}`,
+    };
+  } catch (error) {
+    const err = error as Error;
+
+    if (err.name === 'AbortError') {
+      return {
+        success: false,
+        output: '',
+        error: `Request timed out after ${timeout}ms`,
+      };
+    }
+
+    return {
+      success: false,
+      output: '',
+      error: `Fetch error: ${err.message}`,
+    };
+  }
+}