Update code search to limit results per file and globally

Author: jahooma

backend/src/tools/definitions/tool/code-search.ts

@@ -19,11 +19,18 @@ Use cases:
 
 The pattern supports regular expressions and will search recursively through all files in the project by default. Some tips:
 - Be as constraining in the pattern as possible to limit the number of files returned, e.g. if searching for the definition of a function, use "(function foo|const foo)" or "def foo" instead of merely "foo".
+- Use Rust-style regex, not grep-style, PCRE, RE2 or JavaScript regex - you must always escape special characters like { and }
+- Be as constraining as possible to limit results, e.g. use "(function foo|const foo)" or "def foo" instead of merely "foo"
+- Add context to your search with surrounding terms (e.g., "function handleAuth" rather than just "handleAuth")
 - Use word boundaries (\\b) to match whole words only
+- Use the cwd parameter to narrow your search to specific directories
+- For case-sensitive searches like constants (e.g., ERROR vs error), omit the "-i" flag
 - Searches file content and filenames
 - Automatically ignores binary files, hidden files, and files in .gitignore
 
-Advanced ripgrep flags (use the flags parameter):
+
+ADVANCED RIPGREP FLAGS (use the flags parameter):
+
 - Case sensitivity: "-i" for case-insensitive search
 - File type filtering: "-t ts" (TypeScript), "-t js" (JavaScript), "-t py" (Python), etc.
 - Exclude file types: "--type-not test" to exclude test files
@@ -37,6 +44,14 @@ Advanced ripgrep flags (use the flags parameter):
 
 Note: Do not use the end_turn tool after this tool! You will want to see the output of this tool before ending your turn.
 
+RESULT LIMITING:
+
+- The maxResults parameter limits the number of results shown per file (default: 15)
+- There is also a global limit of 250 total results across all files
+- These limits allow you to see results across multiple files without being overwhelmed by matches in a single file
+- If a file has more matches than maxResults, you'll see a truncation notice indicating how many results were found
+- If the global limit is reached, remaining files will be skipped
+
 Examples:
 ${getToolCallString(toolName, { pattern: 'foo' })}
 ${getToolCallString(toolName, { pattern: 'foo\\.bar = 1\\.0' })}

common/src/tools/params/tool/code-search.ts

