glep 0.2.1

Indexed grep + glob for AI agents

Indexed grep + glob for AI agents.

Ripgrep pays the full scan cost on every query. glep pays it once: a persistent, self-healing trigram index answers warm content queries in ~1-20ms and glob listings with zero filesystem traversal, with output byte-compatible with ripgrep's and no daemon.

Why

Coding agents call Grep and Glob dozens of times per session. On monorepo-scale projects each call costs seconds. glep replaces both with index-backed equivalents built on ripgrep's own crates (ignore, grep-searcher, regex-syntax), so correctness is inherited, not reimplemented.

When to use it

Use glep	Stick with rg / fd
Agent sessions firing dozens of searches over one repo (the bundled hook reroutes Grep/Glob)	One-off searches in a tree you will never search again
Monorepos where rg takes 100ms+ per query; warm glep answers in ~1-20ms	Small repos where rg already answers in under ~50ms
Repeated glob listings: glep --files reads the manifest, no traversal	Ephemeral CI runners where the index never persists between runs
Read-heavy bursts with --ttl 5 to amortize the freshness sweep	rg features glep lacks: replacements, PCRE2, compressed files
Correctness-critical work: self-healing index, sound full-scan fallback	Corpora dominated by binaries or files over the 1MB cap (live-scanned anyway)

Numbers

Linux kernel 6.12 checkout: 86,605 files, ~1.5 GB. Apple Silicon macOS, hyperfine medians, warm filesystem cache, rg and fd at their default parallelism.

Scenario	glep	glep --ttl 5	ripgrep	fd
Rare pattern	173 ms	21 ms	1.42 s
Common pattern (~10k matches)		90 ms	1.54 s
List all .c files (--files)	242 ms	44 ms		92 ms
Index build (one-time)	24 s

Default glep pays the self-healing freshness sweep (a stat of every file) on each query; --ttl amortizes it across read bursts. Index size: 154 MB, about 10% of the corpus. The parity harness pins byte-equality with rg's output; speed differs, bytes do not.

How it works

• A file-level trigram inverted index (the Russ Cox / csearch model) lives in .glep/, memory-mapped, a few percent of corpus size.
• Every query self-heals: a fast parallel mtime sweep incrementally reindexes only what changed, then answers. No watcher, no background process.
• The regex becomes a trigram plan, postings intersection yields a handful of candidate files, and ripgrep's searcher runs over just those.
• Patterns trigrams can't narrow fall back to a full parallel scan: never a wrong answer, worst case is rg-speed.

Interface

glep 'fn parse_intent' src/     # content search (Grep replacement)
glep --files '**/*.py'          # glob listing (Glob replacement)
glep --json 'pattern'           # machine-readable output for agents
glep index                      # explicit (re)build; lazy on first query
glep status                     # index stats

Ships with a Claude Code skill and a PreToolUse hook that routes built-in Grep/Glob calls through glep automatically.

Install

pip install glep          # binary wheel, no Rust toolchain needed
# or
cargo install glep

Claude Code integration (skill + hook): claude/install.sh.

Status

Spec: docs/superpowers/specs/2026-07-14-glep-design.md.