@xortex/xcode 3.0.0

package/tools/GlobTool/UI.tsx

@@ -0,0 +1,63 @@
+import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs';
+import React from 'react';
+import { MessageResponse } from 'src/components/MessageResponse.js';
+import { extractTag } from 'src/utils/messages.js';
+import { FallbackToolUseErrorMessage } from '../../components/FallbackToolUseErrorMessage.js';
+import { TOOL_SUMMARY_MAX_LENGTH } from '../../constants/toolLimits.js';
+import { Text } from '../../ink.js';
+import { FILE_NOT_FOUND_CWD_NOTE, getDisplayPath } from '../../utils/file.js';
+import { truncate } from '../../utils/format.js';
+import { GrepTool } from '../GrepTool/GrepTool.js';
+export function userFacingName(): string {
+  return 'Search';
+}
+export function renderToolUseMessage({
+  pattern,
+  path
+}: Partial<{
+  pattern: string;
+  path: string;
+}>, {
+  verbose
+}: {
+  verbose: boolean;
+}): React.ReactNode {
+  if (!pattern) {
+    return null;
+  }
+  if (!path) {
+    return `pattern: "${pattern}"`;
+  }
+  return `pattern: "${pattern}", path: "${verbose ? path : getDisplayPath(path)}"`;
+}
+export function renderToolUseErrorMessage(result: ToolResultBlockParam['content'], {
+  verbose
+}: {
+  verbose: boolean;
+}): React.ReactNode {
+  if (!verbose && typeof result === 'string' && extractTag(result, 'tool_use_error')) {
+    const errorMessage = extractTag(result, 'tool_use_error');
+    if (errorMessage?.includes(FILE_NOT_FOUND_CWD_NOTE)) {
+      return <MessageResponse>
+          <Text color="error">File not found</Text>
+        </MessageResponse>;
+    }
+    return <MessageResponse>
+        <Text color="error">Error searching files</Text>
+      </MessageResponse>;
+  }
+  return <FallbackToolUseErrorMessage result={result} verbose={verbose} />;
+}
+
+// Note: GlobTool reuses GrepTool's renderToolResultMessage
+export const renderToolResultMessage = GrepTool.renderToolResultMessage;
+export function getToolUseSummary(input: Partial<{
+  pattern: string;
+  path: string;
+}> | undefined): string | null {
+  if (!input?.pattern) {
+    return null;
+  }
+  return truncate(input.pattern, TOOL_SUMMARY_MAX_LENGTH);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/tools/GlobTool/prompt.ts

@@ -0,0 +1,7 @@
+export const GLOB_TOOL_NAME = 'Glob'
+
+export const DESCRIPTION = `- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead`

package/tools/GrepTool/GrepTool.ts

@@ -0,0 +1,577 @@
+import { z } from 'zod/v4'
+import type { ValidationResult } from '../../Tool.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { getCwd } from '../../utils/cwd.js'
+import { isENOENT } from '../../utils/errors.js'
+import {
+  FILE_NOT_FOUND_CWD_NOTE,
+  suggestPathUnderCwd,
+} from '../../utils/file.js'
+import { getFsImplementation } from '../../utils/fsOperations.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { expandPath, toRelativePath } from '../../utils/path.js'
+import {
+  checkReadPermissionForTool,
+  getFileReadIgnorePatterns,
+  normalizePatternsToPath,
+} from '../../utils/permissions/filesystem.js'
+import type { PermissionDecision } from '../../utils/permissions/PermissionResult.js'
+import { matchWildcardPattern } from '../../utils/permissions/shellRuleMatching.js'
+import { getGlobExclusionsForPluginCache } from '../../utils/plugins/orphanedPluginFilter.js'
+import { ripGrep } from '../../utils/ripgrep.js'
+import { semanticBoolean } from '../../utils/semanticBoolean.js'
+import { semanticNumber } from '../../utils/semanticNumber.js'
+import { plural } from '../../utils/stringUtils.js'
+import { GREP_TOOL_NAME, getDescription } from './prompt.js'
+import {
+  getToolUseSummary,
+  renderToolResultMessage,
+  renderToolUseErrorMessage,
+  renderToolUseMessage,
+} from './UI.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    pattern: z
+      .string()
+      .describe(
+        'The regular expression pattern to search for in file contents',
+      ),
+    path: z
+      .string()
+      .optional()
+      .describe(
+        'File or directory to search in (rg PATH). Defaults to current working directory.',
+      ),
+    glob: z
+      .string()
+      .optional()
+      .describe(
+        'Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}") - maps to rg --glob',
+      ),
+    output_mode: z
+      .enum(['content', 'files_with_matches', 'count'])
+      .optional()
+      .describe(
+        'Output mode: "content" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), "files_with_matches" shows file paths (supports head_limit), "count" shows match counts (supports head_limit). Defaults to "files_with_matches".',
+      ),
+    '-B': semanticNumber(z.number().optional()).describe(
+      'Number of lines to show before each match (rg -B). Requires output_mode: "content", ignored otherwise.',
+    ),
+    '-A': semanticNumber(z.number().optional()).describe(
+      'Number of lines to show after each match (rg -A). Requires output_mode: "content", ignored otherwise.',
+    ),
+    '-C': semanticNumber(z.number().optional()).describe('Alias for context.'),
+    context: semanticNumber(z.number().optional()).describe(
+      'Number of lines to show before and after each match (rg -C). Requires output_mode: "content", ignored otherwise.',
+    ),
+    '-n': semanticBoolean(z.boolean().optional()).describe(
+      'Show line numbers in output (rg -n). Requires output_mode: "content", ignored otherwise. Defaults to true.',
+    ),
+    '-i': semanticBoolean(z.boolean().optional()).describe(
+      'Case insensitive search (rg -i)',
+    ),
+    type: z
+      .string()
+      .optional()
+      .describe(
+        'File type to search (rg --type). Common types: js, py, rust, go, java, etc. More efficient than include for standard file types.',
+      ),
+    head_limit: semanticNumber(z.number().optional()).describe(
+      'Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). Defaults to 250 when unspecified. Pass 0 for unlimited (use sparingly — large result sets waste context).',
+    ),
+    offset: semanticNumber(z.number().optional()).describe(
+      'Skip first N lines/entries before applying head_limit, equivalent to "| tail -n +N | head -N". Works across all output modes. Defaults to 0.',
+    ),
+    multiline: semanticBoolean(z.boolean().optional()).describe(
+      'Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall). Default: false.',
+    ),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+// Version control system directories to exclude from searches
+// These are excluded automatically because they create noise in search results
+const VCS_DIRECTORIES_TO_EXCLUDE = [
+  '.git',
+  '.svn',
+  '.hg',
+  '.bzr',
+  '.jj',
+  '.sl',
+] as const
+
+// Default cap on grep results when head_limit is unspecified. Unbounded content-mode
+// greps can fill up to the 20KB persist threshold (~6-24K tokens/grep-heavy session).
+// 250 is generous enough for exploratory searches while preventing context bloat.
+// Pass head_limit=0 explicitly for unlimited.
+const DEFAULT_HEAD_LIMIT = 250
+
+function applyHeadLimit<T>(
+  items: T[],
+  limit: number | undefined,
+  offset: number = 0,
+): { items: T[]; appliedLimit: number | undefined } {
+  // Explicit 0 = unlimited escape hatch
+  if (limit === 0) {
+    return { items: items.slice(offset), appliedLimit: undefined }
+  }
+  const effectiveLimit = limit ?? DEFAULT_HEAD_LIMIT
+  const sliced = items.slice(offset, offset + effectiveLimit)
+  // Only report appliedLimit when truncation actually occurred, so the model
+  // knows there may be more results and can paginate with offset.
+  const wasTruncated = items.length - offset > effectiveLimit
+  return {
+    items: sliced,
+    appliedLimit: wasTruncated ? effectiveLimit : undefined,
+  }
+}
+
+// Format limit/offset information for display in tool results.
+// appliedLimit is only set when truncation actually occurred (see applyHeadLimit),
+// so it may be undefined even when appliedOffset is set — build parts conditionally
+// to avoid "limit: undefined" appearing in user-visible output.
+function formatLimitInfo(
+  appliedLimit: number | undefined,
+  appliedOffset: number | undefined,
+): string {
+  const parts: string[] = []
+  if (appliedLimit !== undefined) parts.push(`limit: ${appliedLimit}`)
+  if (appliedOffset) parts.push(`offset: ${appliedOffset}`)
+  return parts.join(', ')
+}
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    mode: z.enum(['content', 'files_with_matches', 'count']).optional(),
+    numFiles: z.number(),
+    filenames: z.array(z.string()),
+    content: z.string().optional(),
+    numLines: z.number().optional(), // For content mode
+    numMatches: z.number().optional(), // For count mode
+    appliedLimit: z.number().optional(), // The limit that was applied (if any)
+    appliedOffset: z.number().optional(), // The offset that was applied
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+
+type Output = z.infer<OutputSchema>
+
+export const GrepTool = buildTool({
+  name: GREP_TOOL_NAME,
+  searchHint: 'search file contents with regex (ripgrep)',
+  // 20K chars - tool result persistence threshold
+  maxResultSizeChars: 20_000,
+  strict: true,
+  async description() {
+    return getDescription()
+  },
+  userFacingName() {
+    return 'Search'
+  },
+  getToolUseSummary,
+  getActivityDescription(input) {
+    const summary = getToolUseSummary(input)
+    return summary ? `Searching for ${summary}` : 'Searching'
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+  toAutoClassifierInput(input) {
+    return input.path ? `${input.pattern} in ${input.path}` : input.pattern
+  },
+  isSearchOrReadCommand() {
+    return { isSearch: true, isRead: false }
+  },
+  getPath({ path }): string {
+    return path || getCwd()
+  },
+  async preparePermissionMatcher({ pattern }) {
+    return rulePattern => matchWildcardPattern(rulePattern, pattern)
+  },
+  async validateInput({ path }): Promise<ValidationResult> {
+    // If path is provided, validate that it exists
+    if (path) {
+      const fs = getFsImplementation()
+      const absolutePath = expandPath(path)
+
+      // SECURITY: Skip filesystem operations for UNC paths to prevent NTLM credential leaks.
+      if (absolutePath.startsWith('\\\\') || absolutePath.startsWith('//')) {
+        return { result: true }
+      }
+
+      try {
+        await fs.stat(absolutePath)
+      } catch (e: unknown) {
+        if (isENOENT(e)) {
+          const cwdSuggestion = await suggestPathUnderCwd(absolutePath)
+          let message = `Path does not exist: ${path}. ${FILE_NOT_FOUND_CWD_NOTE} ${getCwd()}.`
+          if (cwdSuggestion) {
+            message += ` Did you mean ${cwdSuggestion}?`
+          }
+          return {
+            result: false,
+            message,
+            errorCode: 1,
+          }
+        }
+        throw e
+      }
+    }
+
+    return { result: true }
+  },
+  async checkPermissions(input, context): Promise<PermissionDecision> {
+    const appState = context.getAppState()
+    return checkReadPermissionForTool(
+      GrepTool,
+      input,
+      appState.toolPermissionContext,
+    )
+  },
+  async prompt() {
+    return getDescription()
+  },
+  renderToolUseMessage,
+  renderToolUseErrorMessage,
+  renderToolResultMessage,
+  // SearchResultSummary shows content (mode=content) or filenames.join.
+  // numFiles/numLines/numMatches are chrome ("Found 3 files") — fine to
+  // skip (under-count, not phantom). Glob reuses this via UI.tsx:65.
+  extractSearchText({ mode, content, filenames }) {
+    if (mode === 'content' && content) return content
+    return filenames.join('\n')
+  },
+  mapToolResultToToolResultBlockParam(
+    {
+      mode = 'files_with_matches',
+      numFiles,
+      filenames,
+      content,
+      numLines: _numLines,
+      numMatches,
+      appliedLimit,
+      appliedOffset,
+    },
+    toolUseID,
+  ) {
+    if (mode === 'content') {
+      const limitInfo = formatLimitInfo(appliedLimit, appliedOffset)
+      const resultContent = content || 'No matches found'
+      const finalContent = limitInfo
+        ? `${resultContent}\n\n[Showing results with pagination = ${limitInfo}]`
+        : resultContent
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content: finalContent,
+      }
+    }
+
+    if (mode === 'count') {
+      const limitInfo = formatLimitInfo(appliedLimit, appliedOffset)
+      const rawContent = content || 'No matches found'
+      const matches = numMatches ?? 0
+      const files = numFiles ?? 0
+      const summary = `\n\nFound ${matches} total ${matches === 1 ? 'occurrence' : 'occurrences'} across ${files} ${files === 1 ? 'file' : 'files'}.${limitInfo ? ` with pagination = ${limitInfo}` : ''}`
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content: rawContent + summary,
+      }
+    }
+
+    // files_with_matches mode
+    const limitInfo = formatLimitInfo(appliedLimit, appliedOffset)
+    if (numFiles === 0) {
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content: 'No files found',
+      }
+    }
+    // head_limit has already been applied in call() method, so just show all filenames
+    const result = `Found ${numFiles} ${plural(numFiles, 'file')}${limitInfo ? ` ${limitInfo}` : ''}\n${filenames.join('\n')}`
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: result,
+    }
+  },
+  async call(
+    {
+      pattern,
+      path,
+      glob,
+      type,
+      output_mode = 'files_with_matches',
+      '-B': context_before,
+      '-A': context_after,
+      '-C': context_c,
+      context,
+      '-n': show_line_numbers = true,
+      '-i': case_insensitive = false,
+      head_limit,
+      offset = 0,
+      multiline = false,
+    },
+    { abortController, getAppState },
+  ) {
+    const absolutePath = path ? expandPath(path) : getCwd()
+    const args = ['--hidden']
+
+    // Exclude VCS directories to avoid noise from version control metadata
+    for (const dir of VCS_DIRECTORIES_TO_EXCLUDE) {
+      args.push('--glob', `!${dir}`)
+    }
+
+    // Limit line length to prevent base64/minified content from cluttering output
+    args.push('--max-columns', '500')
+
+    // Only apply multiline flags when explicitly requested
+    if (multiline) {
+      args.push('-U', '--multiline-dotall')
+    }
+
+    // Add optional flags
+    if (case_insensitive) {
+      args.push('-i')
+    }
+
+    // Add output mode flags
+    if (output_mode === 'files_with_matches') {
+      args.push('-l')
+    } else if (output_mode === 'count') {
+      args.push('-c')
+    }
+
+    // Add line numbers if requested
+    if (show_line_numbers && output_mode === 'content') {
+      args.push('-n')
+    }
+
+    // Add context flags (-C/context takes precedence over context_before/context_after)
+    if (output_mode === 'content') {
+      if (context !== undefined) {
+        args.push('-C', context.toString())
+      } else if (context_c !== undefined) {
+        args.push('-C', context_c.toString())
+      } else {
+        if (context_before !== undefined) {
+          args.push('-B', context_before.toString())
+        }
+        if (context_after !== undefined) {
+          args.push('-A', context_after.toString())
+        }
+      }
+    }
+
+    // If pattern starts with dash, use -e flag to specify it as a pattern
+    // This prevents ripgrep from interpreting it as a command-line option
+    if (pattern.startsWith('-')) {
+      args.push('-e', pattern)
+    } else {
+      args.push(pattern)
+    }
+
+    // Add type filter if specified
+    if (type) {
+      args.push('--type', type)
+    }
+
+    if (glob) {
+      // Split on commas and spaces, but preserve patterns with braces
+      const globPatterns: string[] = []
+      const rawPatterns = glob.split(/\s+/)
+
+      for (const rawPattern of rawPatterns) {
+        // If pattern contains braces, don't split further
+        if (rawPattern.includes('{') && rawPattern.includes('}')) {
+          globPatterns.push(rawPattern)
+        } else {
+          // Split on commas for patterns without braces
+          globPatterns.push(...rawPattern.split(',').filter(Boolean))
+        }
+      }
+
+      for (const globPattern of globPatterns.filter(Boolean)) {
+        args.push('--glob', globPattern)
+      }
+    }
+
+    // Add ignore patterns
+    const appState = getAppState()
+    const ignorePatterns = normalizePatternsToPath(
+      getFileReadIgnorePatterns(appState.toolPermissionContext),
+      getCwd(),
+    )
+    for (const ignorePattern of ignorePatterns) {
+      // Note: ripgrep only applies gitignore patterns relative to the working directory
+      // So for non-absolute paths, we need to prefix them with '**'
+      // See: https://github.com/BurntSushi/ripgrep/discussions/2156#discussioncomment-2316335
+      //
+      // We also need to negate the pattern with `!` to exclude it
+      const rgIgnorePattern = ignorePattern.startsWith('/')
+        ? `!${ignorePattern}`
+        : `!**/${ignorePattern}`
+      args.push('--glob', rgIgnorePattern)
+    }
+
+    // Exclude orphaned plugin version directories
+    for (const exclusion of await getGlobExclusionsForPluginCache(
+      absolutePath,
+    )) {
+      args.push('--glob', exclusion)
+    }
+
+    // WSL has severe performance penalty for file reads (3-5x slower on WSL2)
+    // The timeout is handled by ripgrep itself via execFile timeout option
+    // We don't use AbortController for timeout to avoid interrupting the agent loop
+    // If ripgrep times out, it throws RipgrepTimeoutError which propagates up
+    // so Claude knows the search didn't complete (rather than thinking there were no matches)
+    const results = await ripGrep(args, absolutePath, abortController.signal)
+
+    if (output_mode === 'content') {
+      // For content mode, results are the actual content lines
+      // Convert absolute paths to relative paths to save tokens
+
+      // Apply head_limit first — relativize is per-line work, so
+      // avoid processing lines that will be discarded (broad patterns can
+      // return 10k+ lines with head_limit keeping only ~30-100).
+      const { items: limitedResults, appliedLimit } = applyHeadLimit(
+        results,
+        head_limit,
+        offset,
+      )
+
+      const finalLines = limitedResults.map(line => {
+        // Lines have format: /absolute/path:line_content or /absolute/path:num:content
+        const colonIndex = line.indexOf(':')
+        if (colonIndex > 0) {
+          const filePath = line.substring(0, colonIndex)
+          const rest = line.substring(colonIndex)
+          return toRelativePath(filePath) + rest
+        }
+        return line
+      })
+      const output = {
+        mode: 'content' as const,
+        numFiles: 0, // Not applicable for content mode
+        filenames: [],
+        content: finalLines.join('\n'),
+        numLines: finalLines.length,
+        ...(appliedLimit !== undefined && { appliedLimit }),
+        ...(offset > 0 && { appliedOffset: offset }),
+      }
+      return { data: output }
+    }
+
+    if (output_mode === 'count') {
+      // For count mode, pass through raw ripgrep output (filename:count format)
+      // Apply head_limit first to avoid relativizing entries that will be discarded.
+      const { items: limitedResults, appliedLimit } = applyHeadLimit(
+        results,
+        head_limit,
+        offset,
+      )
+
+      // Convert absolute paths to relative paths to save tokens
+      const finalCountLines = limitedResults.map(line => {
+        // Lines have format: /absolute/path:count
+        const colonIndex = line.lastIndexOf(':')
+        if (colonIndex > 0) {
+          const filePath = line.substring(0, colonIndex)
+          const count = line.substring(colonIndex)
+          return toRelativePath(filePath) + count
+        }
+        return line
+      })
+
+      // Parse count output to extract total matches and file count
+      let totalMatches = 0
+      let fileCount = 0
+      for (const line of finalCountLines) {
+        const colonIndex = line.lastIndexOf(':')
+        if (colonIndex > 0) {
+          const countStr = line.substring(colonIndex + 1)
+          const count = parseInt(countStr, 10)
+          if (!isNaN(count)) {
+            totalMatches += count
+            fileCount += 1
+          }
+        }
+      }
+
+      const output = {
+        mode: 'count' as const,
+        numFiles: fileCount,
+        filenames: [],
+        content: finalCountLines.join('\n'),
+        numMatches: totalMatches,
+        ...(appliedLimit !== undefined && { appliedLimit }),
+        ...(offset > 0 && { appliedOffset: offset }),
+      }
+      return { data: output }
+    }
+
+    // For files_with_matches mode (default)
+    // Use allSettled so a single ENOENT (file deleted between ripgrep's scan
+    // and this stat) does not reject the whole batch. Failed stats sort as mtime 0.
+    const stats = await Promise.allSettled(
+      results.map(_ => getFsImplementation().stat(_)),
+    )
+    const sortedMatches = results
+      // Sort by modification time
+      .map((_, i) => {
+        const r = stats[i]!
+        return [
+          _,
+          r.status === 'fulfilled' ? (r.value.mtimeMs ?? 0) : 0,
+        ] as const
+      })
+      .sort((a, b) => {
+        if (process.env.NODE_ENV === 'test') {
+          // In tests, we always want to sort by filename, so that results are deterministic
+          return a[0].localeCompare(b[0])
+        }
+        const timeComparison = b[1] - a[1]
+        if (timeComparison === 0) {
+          // Sort by filename as a tiebreaker
+          return a[0].localeCompare(b[0])
+        }
+        return timeComparison
+      })
+      .map(_ => _[0])
+
+    // Apply head_limit to sorted file list (like "| head -N")
+    const { items: finalMatches, appliedLimit } = applyHeadLimit(
+      sortedMatches,
+      head_limit,
+      offset,
+    )
+
+    // Convert absolute paths to relative paths to save tokens
+    const relativeMatches = finalMatches.map(toRelativePath)
+
+    const output = {
+      mode: 'files_with_matches' as const,
+      filenames: relativeMatches,
+      numFiles: relativeMatches.length,
+      ...(appliedLimit !== undefined && { appliedLimit }),
+      ...(offset > 0 && { appliedOffset: offset }),
+    }
+
+    return {
+      data: output,
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)