home / skills / 0xdarkmatter / claude-mods / find-replace

find-replace skill

This skill helps you perform fast find-and-replace operations using sd across files, with safe batch workflows and preview capabilities.

npx playbooks add skill 0xdarkmatter/claude-mods --skill find-replace

Review the files below or copy the command above to add this skill to your agents.

Files (4)

SKILL.md

2.0 KB

---
name: find-replace
description: "Modern find-and-replace using sd (simpler than sed) and batch replacement patterns. Triggers on: sd, find replace, batch replace, sed replacement, string replacement, rename."
compatibility: "Requires sd CLI tool. Install: brew install sd (macOS) or cargo install sd (cross-platform)."
allowed-tools: "Bash"
---

# Find Replace

Modern find-and-replace using sd.

## sd Basics

```bash
# Replace in file (in-place)
sd 'oldText' 'newText' file.txt

# Replace in multiple files
sd 'oldText' 'newText' *.js

# Preview without changing (pipe)
cat file.txt | sd 'old' 'new'
```

## sd vs sed

| sed | sd |
|-----|-----|
| `sed 's/old/new/g'` | `sd 'old' 'new'` |
| `sed -i 's/old/new/g'` | `sd 'old' 'new' file` |
| `sed 's#path/to#new/path#g'` | `sd 'path/to' 'new/path'` |

**Key difference:** sd is global by default, no delimiter issues.

## Common Patterns

```bash
# Variable/function rename
sd 'oldName' 'newName' src/**/*.ts

# Word boundaries (avoid partial matches)
sd '\boldName\b' 'newName' src/**/*.ts

# Import path update
sd "from '../utils'" "from '@/utils'" src/**/*.ts

# Capture groups
sd 'console\.log\((.*)\)' 'logger.info($1)' src/**/*.js
```

## Safe Batch Workflow

```bash
# 1. List affected files
rg -l 'oldPattern' src/

# 2. Preview replacements
rg 'oldPattern' -r 'newPattern' src/

# 3. Apply
sd 'oldPattern' 'newPattern' $(rg -l 'oldPattern' src/)

# 4. Verify
rg 'oldPattern' src/  # Should return nothing
git diff              # Review changes
```

## Special Characters

| Character | Escape |
|-----------|--------|
| `.` | `\.` |
| `*` | `\*` |
| `[` `]` | `\[` `\]` |
| `$` | `\$` |
| `\` | `\\` |

## Tips

| Tip | Reason |
|-----|--------|
| Always preview with `rg -r` first | Avoid mistakes |
| Use git before bulk changes | Easy rollback |
| Use `\b` for word boundaries | Avoid partial matches |
| Quote patterns | Prevent shell interpretation |

## Additional Resources

For detailed patterns, load:
- `./references/advanced-patterns.md` - Regex, batch workflows, real-world examples

Overview

This skill provides a modern find-and-replace workflow using sd for safe, global, and readable text substitution across files. It simplifies common sed patterns, supports regex captures, and integrates a safe batch workflow with ripgrep (rg) for preview and verification. The skill focuses on predictable, in-place edits and easy rollback with git.

How this skill works

The tool runs sd to perform global replacements by default, so patterns do not require delimiters and are less error-prone than sed. It pairs rg for listing and previewing matches, then applies sd to files returned by rg for batched, targeted edits. It supports regex escapes, word boundaries, and capture groups to handle complex renames and import updates.

When to use it

Rename variables or functions across a codebase
Update import paths or module references in many files
Refactor logging calls or API endpoints with capture-group rewrites
Batch-fix typos, licensing headers, or configuration keys
Preview and apply large-scale changes safely before committing

Best practices

Always preview matches with rg -r or rg -l before applying replacements
Run rg -l to generate a file list and pass it to sd for focused changes
Quote patterns and escape special characters like ., *, [, ], $, and \
Use \b for word boundaries to avoid partial matches
Commit or create a branch before large replacements so you can review diffs and rollback

Example use cases

Rename a function: sd 'oldName' 'newName' src/**/*.ts and verify with rg 'oldName'
Update import paths: sd "from '../utils'" "from '@/utils'" src/**/*.ts
Replace console logs with logger calls using captures: sd 'console\.log$(.*)$' 'logger.info($1)' src/**/*.js
Batch apply a change found with ripgrep: sd 'oldPattern' 'newPattern' $(rg -l 'oldPattern' src/) and then git diff to review

FAQ

How is sd different from sed?

sd is global by default, avoids delimiter hassles, and uses simpler syntax for most common replacements. Use sd for clearer, less error-prone global edits.

How do I avoid matching substrings?

Use word boundaries (\b) in your pattern, or include surrounding context in the regex to limit matches.

What if I need to preview changes before modifying files?

Use rg -r 'old' -r 'new' or pipe file content through sd to preview. Also list files with rg -l and inspect them before passing to sd.