@lincoln504/pi-research 0.0.0

package/src/tools/grep.ts

@@ -0,0 +1,335 @@
+/**
+ * rg_grep Tool (Ripgrep)
+ *
+ * Standalone grep tool using ripgrep (rg) or fallback to grep.
+ */
+
+import { spawn } from 'node:child_process';
+import * as nodePath from 'node:path';
+import type { ToolDefinition, AgentToolResult, ExtensionContext } from '@mariozechner/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+import type { ToolUsageTracker } from '../utils/tool-usage-tracker.ts';
+
+const DEFAULT_MAX_BYTES = 100 * 1024; // 100KB
+const DEFAULT_MAX_LINES = 200;
+const STREAM_MAX_BYTES = 10 * 1024 * 1024; // 10MB max in stream (prevent RangeError)
+
+interface RgGrepParams {
+  pattern: string;
+  path?: string;
+  flags?: string;
+}
+
+function truncateHead(content: string, maxBytes: number, maxLines: number): string {
+  const lines = content.split('\n');
+
+  if (lines.length <= maxLines && Buffer.byteLength(content, 'utf-8') <= maxBytes) {
+    return content;
+  }
+
+  const truncatedLines = lines.slice(0, maxLines);
+  let result = truncatedLines.join('\n');
+
+  if (Buffer.byteLength(result, 'utf-8') > maxBytes) {
+    let byteCount = 0;
+    const charArray: string[] = [];
+
+    for (const char of result) {
+      byteCount += Buffer.byteLength(char, 'utf-8');
+      if (byteCount > maxBytes) break;
+      charArray.push(char);
+    }
+
+    result = charArray.join('');
+  }
+
+  return result;
+}
+
+async function execCommand(
+  command: string,
+  args: string[],
+): Promise<{ stdout: string; stderr: string; exitCode: number | null; wasTruncated: boolean }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args);
+    let stdout = '';
+    let stderr = '';
+    let wasTruncated = false;
+
+    child.stdout?.on('data', (data) => {
+      // Check if adding this chunk would exceed stream limit
+      const chunk = data.toString();
+      if (stdout.length + chunk.length > STREAM_MAX_BYTES) {
+        // Stop collecting data to prevent RangeError
+        wasTruncated = true;
+        child.kill();
+        return;
+      }
+      stdout += chunk;
+    });
+
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      resolve({ stdout, stderr, exitCode: code, wasTruncated });
+    });
+
+    child.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+function resolveWorkspacePath(input: string): string {
+  const root = process.cwd();
+  const resolved = nodePath.resolve(root, input);
+  if (resolved !== root && !resolved.startsWith(root + nodePath.sep)) {
+    throw new Error(`Path outside workspace: ${input}`);
+  }
+  return resolved;
+}
+
+function sanitizeInput(input: string): string[] {
+  // Simple sanitization: split on whitespace, preserve quoted strings
+  const result: string[] = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (const char of input) {
+    if (char === '"' || char === "'") {
+      inQuotes = !inQuotes;
+    } else if (char === ' ' && !inQuotes) {
+      if (current) {
+        result.push(current);
+        current = '';
+      }
+    } else {
+      current += char;
+    }
+  }
+
+  if (current) {
+    result.push(current);
+  }
+
+  return result;
+}
+
+function normalizeSearchOutput(output: string): string {
+  return process.platform === 'win32' ? output.replace(/\\/g, '/') : output;
+}
+
+export function createGrepTool(options: {
+  tracker: ToolUsageTracker;
+}): ToolDefinition {
+  return {
+    name: 'grep',
+    label: 'Code Search',
+    description: 'Search codebase using ripgrep (rg) or grep fallback. Fast recursive text search.',
+    promptSnippet: 'Search codebase using ripgrep/grep',
+    promptGuidelines: [
+      'Use grep for fast recursive text search in codebases.',
+      'Pattern supports regex. Path and flags are optional.',
+      'Falls back to grep if rg is not available.',
+      'CRITICAL: You are allowed a maximum of 4 gathering calls total across ALL tools. Use them for breadth.',
+    ],
+    parameters: Type.Object({
+      pattern: Type.String({ description: 'Search pattern (regex supported)' }),
+      path: Type.Optional(Type.String({ description: 'Directory to search (default: current directory)' })),
+      flags: Type.Optional(Type.String({ description: 'Additional flags (e.g., "-i" for case-insensitive)' })),
+    }),
+    async execute(
+      _toolCallId: string,
+      params: unknown,
+      _signal: unknown,
+      _onUpdate: unknown,
+      _ctx: ExtensionContext,
+    ): Promise<AgentToolResult<unknown>> {
+      // Record call in tracker - returns false if limit reached
+      const allowed = options.tracker.recordCall('grep');
+      if (!allowed) {
+        // THROW to prevent researcher from calling again
+        throw new Error(options.tracker.getLimitMessage('grep'));
+      }
+
+      const record = params as RgGrepParams;
+      const { pattern } = record;
+      const path = resolveWorkspacePath(record.path ?? '.');
+      const flags = record.flags ?? '';
+
+      if (!pattern) {
+        return {
+          content: [{ type: 'text', text: 'Error: pattern is required' }],
+          details: {},
+        };
+      }
+
+      // Sanitize inputs to prevent shell injection
+      const flagParts = flags ? sanitizeInput(flags) : [];
+
+      // Try rg first
+      try {
+        const rgArgs = ['--no-heading', '-n', ...flagParts, pattern, path];
+        const { stdout, stderr, exitCode, wasTruncated } = await execCommand('rg', rgArgs);
+
+        const truncated = truncateHead(normalizeSearchOutput(stdout), DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES);
+
+        let markdown = '# Search Results (rg)\n\n';
+        markdown += `**Pattern:** \`${pattern}\`\n`;
+        markdown += `**Path:** \`${path}\`\n`;
+        if (flags) markdown += `**Flags:** \`${flags}\`\n`;
+        markdown += `**Exit Code:** ${exitCode}\n\n`;
+
+        if (wasTruncated) {
+          markdown += '⚠️ **Output was truncated to prevent memory overflow (>10MB)**\n\n';
+        }
+
+        if (truncated) {
+          markdown += '```\n' + truncated + '\n```';
+        } else {
+          markdown += 'No matches found.';
+        }
+
+        if (stderr) {
+          markdown += '\n\n**Stderr:**\n```\n' + stderr + '\n```';
+        }
+
+        return {
+          content: [{ type: 'text', text: markdown }],
+          details: {
+            command: 'rg',
+            args: rgArgs,
+            exitCode,
+            wasTruncated,
+          },
+        };
+      } catch (rgError) {
+        // rg not found, try grep
+        try {
+          const grepArgs = ['-rn', ...flagParts, pattern, path];
+          const { stdout, stderr, exitCode, wasTruncated } = await execCommand('grep', grepArgs);
+
+          const truncated = truncateHead(normalizeSearchOutput(stdout), DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES);
+
+          let markdown = '# Search Results (grep)\n\n';
+          markdown += `**Pattern:** \`${pattern}\`\n`;
+          markdown += `**Path:** \`${path}\`\n`;
+          if (flags) markdown += `**Flags:** \`${flags}\`\n`;
+          markdown += `**Exit Code:** ${exitCode}\n\n`;
+          markdown += '*Note: Using grep fallback (rg not available)*\n\n';
+
+          if (wasTruncated) {
+            markdown += '⚠️ **Output was truncated to prevent memory overflow (>10MB)**\n\n';
+          }
+
+          if (truncated) {
+            markdown += '```\n' + truncated + '\n```';
+          } else {
+            markdown += 'No matches found.';
+          }
+
+          if (stderr) {
+            markdown += '\n\n**Stderr:**\n```\n' + stderr + '\n```';
+          }
+
+          return {
+            content: [{ type: 'text', text: markdown }],
+            details: {
+              command: 'grep',
+              args: grepArgs,
+              exitCode,
+              wasTruncated,
+            },
+          };
+        } catch (grepError) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `Error: Neither rg nor grep is available.\n\nrg error: ${rgError}\ngrep error: ${grepError}`,
+              },
+            ],
+            details: {},
+          };
+        }
+      }
+    },
+  };
+}
+
+/**
+ * Standalone function to execute rg/grep search
+ */
+export async function grep(pattern: string, path: string = '.', flags: string = ''): Promise<string> {
+  if (!pattern) {
+    throw new Error('Pattern is required');
+  }
+
+  const resolvedPath = resolveWorkspacePath(path);
+  const flagParts = flags ? sanitizeInput(flags) : [];
+
+  // Try rg first
+  try {
+    const rgArgs = ['--no-heading', '-n', ...flagParts, pattern, resolvedPath];
+    const { stdout, stderr, exitCode, wasTruncated } = await execCommand('rg', rgArgs);
+
+    let markdown = '# Search Results (rg)\n\n';
+    markdown += `**Pattern:** \`${pattern}\`\n`;
+    markdown += `**Path:** \`${resolvedPath}\`\n`;
+    if (flags) markdown += `**Flags:** \`${flags}\`\n`;
+    markdown += `**Exit Code:** ${exitCode}\n\n`;
+
+    const truncated = truncateHead(normalizeSearchOutput(stdout), DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES);
+
+    if (wasTruncated) {
+      markdown += '⚠️ **Output was truncated to prevent memory overflow (>10MB)**\n\n';
+    }
+
+    if (truncated) {
+      markdown += '```\n' + truncated + '\n```';
+    } else {
+      markdown += 'No matches found.';
+    }
+
+    if (stderr) {
+      markdown += '\n\n**Stderr:**\n```\n' + stderr + '\n```';
+    }
+
+    return markdown;
+  } catch (rgError) {
+    // rg not found, try grep
+    try {
+      const grepArgs = ['-rn', ...flagParts, pattern, resolvedPath];
+      const { stdout, stderr, exitCode, wasTruncated } = await execCommand('grep', grepArgs);
+
+      let markdown = '# Search Results (grep)\n\n';
+      markdown += `**Pattern:** \`${pattern}\`\n`;
+      markdown += `**Path:** \`${resolvedPath}\`\n`;
+      if (flags) markdown += `**Flags:** \`${flags}\`\n`;
+      markdown += `**Exit Code:** ${exitCode}\n\n`;
+      markdown += '*Note: Using grep fallback (rg not available)*\n\n';
+
+      const truncated = truncateHead(normalizeSearchOutput(stdout), DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES);
+
+      if (wasTruncated) {
+        markdown += '⚠️ **Output was truncated to prevent memory overflow (>10MB)**\n\n';
+      }
+
+      if (truncated) {
+        markdown += '```\n' + truncated + '\n```';
+      } else {
+        markdown += 'No matches found.';
+      }
+
+      if (stderr) {
+        markdown += '\n\n**Stderr:**\n```\n' + stderr + '\n```';
+      }
+
+      return markdown;
+    } catch (grepError) {
+      return `Error: Neither rg nor grep is available.\n\nrg error: ${rgError}\ngrep error: ${grepError}`;
+    }
+  }
+}