@@ -30,8 +30,10 @@ export const codeSearchParams = {
         .int()
         .positive()
         .optional()
-        .default(30)
-        .describe(`Maximum number of results to return. Defaults to 30.`),
+        .default(15)
+        .describe(
+          `Maximum number of results to return per file. Defaults to 15. There is also a global limit of 250 results across all files.`,
+        ),
     })
     .describe(
       `Search for string patterns in the project's files. This tool uses ripgrep (rg), a fast line-oriented search tool. Use this tool only when read_files is not sufficient to find the files you need.`,

npm-app/src/__tests__/tool-handlers.test.ts

@@ -140,8 +140,251 @@ export interface TestInterface {
 
     // Should contain results limited message when there are more results than maxResults
     const stdout = (result[0].value as any).stdout
-    if (stdout.includes('Results limited to 1 of')) {
-      expect(stdout).toContain('Results limited to 1 of')
+    if (stdout.includes('Results limited to')) {
+      expect(stdout).toContain('Results limited to')
+    }
+  })
+
+  test('uses default limit of 15 per file when maxResults not specified', async () => {
+    // Create a file with many lines matching the pattern
+    const manyLinesContent = Array.from(
+      { length: 30 },
+      (_, i) => `export const TEST_VAR_${i} = 'value${i}';`,
+    ).join('\n')
+
+    await fs.promises.writeFile(
+      path.join(testDataDir, 'many-matches.ts'),
+      manyLinesContent,
+    )
+
+    // Explicitly not passing maxResults to test default
+    const parameters: any = {
+      pattern: 'TEST_VAR_',
+      cwd: 'src/__tests__/data',
+    }
+
+    const result = await handleCodeSearch(parameters, 'test-id')
+    const stdout = (result[0].value as any).stdout
+
+    // Should limit to 15 results per file by default
+    const lines = stdout
+      .split('\n')
+      .filter((line: string) => line.includes('TEST_VAR_'))
+    expect(lines.length).toBeLessThanOrEqual(15)
+    expect(stdout).toContain('Results limited to 15 per file')
+  })
+
+  test('applies per-file limit correctly across multiple files', async () => {
+    // Create multiple files with many matches each
+    for (let fileNum = 1; fileNum <= 3; fileNum++) {
+      const content = Array.from(
+        { length: 20 },
+        (_, i) => `export const VAR_F${fileNum}_${i} = 'value';`,
+      ).join('\n')
+
+      await fs.promises.writeFile(
+        path.join(testDataDir, `file${fileNum}.ts`),
+        content,
+      )
+    }
+
+    const parameters = {
+      pattern: 'VAR_F',
+      cwd: 'src/__tests__/data',
+      maxResults: 10,
+    }
+
+    const result = await handleCodeSearch(parameters, 'test-id')
+    const stdout = (result[0].value as any).stdout
+
+    // Each file should be limited to 10 results
+    expect(stdout).toContain('Results limited to 10 per file')
+
+    // Count actual result lines (not truncation messages)
+    // Split by the truncation message section to only count actual results
+    const resultsSection = stdout.split('[Results limited to')[0]
+    const file1Matches = (resultsSection.match(/file1\.ts:/g) || []).length
+    const file2Matches = (resultsSection.match(/file2\.ts:/g) || []).length
+    const file3Matches = (resultsSection.match(/file3\.ts:/g) || []).length
+
+    // Each file should have at most 10 result lines
+    expect(file1Matches).toBeLessThanOrEqual(10)
+    expect(file2Matches).toBeLessThanOrEqual(10)
+    expect(file3Matches).toBeLessThanOrEqual(10)
+  })
+
+  test('respects global limit of 250 results', async () => {
+    // Create many files with multiple matches to exceed global limit
+    for (let fileNum = 1; fileNum <= 30; fileNum++) {
+      const content = Array.from(
+        { length: 15 },
+        (_, i) => `export const GLOBAL_VAR_${fileNum}_${i} = 'value';`,
+      ).join('\n')
+
+      await fs.promises.writeFile(
+        path.join(testDataDir, `global-test-${fileNum}.ts`),
+        content,
+      )
+    }
+
+    // Using default maxResults of 15
+    const parameters: any = {
+      pattern: 'GLOBAL_VAR_',
+      cwd: 'src/__tests__/data',
+    }
+
+    const result = await handleCodeSearch(parameters, 'test-id')
+    const stdout = (result[0].value as any).stdout
+
+    // Count total result lines
+    const totalMatches = (stdout.match(/GLOBAL_VAR_/g) || []).length
+
+    // Should not exceed 250 results
+    expect(totalMatches).toBeLessThanOrEqual(250)
+
+    // Should mention global limit if reached
+    if (totalMatches === 250) {
+      expect(stdout).toContain('Global limit of 250 results reached')
+    }
+  })
+
+  test('shows correct truncation message with per-file limits', async () => {
+    // Create a file with many matches
+    const content = Array.from(
+      { length: 25 },
+      (_, i) => `const TRUNC_VAR_${i} = 'value${i}';`,
+    ).join('\n')
+
+    await fs.promises.writeFile(
+      path.join(testDataDir, 'truncate-test.ts'),
+      content,
+    )
+
+    const parameters = {
+      pattern: 'TRUNC_VAR_',
+      cwd: 'src/__tests__/data',
+      maxResults: 10,
+    }
+
+    const result = await handleCodeSearch(parameters, 'test-id')
+    const stdout = (result[0].value as any).stdout
+
+    // Should show which file was truncated
+    expect(stdout).toContain('Results limited to 10 per file')
+    expect(stdout).toContain('truncate-test.ts')
+    expect(stdout).toMatch(/25 results \(showing 10\)/)
+  })
+
+  test('handles global limit with skipped files message', async () => {
+    // Create enough files to trigger global limit
+    for (let fileNum = 1; fileNum <= 25; fileNum++) {
+      const content = Array.from(
+        { length: 12 },
+        (_, i) => `const SKIP_VAR_${fileNum}_${i} = ${i};`,
+      ).join('\n')
+
+      await fs.promises.writeFile(
+        path.join(testDataDir, `skip-test-${fileNum}.ts`),
+        content,
+      )
+    }
+
+    // Using default maxResults of 15
+    const parameters: any = {
+      pattern: 'SKIP_VAR_',
+      cwd: 'src/__tests__/data',
+    }
+
+    const result = await handleCodeSearch(parameters, 'test-id')
+    const stdout = (result[0].value as any).stdout
+
+    // Should show skipped files message
+    const totalMatches = (stdout.match(/SKIP_VAR_/g) || []).length
+
+    if (totalMatches >= 250) {
+      expect(stdout).toContain('Global limit of 250 results reached')
+      expect(stdout).toMatch(/\d+ file\(s\) skipped/)
+    }
+  })
+
+  test('applies remaining global space correctly', async () => {
+    // Create files where global limit is hit mid-file
+    for (let fileNum = 1; fileNum <= 20; fileNum++) {
+      const content = Array.from(
+        { length: 15 },
+        (_, i) => `const SPACE_VAR_${fileNum}_${i} = ${i};`,
+      ).join('\n')
+
+      await fs.promises.writeFile(
+        path.join(testDataDir, `space-test-${fileNum}.ts`),
+        content,
+      )
+    }
+
+    const parameters = {
+      pattern: 'SPACE_VAR_',
+      cwd: 'src/__tests__/data',
+      maxResults: 15,
+    }
+
+    const result = await handleCodeSearch(parameters, 'test-id')
+    const stdout = (result[0].value as any).stdout
+
+    // Count total matches - should not exceed 250
+    const totalMatches = (stdout.match(/SPACE_VAR_/g) || []).length
+    expect(totalMatches).toBeLessThanOrEqual(250)
+  })
+
+  test('handles case when no results exceed limits', async () => {
+    // Create files with few matches
+    await fs.promises.writeFile(
+      path.join(testDataDir, 'small-file.ts'),
+      'const SMALL_VAR = 1;\nconst SMALL_VAR_2 = 2;',
+    )
+
+    const parameters = {
+      pattern: 'SMALL_VAR',
+      cwd: 'src/__tests__/data',
+      maxResults: 15,
+    }
+
+    const result = await handleCodeSearch(parameters, 'test-id')
+    const stdout = (result[0].value as any).stdout
+
+    // Should not contain truncation messages
+    expect(stdout).not.toContain('Results limited to')
+    expect(stdout).not.toContain('Global limit')
+  })
+
+  test('combines per-file and global limit messages correctly', async () => {
+    // Create scenario where both limits are triggered
+    for (let fileNum = 1; fileNum <= 22; fileNum++) {
+      const content = Array.from(
+        { length: 20 },
+        (_, i) => `const COMBINED_VAR_${fileNum}_${i} = ${i};`,
+      ).join('\n')
+
+      await fs.promises.writeFile(
+        path.join(testDataDir, `combined-test-${fileNum}.ts`),
+        content,
+      )
+    }
+
+    const parameters = {
+      pattern: 'COMBINED_VAR_',
+      cwd: 'src/__tests__/data',
+      maxResults: 12,
+    }
+
+    const result = await handleCodeSearch(parameters, 'test-id')
+    const stdout = (result[0].value as any).stdout
+
+    // Should contain both messages
+    const totalMatches = (stdout.match(/COMBINED_VAR_/g) || []).length
+
+    if (totalMatches >= 250) {
+      expect(stdout).toContain('Results limited to 12 per file')
+      expect(stdout).toContain('Global limit of 250 results reached')
     }
   })
 })