名称: ripgrep 描述: 增强的代码搜索，支持ES模块扩展和高级模式的自定义ripgrep二进制文件。版本: 1.1.0 模型: sonnet 调用者: 用户用户可调用: true 工具: [读取, 写入, 编辑] 已验证: false 最后验证时间: 2026-02-19T05:29:09.098Z

Ripgrep技能

<标识> 增强的代码搜索与ripgrep二进制文件。注意：优先使用pnpm search:code进行发现/排名和较小的输出负载；优先使用原始rg进行最快的精确字面匹配。 </标识>

<能力>

通过pnpm search:code进行混合代码搜索（BM25文本 + 语义向量排名）
原始ripgrep用于详尽模式扫描（每个匹配，非排名前N）
高级正则表达式模式（使用-P标志的PCRE2）
通过.ripgreprc自定义文件类型定义
与.gitignore和自定义忽略模式集成 </能力>

⚡ 推荐：混合代码搜索

使用混合搜索系统进行日常代码发现：

文本搜索即时工作，无需设置（基于ripgrep的BM25）
语义搜索需要一次性索引构建：pnpm code:index:reindex（约12分钟使用GPU，约17分钟CPU）
GPU加速嵌入通过fastembed（自动检测NVIDIA CUDA）
内存安全：嵌入在隔离子进程中运行，以解决ONNX Runtime内存泄漏问题
混合评分：互惠排名融合（RRF）结合文本匹配 + 语义相似度

先决条件

# 构建语义索引（一次性，或在主要代码库更改后）
pnpm code:index:reindex

# 验证.env已启用嵌入（默认为启用）
# HYBRID_EMBEDDINGS=on
# LANCEDB_EMBEDDING_MODE=fastembed

如果没有构建索引，pnpm search:code将回退到仅文本匹配。概念查询如“身份验证流程”在没有嵌入时将返回较差结果。

搜索命令

# 项目结构（目录树 + 入口点 + 依赖图 + Mermaid）
pnpm search:structure

# 令牌预算分析（文件大小 + 令牌估计 + 重构建议）
pnpm search:tokens .claude/lib          # 目录分析
pnpm search:tokens path/to/file.cjs     # 单个文件分析

# 语义 + 文本混合搜索（概念发现，排名结果）
# 重复/相似查询从缓存服务（约5ms命中 vs 约800ms未命中）
pnpm search:code "身份验证逻辑"
pnpm search:code "导出类用户"

# 一次性搜索 + 压缩 + 去重管道（用于大型上下文任务）
pnpm search:compress "路由如何工作"

# 获取带行号的文件内容
pnpm search:file src/auth.ts 1 50

# 缓存可观察性（守护进程必须运行）
pnpm search:code --cache-stats          # 查看命中、未命中、条目
pnpm search:code --cache-clear          # 清除缓存结果

`pnpm search:structure` — 了解事物位置

在进行任何编辑、重构或入职任务之前首先运行此命令。 它提供一个完整地图：

目录树 — 最多3层深的文件夹层次结构（排除node_modules, .git）
入口点 — 所有ESM export和CJS module.exports声明，带文件:行引用
顶级依赖 — 最常导入的模块（包括import和require），带计数，按以下分类：
- 📦 外部包（node:test, path, fs, child_process）
- 📁 本地模块（哪些内部文件最常导入 — 这些是架构热点）
Mermaid图 — 可视化依赖图，包括：
- 目录子图显示每个文件夹的导出计数
- 外部依赖子图
- 最常导入的本地模块突出显示为枢纽节点

代理如何使用：

编辑前：运行pnpm search:structure找到需要更改的代码所属目录
查找热点：📁本地依赖计数最高的模块是最连接的模块 — 更改那里影响范围最广
查找入口点：导出列表显示哪些文件公开公共API — 从那里开始阅读
理解架构：Mermaid图显示哪些目录最互连
重构前：依赖计数告诉您有多少文件将受重命名/移动影响

`pnpm search:tokens [路径]` — 了解上下文容纳能力

在决定如何读取文件或目录之前运行此命令。 它告诉您：

每文件和每目录的令牌估计（约4字符每令牌）
可操作建议：是否直接读取、使用偏移/限制，或使用search:code替代
需要特殊处理的最大文件
按令牌大小的目录排名 — 优先探索哪些子目录

