Run a regex codemod across many files and preview the diff

About this tool

A codemod is a mechanical, repeatable edit applied across a whole set of files — renaming a symbol, reshaping a date format, swapping an import path, redacting a field. Doing it by hand in a dozen files is slow and easy to get subtly wrong; doing it with a one-line shell pipeline is fast and gives you no chance to look before it lands.

This tool sits in between. Paste the files you want to change as one bundle, write a single regular expression and its replacement, and get back a unified diff showing exactly which lines move in which files. Nothing is written anywhere — the diff is a preview you read, copy, or feed to git apply. Everything runs locally in your browser, so the code you paste never leaves the page.

How the bundle is split

The paste is cut into files at marker lines. By default (Auto-detect) any of these work, and you can mix them in one paste:

If your bundle uses something else, pick Custom pattern and supply a marker regex with one capture group for the path, such as ^@@@ (\S+)$. Pick No markers to treat the whole paste as a single file. Any content before the first marker is treated as a file named input.

A quick way to build a bundle on the command line:

tail -n +1 src/*.js

Worked example

Paste this, with Find \boldName\b and Replace with newName:

=== src/a.js ===
const oldName = 1;
use(oldName);
=== src/b.js ===
const other = 2;

The diff preview comes back as:

# 2 replacements in 1 of 2 files
--- a/src/a.js
+++ b/src/a.js
@@ -1,2 +1,2 @@
-const oldName = 1;
-use(oldName);
+const newName = 1;
+use(newName);

src/b.js has no match, so it does not appear at all — switch on List untouched files too to see it reported as # unchanged: src/b.js. Switch Output to Full rewritten files to get the whole bundle back with the edit applied, or to JSON report for per-file replacement counts.

Capture groups

The replacement understands $1, $2, … for numbered groups, ${name} for named groups ((?P<name>…)), and $$ for a literal dollar sign. Reformatting American dates to ISO is a one-liner: find (\d{2})/(\d{2})/(\d{4}), replace with $3-$1-$2. Braces are worth using whenever a digit could run into the following text — ${1}0 means "group 1 then a zero", while $10 means "group 10".

Matching options

• Plain text — escape the pattern and insert the replacement verbatim, so . and $1 mean themselves. Use it when your search string is code, not a pattern.
• Ignore case (i), ^ and $ match every line (m), . matches newlines (s) — the usual regex flags, applied to the whole pattern. You can also write them inline, e.g. (?i)todo.
• Whole word only — wraps the pattern in word boundaries, so id will not match inside idx.
• Replace every match (g) — on by default. Turn it off to change only the first match in each file, which is handy for one-per-file headers.

Limits

• Up to 1,000,000 characters and 2,000 files in one paste; larger inputs are rejected with an error rather than silently truncated. Split the work into batches.
• Patterns use Rust regex syntax: character classes, named groups (?P<name>…), non-greedy quantifiers and Unicode classes all work. Backreferences inside the pattern (\1) and lookaround ((?=…), (?<=…)) are not supported — that is the deliberate trade that keeps matching linear-time, so no pattern can hang the page.
• Line endings are preserved exactly as pasted, including CRLF and a missing final newline (which the diff marks with \ No newline at end of file).
• The diff is line-based. A change that rewrites an enormous, completely different block falls back to one coarse "remove all, add all" hunk instead of a fine-grained alignment.

FAQ