dsh-vscode-mode 0.1.28 → 0.1.30

package/src/rpc.ts

@@ -23,6 +23,8 @@ import type { Registry } from './registry.js'
 import { bucketOf, cwdOf, sessionOf } from './registry.js'
 import type { SearchOrchestrator } from './search/orchestrator.js'
 import { newSearcher } from './search/orchestrator.js'
+import type { ContentSearcher } from './search/content.js'
+import { newContentSearcher } from './search/content.js'
 import { restoreFile, revertCall, revertHunk } from './revert.js'
 import { listMcp, refreshMcp, removeMcp, saveMcp, toggleMcp } from './mcp.js'
 import { listProjects, projectRefresh, projectRemove, projectSave, projectToggle } from './mcpProject.js'
@@ -32,10 +34,75 @@ import { readDevForm, setDevForm } from './devForm.js'
 import { normalizeRel, toTreeEntries } from './tree.js'
 import { revealInExplorer } from './reveal.js'
 
-/** cwd → Promise 链：串行化 debug 日志追加（fs read+write 非原子，避免并发丢行）。 */
+/** cwd → 内存缓冲：行数组 + 累计字节数 + 待触发 flush 定时器（攒批落盘，避免每条日志全文件读改写）。 */
+const debugBuffers = new Map<string, { lines: string[]; len: number; timer: ReturnType<typeof setTimeout> | null }>()
+/** cwd → Promise 链：串行化 debug 日志落盘（fs read+write 非原子，避免并发丢行）。 */
 const debugWriteQueues = new Map<string, Promise<void>>()
 /** debug 日志单文件上限：超限截断保留尾部，防文件无限增长拖慢每次追加。 */
 const DEBUG_LOG_CAP = 512 * 1024
