grep()

// Basic pattern search
const results = await repo.grep({
  query: { pattern: 'TODO' },
});

console.log(`Found ${results.matches.length} files with matches`);
results.matches.forEach((match) => {
  console.log(`${match.path}:`);
  match.lines.forEach((line) => {
    if (line.type === 'match') {
      console.log(`  ${line.lineNumber}: ${line.text}`);
    }
  });
});

// Search inside an ephemeral ref
const previewResults = await repo.grep({
  ref: 'preview/pr-123',
  ephemeral: true,
  query: { pattern: 'TODO' },
});

// Advanced search with filtering and context
const advancedResults = await repo.grep({
  ref: 'main',
  query: {
    pattern: 'function\\s+\\w+Error',
    caseSensitive: true,
  },
  paths: ['src/'],
  fileFilters: {
    includeGlobs: ['**/*.js', '**/*.ts'],
    excludeGlobs: ['**/node_modules/**', '**/*.test.js'],
  },
  context: { before: 2, after: 2 },
  limits: { maxLines: 200, maxMatchesPerFile: 10 },
  pagination: { limit: 50 },
});

// Handle pagination
let cursor = advancedResults.nextCursor;
while (cursor && advancedResults.hasMore) {
  const moreResults = await repo.grep({
    query: { pattern: 'TODO' },
    pagination: { cursor, limit: 50 },
  });
  console.log('Next page:', moreResults.matches);
  cursor = moreResults.nextCursor;
}

// Paging is done, but the search itself may have hit the server cap
if (advancedResults.incompleteResults) {
  console.log('Results capped at maxLines, narrow the search to see more');
}

# Basic pattern search
results = await repo.grep(pattern="TODO")

print(f"Found {len(results['matches'])} files with matches")
for match in results['matches']:
    print(f"{match['path']}:")
    for line in match['lines']:
        if line['type'] == 'match':
            print(f"  {line['line_number']}: {line['text']}")

# Search inside an ephemeral ref
preview_results = await repo.grep(
    pattern="TODO",
    ref="preview/pr-123",
    ephemeral=True,
)

# Advanced search with all options
advanced_results = await repo.grep(
    pattern=r"function\s+\w+Error",
    ref="main",
    paths=["src/"],
    case_sensitive=True,
    file_filters={
        "include_globs": ["**/*.py", "**/*.js"],
        "exclude_globs": ["**/tests/**", "**/node_modules/**"],
        "extension_filters": [".py", ".js", ".ts"]
    },
    context={"before": 2, "after": 2},
    limits={"max_lines": 200, "max_matches_per_file": 10},
    pagination={"limit": 50}
)

# Handle pagination
cursor = advanced_results.get('next_cursor')
while cursor and advanced_results['has_more']:
    more_results = await repo.grep(
        pattern="TODO",
        pagination={"cursor": cursor, "limit": 50}
    )
    print('Next page:', more_results['matches'])
    cursor = more_results.get('next_cursor')

# Paging is done, but the search itself may have hit the server cap
if advanced_results['incomplete_results']:
    print('Results capped at max_lines, narrow the search to see more')

// Basic pattern search
results, err := repo.Grep(context.Background(), storage.GrepOptions{
	Query: storage.GrepQuery{Pattern: "TODO"},
})
fmt.Printf("Found %d files with matches", len(results.Matches))

// Search inside an ephemeral ref
ephemeral := true
preview, err := repo.Grep(context.Background(), storage.GrepOptions{
	Ref:       "preview/pr-123",
	Ephemeral: &ephemeral,
	Query:     storage.GrepQuery{Pattern: "TODO"},
})

caseSensitive := true
before := 2
after := 2
maxLines := 200
maxMatches := 10
pageLimit := 50

// Advanced search with filters
advanced, err := repo.Grep(context.Background(), storage.GrepOptions{
	Ref: "main",
	Query: storage.GrepQuery{
		Pattern:       `function\s+\w+Error`,
		CaseSensitive: &caseSensitive,
	},
	Paths: []string{"src/"},
	FileFilters: &storage.GrepFileFilters{
		IncludeGlobs:     []string{"**/*.go", "**/*.ts"},
		ExcludeGlobs:     []string{"**/node_modules/**", "**/*.test.ts"},
		ExtensionFilters: []string{".go", ".ts"},
	},
	Context: &storage.GrepContext{Before: &before, After: &after},
	Limits:  &storage.GrepLimits{MaxLines: &maxLines, MaxMatchesPerFile: &maxMatches},
	Pagination: &storage.GrepPagination{Limit: &pageLimit},
})

// Handle pagination
cursor := advanced.NextCursor
for cursor != "" && advanced.HasMore {
	moreLimit := 50
	more, err := repo.Grep(context.Background(), storage.GrepOptions{
		Query:      storage.GrepQuery{Pattern: "TODO"},
		Pagination: &storage.GrepPagination{Cursor: cursor, Limit: &moreLimit},
	})
	fmt.Println("Next page:", more.Matches)
	cursor = more.NextCursor
}

// Paging is done, but the search itself may have hit the server cap
if advanced.IncompleteResults {
	fmt.Println("Results capped at MaxLines, narrow the search to see more")
}