finding-files

Original source / Raw SKILL.md

---
name: finding-files
description: Performs fast file discovery with parallel search and smart defaults. Use this skill when searching for files by name, pattern, or type, especially when performance matters or when working with large directories
---

# fd: Intuitive File Search

**Always invoke fd skill for fast file discovery - do not execute bash commands directly.**

Use fd for fast file discovery that's 13-23x faster than find.

## Default Strategy

**Invoke fd skill** for fast file discovery with parallel search and smart defaults. Use when searching for files by name, pattern, or type, especially when performance matters or when working with large directories.

Common workflow: fd skill → other skills (fzf, bat, ripgrep, sd) for further processing.

## Key Options

- `-e ext` for extension filtering
- `-t file|dir` for type filtering  
- `-H` include hidden files
- `-I` ignore .gitignore
- `--exclude pattern` exclusions
- `-x` exec per file, `-X` exec batch
- `{}`, `{.}`, `{/}` placeholders

## When to Use

- Quick file searches by pattern
- Filter by type, size, extension
- Search with depth limits
- Batch file operations
- Integration with other tools

### Common Workflows
- `fd → fzf → bat`: Search files, select interactively, view with syntax highlighting
- `fd → sd`: Find files and perform batch replacements
- `fd → xargs tool`: Execute commands on found files
- `fd → ripgrep`: Search within specific file types

## Core Principle

Smart defaults: ignores hidden/.gitignore files, case-insensitive, parallel search - much faster than find.

## Detailed Reference

For comprehensive search patterns, filtering options, execution examples, and performance tips, load [fd guide](./reference/fd-guide.md) when needing:
- Advanced filtering patterns (size, time, depth)
- Batch execution with placeholders
- Performance optimization techniques
- Integration with shell scripts
- Complex exclusion patterns

The guide includes:
- Core search patterns and file discovery
- Extension and type filtering techniques
- Execution and batch operation examples
- Performance optimization strategies
- Integration with other tools (xargs, ripgrep)
- Advanced filtering and exclusion patterns

## Skill Combinations

### For Discovery Phase
- **fd → fzf**: Interactive file selection with preview
- **fd → ripgrep**: Search within specific file types
- **fd → jq/yq**: Extract data from found config files
- **fd → extracting-code-structure**: Get structure overview of found files

### For Analysis Phase
- **fd → bat**: View found files with syntax highlighting
- **fd → tokei**: Get statistics for specific file sets
- **fd → jq/yq**: Analyze configuration files in directory

### For Refactoring Phase
- **fd → sd**: Perform batch replacements across found files
- **fd → analyzing-code-structure**: Apply structural changes to specific file types
- **fd → xargs**: Execute commands on found files

### Integration Examples
```bash
# Find and edit source files
fd -e py | fzf --multi --preview="bat --color=always {}" | xargs vim

# Find and replace in JavaScript files
fd -e js -x sd "oldPattern" "newPattern"


---

## Referenced Files

> The following files are referenced in this skill and included for context.

### reference/fd-guide.md

```markdown
# fd Quick Reference

**Goal: Fast, intuitive file discovery with parallel search.**

## Core Patterns
```bash
fd 'pattern' [path] [options]          # Basic search
fd -e js -e ts                    # Multiple extensions
fd --type file | dir | exec         # Filter by type
fd --max-depth 3                    # Depth limit
fd -H                              # Include hidden files
fd -I                              # Ignore .gitignore
```

## Filtering Options
```bash
fd --exclude node_modules           # Exclude patterns
fd --size '+1M'                    # Size filtering (+/-/range)
fd --changed-within 1d              # Time filtering (d/h/m)
fd --full-path                      # Search full path
fd --case-sensitive                 # Smart case override
```

## Command Execution
```bash
fd -e js -x wc -l                 # Per file
fd -e js -X wc -l                 # Batch all
# Placeholders: {}, {.}, {/}, {/.}, {//}
fd -e jpg -x convert {} {.}.png       # Convert files
```

## Common Tasks
```bash
fd -e js src/                       # Find JS in src
fd '\.test\.' -e js                 # Find test files
fd --type empty -x rm                # Clean empty files
fd -e json -X jq '.version'         # Process JSON
fd -l                               # List with details
```

## Key Advantages vs find
- **13-23x faster** performance  
- Smart defaults (ignore hidden/.gitignore)
- Parallel directory traversal
- Intuitive pattern syntax (no -name -o -print)
- Colorized output by file type

```