# 检查特定文件
pnpm search:tokens .claude/lib/memory/lancedb-client-impl.cjs
# 输出: 大小: 41.1KB | 令牌: ~10.5K | 建议: △ 中等 — 使用带偏移/限制的读取

# 检查目录
pnpm search:tokens .claude/lib
# 输出: 333文件, 2.0MB, ~527K令牌（太大无法全部读取 — 使用search:code）

# 检查整个项目
pnpm search:tokens .
# 输出: 12478文件, 61MB, ~16M令牌，带每目录细分

令牌预算图例：

✓ 正常 (<8K令牌) — 安全地读取整个文件
△ 中等 (8-32K) — 使用带偏移/限制参数的读取，或search:file
⚠ 大 (32-100K) — 优先使用search:code而非完整读取；仅读取目标部分
⚠ 超大 (>100K) — 必须使用search:code或调用token-saver-context-compression技能

何时调用token-saver-context-compression：

目录总计超过100K令牌，且您需要理解整个子系统
文件超过32K令牌，且您需要摘要而非特定行
您正在构建的提示将超过上下文窗口限制

重构建议 — 对于超过15K令牌的源代码文件，工具建议拆分：

pnpm search:tokens .claude/hooks/routing
# 输出包括:
#   ✂ 重构建议: user-prompt-unified.core.cjs (18.2K令牌)
#     拆分为~3个模块，每个~8K令牌:
#       user-prompt-unified.cjs          — 薄门面（重新导出）
#       user-prompt-unified-impl.cjs     — 主要逻辑
#       user-prompt-unified-helpers.cjs  — 提取的帮助函数

这仅适用于源代码文件（.js, .cjs, .mjs, .ts, .py），不适用于数据文件或配置。模式遵循代码库中现有拆分（例如，routing-table.cjs → routing-table-data.cjs, index-manager.cjs → index-manager-operations.cjs）。

`pnpm search:compress "查询"` — 一次性搜索 + 压缩

当search:tokens显示主题跨越>32K令牌且您需要压缩摘要时使用。

在单个命令中结合完整管道：

混合搜索为您的查询找到相关文件
读取实际文件内容（不仅是文件路径）
基于语料库大小自适应设置压缩比率（小0.8，大0.1）
通过Python引擎压缩，带证据感知模式
去重提取的见解与现有内存（patterns.json, gotchas.json）
输出JSON，包含压缩上下文 + 分类内存记录

pnpm search:compress "路由系统如何工作"
# 返回JSON:
# {
#   "ok": true,
#   "search": { "query": "...", "hits": 20 },
#   "compression": { "mode": "evidence_aware", "skeletonRatio": 0.5 },
#   "memoryRecords": { "patterns": [...], "gotchas": [...], "issues": [...], "decisions": [...] },
#   "dedupStats": { "total": 24, "kept": 18, "filtered": 6 }
# }

关键特性：

自适应压缩：小语料库（<8K令牌）保留80%，大语料库（>100K）仅保留10%
内存去重：不会重新持久化已存在于内存系统中的模式/陷阱
证据门控：使用--fail-on-insufficient-evidence在查询未找到强匹配时中止

自动优化（无需操作）

这些特性在后台工作，无需命令：

查询缓存 — 重复或语义相似的search:code查询从内存缓存服务（约5ms vs 约800ms）。缓存使用余弦相似度（阈值：0.95），因此“路由系统”和“路由如何工作”共享缓存结果。条目5分钟后过期。缓存驻留在守护进程中，以便在查询间持久化。

BM25自动更新 — 编辑文件时，BM25文本索引增量更新（约10ms每文件）。这意味着search:code始终反映您的最新更改，无需code:index:reindex。仅文本索引更新；语义嵌入需要完全重新索引。

缓存可观察性：

pnpm search:code --cache-stats    # 条目、命中、未命中、命中率
pnpm search:code --cache-clear    # 清除所有缓存结果

搜索模式契约（确定性）

模式	使用场景	延迟	输出
`pnpm search:structure`	第一步：了解项目布局，找到编辑位置	快	目录树 + 导出 + 依赖 + Mermaid
`pnpm search:tokens [路径]`	读取前：检查文件/目录是否适合上下文	快	令牌估计 + 重构建议
`pnpm search:code "查询"`	概念发现，查找未知路径。自动缓存（约5ms重复）	~0.2-0.8s（首次），~5ms（缓存）	紧凑排名前20
`pnpm search:compress "查询"`	大型上下文：一次性搜索 + 压缩 + 去重	~2-5s	JSON：压缩上下文 + 内存记录
`rg -F "字面"`	精确符号/字面查找和编辑前锚点检查	最快（~35ms）	所有匹配（非排名）
`Grep`（内置）	审计的详尽模式扫描	快	所有匹配带上下文

