dsh-vscode-mode 0.1.12 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-vscode-mode",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "DSH 上的类 VSCode 编码体验：Monaco 中央编辑器（文件页签/QuickOpen/状态栏）+ Agent 编辑差异审查（整文件差异/采纳/拒绝/归档/回滚），状态持久化到工作区旁车",
   "keywords": [
     "dsh",
@@ -39,6 +39,9 @@
     "cordis.patch.yml"
   ],
   "license": "BSD-3-Clause",
+  "dependencies": {
+    "@vscode/ripgrep": "^1.18.0"
+  },
   "peerDependencies": {
     "@deepseek-ai/dsh-client-ui-slots": ">=0.0.1-rc.1 <0.1.0 || >=0.1.0-rc.1 <0.2.0-0",
     "@deepseek-ai/dsh-llm": ">=0.0.1-rc.1 <0.1.0 || >=0.1.0-rc.1 <0.2.0-0",

package/src/index.ts

@@ -8,6 +8,7 @@
 import { registerRoutes } from './routes.js'
 import { captureToolResult } from './capture.js'
 import { handleRpc } from './rpc.js'
+import { newSearcher } from './search/orchestrator.js'
 import { installIsolation } from './mcpIsolation.js'
 import { dropFileIndex } from './workspace.js'
 import { cwdOf } from './registry.js'
@@ -25,6 +26,7 @@ export const inject = ['sessions', 'fs', 'webServer', 'loader', 'tools', 'worksp
  */
 export function apply(ctx: Ctx, config?: unknown): void {
   const registry: Registry = new Map()
+  const searcher = newSearcher(ctx)
 
   ctx.on('tools/result', (exec: unknown, result: unknown) => {
     void captureToolResult(ctx, registry, exec, result)
@@ -35,10 +37,11 @@ export function apply(ctx: Ctx, config?: unknown): void {
     if (cwd) {
       registry.delete(cwd)
       dropFileIndex(cwd)
+      searcher.dispose(cwd)
     }
   })
 
-  registerRoutes(ctx, config, (method, args) => handleRpc(ctx, registry, method, args))
+  registerRoutes(ctx, config, (method, args) => handleRpc(ctx, registry, method, args, searcher))
   installIsolation(ctx)
 
   ctx.logger?.info?.('[' + name + '] 编辑差异审查已装配（/edrv/rpc 路由就绪，项目 MCP 隔离已启用）')

package/src/rpc.ts

@@ -21,7 +21,8 @@ import {
 import { archiveEntryFor, markDecision, recordResolved, reconstructOriginal } from './model.js'
 import type { Registry } from './registry.js'
 import { bucketOf, cwdOf, sessionOf } from './registry.js'
-import { listWorkspaceFiles } from './workspace.js'
+import type { SearchOrchestrator } from './search/orchestrator.js'
+import { newSearcher } from './search/orchestrator.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'
@@ -63,7 +64,7 @@ async function requireSession(ctx: Ctx, sessionId: string | undefined): Promise<
 }
 
 /** 各方法 handler 表（类型由 shared/rpc 的 RpcHandlerMap 约束）。 */
-export function buildHandlers(ctx: Ctx, registry: Registry): RpcHandlerMap {
+export function buildHandlers(ctx: Ctx, registry: Registry, searcher = newSearcher(ctx)): RpcHandlerMap {
   return {
     'edrv.list': async (args) => {
       const sc = await requireSession(ctx, args.sessionId)
@@ -260,27 +261,11 @@ export function buildHandlers(ctx: Ctx, registry: Registry): RpcHandlerMap {
     'edrv.searchFiles': async (args) => {
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
-      const query = String(args.query ?? '').trim().toLowerCase()
-      const files: string[] = []
-      if (query.length >= 2) {
-        const bucket = await bucketOf(registry, ctx, sc.cwd)
-        const pool = new Set<string>()
-        // 活跃差异路径恒并入（保证差异文件一定可搜到，即使工作区扫描不可用）
-        for (const rec of bucket.values()) if (rec.path) pool.add(rec.path)
-        const listed = await listWorkspaceFiles(ctx, sc.session, sc.cwd)
-        if (listed) for (const f of listed) pool.add(f)
-        const score = (p: string): number => {
-          const pl = p.toLowerCase()
-          const base = pl.split(/[\\/]/).pop() || ''
-          if (base.includes(query)) return 0
-          if (pl.includes(query)) return 1
-          return -1
-        }
-        const hit = [...pool].filter((p) => score(p) >= 0)
-        hit.sort((a, b) => (score(a) - score(b)) || (a < b ? -1 : 1))
-        files.push(...hit.slice(0, 50))
-      }
-      return { ok: true, files, truncated: files.length >= 50 }
+      const bucket = await bucketOf(registry, ctx, sc.cwd)
+      const activePaths: string[] = []
+      for (const record of bucket.values()) if (record.path) activePaths.push(record.path)
+      const result = await searcher.search({ session: sc.session, cwd: sc.cwd, query: args.query, activePaths })
+      return { ok: true, ...result }
     },
     'mcp.list': async () => ({ ok: true, ...listMcp(ctx) }),
     'mcp.save': async (args) => {
@@ -331,8 +316,9 @@ export async function handleRpc<M extends RpcMethod>(
   registry: Registry,
   method: M,
   args: RpcRequestMap[M],
+  searcher = newSearcher(ctx),
 ): Promise<RpcResult<M>> {
-  const handlers = buildHandlers(ctx, registry)
+  const handlers = buildHandlers(ctx, registry, searcher)
   const handler = handlers[method]
   if (!handler) return { ok: false, error: '未知方法: ' + String(method) } as RpcResult<M>
   return handler(args)

package/src/search/fallback.ts

@@ -0,0 +1,76 @@
+/**
+ * dsh-vscode-mode host — fs.listDir 查询感知 fallback。
+ * provider 不可用时边遍历边匹配，不再伪装有限全量扫描为完整索引。
+ * 作者 ddj 2026年08月24号
+ */
+import type { Ctx, Session } from '../store.js'
+import { policyOf } from '../store.js'
+import { pathText, pathMatch } from './query.js'
+import { searchRoot } from './ripgrep.js'
+import type { WorkspaceSearchInput, WorkspaceSearchProvider, WorkspaceSearchResult } from './types.js'
+
+interface FsTarget { displayPath?: string }
+interface FsEntry { name: string; type: 'file' | 'directory' | 'other'; target: FsTarget }
+interface SearchFs {
+  resolve(path: string, opts?: { cwd?: string; signal?: AbortSignal }): Promise<FsTarget>
+  listDir(target: FsTarget, signal?: AbortSignal): Promise<FsEntry[]>
+}
+
+const RESULT_CAP = 500
+const EXCLUDED = new Set(['node_modules', '.git', '.tmp', '.cache', 'dist', 'build', 'vendor', 'coverage', '__pycache__'])
+
+/**
+ * 在一个目录树中递归查找匹配文件。
+ * @author ddj 2026年08月24号
+ * @param fs 文件系统能力
+ * @param target 当前目录目标
+ * @param input 搜索输入
+ * @param files 已保留候选
+ * @param signal 取消信号
+ * @returns 是否因达到上限而截断
+ */
+async function walk(fs: SearchFs, target: FsTarget, input: WorkspaceSearchInput, files: string[], signal: AbortSignal): Promise<boolean> {
+  if (signal.aborted) throw new DOMException('搜索已取消', 'AbortError')
+  const entries = await fs.listDir(target, signal)
+  for (const entry of entries) {
+    if (signal.aborted) throw new DOMException('搜索已取消', 'AbortError')
+    if (entry.type === 'directory') {
+      if (EXCLUDED.has(entry.name)) continue
+      if (await walk(fs, entry.target, input, files, signal)) return true
+      continue
+    }
+    if (entry.type !== 'file') continue
+    const path = pathText(entry.target.displayPath ?? entry.name)
+    if (!pathMatch(path, { raw: input.query, text: pathText(input.query).toLocaleLowerCase('en-US') })) continue
+    files.push(path)
+    if (files.length >= Math.min(input.maxResults, RESULT_CAP)) return true
+  }
+  return false
+}
+
+/**
+ * 使用 ctx.fs.listDir 搜索文件。
+ * @author ddj 2026年08月24号
+ * @param input provider 输入
+ * @returns 有界 fallback 结果
+ */
+export async function searchFallback(input: WorkspaceSearchInput): Promise<WorkspaceSearchResult> {
+  const fs = input.ctx.get('fs') as SearchFs | undefined
+  if (!fs) throw new Error('缺少 fs')
+  const policy = policyOf(input.ctx, input.session)
+  const cwd = input.session?.header?.cwd
+  const rootTarget = await fs.resolve(policy?.workspaceRoot ?? '.', cwd ? { cwd, signal: input.signal } : { signal: input.signal })
+  const signal = input.signal ?? new AbortController().signal
+  const files: string[] = []
+  const truncated = await walk(fs, rootTarget, input, files, signal)
+  return { files, truncated, complete: !truncated, source: 'fallback' }
+}
+
+/**
+ * 构造 fallback provider。
+ * @author ddj 2026年08月24号
+ * @returns provider 实例
+ */
+export function newFallback(): WorkspaceSearchProvider {
+  return { search: searchFallback }
+}

package/src/search/orchestrator.ts

@@ -0,0 +1,276 @@
+/**
+ * dsh-vscode-mode host — 搜索编排、缓存和旧任务取消。
+ * 对外只返回旧 RPC 所需的 files/truncated，内部保留 provider 边界。
+ * 作者 ddj 2026年08月24号
+ */
+import type { Ctx, Session } from '../store.js'
+import { policyOf } from '../store.js'
+import { pathKey, pathMatch, pathText, prepareQuery } from './query.js'
+import { searchRoot } from './ripgrep.js'
+import { newRgProvider } from './ripgrep.js'
+import { newFallback } from './fallback.js'
+import { candidateOf, rankCandidates } from './ranker.js'
+import type { CandidateRanker, SearchCandidate, WorkspaceSearchProvider, WorkspaceSearchResult } from './types.js'
+
+const CACHE_TTL = 60_000
+const CACHE_LIMIT = 100
+const RESULT_LIMIT = 50
+const PROVIDER_VERSION = 'ripgrep-v1'
+const POLICY_VERSION = 'search-policy-v1'
+
+type CacheEntry = { at: number; result: WorkspaceSearchResult }
+type SearchRequest = { session: Session; cwd: string; query: string; activePaths: string[] }
+type SearchResponse = { files: string[]; truncated: boolean }
+
+/**
+ * 短期有界搜索缓存。
+ * @author ddj 2026年08月24号
+ * @returns 缓存对象
+ */
+export class SearchCache {
+  private readonly entries = new Map<string, CacheEntry>()
+
+  /**
+   * 读取未过期条目。
+   * @author ddj 2026年08月24号
+   * @param key 缓存 key
+   * @param now 当前时间
+   * @returns 缓存结果或 undefined
+   */
+  get(key: string, now = Date.now()): WorkspaceSearchResult | 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] }
+  }
+
+  /**
+   * 写入成功 provider 结果。
+   * @author ddj 2026年08月24号
+   * @param key 缓存 key
+   * @param result provider 结果
+   * @param now 当前时间
+   */
+  set(key: string, result: WorkspaceSearchResult, now = Date.now()): void {
+    this.entries.delete(key)
+    this.entries.set(key, { at: now, result: { ...result, files: [...result.files] } })
+    while (this.entries.size > CACHE_LIMIT) this.entries.delete(this.entries.keys().next().value as string)
+  }
+
+  /**
+   * 清理指定根目录的缓存。
+   * @author ddj 2026年08月24号
+   * @param root 工作区根目录
+   */
+  clearRoot(root: string): void {
+    for (const key of this.entries.keys()) if (key.startsWith(root + '|')) this.entries.delete(key)
+  }
+
+  /**
+   * 清空全部缓存。
+   * @author ddj 2026年08月24号
+   */
+  clear(): void { this.entries.clear() }
+}
+
+/**
+ * 获取 policy 版本，未知策略使用固定插件版本。
+ * @author ddj 2026年08月24号
+ * @param ctx DSH 上下文
+ * @param session 当前会话
+ * @returns 稳定版本文本
+ */
+function policyVersion(ctx: Ctx, session: Session): string {
+  const policy = policyOf(ctx, session)
+  const version = policy?.version ?? policy?.policyVersion
+  return typeof version === 'string' || typeof version === 'number' ? String(version) : POLICY_VERSION
+}
+
+/**
+ * 将 root 内绝对路径统一成相对显示路径。
+ * @author ddj 2026年08月24号
+ * @param value 原始路径
+ * @param root 搜索根
+ * @returns 兼容 edrv.read 的路径
+ */
+function displayPath(value: string, root: string): string {
+  const path = pathText(value)
+  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
+}
+
+/**
+ * 为显示路径生成跨绝对/相对形式的去重 key。
+ * @author ddj 2026年08月24号
+ * @param value 原始路径
+ * @param root 搜索根
+ * @returns 去重 key
+ */
+function displayKey(value: string, root: string): string {
+  return pathKey(displayPath(value, root))
+}
+
+/**
+ * 合并 provider 与 active diff 候选并去重。
+ * @author ddj 2026年08月24号
+ * @param result provider 结果
+ * @param activePaths 活跃差异路径
+ * @param root 搜索根
+ * @param query 已规范化 query
+ * @returns 候选列表
+ */
+function mergeCandidates(result: WorkspaceSearchResult, activePaths: string[], root: string, query: ReturnType<typeof prepareQuery>): SearchCandidate[] {
+  const candidates = new Map<string, SearchCandidate>()
+  for (const path of result.files) {
+    const shown = displayPath(path, root)
+    if (pathMatch(shown, query)) candidates.set(displayKey(path, root), candidateOf(shown, 'workspace'))
+  }
+  for (const path of activePaths) {
+    const shown = displayPath(path, root)
+    if (!pathMatch(shown, query)) continue
+    const key = displayKey(path, root)
+    if (!candidates.has(key)) candidates.set(key, candidateOf(shown, 'active-diff'))
+  }
+  return [...candidates.values()]
+}
+
+/**
+ * 搜索编排器。
+ * @author ddj 2026年08月24号
+ */
+export class SearchOrchestrator {
+  private readonly cache = new SearchCache()
+  private readonly inflight = new Map<string, AbortController>()
+  private readonly rootsByCwd = new Map<string, Set<string>>()
+  private readonly provider: WorkspaceSearchProvider
+  private readonly fallback: WorkspaceSearchProvider
+  private readonly ranker: CandidateRanker
+
+  /**
+   * 创建搜索编排器。
+   * @author ddj 2026年08月24号
+   * @param ctx DSH 上下文
+   * @param provider 主 provider，可替换测试
+   * @param fallback 降级 provider，可替换测试
+   * @param ranker 排序器，可替换测试
+   */
+  constructor(private readonly ctx: Ctx, provider = newRgProvider(), fallback = newFallback(), ranker: CandidateRanker = { rank: rankCandidates }) {
+    this.provider = provider
+    this.fallback = fallback
+    this.ranker = ranker
+  }
+
+  /**
+   * 执行一次工作区搜索。
+   * @author ddj 2026年08月24号
+   * @param request 搜索请求
+   * @returns 旧 RPC 响应字段
+   */
+  async search(request: SearchRequest): Promise<SearchResponse> {
+    const query = prepareQuery(request.query)
+    if (query.text.length < 2) return { files: [], truncated: false }
+    let root: string
+    try { root = await searchRoot(this.ctx, request.session) } catch (error) {
+      return this.rankActive(request.activePaths, request.cwd, query)
+    }
+    const rootKey = pathText(root)
+    const roots = this.rootsByCwd.get(request.cwd) ?? new Set<string>()
+    roots.add(rootKey)
+    this.rootsByCwd.set(request.cwd, roots)
+    const key = [rootKey, query.text, policyVersion(this.ctx, request.session), PROVIDER_VERSION].join('|')
+    const cached = this.cache.get(key)
+    if (cached) return this.finish(cached, request.activePaths, root, query)
+    this.inflight.get(root)?.abort()
+    const controller = new AbortController()
+    this.inflight.set(root, controller)
+    try {
+      let result: WorkspaceSearchResult
+      let providerOk = true
+      try {
+        result = await this.provider.search({ ctx: this.ctx, session: request.session, cwd: request.cwd, query: query.raw, maxResults: 500, signal: controller.signal, root })
+      } catch (error) {
+        providerOk = false
+        if (controller.signal.aborted) return { files: [], truncated: false }
+        try {
+          result = await this.fallback.search({ ctx: this.ctx, session: request.session, cwd: request.cwd, query: query.raw, maxResults: 500, signal: controller.signal, root })
+        } catch (fallbackError) {
+          return this.rankActive(request.activePaths, root, query)
+        }
+      }
+      if (controller.signal.aborted) return { files: [], truncated: false }
+      if (providerOk) this.cache.set(key, result)
+      return this.finish(result, request.activePaths, root, query)
+    } finally {
+      if (this.inflight.get(root) === controller) this.inflight.delete(root)
+    }
+  }
+
+  /**
+   * 清理会话对应根目录的缓存和在途搜索。
+   * @author ddj 2026年08月24号
+   * @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月24号
+   */
+  disposeAll(): void {
+    for (const controller of this.inflight.values()) controller.abort()
+    this.inflight.clear()
+    this.rootsByCwd.clear()
+    this.cache.clear()
+  }
+
+  /**
+   * 将 provider 结果与 active diff 合并、排序和截断。
+   * @author ddj 2026年08月24号
+   * @param result provider 结果
+   * @param activePaths active diff 路径
+   * @param root 搜索根
+   * @param query 已规范化 query
+   * @returns 旧 RPC 响应字段
+   */
+  private finish(result: WorkspaceSearchResult, activePaths: string[], root: string, query: ReturnType<typeof prepareQuery>): SearchResponse {
+    const candidates = this.ranker.rank(mergeCandidates(result, activePaths, root, query), query)
+    return { files: candidates.slice(0, RESULT_LIMIT).map((candidate) => candidate.path), truncated: result.truncated || candidates.length > RESULT_LIMIT }
+  }
+
+  /**
+   * provider 失败时仅保留 active diff 命中。
+   * @author ddj 2026年08月24号
+   * @param paths active diff 路径
+   * @param root 搜索根
+   * @param query 已规范化 query
+   * @returns 旧 RPC 响应字段
+   */
+  private rankActive(paths: string[], root: string, query: ReturnType<typeof prepareQuery>): SearchResponse {
+    const result: WorkspaceSearchResult = { files: [], truncated: false, complete: true, source: 'active-diff' }
+    return this.finish(result, paths, root, query)
+  }
+}
+
+/**
+ * 创建默认编排器。
+ * @author ddj 2026年08月24号
+ * @param ctx DSH 上下文
+ * @returns 搜索编排器
+ */
+export function newSearcher(ctx: Ctx): SearchOrchestrator {
+  return new SearchOrchestrator(ctx)
+}

package/src/search/query.ts

@@ -0,0 +1,62 @@
+/**
+ * dsh-vscode-mode host — 搜索 query 与路径规范化。
+ * 查询只按字面连续片段比较，不解释为正则或 shell 语句。
+ * 作者 ddj 2026年08月24号
+ */
+import { isAbsolute, resolve } from 'node:path'
+import type { PreparedQuery } from './types.js'
+
+/**
+ * 规范化用户搜索文本。
+ * @author ddj 2026年08月24号
+ * @param raw 原始搜索文本
+ * @returns 用于比较和缓存的 query
+ */
+export function prepareQuery(raw: unknown): PreparedQuery {
+  const value = String(raw ?? '').trim()
+  return { raw: value, text: value.replaceAll('\\', '/').toLocaleLowerCase('en-US') }
+}
+
+/**
+ * 归一化路径分隔符并移除无意义前缀。
+ * @author ddj 2026年08月24号
+ * @param value 原始路径
+ * @returns 比较用路径
+ */
+export function pathText(value: string): string {
+  return value.replaceAll('\\', '/').replace(/^\.\//, '')
+}
+
+/**
+ * 生成不区分大小写的路径 key。
+ * @author ddj 2026年08月24号
+ * @param value 原始路径
+ * @returns 去重 key
+ */
+export function pathKey(value: string): string {
+  return pathText(value).toLocaleLowerCase('en-US')
+}
+
+/**
+ * 将相对文件路径映射到 provider 根目录。
+ * @author ddj 2026年08月24号
+ * @param value 文件路径
+ * @param root 工作区根目录
+ * @returns 可供 edrv.read 使用的路径
+ */
+export function displayPath(value: string, root: string): string {
+  const normalized = pathText(value)
+  if (isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized) || normalized.startsWith('//')) return normalized
+  return resolve(root, normalized)
+}
+
+/**
+ * 判断路径是否包含连续 query。
+ * @author ddj 2026年08月24号
+ * @param value 文件路径
+ * @param query 已规范化 query
+ * @returns 是否命中
+ */
+export function pathMatch(value: string, query: PreparedQuery): boolean {
+  return pathText(value).toLocaleLowerCase('en-US').includes(query.text)
+}

package/src/search/ranker.ts

@@ -0,0 +1,48 @@
+/**
+ * dsh-vscode-mode host — 可替换的连续匹配排序器。
+ * 第一版保持 basename 优先和稳定路径序，后续可接 fuzzy scorer。
+ * 作者 ddj 2026年08月24号
+ */
+import type { CandidateRanker, PreparedQuery, SearchCandidate } from './types.js'
+import { pathText } from './query.js'
+
+/**
+ * 生成搜索候选。
+ * @author ddj 2026年08月24号
+ * @param path 文件路径
+ * @param source 候选来源
+ * @returns 内部候选
+ */
+export function candidateOf(path: string, source: SearchCandidate['source']): SearchCandidate {
+  const normalizedPath = pathText(path)
+  const basename = normalizedPath.split('/').pop() ?? normalizedPath
+  return { path, basename, normalizedPath: normalizedPath.toLocaleLowerCase('en-US'), source }
+}
+
+/**
+ * 对连续匹配候选进行排序。
+ * @author ddj 2026年08月24号
+ * @param candidates 候选列表
+ * @param query 已规范化 query
+ * @returns 排序后的候选
+ */
+export function rankCandidates(candidates: SearchCandidate[], query: PreparedQuery): SearchCandidate[] {
+  const text = query.text
+  const score = (candidate: SearchCandidate): number => {
+    const base = candidate.basename.toLocaleLowerCase('en-US')
+    if (base.startsWith(text)) return 0
+    if (base.includes(text)) return 1
+    if (candidate.normalizedPath.includes(text)) return 2
+    return 3
+  }
+  return [...candidates].sort((left, right) => score(left) - score(right) || left.normalizedPath.localeCompare(right.normalizedPath, 'en-US'))
+}
+
+/**
+ * 默认候选排序器。
+ * @author ddj 2026年08月24号
+ * @returns 排序器
+ */
+export function substringRanker(): CandidateRanker {
+  return { rank: rankCandidates }
+}