dsh-vscode-mode 0.1.17 → 0.1.20

package/src/rpc.ts

@@ -4,7 +4,7 @@
  * 新功能 = shared/rpc.ts 加方法 + 这里加一个 handler，不改其他模块。
  * 作者 ddj 2026-08-20
  */
-import type { RpcHandlerMap, RpcMethod, RpcRequestMap, RpcResult } from './shared/rpc.js'
+import type { DecideItem, DecideResult, RpcHandlerMap, RpcMethod, RpcRequestMap, RpcResult, RpcScope } from './shared/rpc.js'
 import type { DiffRecord, RecordView } from './shared/types.js'
 import type { Ctx, Session } from './store.js'
 import {
@@ -29,6 +29,7 @@ import { listProjects, projectRefresh, projectRemove, projectSave, projectToggle
 import { normalizeFileOpenTool, FILE_OPEN_DEFAULT, FILE_OPEN_SETTINGS_NS } from './fileOpenSettings.js'
 import { buildReport } from './compat.js'
 import { readDevForm, setDevForm } from './devForm.js'
+import { normalizeRel, toTreeEntries } from './tree.js'
 
 /** cwd → Promise 链：串行化 debug 日志追加（fs read+write 非原子，避免并发丢行）。 */
 const debugWriteQueues = new Map<string, Promise<void>>()
@@ -66,6 +67,52 @@ async function requireSession(ctx: Ctx, sessionId: string | undefined): Promise<
   return { session, cwd }
 }
 
+/**
+ * 批量决策核心：一次会话/桶解析 + 逐项处理 + 统一落盘（accept/reject 单条与 decideBatch 共用）。
+ * rejected 项先做回滚，失败记入该项 error 且不改决策；本批次新增"已解决"记录一次性归档，
+ * 有任何成功项则整桶只写盘一次，避免逐条读写整个 sidecar。
+ * @author ddj 2026年08月25号
+ * @param items 决策项（按数组顺序处理，rejected 的先后即回滚顺序）
+ * @returns 逐项结果（ok 项含更新后的记录视图）
+ */
+async function applyDecisions(
+  ctx: Ctx,
+  session: Session,
+  cwd: string,
+  bucket: Map<string, DiffRecord>,
+  items: DecideItem[],
+): Promise<DecideResult[]> {
+  const results: DecideResult[] = []
+  const resolved: DiffRecord[] = []
+  let changed = false
+  for (const item of items) {
+    const record = bucket.get(item.callId)
+    if (!record) {
+      results.push({ callId: item.callId, ok: false, error: '记录不存在' })
+      continue
+    }
+    if (item.decision === 'rejected') {
+      const scope: RpcScope = item.scope ?? 'call'
+      const outcome = scope === 'hunk' ? await revertHunk(ctx, session, record, item.hunkIndex ?? -1) : await revertCall(ctx, session, record)
+      if (!outcome.ok) {
+        results.push({ callId: item.callId, ok: false, error: outcome.error })
+        continue
+      }
+    }
+    const wasResolved = recordResolved(record)
+    markDecision(record, item.scope ?? 'call', item.hunkIndex, item.decision)
+    changed = true
+    if (!wasResolved && recordResolved(record)) resolved.push(record)
+    results.push({ callId: item.callId, ok: true, record: recView(record) })
+  }
+  if (resolved.length) {
+    const reason = items.some((item) => item.decision === 'rejected') ? '已处理（回滚）' : '已处理'
+    await archiveRecords(ctx, session, cwd, bucket, resolved, reason, { deferSave: true })
+  }
+  if (changed) await saveBucket(ctx, cwd, bucket, session)
+  return results
+}
+
 /** 各方法 handler 表（类型由 shared/rpc 的 RpcHandlerMap 约束）。 */
 export function buildHandlers(ctx: Ctx, registry: Registry, searcher = newSearcher(ctx)): RpcHandlerMap {
   return {
@@ -74,7 +121,7 @@ export function buildHandlers(ctx: Ctx, registry: Registry, searcher = newSearch
       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) await autoArchiveStale(ctx, sc.session, sc.cwd, bucket) // 全量轮询时自动清理 stale 幽灵差异
+      if (!want && args.skipStale !== true) await autoArchiveStale(ctx, sc.session, sc.cwd, bucket) // 全量轮询时自动清理 stale 幽灵差异（批量决策后的即时刷新可 skipStale 跳过）
       const out: RecordView[] = []
       for (const rec of bucket.values()) {
         // 面板全量查询过滤已归档；聊天条按 callId 查询保留（状态徽章仍需正确显示）
@@ -89,27 +136,26 @@ export function buildHandlers(ctx: Ctx, registry: Registry, searcher = newSearch
       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 record = bucket.get(args.callId)
-      if (!record) return { ok: false, error: '记录不存在' }
-      markDecision(record, args.scope ?? 'call', args.hunkIndex, 'accepted')
-      if (recordResolved(record)) await archiveRecords(ctx, sc.session, sc.cwd, bucket, [record], '已处理')
-      else await saveBucket(ctx, sc.cwd, bucket, sc.session)
-      return { ok: true, record: recView(record) }
+      const results = await applyDecisions(ctx, sc.session, sc.cwd, bucket, [{ callId: args.callId, scope: args.scope, hunkIndex: args.hunkIndex, decision: 'accepted' }])
+      const item = results[0]
+      if (!item?.ok) return { ok: false, error: item?.error ?? '操作失败' }
+      return { ok: true, record: item.record! }
     },
     'edrv.reject': 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 record = bucket.get(args.callId)
-      if (!record) return { ok: false, error: '记录不存在' }
-      const scope = args.scope ?? 'call'
-      const outcome = scope === 'hunk' ? await revertHunk(ctx, sc.session, record, args.hunkIndex ?? -1) : await revertCall(ctx, sc.session, record)
-      if (!outcome.ok) return { ok: false, error: outcome.error }
-      markDecision(record, scope, args.hunkIndex, 'rejected')
-      record.at = new Date().toISOString()
-      if (recordResolved(record)) await archiveRecords(ctx, sc.session, sc.cwd, bucket, [record], '已处理（回滚）')
-      else await saveBucket(ctx, sc.cwd, bucket, sc.session)
-      return { ok: true, record: recView(record) }
+      const results = await applyDecisions(ctx, sc.session, sc.cwd, bucket, [{ callId: args.callId, scope: args.scope, hunkIndex: args.hunkIndex, decision: 'rejected' }])
+      const item = results[0]
+      if (!item?.ok) return { ok: false, error: item?.error ?? '操作失败' }
+      return { ok: true, record: item.record! }
+    },
+    'edrv.decideBatch': 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 results = await applyDecisions(ctx, sc.session, sc.cwd, bucket, Array.isArray(args.items) ? args.items : [])
+      return { ok: true, results }
     },
     'edrv.read': async (args) => {
       const sc = await requireSession(ctx, args.sessionId)
@@ -270,6 +316,26 @@ 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.listDir': async (args) => {
+      // 目录树（侧边栏文件管理用）：按会话 cwd 解析，与 edrv.read 同基准，树内相对路径点开即打开。
+      const sc = await requireSession(ctx, args.sessionId)
+      if ('err' in sc) return { ok: false, error: sc.err }
+      const fs = ctx.get('fs')
+      if (!fs) return { ok: false, error: '缺少 fs' }
+      try {
+        const rel = normalizeRel(args.path)
+        if (rel === null) return { ok: false, error: '路径不合法' }
+        const target = await resolveTarget(ctx, sc.session, rel || '.')
+        const info = await fs.stat(target)
+        if (!info) return { ok: false, error: '目录不存在' }
+        if (info.type !== 'directory') return { ok: false, error: '不是目录' }
+        const children = await fs.listDir(target)
+        const root = fs.processPath(await fs.resolve('.', { cwd: sc.cwd }))
+        return { ok: true, root, path: rel, entries: toTreeEntries(rel, children) }
+      } catch (error) {
+        return { ok: false, error: '读取目录失败：' + String(error) }
+      }
+    },
     'mcp.list': async () => ({ ok: true, ...listMcp(ctx) }),
     'mcp.save': async (args) => {
       try { return { ok: true, server: await saveMcp(ctx, args.config) } }

package/src/shared/rpc.ts

@@ -21,11 +21,36 @@ export const RPC_PATH = '/edrv/rpc'
 /** 决策作用域：call=整条记录，hunk=单个差异块。 */
 export type RpcScope = 'call' | 'hunk'
 
+/** 目录树单项（edrv.listDir 返回；path 相对工作区根，'/' 分隔）。 */
+export interface TreeEntry {
+  name: string
+  path: string
+  type: 'file' | 'directory' | 'other'
+  size?: number
+}
+
+/** 一条批量决策项（decideBatch 的 items 元素，与 accept/reject 单条参数同构）。 */
+export interface DecideItem {
+  callId: string
+  scope?: RpcScope
+  hunkIndex?: number
+  decision: 'accepted' | 'rejected'
+}
+
+/** 批量决策逐项结果。 */
+export interface DecideResult {
+  callId: string
+  ok: boolean
+  error?: string
+  record?: RecordView
+}
+
 /** 每个方法的请求参数（sessionId 为公共可选字段）。 */
 export interface RpcRequestMap {
-  'edrv.list': { sessionId?: string; callIds?: string[] }
+  'edrv.list': { sessionId?: string; callIds?: string[]; skipStale?: boolean }
   'edrv.accept': { sessionId?: string; callId: string; scope?: RpcScope; hunkIndex?: number }
   'edrv.reject': { sessionId?: string; callId: string; scope?: RpcScope; hunkIndex?: number }
+  'edrv.decideBatch': { sessionId?: string; items: DecideItem[] }
   'edrv.read': { sessionId?: string; path: string }
   'edrv.original': { sessionId?: string; path: string }
   'edrv.save': { sessionId?: string; path: string; content: string }
@@ -34,6 +59,7 @@ export interface RpcRequestMap {
   'edrv.rollback': { sessionId?: string; path: string; batch?: number }
   'edrv.debug': { sessionId?: string; text: string }
   'edrv.searchFiles': { sessionId?: string; query: string }
+  'edrv.listDir': { sessionId?: string; path: string }
   'mcp.list': {}
   'mcp.save': { config: MpcConfig }
   'mcp.remove': { id: string }
@@ -58,6 +84,7 @@ export interface RpcOkMap {
   'edrv.list': { records: RecordView[] }
   'edrv.accept': { record: RecordView }
   'edrv.reject': { record: RecordView }
+  'edrv.decideBatch': { results: DecideResult[] }
   'edrv.read': { content: string; size: number }
   'edrv.original': { content: string; size: number; stale: StaleHunk[]; fallback: boolean }
   'edrv.save': object
@@ -66,6 +93,7 @@ export interface RpcOkMap {
   'edrv.rollback': { path: string; batch: number | null }
   'edrv.debug': object
   'edrv.searchFiles': { files: string[]; truncated: boolean }
+  'edrv.listDir': { root: string; path: string; entries: TreeEntry[] }
   'mcp.list': { servers: MpcServer[] }
   'mcp.save': { server: MpcServer }
   'mcp.remove': object

package/src/store.ts

@@ -223,7 +223,10 @@ export async function appendArchiveEntries(ctx: Ctx, cwd: string, entries: Array
   }
 }
 
-/** 归档记录：标记 archived、按批次写入归档、落盘工作区桶。 */
+/**
+ * 归档记录：标记 archived、按批次写入归档、落盘工作区桶。
+ * @param opts.deferSave 为 true 时只写归档、不落盘桶（由批量调用方统一 saveBucket 一次）
+ */
 export async function archiveRecords(
   ctx: Ctx,
   session: Session,
@@ -231,6 +234,7 @@ export async function archiveRecords(
   bucket: Map<string, DiffRecord>,
   recs: DiffRecord[],
   reason: string,
+  opts?: { deferSave?: boolean },
 ): Promise<void> {
   if (!recs.length) return
   const fresh = recs.filter((r) => !r.archived)
@@ -238,5 +242,5 @@ export async function archiveRecords(
   const entries: Array<ReturnType<typeof archiveEntryFor>> = []
   for (const list of groupByBatch(recs).values()) entries.push(archiveEntryFor(list, cwd, reason))
   await appendArchiveEntries(ctx, cwd, entries, session)
-  if (fresh.length) await saveBucket(ctx, cwd, bucket, session)
+  if (fresh.length && !opts?.deferSave) await saveBucket(ctx, cwd, bucket, session)
 }

package/src/tree.ts

@@ -0,0 +1,62 @@
+/**
+ * dsh-vscode-mode host — 目录树纯函数（edrv.listDir 的数据整形与守卫）。
+ * 不触 fs/node，仅结构类型，可单测；RPC handler 只做装配，判定都收在这里。
+ * 作者 ddj 2026-08-26
+ */
+import type { TreeEntry } from './shared/rpc.js'
+
+/** fs.listDir 返回项的结构最小视图（不引 dsh-fs，保持纯函数零依赖）。 */
+export interface DirChildLike {
+  name: string
+  type: 'file' | 'directory' | 'other'
+  size?: number
+}
+
+/** 目录在文件前、名称按小写字母序的比较器（对齐 VSCode 资源管理器习惯）。 */
+function entryOrder(a: { name: string; type: string }, b: { name: string; type: string }): number {
+  const aDir = a.type === 'directory' ? 0 : 1
+  const bDir = b.type === 'directory' ? 0 : 1
+  if (aDir !== bDir) return aDir - bDir
+  const la = a.name.toLocaleLowerCase('en-US')
+  const lb = b.name.toLocaleLowerCase('en-US')
+  return la < lb ? -1 : la > lb ? 1 : 0
+}
+
+/**
+ * 归一化目录相对路径：去空白、反斜杠→斜杠、去首尾斜杠、`.`→''。
+ * 任一路径段为 `..` 返回 null（拒绝越界）。
+ * @author ddj 2026年08月26号
+ * @param path 原始相对路径（'' 表示根目录）
+ * @returns 归一化相对路径（'' = 根），非法返回 null
+ */
+export function normalizeRel(path: string | undefined | null): string | null {
+  const rel = String(path ?? '').trim().replace(/\\/g, '/').replace(/^\/+|\/+$/g, '')
+  if (!rel) return ''
+  const segs = rel.split('/').filter((seg) => seg !== '.')
+  if (!segs.length) return ''
+  for (const seg of segs) {
+    if (seg === '..') return null
+  }
+  return segs.join('/')
+}
+
+/**
+ * fs.listDir 结果 → TreeEntry 数组：相对路径拼接 + 目录优先排序。
+ * @author ddj 2026年08月26号
+ * @param rel 父目录相对路径（'' = 根）
+ * @param children 目录子项
+ * @returns 排序后的树条目
+ */
+export function toTreeEntries(rel: string, children: DirChildLike[]): TreeEntry[] {
+  const out: TreeEntry[] = []
+  for (const child of children) {
+    if (!child || typeof child.name !== 'string' || !child.name) continue
+    out.push({
+      name: child.name,
+      path: rel ? rel + '/' + child.name : child.name,
+      type: child.type === 'directory' ? 'directory' : child.type === 'file' ? 'file' : 'other',
+      size: typeof child.size === 'number' ? child.size : undefined,
+    })
+  }
+  return out.sort(entryOrder)
+}