必需的选择行为：

首先：pnpm search:structure定位 — 了解目录布局和依赖热点。
检查大小：pnpm search:tokens在读取前 — 了解文件是否适合上下文。
然后：pnpm search:code进行概念发现 — 找到与任务相关的文件。重复查询自动缓存。
对于大型上下文：pnpm search:compress当您需要广泛主题的压缩理解时。在单个命令中结合搜索 + 自适应压缩 + 内存去重。
编辑前：rg -F验证精确锚点 — 确认符号/函数存在。
对于审计：Grep（内置）进行详尽扫描 — 需要所有匹配，非前N。
BM25文本索引在文件编辑时自动更新（无需手动操作）。
fzf保持可选用于人工工作流；自动化中不需要。

编辑前定位（代理的强制工作流）

在编写或编辑任何文件前，代理必须首先定位它。盲目编辑浪费令牌并导致错误。

步骤1 — 定位（每个任务运行一次）：

pnpm search:structure

阅读输出以了解：

存在哪些目录及其内容
哪些模块最常导入（📁本地依赖计数高）
公共API在哪里（入口点列表）

步骤2 — 检查令牌预算（读取文件前）：

# 此文件是否安全完整读取，或需要使用search:code？
pnpm search:tokens .claude/lib/memory/lancedb-client-impl.cjs
# 输出: △ 中等（10.5K令牌） — 使用带偏移/限制的读取

# 此目录多大？能读取所有文件吗？
pnpm search:tokens .claude/lib/routing
# 如果>32K总计 → 使用search:code发现，不要尝试读取所有内容

步骤3 — 发现（每子任务）：

# 找到与任务概念相关的文件
pnpm search:code "钩子验证预工具"

这返回与概念最相关的排名文件。记下文件路径。

步骤4 — 精确定位（每次编辑前）：

# 确认带行号的精确符号位置
rg -F "validateHookInput" -g "*.cjs" -n

# 读取文件以理解上下文（对中等+文件使用偏移/限制）
pnpm search:file .claude/lib/utils/hook-input.cjs 1 50

步骤5 — 检查影响范围（重构前）：

# 有多少文件导入您即将更改的模块？
rg -F "hook-input.cjs" -g "*.cjs" -c
# 如果40+文件导入它，考虑向后兼容更改

此工作流防止：

浪费令牌在过大文件上（先检查令牌）
编辑错误文件（可能有不同目录中类似名称文件）
重构期间错过调用点（rg -c显示精确计数）
在不知影响范围的情况下破坏高导入模块
不必要地触发上下文压缩（事先知道大小）

使用fzf的交互式筛选（操作员UX）

当结果集大时，使用fzf交互式筛选rg/rga输出。

# rg + fzf + 文件预览
rg --line-number --no-heading --color=always "auth|token|session" . \
  | fzf --ansi --delimiter ":" \
    --preview "bat --color=always --style=numbers --highlight-line {2} {1}"

# rga（文档/存档）+ fzf
rga --line-number --no-heading --color=always "invoice|receipt|policy" . \
  | fzf --ansi --delimiter ":" \
    --preview "bat --color=always --style=numbers --line-range=:300 {1}"

高级交互式ripgrep启动器模式：

: | rg_prefix='rg --column --line-number --no-heading --color=always --smart-case' \
  fzf --ansi --disabled \
      --bind 'start:reload:$rg_prefix ""' \
      --bind 'change:reload:$rg_prefix {q} || true'

使用契约：

使用fzf进行操作员选择/筛选，而非替代搜索后端。
保持pnpm search:code作为代理发现/排名工作流的默认。
使用rg/rga + fzf进行交互式分类和手动结果挑选。

结构 + 交互式工作流（人工分类）：

# 结构候选（ast-grep）
ast-grep -p 'function $NAME($$$) { $$$ }' --lang javascript --files-with-matches .

# 交互式筛选候选
ast-grep -p 'function $NAME($$$) { $$$ }' --lang javascript --files-with-matches . \
  | fzf --ansi --delimiter ":" \
    --preview "bat --color=always --style=numbers --line-range=:220 {}"

