code-search
/code-search
Search for patterns inside file contents using ripgrep (rg). Use when searching for code patterns, finding function definitions, locating usages, or when the user asks to search/grep content inside files.
- Author
- brettatoms ↗
- Repository
- agent-skills ↗
- Licence
- MIT
- Last repository change
- 17.08.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 17.08.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Search for patterns inside file contents using ripgrep (rg). Use when searching for code patterns, finding function definitions, locating usages, or when the user asks to search/grep content inside files.
Original author description
Search for patterns inside file contents using ripgrep (rg). Use when searching for code patterns, finding function definitions, locating usages, or when the user asks to search/grep content inside files.
How it works
- Prerequisites
- Quick Reference
- Core rg Options
- Common Search Patterns
- Search Strategies
- Regex Tips
- Performance Tips
- Advanced Options
SKILL.md preview
---
name: code-search
description: Search for patterns inside file contents using ripgrep (rg). Use when searching for code patterns, finding function definitions, locating usages, or when the user asks to search/grep content inside files.
allowed-tools: Bash, Read, Task
---
# Code Search Skill
Use **ripgrep (`rg`)** for searching patterns inside file contents. For finding files by name, use the `file-nav` skill instead.
## Prerequisites
If `rg` is not installed, recommend the user install it:
```bash
# Arch Linux
sudo pacman -S ripgrep
# Ubuntu/Debian
sudo apt install ripgrep
# macOS
brew install ripgrep
# Cargo
cargo install ripgrep
```
## Quick Reference
| Task | Command |
|------|---------|
| Search content | `rg "pattern"` |
| List matching files | `rg -l "pattern"` |
| Search with context | `rg -C 3 "pattern"` |
## Core rg Options
### Output Control
```bash
rg "pattern" # Show matching lines (default)
rg -l "pattern" # List files only (--files-with-matches)
rg -c "pattern" # Count matches per file
rg -o "pattern" # Only show matched text
```
### Context Lines
```bash
rg -A 5 "pattern" # 5 lines after
rg -B 5 "pattern" # 5 lines before
rg -C 5 "pattern" # 5 lines before and after
```
### Filtering by File Type
```bash
rg -t clojure "pattern" # Only Clojure files
rg -t js "pattern" # Only JavaScript files
rg -t py "pattern" # Only Python files
rg -t rust "pattern" # Only Rust files
rg -T test "pattern" # Exclude test files
rg -g "*.clj" "pattern" # Glob filter
rg -g "!*.test.*" "pat" # Exclude glob pattern
```
### Scope
```bash
rg "pattern" src/ # Search specific directory
rg "pattern" file.clj # Search specific file
```
### Case Sensitivity
```bash
rg -i "pattern" # Case insensitive
rg -s "pattern" # Case sensitive (default)
rg -S "pattern" # Smart case (insensitive if all lowercase)
```
### Line Numbers
```bash
rg -n "pattern" # Show line numbers (default)
rg -N "pattern" # Hide line numbers
```
### Multiline
```bash
rg -U "pattern" # Multiline mode (pattern can span lines)
rg -U "start.*?end" # Non-greedy multiline match
```
### Limiting Output
```bash
rg -m 5 "pattern" # Max 5 matches per file
rg "pattern" | head -20 # First 20 lines of output
```
## Common Search Patterns
### Find Function Definitions
```bash
# Clojure
rg -t clojure "\(defn\s+my-function"
rg -t clojure "\(defn-?\s+my-function" # defn or defn-
# JavaScript/TypeScript
rg -t js "function\s+myFunction|const\s+myFunction\s*="
rg -t ts "function\s+myFunction"
# Python
rg -t py "def\s+my_function"
# Go
rg -t go "func\s+MyFunction"
# Rust
rg -t rust "fn\s+my_function"
```
### Find Class/Type Definitions
```bash
# Clojure defrecord/deftype
rg -t clojure "\(def(record|type)\s+MyType"
# TypeScript interface/type
rg -t ts "(interface|type)\s+MyType"
# Python class
rg -t py "class\s+MyClass"
# Java/Kotlin class
rg -t java "class\s+MyClass"
```
### Find Usages/References
```bash
# Find all uses of a symbol
rg -C 2 "my-function"
# Word boundary match (avoid partial matches)
rg -w "user"
# Find require/import statements
rg "\[my\.namespace" -t clojure
rg "import.*MyModule" -t js
rg "from.*import.*my_func" -t py
```
### Find TODO/FIXME Comments
```bash
rg -i "(TODO|FIXME|HACK|XXX)"
rg -i "TODO" -C 1
```
### Find Configuration Values
```bash
rg "database|connection" -g "*.{yml,yaml,json,edn}"
rg "password|secret|key" -g "*.env*"
```
## Search Strategies
### 1. Broad to Narrow
Start with file listing, then search with context:
```bash
# Step 1: Find files containing pattern
rg -l "authentication"
# Step 2: Search specific file with context
rg -C 5 "authentication" src/auth.clj
```
### 2. Definition + Usages (run in parallel)
```bash
# Find definition
rg -t clojure "\(defn\s+create-user" -A 10
# Find usages
rg "create-user" -C 2
```
### 3. Exclude Tests/Vendor
```bash
rg "pattern" -g "!*test*" -g "!vendor/*" -g "!node_modules/*"
```
### 4. Multiple File Types
```bash
rg "pattern" -t clojure -t edn
rg "pattern" -g "*.{ts,tsx,js,jsx}"
```
## Regex Tips
- `\s+` for whitespace
- `\(` for literal parentheses
- `.*?` for non-greedy matching
- `[^)]+` for anything except closing paren
- `\{` and `\}` for literal braces
- `(?:...)` for non-capturing groups
- `\b` for word boundaries
- `^` and `$` for line start/end
## Performance Tips
1. **Use `-t type` filters** - Much faster than searching all files
2. **Use `-l` first** - Cheaper than showing content
3. **Specify directory** - `rg "pattern" src/` narrows scope
4. **Use `-m N`** - Stop after N matches per file
5. **Parallel searches** - Run independent rg commands in parallel
6. **Exclude directories** - `-g "!node_modules/*"` etc.
## Advanced Options
```bash
rg --hidden "pattern" # Include hidden files
rg --no-ignore "pattern" # Don't respect .gitignore
rg -uuu "pattern" # Unrestricted (all files)
rg --json "pattern" # JSON output for parsing
rg -p "pattern" | less -R # Pager with color
```
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · brettatoms/agent-skills | 100 | MIT |
| langwatch/langwatch | 100 | Apache-2.0 |
| edmundmiller/dotfiles | 100 | MIT |
| atretyak1985/swarmery | 100 | Apache-2.0 |
| athola/claude-night-market | 100 | MIT |
| elastic/sourcerer | 100 | Apache-2.0 |
| agentscope-ai/agentscope-java | 90 | Apache-2.0 |
Database snapshot: 13.11.2026 · package version 3b645e3b154d (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100file-search
This skill should be used when agents need to search codebases for text patterns or structural code patterns. Provides fast search using ripgrep for text and ast-grep for syntax-aware code search. - 100rg-code-search
ripgrep (rg) fast code search: smart defaults, regex, file filtering. Use when searching for text patterns, code snippets, or doing multi-file analysis. - 95file-search
Modern file and content search using fd, ripgrep (rg), and fzf. Triggers on: fd, ripgrep, rg, find files, search code, fzf, fuzzy find, search codebase. - 100ripgrep
Fast, recursive search tool for pattern matching in files with regex support, ignore handling, and glob filtering. Use when searching codebases for patterns, finding function definitions, filtering by file type, or performing find/replace operations. Triggers: "search for X in… - 95mgrep-code-search
Semantic code search using mgrep for efficient codebase exploration. This skill should be used when searching or exploring codebases with more than 30 non-gitignored files and/or nested directory structures. It provides natural language semantic search that complements… - 100file-search
Perform fast file name and content searches with ripgrep (rg); use it when you need to locate files by glob/regex, find keywords across directories, or replace common find/grep workflows.