+/** debug 日志批量缓冲上限：攒满即落盘（一次读改写），上限内不逐条写文件。 */
+const DEBUG_BUF_CAP = 32 * 1024
+/** debug 日志空闲 flush 延迟：缓冲未满时，静默一段时间后落盘一次。 */
+const DEBUG_FLUSH_IDLE_MS = 1000
+/** cwd → 上次 stale 自动清理时间：全量轮询（EditorView/DiffBadge/Dock 各自 5s）节流，避免每轮都读文件算指纹。 */
+const staleCheckedAt = new Map<string, number>()
+/** stale 自动清理最小间隔。 */
+const STALE_CHECK_MIN_MS = 10_000
+
+/**
+ * 调试日志入队：先攒内存缓冲（行 + 字节数），满 DEBUG_BUF_CAP 立即落盘，
+ * 否则空闲 DEBUG_FLUSH_IDLE_MS 后落盘；落盘 = 读旧文件 + 追加整批 + 超限截断 + 一次写入。
+ * @author ddj 2026年08月26号
+ * @param ctx DSH 上下文
+ * @param cwd 工作区（日志文件按工作区旁车存放）
+ * @param policy 会话沙箱策略（入队时刻捕获）
+ * @param line 单条日志文本（不含换行）
+ */
+function enqueueDebug(ctx: Ctx, cwd: string, policy: unknown, line: string): void {
+  const st = debugBuffers.get(cwd) ?? { lines: [], len: 0, timer: null }
+  st.lines.push(line)
+  st.len += line.length
+  const flush = () => {
+    st.timer = null
+    const batch = st.lines
+    st.lines = []
+    st.len = 0
+    void flushDebug(ctx, cwd, policy, batch)
+  }
+  if (st.len >= DEBUG_BUF_CAP) {
+    if (st.timer) clearTimeout(st.timer)
+    flush()
+  } else if (!st.timer) {
+    st.timer = setTimeout(flush, DEBUG_FLUSH_IDLE_MS)
+  }
+  debugBuffers.set(cwd, st)
+}
+
+/**
+ * 批量落盘一条 debug 日志缓冲：读旧文件 → 追加 → 超上限截断保留尾部 → 一次写回。
+ * 串行链保证同一 cwd 的读改写不交错丢行；写失败静默忽略（调试日志不阻塞业务）。
+ * @author ddj 2026年08月26号
+ * @param ctx DSH 上下文
+ * @param cwd 工作区
+ * @param policy 会话沙箱策略（enqueue 时刻捕获）
+ * @param batch 本批日志行
+ */
+function flushDebug(ctx: Ctx, cwd: string, policy: unknown, batch: string[]): Promise<void> {
+  const prev = debugWriteQueues.get(cwd) ?? Promise.resolve()
+  const task = prev.then(async () => {
+    try {
+      const fs = ctx.get('fs')
+      if (!fs) return
+      const target = await fs.resolve('.dsh-edit-review-debug.log', { cwd })
+      const old = await fs.readText(target).catch(() => '')
+      const appended = old + batch.map((l) => new Date().toISOString() + ' ' + l + '\n').join('')
+      const next = appended.length > DEBUG_LOG_CAP ? appended.slice(-Math.floor(DEBUG_LOG_CAP / 2)) : appended
+      await fs.writeText(target, next, void 0, void 0, policy)
+    } catch (e) { /* 写日志失败忽略 */ }
+  })
+  debugWriteQueues.set(cwd, task)
+  return task
+}
 
 /** 记录 → 客户端视图（不含 before 全文，仅长度）。 */
 function recView(record: DiffRecord): RecordView {
@@ -117,14 +184,23 @@ async function applyDecisions(
 }
 
 /** 各方法 handler 表（类型由 shared/rpc 的 RpcHandlerMap 约束）。 */
-export function buildHandlers(ctx: Ctx, registry: Registry, searcher = newSearcher(ctx)): RpcHandlerMap {
+export function buildHandlers(ctx: Ctx, registry: Registry, searcher = newSearcher(ctx), contentSearcher = newContentSearcher(ctx)): RpcHandlerMap {
   return {
     'edrv.list': async (args) => {
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const bucket = await bucketOf(registry, ctx, sc.cwd)
       const want = Array.isArray(args.callIds) ? new Set(args.callIds) : null
-      if (!want && args.skipStale !== true) await autoArchiveStale(ctx, sc.session, sc.cwd, bucket) // 全量轮询时自动清理 stale 幽灵差异（批量决策后的即时刷新可 skipStale 跳过）
+      // 全量轮询时自动清理 stale 幽灵差异（批量决策后的即时刷新可 skipStale 跳过）；
+      // 三个组件各自 5s 全量 list，stale 检查节流到 STALE_CHECK_MIN_MS 一次，
+      // 避免每轮都对全部记录读文件 + 算指纹（keepall 期间多组件同时刷新的主要 host 开销）。
+      if (!want && args.skipStale !== true) {
+        const now = Date.now()
+        if (now - (staleCheckedAt.get(sc.cwd) ?? 0) > STALE_CHECK_MIN_MS) {
+          staleCheckedAt.set(sc.cwd, now)
+          await autoArchiveStale(ctx, sc.session, sc.cwd, bucket)
+        }
+      }
       const out: RecordView[] = []
       for (const rec of bucket.values()) {
         // 面板全量查询过滤已归档；聊天条按 callId 查询保留（状态徽章仍需正确显示）
@@ -291,26 +367,12 @@ export function buildHandlers(ctx: Ctx, registry: Registry, searcher = newSearch
       return { ok: true, path: args.path, batch: batch ?? null }
     },
     'edrv.debug': async (args) => {
-      // 诊断日志：client 上报 → 写入工作区旁车 .dsh-edit-review-debug.log（console 不一定落盘，文件可靠）
+      // 诊断日志：client 上报 → 内存缓冲批量落盘 .dsh-edit-review-debug.log（console 不一定落盘，文件可靠）。
+      // 只出现在调试开关开启时（client dbg 默认关），终端仍逐条打印便于实时观察。
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
-      const fs = ctx.get('fs')
       const text = String(args.text ?? '')
-      const prev = debugWriteQueues.get(sc.cwd) || Promise.resolve()
-      const task = prev.then(async () => {
-        try {
-          const target = await fs.resolve('.dsh-edit-review-debug.log', { cwd: sc.cwd })
-          const old = await fs.readText(target).catch(() => '')
-          const line = new Date().toISOString() + ' ' + text + '\n'
-          // 超上限时截断保留尾部：单文件体积有界，每次追加的读改写成本不随会话时长增长
-          const next = old.length + line.length > DEBUG_LOG_CAP
-            ? old.slice(-Math.floor(DEBUG_LOG_CAP / 2)) + line
-            : old + line
-          await fs.writeText(target, next, void 0, void 0, policyOf(ctx, sc.session))
-        } catch (e) { /* 写日志失败忽略 */ }
-      })
-      debugWriteQueues.set(sc.cwd, task)
-      await task
+      enqueueDebug(ctx, sc.cwd, policyOf(ctx, sc.session), text)
       console.error('[edrv-debug] ' + text)
       return { ok: true }
     },
@@ -323,6 +385,27 @@ export function buildHandlers(ctx: Ctx, registry: Registry, searcher = newSearch
       const result = await searcher.search({ session: sc.session, cwd: sc.cwd, query: args.query, activePaths })
       return { ok: true, ...result }
     },
+    'edrv.searchContent': async (args) => {
+      // 工作区内容搜索：rg --json 主路径；provider 失败转错误响应（无 fallback）。
+      const sc = await requireSession(ctx, args.sessionId)
+      if ('err' in sc) return { ok: false, error: sc.err }
+      try {
+        const result = await contentSearcher.search({
+          session: sc.session,
+          cwd: sc.cwd,
+          query: args.query,
+          matchCase: args.matchCase,
+          wholeWord: args.wholeWord,
+          regex: args.regex,
+          maxResults: args.maxResults,
+          include: args.include,
+          exclude: args.exclude,
+        })
+        return { ok: true, ...result }
+      } catch (error) {
+        return { ok: false, error: '搜索失败：' + String(error) }
+      }
+    },
     'edrv.listDir': async (args) => {
       // 目录树（侧边栏文件管理用）：按会话 cwd 解析，与 edrv.read 同基准，树内相对路径点开即打开。
       const sc = await requireSession(ctx, args.sessionId)
@@ -433,7 +516,7 @@ export function buildHandlers(ctx: Ctx, registry: Registry, searcher = newSearch
 
 /**
  * 统一入口：按方法分发到 handler 表。
- * @author ddj 2026年08月20号
+ * @author ddj 2026年08月20号 / 2026年08月26号
  */
 export async function handleRpc<M extends RpcMethod>(
   ctx: Ctx,
@@ -441,8 +524,9 @@ export async function handleRpc<M extends RpcMethod>(
   method: M,
   args: RpcRequestMap[M],
   searcher = newSearcher(ctx),
+  contentSearcher = newContentSearcher(ctx),
 ): Promise<RpcResult<M>> {
-  const handlers = buildHandlers(ctx, registry, searcher)
+  const handlers = buildHandlers(ctx, registry, searcher, contentSearcher)
   const handler = handlers[method]
   if (!handler) return { ok: false, error: '未知方法: ' + String(method) } as RpcResult<M>
   return handler(args)

package/src/search/content.ts

@@ -0,0 +1,319 @@
+/**
+ * dsh-vscode-mode host — 工作区内容搜索（rg --json 主路径 + 有界编排）。
+ * 命中列由 rg 行内字节偏移转 UTF-16（1-based），可直接供 Monaco 跳转/高亮。
+ * 无 fallback：provider 失败抛错，由 RPC 层转错误响应（避免整树读文件）。
+ * 作者 ddj 2026年08月26号
+ */
+import type { Ctx, Session } from '../store.js'
+import { pathText } from './query.js'
+import { EXCLUDES, FILE_EXCLUDES, ripgrepPath, searchRoot } from './ripgrep.js'
+import { SearchCache } from './orchestrator.js'
+import type { ContentMatch, ContentSearchInput, ContentSearchProvider, ContentSearchResult } from './types.js'
+
+const STDOUT_CAP = 16 << 20
+const STDERR_CAP = 64 << 10
+const GRACE_MS = 20_000
+const DEFAULT_MAX_MATCHES = 500
+const DEFAULT_MAX_FILES = 100
+const CACHE_TTL = 60_000
+const CACHE_LIMIT = 100
+const PROVIDER_VERSION = 'content-ripgrep-v1'
+/** 单行 JSON 记录上限：巨型单行文件（源映射/打包产物）的命中行对搜索 UI 无意义，直接跳过。 */
+const MAX_RECORD_LINE = 1 << 20
+
+/** rg --json 单条 match 记录的宽松形状（未知字段忽略）。 */
+interface RgJsonItem {
+  type?: string
+  data?: {
+    path?: { text?: string }
+    lines?: { text?: string }
+    line_number?: number
+    submatches?: Array<{ start?: number; end?: number }>
+  }
+}
+
+/** 内容搜索请求（RPC 参数映射）。 */
+export interface ContentSearchRequest {
+  session: Session
+  cwd: string
+  query: string
+  matchCase?: boolean
+  wholeWord?: boolean
+  regex?: boolean
+  maxResults?: number
+  /** 正选 glob（仅在这些文件内搜索）。 */
+  include?: string[]
+  /** 排除 glob（这些文件不参与搜索）。 */
+  exclude?: string[]
+}
+
+type ContentSearchResponse = { matches: ContentMatch[]; truncated: boolean }
+
+/**
+ * 把行内字节偏移转成 UTF-16 列（1-based；越界钳到行尾）。
+ * @author ddj 2026年08月26号
+ * @param text 行文本
+ * @param byteOffset 行内字节偏移（rg submatches.start/end，实测为行相对）
+ * @returns 1-based UTF-16 列
+ */
+export function byteToUtf16Col(text: string, byteOffset: number): number {
+  let bytes = 0
+  let col = 1
+  for (const char of text) {
+    if (bytes >= byteOffset) break
+    bytes += Buffer.byteLength(char)
+    col++
+  }
+  return col
+}
+
+/**
+ * 根内绝对路径 → 工作区相对显示路径（供 edrv.read 与面板展示）。
+ * @author ddj 2026年08月26号
+ * @param value rg 输出路径
+ * @param root 搜索根（subprocess 执行世界）
+ * @returns 相对路径（根外路径原样返回）
+ */
+export function displayPathOf(value: string | undefined, root: string): string {
+  const path = pathText(String(value ?? ''))
+  if (!path) return path
+  const base = pathText(root).replace(/\/$/, '')
+  const lowerPath = path.toLocaleLowerCase('en-US')
+  const lowerBase = base.toLocaleLowerCase('en-US')
+  if (lowerPath === lowerBase) return '.'
+  if (lowerPath.startsWith(lowerBase + '/')) return path.slice(base.length + 1)
+  return path
+}
+
+/**
+ * 解析 rg --json 输出为扁平命中列表（多子匹配展开，列转 UTF-16）。
+ * @author ddj 2026年08月26号
+ * @param text stdout 文本
+ * @param root 搜索根
+ * @returns 命中列表
+ */
+export function parseRgJsonLines(text: string, root: string): ContentMatch[] {
+  const matches: ContentMatch[] = []
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    let item: RgJsonItem
+    try {
+      item = JSON.parse(trimmed) as RgJsonItem
+    } catch {
+      continue
+    }
+    if (item?.type !== 'match' || !item.data) continue
+    const data = item.data
+    const path = displayPathOf(data.path?.text, root)
+    const lineText = (data.lines?.text ?? '').replace(/\r?\n$/, '').replace(/\r$/, '')
+    if (lineText.length > MAX_RECORD_LINE) continue
+    const lineNumber = data.line_number ?? 0
+    for (const sub of data.submatches ?? []) {
+      matches.push({
+        path,
+        line: lineNumber,
+        startColumn: byteToUtf16Col(lineText, sub.start ?? 0),
+        endColumn: byteToUtf16Col(lineText, sub.end ?? 0),
+        text: lineText,
+      })
+    }
+  }
+  return matches
+}
+
+/**
+ * 命中截断：匹配数/文件数双上限，超限标记 truncated。
+ * @author ddj 2026年08月26号
+ * @param matches 全部命中
+ * @param maxMatches 匹配数上限
+ * @param maxFiles 文件数上限
+ * @returns 截断后的命中与标志
+ */
+export function applyCaps(matches: ContentMatch[], maxMatches: number, maxFiles: number): { matches: ContentMatch[]; truncated: boolean } {
+  const seen = new Set<string>()
+  const out: ContentMatch[] = []
+  let truncated = false
+  for (const match of matches) {
+    if (out.length >= maxMatches) { truncated = true; break }
+    if (!seen.has(match.path)) {
+      if (seen.size >= maxFiles) { truncated = true; break }
+      seen.add(match.path)
+    }
+    out.push(match)
+  }
+  return { matches: out, truncated }
+}
+
+/**
+ * 构造 rg 内容搜索 argv（pattern 放 `--` 后首位置，支持前导 `-` 的查询）。
+ * include/exclude 为用户 glob（gitignore 式，原样透传不转义），
+ * 分别转正选 `--glob` 与排除 `--glob !`。
+ * @author ddj 2026年08月26号
+ * @param binary rg 路径
+ * @param root 搜索根
+ * @param input 搜索输入
+ * @returns argv 数组
+ */
+export function contentArgv(binary: string, root: string, input: ContentSearchInput): string[] {
+  const argv = [binary, '--no-config', '--json', '--line-number', '--no-heading', '--color', 'never', '--hidden', '--no-ignore']
+  if (input.matchCase === true) argv.push('--case-sensitive')
+  if (input.wholeWord === true) argv.push('--word-regexp')
+  if (input.regex !== true) argv.push('--fixed-strings')
+  for (const excluded of EXCLUDES) argv.push('--glob', '!**/' + excluded + '/**')
+  for (const excluded of FILE_EXCLUDES) argv.push('--glob', '!' + excluded)
+  for (const pattern of input.include ?? []) {
+    const glob = String(pattern).trim()
+    if (glob) argv.push('--glob', glob)
+  }
+  for (const pattern of input.exclude ?? []) {
+    const glob = String(pattern).trim()
+    if (glob) argv.push('--glob', '!' + glob)
+  }
+  argv.push('--', input.query, root)
+  return argv
+}
+
+/**
+ * 使用打包 ripgrep 搜索文件内容。
+ * @author ddj 2026年08月26号
+ * @param input provider 输入
+ * @returns 有界内容搜索结果
+ */
+export async function searchRipgrepContent(input: ContentSearchInput): Promise<ContentSearchResult> {
+  const sub = input.ctx.get('subprocess') as { spawn(spec: unknown): { done: Promise<{ exitCode: number | null; code?: number | null }>; collected?: { stdout?: { readFrom(offset: number): { text: string; lossy?: boolean } } } } } | undefined
+  if (!sub) throw new Error('缺少 subprocess')
+  const binary = ripgrepPath()
+  if (!binary) throw new Error('ripgrep 不可用')
+  const root = input.root ?? await searchRoot(input.ctx, input.session)
+  const handle = sub.spawn({
+    argv: contentArgv(binary, root, input),
+    cwd: root,
+    stdio: { stdin: 'ignore', stdout: { maxBytes: STDOUT_CAP }, stderr: { maxBytes: STDERR_CAP } },
+    graceMs: GRACE_MS,
+    signal: input.signal,
+  })
+  let outcome: { exitCode: number | null; code?: number | null }
+  try {
+    outcome = await handle.done
+  } catch (error) {
+    throw new Error('ripgrep 启动失败：' + String(error))
+  }
+  const code = outcome.exitCode ?? outcome.code
+  if (code !== 0 && code !== 1) throw new Error('ripgrep 退出码：' + String(code))
+  const reader = handle.collected?.stdout
+  if (!reader) throw new Error('ripgrep stdout 不可用')
+  const output = reader.readFrom(0)
+  const all = parseRgJsonLines(output.text, root)
+  const maxMatches = Math.max(1, Math.min(input.maxResults ?? DEFAULT_MAX_MATCHES, DEFAULT_MAX_MATCHES))
+  const capped = applyCaps(all, maxMatches, DEFAULT_MAX_FILES)
+  const truncated = Boolean(output.lossy) || capped.truncated
+  return { ...capped, complete: !truncated, source: 'ripgrep' }
+}
+
+/**
+ * 内容搜索编排器：短期缓存 + 同根在途取消 + 会话清理。
+ * @author ddj 2026年08月26号
+ */
+export class ContentSearcher {
+  private readonly cache = new SearchCache<ContentSearchResult>((r) => ({ ...r, matches: [...r.matches] }))
+  private readonly inflight = new Map<string, AbortController>()
+  private readonly rootsByCwd = new Map<string, Set<string>>()
+
+  /**
+   * 创建内容搜索编排器。
+   * @author ddj 2026年08月26号
+   * @param ctx DSH 上下文
+   * @param provider 内容搜索 provider（测试可替换）
+   */
+  constructor(private readonly ctx: Ctx, private readonly provider: ContentSearchProvider = { search: searchRipgrepContent }) {}
+
+  /**
+   * 执行一次工作区内容搜索。
+   * @author ddj 2026年08月26号
+   * @param request 搜索请求
+   * @returns RPC 响应字段（provider 失败抛错，abort 返回空）
+   */
+  async search(request: ContentSearchRequest): Promise<ContentSearchResponse> {
+    const query = String(request.query ?? '').trim()
+    if (query.length < 2) return { matches: [], truncated: false }
+    let root: string
+    try {
+      root = await searchRoot(this.ctx, request.session)
+    } catch {
+      return { matches: [], truncated: false }
+    }
+    const rootKey = pathText(root)
+    const roots = this.rootsByCwd.get(request.cwd) ?? new Set<string>()
+    roots.add(rootKey)
+    this.rootsByCwd.set(request.cwd, roots)
+    const includeKey = (request.include ?? []).join(',')
+    const excludeKey = (request.exclude ?? []).join(',')
+    const key = [rootKey, query, request.matchCase ? 'mc' : '', request.wholeWord ? 'ww' : '', request.regex ? 'rx' : '', includeKey, excludeKey, PROVIDER_VERSION].join('|')
+    const cached = this.cache.get(key)
+    if (cached) return { matches: cached.matches, truncated: cached.truncated }
+    this.inflight.get(root)?.abort()
+    const controller = new AbortController()
+    this.inflight.set(root, controller)
+    try {
+      const result = await this.provider.search({
+        ctx: this.ctx,
+        session: request.session,
+        cwd: request.cwd,
+        query,
+        matchCase: request.matchCase,
+        wholeWord: request.wholeWord,
+        regex: request.regex,
+        maxResults: request.maxResults,
+        include: request.include,
+        exclude: request.exclude,
+        signal: controller.signal,
+        root,
+      })
+      if (controller.signal.aborted) return { matches: [], truncated: false }
+      this.cache.set(key, result)
+      return { matches: result.matches, truncated: result.truncated }
+    } catch (error) {
+      if (controller.signal.aborted) return { matches: [], truncated: false }
+      throw error
+    } finally {
+      if (this.inflight.get(root) === controller) this.inflight.delete(root)
+    }
+  }
+
+  /**
+   * 清理会话对应根目录的缓存和在途搜索。
+   * @author ddj 2026年08月26号
+   * @param cwd 会话工作区
+   */
+  dispose(cwd: string): void {
+    const roots = this.rootsByCwd.get(cwd) ?? new Set<string>([cwd])
+    for (const root of roots) {
+      this.inflight.get(root)?.abort()
+      this.inflight.delete(root)
+      this.cache.clearRoot(root)
+    }
+    this.rootsByCwd.delete(cwd)
+  }
+
+  /**
+   * 清理全部状态。
+   * @author ddj 2026年08月26号
+   */
+  disposeAll(): void {
+    for (const controller of this.inflight.values()) controller.abort()
+    this.inflight.clear()
+    this.rootsByCwd.clear()
+    this.cache.clear()
+  }
+}
+
+/**
+ * 创建默认内容搜索编排器。
+ * @author ddj 2026年08月26号
+ * @param ctx DSH 上下文
+ * @returns 内容搜索编排器
+ */
+export function newContentSearcher(ctx: Ctx): ContentSearcher {
+  return new ContentSearcher(ctx)
+}

package/src/search/fallback.ts

@@ -17,7 +17,7 @@ interface SearchFs {
 }
 
 const RESULT_CAP = 500
-const EXCLUDED = new Set(['node_modules', '.git', '.tmp', '.cache', 'dist', 'build', 'vendor', 'coverage', '__pycache__'])
+const EXCLUDED = new Set(['node_modules', '.git', '.tmp', '.cache', 'dist', 'build', 'vendor', 'coverage', '__pycache__', '.pnpm-store', '.npm-cache', '.codegraph', '.workbuddy', '.dsh-edit-review.json', '.dsh-edit-review-archive.json', '.dsh-edit-review-debug.log'])
 
 /**
  * 在一个目录树中递归查找匹配文件。

package/src/search/orchestrator.ts

@@ -18,17 +18,24 @@ const RESULT_LIMIT = 50
 const PROVIDER_VERSION = 'ripgrep-v1'
 const POLICY_VERSION = 'search-policy-v1'
 
-type CacheEntry = { at: number; result: WorkspaceSearchResult }
+type CacheEntry<T> = { at: number; result: T }
 type SearchRequest = { session: Session; cwd: string; query: string; activePaths: string[] }
 type SearchResponse = { files: string[]; truncated: boolean }
 
 /**
- * 短期有界搜索缓存。
+ * 短期有界搜索缓存（泛型：文件/内容搜索共用；clone 由调用方保证写隔离）。
  * @author ddj 2026年08月24号
- * @returns 缓存对象
+ * @param clone 结果写隔离克隆（缺省恒等）
  */
-export class SearchCache {
-  private readonly entries = new Map<string, CacheEntry>()
+export class SearchCache<T> {
+  private readonly entries = new Map<string, CacheEntry<T>>()
+
+  /**
+   * 创建缓存。
+   * @author ddj 2026年08月24号
+   * @param clone 结果克隆函数（缺省直接引用）
+   */
+  constructor(private readonly clone: (value: T) => T = (value) => value) {}
 
   /**
    * 读取未过期条目。
@@ -37,13 +44,13 @@ export class SearchCache {
    * @param now 当前时间
    * @returns 缓存结果或 undefined
    */
-  get(key: string, now = Date.now()): WorkspaceSearchResult | undefined {
+  get(key: string, now = Date.now()): T | undefined {
     const entry = this.entries.get(key)
     if (!entry) return undefined
     if (now - entry.at >= CACHE_TTL) { this.entries.delete(key); return undefined }
     this.entries.delete(key)
     this.entries.set(key, entry)
-    return { ...entry.result, files: [...entry.result.files] }
+    return this.clone(entry.result)
   }
 
   /**
@@ -53,9 +60,9 @@ export class SearchCache {
    * @param result provider 结果
    * @param now 当前时间
    */
-  set(key: string, result: WorkspaceSearchResult, now = Date.now()): void {
+  set(key: string, result: T, now = Date.now()): void {
     this.entries.delete(key)
-    this.entries.set(key, { at: now, result: { ...result, files: [...result.files] } })
+    this.entries.set(key, { at: now, result: this.clone(result) })
     while (this.entries.size > CACHE_LIMIT) this.entries.delete(this.entries.keys().next().value as string)
   }
 
@@ -145,7 +152,7 @@ function mergeCandidates(result: WorkspaceSearchResult, activePaths: string[], r
  * @author ddj 2026年08月24号
  */
 export class SearchOrchestrator {
-  private readonly cache = new SearchCache()
+  private readonly cache = new SearchCache<WorkspaceSearchResult>((r) => ({ ...r, files: [...r.files] }))
   private readonly inflight = new Map<string, AbortController>()
   private readonly rootsByCwd = new Map<string, Set<string>>()
   private readonly provider: WorkspaceSearchProvider

package/src/search/ripgrep.ts

@@ -14,9 +14,23 @@ import type { WorkspaceSearchInput, WorkspaceSearchProvider, WorkspaceSearchResu
 const STDOUT_CAP = 4 << 20
 const STDERR_CAP = 64 << 10
 const GRACE_MS = 20_000
-const EXCLUDES = [
+
+/** 默认排除目录（文件/内容搜索共用，导出供 provider 复用）。 */
+export const EXCLUDES = [
   'node_modules', '.git', '.tmp', '.cache', 'dist', 'build', 'vendor',
-  'coverage', '__pycache__',
+  'coverage', '__pycache__', '.pnpm-store', '.npm-cache', '.codegraph', '.workbuddy',
+]
+
+/**
+ * 默认排除文件（glob 模式，文件/内容搜索共用）。
+ * 插件自身 sidecar（内容搜索会命中其历史编辑文本，且单行巨型 JSON 会撑爆输出上限）；
+ * *.map 源映射（纯构建产物，内容搜索无意义且常为单行巨文件）。
+ */
+export const FILE_EXCLUDES = [
+  '**/.dsh-edit-review.json',
+  '**/.dsh-edit-review-archive.json',
+  '**/.dsh-edit-review-debug.log',
+  '**/*.map',
 ]
 
 interface SearchHandle {
@@ -113,6 +127,7 @@ export async function searchRipgrep(input: WorkspaceSearchInput): Promise<Worksp
   const query = prepareQuery(input.query)
   const argv = [binary, '--no-config', '--files', '--hidden', '--no-ignore', '--glob-case-insensitive', '--glob', queryGlob(query.text)]
   for (const excluded of EXCLUDES) argv.push('--glob', '!**/' + excluded + '/**')
+  for (const excluded of FILE_EXCLUDES) argv.push('--glob', '!' + excluded)
   argv.push('--', root)
   const handle = sub.spawn({
     argv,

package/src/search/types.ts

@@ -45,3 +45,43 @@ export interface SearchCandidate {
 export interface CandidateRanker {
   rank(candidates: SearchCandidate[], query: PreparedQuery): SearchCandidate[]
 }
+
+/** 内容搜索单条命中（列 = 1-based UTF-16，直接供 Monaco 跳转/高亮）。 */
+export interface ContentMatch {
+  path: string
+  line: number
+  startColumn: number
+  endColumn: number
+  text: string
+}
+
+/** 内容搜索输入（options 缺省 = 大小写不敏感、字面匹配、非全词；include/exclude 为 rg glob）。 */
+export interface ContentSearchInput {
+  ctx: Ctx
+  session: Session
+  cwd: string
+  query: string
+  matchCase?: boolean
+  wholeWord?: boolean
+  regex?: boolean
+  maxResults?: number
+  /** 正选 glob（仅在这些文件内搜索；逗号已在客户端拆分）。 */
+  include?: string[]
+  /** 排除 glob（这些文件不参与搜索）。 */
+  exclude?: string[]
+  signal?: AbortSignal
+  root?: string
+}
+
+/** 内容搜索输出：扁平命中列表 + 截断标志。 */
+export interface ContentSearchResult {
+  matches: ContentMatch[]
+  truncated: boolean
+  complete: boolean
+  source: SearchSource
+}
+
+/** 内容搜索 provider（rg JSON 主路径；无 fallback，失败抛错由调用方处理）。 */
+export interface ContentSearchProvider {
+  search(input: ContentSearchInput): Promise<ContentSearchResult>
+}