工作原理

pnpm code:index:reindex构建BM25文本索引 + LanceDB向量嵌入
嵌入生成在隔离子进程中运行（GPU加速时可用）
子进程每50批次重启以回收ONNX原生内存泄漏
search:code首先检查查询缓存（约5ms命中）；未命中时，查询BM25 + 向量索引
RRF合并文本和语义排名为单个有序结果集
结果缓存用于未来相似查询（余弦 > 0.95 = 缓存命中）
编辑后钩子增量更新BM25文本索引（约10ms每文件）
search:compress结合搜索 + 自适应压缩 + 内存去重于单个管道

配置

# 语义搜索（默认：运行code:index:reindex后启用）
HYBRID_EMBEDDINGS=on

# 嵌入引擎（推荐fastembed用于速度 + GPU支持）
LANCEDB_EMBEDDING_MODE=fastembed

# 子进程隔离用于ONNX内存安全（默认：启用）
EMBED_SUBPROCESS=on

# 查询缓存（自动缓存重复/相似查询）
SEARCH_CACHE_ENABLED=on            # 关闭开关：设置为off禁用
SEARCH_CACHE_TTL_MS=300000          # 缓存TTL：5分钟
SEARCH_CACHE_SIMILARITY=0.95        # 语义缓存命中的余弦阈值

# 文件编辑后BM25增量更新
BM25_INCREMENTAL_UPDATE=on          # 关闭开关：设置为off禁用

# 禁用语义搜索（仅文本，最快，无需索引）
# HYBRID_EMBEDDINGS=off

# 重复查询的守护进程传输（缓存驻留于此）
HYBRID_SEARCH_DAEMON=on
HYBRID_DAEMON_PREWARM=true
HYBRID_DAEMON_IDLE_MS=600000

# 查询缓存（通过嵌入相似度缓存重复/相似查询）
SEARCH_CACHE_ENABLED=on          # 设置为off禁用
SEARCH_CACHE_TTL_MS=300000       # 缓存条目TTL（5分钟）
SEARCH_CACHE_SIMILARITY=0.95     # 缓存命中的余弦阈值

# 文件编辑后BM25增量更新
BM25_INCREMENTAL_UPDATE=on       # 设置为off禁用

守护进程 + 预热运行手册

# 启动、验证、预热
pnpm search:daemon:start
pnpm search:daemon:status
pnpm search:daemon:prewarm

# 搜索（守护进程路径）
pnpm search:code "身份验证逻辑"

# 停止守护进程
pnpm search:daemon:stop

此仓库上的预期延迟配置文件：

冷守护进程首次查询（无预热）：约1.35s平均
预热后首次查询：约0.40s平均
温暖重复守护进程查询：约0.18-0.19s
直接模式（HYBRID_SEARCH_DAEMON=off）：约0.73s平均用于重复CLI调用

索引构建性能

指标	使用GPU（RTX 4070）	仅CPU
索引时间（2843文件）	约12分钟	约17分钟
主进程内存	约200MB	约200MB
子进程内存（隔离）	约500MB	约300MB
堆分配所需	4GB	4GB
磁盘索引大小	约6MB（BM25）+ 约10MB（向量）	相同

此仓库的测量性能和输出

使用相同的5个查询在此仓库上：

模式	平均延迟	平均输出字节	最佳使用案例
`pnpm search:code`（`HYBRID_EMBEDDINGS=off`）	约227ms	约461字节	快速发现，紧凑输出
`pnpm search:code`（`HYBRID_EMBEDDINGS=on`）	约734ms	约512字节	语义/概念查询
原始`rg`字面搜索	约35ms	约2478字节	精确符号/字面查找

解释：

原始rg对精确字面/符号查找最快
混合搜索返回显著较小的输出负载（通常令牌压力较低）
嵌入改进语义召回，但增加延迟

决策规则（实用）

使用pnpm search:code当：

查询是概念/自然语言（"刷新令牌的身份验证流程"）
您需要排名结果和简洁上下文用于代理提示
您希望默认输出量较低

使用原始rg当：