package/src/tools/index.ts

@@ -0,0 +1,77 @@
+/**
+ * Tool Factory
+ *
+ * Creates all research tools with properly configured SearXNG URL.
+ * These tools are used by both direct tool calls and researcher agents.
+ */
+
+import type { ToolDefinition, ExtensionContext } from '@mariozechner/pi-coding-agent';
+import type { ToolUsageTracker } from '../utils/tool-usage-tracker.ts';
+import type { SystemResearchState } from '../orchestration/deep-research-types.ts';
+import { createSearchTool } from './search.ts';
+import { createScrapeTool } from './scrape.ts';
+import { createSecuritySearchTool } from './security.ts';
+import { createStackexchangeTool } from './stackexchange.ts';
+import { createGrepTool } from './grep.ts';
+
+interface CreateToolsOptions {
+  searxngUrl: string;
+  ctx: ExtensionContext;
+  tracker: ToolUsageTracker;
+  getGlobalState?: () => SystemResearchState;
+  updateGlobalLinks?: (links: string[]) => void;
+  /** Returns tokens consumed by this researcher session so far (for context-aware scrape gating). */
+  getTokensUsed?: () => number;
+  /** Model context window size in tokens; defaults to DEFAULT_MODEL_CONTEXT_WINDOW. */
+  contextWindowSize?: number;
+}
+
+/**
+ * Create all research tools
+ */
+export function createResearchTools(options: CreateToolsOptions): ToolDefinition[] {
+  // Create a fresh fallback state per tool instance to avoid state leakage between research runs
+  // This is only used when getGlobalState is not provided (e.g., quick mode with single researcher)
+  const createFallbackState = (): SystemResearchState => ({
+    version: 1,
+    rootQuery: '',
+    complexity: 1,
+    currentRound: 1,
+    status: 'researching',
+    lastUpdated: Date.now(),
+    initialAgenda: [],
+    allScrapedLinks: [],
+    aspects: {},
+  });
+  
+  const fallbackState = createFallbackState();
+  
+  const resolvedOptions = {
+    ...options,
+    getGlobalState: options.getGlobalState ?? (() => fallbackState),
+    updateGlobalLinks: options.updateGlobalLinks ?? ((links: string[]) => {
+      fallbackState.allScrapedLinks = [...new Set([...fallbackState.allScrapedLinks, ...links])];
+    }),
+  };
+
+  return [
+    createSearchTool(resolvedOptions),
+    createScrapeTool({
+      ...resolvedOptions,
+      getTokensUsed: options.getTokensUsed,
+      contextWindowSize: options.contextWindowSize,
+    }),
+    createSecuritySearchTool(resolvedOptions),
+    createStackexchangeTool(resolvedOptions),
+    createGrepTool(resolvedOptions),
+  ];
+}
+
+/**
+ * Create individual tool exports for direct registration
+ */
+export { createSearchTool } from './search.ts';
+export { createScrapeTool } from './scrape.ts';
+export { createSecuritySearchTool } from './security.ts';
+export { createStackexchangeTool } from './stackexchange.ts';
+export { createGrepTool } from './grep.ts';