查询是精确符号/字面（TaskUpdate(, HybridLazyIndexer, 精确导出名称）
您需要最快可能的查找时间
您需要高级正则表达式/PCRE2行为

按文件大小测量（此仓库）

样本大小：4个小文件（0.5-5KB），4个大文件（30-109KB），字面令牌查询。

桶	`search:code`关闭	`search:code`开启	`rg_repo`	`rg_file`
小文件	约230ms / 约2707B	约600ms / 约2965B	约34ms / 约17075B	约15ms / 约1156B
大文件	约228ms / 约2354B	约475ms / 约2847B	约35ms / 约17811B	约15ms / 约6564B

要点：

rg_file最快且最适合目标文件级检查。
rg_repo对仓库范围字面扫描保持最快，但发射更大的输出负载。
search:code跨文件大小有更稳定的延迟，通常对提示使用输出量较低。

真实世界场景剧本（测试模式）

使用这些场景模式快速选择正确的搜索路径。

场景1：事件分类（未知根本原因）

目标：快速找到生产症状的可能热点，不淹没上下文。

# 1) 从广泛和语义开始
pnpm search:code "任务完成后状态未更新"

# 2) 一旦候选出现，转向精确符号检查
pnpm search:code "TaskUpdate("

模式：

以search:code开始进行意图级召回。
一旦识别候选文件，使用字面/符号查询缩小。

场景2：快速精确查找（您知道标识符）

目标：尽可能快地定位精确定义/使用。

# 仓库范围精确字面（此仓库中稳定示例）
rg -F "TaskUpdate(" -g "*.cjs" -g "*.js" -g "*.ts" .

# 单文件精确查找（最快路径）
rg -F "spawnSync" .claude/skills/skill-creator/scripts/create.cjs

模式：

对精确符号搜索使用原始rg -F，特别是大文件或已知路径。

场景3：安全重构准备

目标：枚举调用点并评估影响范围，然后重命名或行为更改。

# 1) 检查影响范围 — 有多少文件导入此模块？
pnpm search:structure
# 查看📁本地依赖："📁 router-state (22)" = 22文件受更改影响

# 2) 使用语义搜索收集广泛调用点
pnpm search:code "TaskUpdate完成状态工作流"

# 3) 获取精确调用点清单（每个匹配，非排名）
rg -F "TaskUpdate(" -g "*.cjs" -g "*.js" -g "*.ts" -c
# 显示每文件计数 — 计划跨所有文件的编辑

# 4) 编辑前验证特定行
rg -F "TaskUpdate(" -g "*.cjs" -n -C 2

模式：

首先search:structure检查依赖计数（影响范围）。
混合搜索找到可能错过的语义变体。
原始rg -c获取每文件精确调用点计数。
原始rg -n -C 2获取行号 + 编辑前上下文。

场景4：安全审计扫描

目标：检测风险模式并确认精确高置信度匹配。

对于详尽扫描（审计），使用rg或Grep（内置）作为主要工具。 混合搜索返回排名前N结果，这对发现很好，但可能错过匹配。安全审计需要模式的所有实例，而非排名样本。

# 首先进行详尽扫描（每个匹配，非排名）
rg -F "shell: true" -g "*.cjs" -g "*.js" -g "*.mjs"
rg -F "JSON.parse(" -g "*.cjs" -g "*.js" --no-heading
rg "eval\(|new Function\(" -g "*.cjs" -g "*.js"
rg -F "child_process" -g "*.cjs" -g "*.js"

# 然后使用混合进行概念发现（找到您未想到要grep的模式）
pnpm search:code "命令注入shell执行安全"
pnpm search:code "原型污染不安全解析"

# 使用文件级rg验证特定发现
rg -F "exec(" .claude/lib/tools/standard-tools.cjs

模式：

rg/Grep用于完整性重要的详尽扫描（安全、合规）。
混合搜索进行概念发现，找到您未知要grep的模式。
从不依赖混合前N结果进行安全声明。

场景5：架构入职（新贡献者/代理）

目标：理解结构并知道在哪里进行更改。

# 1) 获取完整项目地图（目录树 + 导出 + 依赖 + Mermaid）
pnpm search:structure

# 从输出中，您将看到：
#   - 目录树：哪些文件夹存在及其嵌套
#   - 入口点：哪些文件导出API（带文件:行）
#   - 顶级依赖：最常导入的本地模块（📁）= 架构热点
#     例如，"📁 memory-manager.cjs (56)"表示56文件导入它 — 高影响范围
#   - Mermaid图：视觉模块图

# 2) 按概念钻取子系统
pnpm search:code "路由守卫任务生命周期"
pnpm search:code "内存调度器会话上下文"

# 3) 一旦找到候选文件，读取它们
pnpm search:file .claude/lib/routing/router-state.cjs 1 50

# 4) 编辑前，使用rg确认精确位置
rg -F "resetToRouterMode" -g "*.cjs" -n

模式：

首先search:structure — 接触任何事物前了解情况。
查看📁本地依赖计数最高的模块 — 那些是更改影响最广的模块。
使用search:code找到与概念相关的文件。
使用search:file读取带行号的特定文件。
使用rg -F确认编辑前的精确符号位置。

场景6：代码库审计 / 深度钻取

目标：对代码库进行系统审计，查找错误、安全问题和死代码。

# 1) 映射项目 — 首先识别架构热点
pnpm search:structure
# 从输出中注意关键事项：
#   - 📁本地依赖计数高的模块 = 审计优先级（最连接 = 最高风险）
#   - 入口点列表 = 要审查的公共API表面
#   - 目录树 = 需要审计的范围

# 2) 使用rg进行详尽模式扫描（需要所有匹配，非前N）
rg -F "JSON.parse(" -g "*.cjs" -g "*.js" --no-heading
rg -F "shell: true" -g "*.cjs" -g "*.js"
rg "eval\(|new Function\(" -g "*.cjs" -g "*.js"
rg "TODO|FIXME|HACK|STUB" -g "*.cjs" -g "*.js" -g "*.mjs"
rg -F "catch" -A1 -g "*.cjs" | rg "^\s*\}"  # 空catch块

# 3) 概念发现，用于您未想到要grep的模式
pnpm search:code "原型污染不安全解析"
pnpm search:code "竞态条件并发文件写入"
pnpm search:code "硬编码秘密凭据密码"

# 4) 交叉引用：找到调用特定模块的内容
pnpm search:code "routing-table-intent"
rg -F "standard-tools" -g "*.cjs" -c  # 每文件精确导入计数

# 5) 检查死代码：找到从未导入的导出
# 比较search:structure的入口点与rg导入计数
rg -F "orchestrator-tool.cjs" -g "*.cjs" -c  # 0结果 = 死模块

模式：

首先search:structure识别热点（高导入模块 = 审计优先级）。
rg/Grep用于详尽扫描（安全、死代码、模式匹配）。
search:code用于概念发现（找到您未知要grep的事物）。
交叉引用search:structure入口点与rg导入计数以找到死代码。
从不依赖混合搜索进行审计完整性；它返回排名前N，非所有匹配。

场景7：令牌约束代理工作流

目标：最小化提示/上下文膨胀，同时保持检索质量。

# 默认：语义搜索开启（紧凑排名输出，适合代理）
pnpm search:code "工作流任务完成守卫"

# 当您知道精确术语时，最快可能响应
HYBRID_EMBEDDINGS=off pnpm search:code "TaskUpdate完成"

# 对于意图重查询，其中精确术语未知
pnpm search:code "为什么代理完成后任务卡住"

模式：

默认HYBRID_EMBEDDINGS=on（紧凑排名输出已令牌高效）。
仅当精确关键字匹配足够且速度关键时使用HYBRID_EMBEDDINGS=off覆盖。
混合搜索输出通常比原始rg输出小（排名前N vs 所有匹配）。

可重用查询模式

概念查询："身份验证流程刷新令牌验证"
混合查询："TaskUpdate完成状态"
精确查询："TaskUpdate("（速度关键时优先rg -F）
结构查询：大型编辑前使用pnpm search:structure
文件钻取：pnpm search:file <路径> <起始行> <结束行>

仅使用原始ripgrep（以下）用于：

高级PCRE2正则表达式模式（向前/向后查看）
search:code不支持的自定义文件类型筛选
与其他CLI工具的管道集成

<指令> <执行过程>

概述

此技能通过@vscode/ripgrep npm包提供对ripgrep（rg）的访问，该包自动为您的平台下载正确的二进制文件（Windows, Linux, macOS）。增强对现代JavaScript/TypeScript项目的文件类型支持。

二进制源：@vscode/ripgrep npm包（跨平台，自动安装）

自动处理Windows, Linux, macOS二进制文件
无需手动二进制管理

可选配置：bin/.ripgreprc（如果存在，自动使用）

何时使用什么

工具	最适合	权衡
`pnpm search:code`	概念发现，排名结果，代理工作流	前N排名，非详尽；语义需要索引
内置`Grep`工具	详尽模式扫描，审计，精确计数	返回所有匹配；更高令牌输出
原始`rg`通过Bash	PCRE2正则表达式，管道集成，`.ripgreprc`类型	需要Bash工具；更大的原始输出
内置`Glob`工具	通过名称模式查找文件	无内容搜索

对于审计和安全扫描：优先Grep（内置） — 它返回每个匹配，非排名前N。您需要完整性，非排名。

对于发现和入职：优先pnpm search:code — 紧凑排名输出，语义理解，低令牌压力。

对于编辑前的精确符号查找：优先原始rg -F — 最快可能，确定性。

快速开始命令

基本搜索

# 在所有文件中搜索模式
node .claude/skills/ripgrep/scripts/search.mjs "模式"

# 搜索特定文件类型
node .claude/skills/ripgrep/scripts/search.mjs "模式" -tjs
node .claude/skills/ripgrep/scripts/search.mjs "模式" -tts

# 大小写不敏感搜索
node .claude/skills/ripgrep/scripts/search.mjs "模式" -i

# 带上下文行搜索
node .claude/skills/ripgrep/scripts/search.mjs "模式" -C 3

快速搜索预设

# 搜索JavaScript文件（包括.mjs, .cjs）
node .claude/skills/ripgrep/scripts/quick-search.mjs js "模式"

# 搜索TypeScript文件（包括.mts, .cts）
node .claude/skills/ripgrep/scripts/quick-search.mjs ts "模式"

# 搜索所有.mjs文件特定
node .claude/skills/ripgrep/scripts/quick-search.mjs mjs "模式"

# 搜索.claude目录用于钩子
node .claude/skills/ripgrep/scripts/quick-search.mjs hooks "模式"

# 搜索.claude目录用于技能
node .claude/skills/ripgrep/scripts/quick-search.mjs skills "模式"

# 搜索.claude目录用于工具
node .claude/skills/ripgrep/scripts/quick-search.mjs tools "模式"

# 搜索.claude目录用于代理
node .claude/skills/ripgrep/scripts/quick-search.mjs agents "模式"

# 搜索所有文件（无筛选）
node .claude/skills/ripgrep/scripts/quick-search.mjs all "模式"

常见模式

文件类型搜索

# JavaScript文件（包括.js, .mjs, .cjs）
rg "function" -tjs

# TypeScript文件（包括.ts, .mts, .cts）
rg "interface" -tts

# 配置文件（.yaml, .yml, .toml, .ini）
rg "port" -tconfig

# Markdown文件（包括.md, .mdc）
rg "# 标题" -tmd

高级正则表达式

# 单词边界搜索
rg "\bfoo\b"

# 大小写不敏感
rg "pattern" -i

# 智能大小写（除非存在大写，否则大小写不敏感）
rg "pattern" -S  # 已在.ripgreprc中默认

# 多行搜索
rg "pattern.*
.*another" -U

# PCRE2向前/向后查看
rg -P "foo(?=bar)"        # 正向前查看
rg -P "foo(?!bar)"        # 负向前查看
rg -P "(?<=foo)bar"       # 正向后查看
rg -P "(?<!foo)bar"       # 负向后查看

筛选

# 排除目录
rg "pattern" -g "!node_modules/**"
rg "pattern" -g "!.git/**"

# 仅包括特定目录
rg "pattern" -g ".claude/**"

# 排除特定文件类型
rg "pattern" -Tjs  # 排除JavaScript

# 搜索隐藏文件
rg "pattern" --hidden

# 搜索二进制文件
rg "pattern" -a

上下文和输出

# 显示匹配前后3行
rg "pattern" -C 3

# 显示前2行
rg "pattern" -B 2

# 显示后2行
rg "pattern" -A 2

# 仅显示带匹配的文件名
rg "pattern" -l

# 显示每文件匹配计数
rg "pattern" -c

# 显示行号（.ripgreprc中默认）
rg "pattern" -n

PCRE2高级模式

使用-P启用PCRE2模式进行高级特性：

向前和向后查看

# 仅当后跟“critical”时找到“error”
rg -P "error(?=.*critical)"

# 找到“test”后不跟“.skip”
rg -P "test(?!\.skip)"

# 找到“Dr. ”后以大写开头的单词
rg -P "(?<=Dr\. )[A-Z]\w+"

# 找到“await ”前未预见的函数调用
rg -P "(?<!await )\b\w+\("

后向引用

# 找到重复单词
rg -P "\b(\w+)\s+\1\b"

# 找到匹配的HTML标签
rg -P "<(\w+)>.*?</\1>"

条件

# 匹配IPv4或IPv6
rg -P "(\d{1,3}\.){3}\d{1,3}|([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}"

与其他工具集成

与fzf（交互式搜索）

# 搜索并交互式选择文件
rg --files | fzf

# 搜索模式并在编辑器中打开
rg "pattern" -l | fzf | xargs code

与vim

# 在.vimrc中设置ripgrep为grep程序
set grepprg=rg\ --vimgrep\ --smart-case\ --follow

与其他命令的管道

# 搜索并计数唯一匹配
rg "pattern" -o | sort | uniq -c

# 搜索和替换预览
rg "old" -l | xargs sed -i 's/old/new/g'

性能优化

大型代码库提示

使用文件类型筛选器：-tjs比搜索所有文件更快
排除大目录：-g "!node_modules/**"
可能时使用字面字符串：-F "literal"（禁用正则表达式）
启用并行搜索：Ripgrep默认使用所有核心
使用.gitignore：Ripgrep自动尊重.gitignore

基准

Ripgrep通常：

比grep快10-100倍
比ag（The Silver Searcher）快5-10倍
比git grep快3-5倍

自定义配置

可选的.ripgreprc文件在bin/.ripgreprc（如果存在）包含：

# 扩展文件类型
--type-add=js:*.mjs
--type-add=js:*.cjs
--type-add=ts:*.mts
--type-add=ts:*.cts
--type-add=md:*.mdc
--type-add=config:*.yaml
--type-add=config:*.yml
--type-add=config:*.toml
--type-add=config:*.ini

# 默认选项
--smart-case
--follow
--line-number

框架特定模式

搜索.claude目录

# 找到所有钩子
rg "PreToolUse\|PostToolUse" .claude/hooks/

# 找到所有技能
rg "^# " .claude/skills/ -tmd

# 找到代理定义
rg "^name:" .claude/agents/ -tmd

# 找到工作流步骤
rg "^### Step" .claude/workflows/ -tmd

常见代理工作室搜索

# 找到所有TaskUpdate调用
rg "TaskUpdate\(" -tjs -tts

# 找到所有技能调用
rg "Skill\(\{" -tjs -tts

# 找到所有内存协议部分
rg "## Memory Protocol" -tmd

# 找到所有BLOCKING强制注释
rg "BLOCKING|CRITICAL" -C 2

</执行过程>

<最佳实践>

使用文件类型筛选器（-tjs, -tts）进行更快搜索
尊重.gitignore模式（默认自动）
使用智能大小写进行大小写不敏感搜索（配置中默认）
仅当需要高级特性时启用PCRE2（-P）
使用-g "!node_modules/**"排除大目录
当模式无正则表达式时使用字面搜索（-F）
二进制通过@vscode/ripgrep npm包自动管理
使用快速搜索预设进行常见.claude目录搜索 </最佳实践> </指令>

<示例> <使用示例> 搜索项目中的所有TaskUpdate调用：

node .claude/skills/ripgrep/scripts/search.mjs "TaskUpdate" -tjs -tts

找到所有安全相关钩子：

node .claude/skills/ripgrep/scripts/quick-search.mjs hooks "security|SECURITY" -i

使用PCRE2搜索函数定义：

node .claude/skills/ripgrep/scripts/search.mjs -P "^function\s+\w+\(" -tjs

</使用示例> </示例>

二进制管理

搜索脚本使用@vscode/ripgrep npm包，该包自动：

检测您的平台（Windows, Linux, macOS）
在pnpm install期间下载正确的二进制文件
处理所有架构变体（x64, ARM64等）

无需手动二进制管理 — npm包自动处理一切。

内存协议（强制）

开始前： 读取.claude/context/memory/learnings.md

完成后：

新模式 -> .claude/context/memory/learnings.md
发现问题 -> .claude/context/memory/issues.md
做出决策 -> .claude/context/memory/decisions.md

假设中断：如果不在内存中，则未发生。

名称: ripgrep 描述: 增强的代码搜索，支持ES模块扩展和高级模式的自定义ripgrep二进制文件。 版本: 1.1.0 模型: sonnet 调用者: 用户 用户可调用: true 工具: [读取, 写入, 编辑] 已验证: false 最后验证时间: 2026-02-19T05:29:09.098Z