dsh-vscode-mode 0.25.1 → 0.27.0

package/src/pending/capture.ts

@@ -2,15 +2,32 @@
  * 待审差异采集：环绕一次文件写入读取真实前后内容，只有内容确实变化才落库。
  * @author ddj 2026年10月29号
  */
-import { cwdOf } from '../registry.js'
-import { resolveTarget } from '../store.js'
+import { cwdOfSession } from '../store.js'
 import type { Ctx } from '../store.js'
 import { log } from '../log.js'
+import { toolTargets, patchDiagnostics } from '../toolTargets.js'
+import { rawText, rawReviewFile } from '../reviewEvidence.js'
 
 /** 可被采信为待审来源的写文件工具。 */
-const WRITE_TOOLS = ['edit', 'write', 'str_replace_editor']
+const WRITE_TOOLS = ['edit', 'write', 'str_replace_editor', 'apply_patch']
 /** 单文件文本上限：超过即标注 oversized，不静默截断。 */
 const MAX_TEXT = 1024 * 1024
+const captureGaps = new Map<string, { cwd: string; sessionId: string; message: string }>()
+
+/** @public @author ddj 2026年11月04号 @param cwd Workspace identity. @returns Bounded runtime-only capture diagnostics. */
+export function pendingGaps(cwd: string): string[] {
+  return [...captureGaps.values()].filter((gap) => gap.cwd === cwd).map((gap) => gap.message)
+}
+
+/** @private @author ddj 2026年11月04号 @param ctx Host scope. @param exec Original call. @param path Failed target. @param error Evidence failure. Records no writable state. */
+function recordGap(scope: { cwd: string; sessionId: string }, exec: WriteExec, path: string, error: unknown): void {
+  const { cwd, sessionId } = scope
+  const key = JSON.stringify([cwd, sessionId, exec.id, path])
+  captureGaps.set(key, { cwd, sessionId, message: path + ': ' + String(error) })
+  const local = [...captureGaps].filter(([, gap]) => gap.cwd === cwd)
+  while (local.length > 50) captureGaps.delete(local.shift()![0])
+  while (captureGaps.size > 500) captureGaps.delete(captureGaps.keys().next().value!)
+}
 
 /** 一次已确认的写入。 */
 export interface PendingWrite {
@@ -33,12 +50,14 @@ export interface PendingCapture {
 interface CaptureState {
   busy: Set<string>
   stopped: boolean
+  disposed: Set<string>
 }
 
 /** 工具的写工具参数形状；只取本采集关心的字段。 */
 interface WriteExec {
+  id?: string
   name?: string
-  arguments?: { file_path?: unknown; path?: unknown }
+  arguments?: { file_path?: unknown; path?: unknown; input?: unknown }
   agent?: { session?: { id?: string; cwd?: string } }
 }
 
@@ -50,12 +69,19 @@ interface WriteExec {
  * @returns 可释放的采集器
  */
 export function installPending(ctx: Ctx, sink: (write: PendingWrite) => void): PendingCapture {
-  const state: CaptureState = { busy: new Set<string>(), stopped: false }
+  const state: CaptureState = { busy: new Set<string>(), stopped: false, disposed: new Set<string>() }
   ctx.on('tools/execute', (exec: WriteExec, next: () => Promise<unknown>) => aroundTool(ctx, state, sink, exec, next))
+  ctx.on('session/disposed', (session: { id: string }) => {
+    state.disposed.add(session.id)
+    for (const [key, gap] of captureGaps) {
+      if (gap.sessionId === session.id) captureGaps.delete(key)
+    }
+  })
   return {
     dispose(): void {
       state.stopped = true
       state.busy.clear()
+      captureGaps.clear()
     },
   }
 }
@@ -68,20 +94,24 @@ export function installPending(ctx: Ctx, sink: (write: PendingWrite) => void): P
  * @param exec 工具分发上下文
  * @returns 采集计划或 null
  */
-async function planOf(ctx: Ctx, state: CaptureState, exec: WriteExec): Promise<CapturePlan | null> {
-  const session = exec.agent?.session
-  const requested = exec.arguments?.file_path ?? exec.arguments?.path
-  if (state.stopped || !session?.id || typeof requested !== 'string') return null
-  if (!WRITE_TOOLS.includes(String(exec.name))) return null
-  const cwd = cwdOf(session as never)
-  if (!cwd) return null
-  const fs = ctx.get('fs')
-  const target = await resolveTarget(ctx, session as never, requested)
+async function planOf(scope: { cwd: string; sessionId: string; fs: any }, state: CaptureState, requested: string): Promise<CapturePlan | null> {
+  const { cwd, sessionId, fs } = scope
+  if (state.stopped || state.disposed.has(sessionId)) return null
+  const target = await fs.resolve(requested, { cwd })
   const identity = fs.processPath(target)
-  if (typeof identity !== 'string' || !identity || state.busy.has(identity)) return null
-  const before = await readText(fs, target)
-  if (before !== null && before.length > MAX_TEXT) return null
-  return { cwd: String(cwd), sessionId: String(session.id), path: requested, identity, before, session: session as never }
+  if (state.stopped || state.disposed.has(sessionId) || typeof identity !== 'string' || !identity || state.busy.has(identity)) return null
+  state.busy.add(identity)
+  try {
+    const before = await readText(fs, target)
+    if (state.stopped || state.disposed.has(sessionId) || (before !== null && before.length > MAX_TEXT)) {
+      state.busy.delete(identity)
+      return null
+    }
+    return { cwd: String(cwd), sessionId, path: requested, identity, before, target, fs }
+  } catch (error) {
+    state.busy.delete(identity)
+    throw error
+  }
 }
 
 /** 一次采集所需的固定信息。 */
@@ -91,7 +121,8 @@ interface CapturePlan {
   path: string
   identity: string
   before: string | null
-  session: never
+  target: unknown
+  fs: any
 }
 
 /**
@@ -108,58 +139,76 @@ async function aroundTool(
   ctx: Ctx, state: CaptureState, sink: (write: PendingWrite) => void,
   exec: WriteExec, next: () => Promise<unknown>,
 ): Promise<unknown> {
-  let plan: CapturePlan | null = null
+  if (state.stopped || !WRITE_TOOLS.includes(String(exec.name))) return next()
+  const session = exec.agent?.session
+  const cwd = session ? cwdOfSession(ctx, session as never) : null
+  if (!session?.id || !cwd) return next()
+  const scope = { cwd, sessionId: session.id, fs: ctx.get('fs') }
+  const plans: CapturePlan[] = []
   try {
-    plan = await planOf(ctx, state, exec)
-  } catch (error) {
-    log.debug('待审采集跳过：' + String(error))
-  }
-  if (!plan) return next()
+    const paths = await toolTargets(exec)
+    for (const path of paths) {
+      try {
+        if (plans.length >= 16) throw new Error('capture target budget exceeded')
+        const plan = await planOf(scope, state, path)
+        if (plan) plans.push(plan)
+      } catch (error) { if (!state.stopped && !state.disposed.has(scope.sessionId)) recordGap(scope, exec, path, error); log.debug('待审采集跳过：' + path + ': ' + String(error)) }
+    }
+  } catch (error) { if (!state.stopped && !state.disposed.has(scope.sessionId)) recordGap(scope, exec, String(exec.name), error); log.debug('待审目标不可用：' + String(error)) }
 
-  state.busy.add(plan.identity)
   try {
-    return await next()
+    const result = await next()
+    if (exec.name === 'apply_patch' && !state.stopped && !state.disposed.has(scope.sessionId)) {
+      for (const diagnostic of patchDiagnostics(result)) recordGap(scope, exec, 'apply_patch', diagnostic)
+    }
+    return result
   } finally {
-    state.busy.delete(plan.identity)
-    try {
-      reportWrite(ctx, sink, plan)
-    } catch (error) {
-      log.debug('待审上报失败：' + String(error))
+    for (const plan of plans) {
+      try { await reportWrite(state, sink, plan) }
+      catch (error) { if (!state.stopped && !state.disposed.has(scope.sessionId)) recordGap(scope, exec, plan.path, error); log.debug('待审上报失败：' + String(error)) }
+      finally { state.busy.delete(plan.identity) }
     }
   }
 }
 
 /**
- * @author ddj 2026年10月29号
- * @description: 写后读回并比较，内容一致视为无净变化不产生条目。
- * @param ctx Host 生命周期
+ * @author ddj 2026年11月04号
+ * @description: 固定目标写后读回；内容一致不产生条目，卸载后不再上报。
+ * @param state 采集生命周期状态
  * @param sink 已确认写入的接收方
  * @param plan 采集计划
  * @returns 无；读回失败只记日志
  */
-function reportWrite(ctx: Ctx, sink: (write: PendingWrite) => void, plan: CapturePlan): void {
-  const fs = ctx.get('fs')
-  void resolveTarget(ctx, plan.session, plan.path).then(async (target: unknown) => {
-    const after = await readText(fs, target)
-    if (after !== null && after.length > MAX_TEXT) return
-    if (plan.before === after) return
-    sink({ cwd: plan.cwd, sessionId: plan.sessionId, path: plan.path, identity: plan.identity, before: plan.before, after, now: Date.now() })
-  }).catch((error: unknown) => log.debug('待审读回失败：' + String(error)))
+async function reportWrite(state: CaptureState, sink: (write: PendingWrite) => void, plan: CapturePlan): Promise<void> {
+  if (state.stopped || state.disposed.has(plan.sessionId)) return
+  // 目录、provider 和目标均在写前冻结，切目录或卸载不能将内容串到其他工作区。
+  const after = await readText(plan.fs, plan.target)
+  if (state.stopped || state.disposed.has(plan.sessionId)) return
+  if (after !== null && after.length > MAX_TEXT) throw new Error('capture text budget exceeded')
+  for (const [key, gap] of captureGaps) {
+    const identity = JSON.parse(key) as unknown[]
+    if (gap.cwd === plan.cwd && gap.sessionId === plan.sessionId && identity[3] === plan.path) captureGaps.delete(key)
+  }
+  if (plan.before === after) return
+  sink({ cwd: plan.cwd, sessionId: plan.sessionId, path: plan.path, identity: plan.identity, before: plan.before, after, now: Date.now() })
 }
 
 /**
  * @author ddj 2026年10月29号
- * @description: 读取全文；缺失或不可读按"无内容"处理，交由上层决定语义。
+ * @description: 读取全文；只有明确缺失返回 null，不可读或超限错误保留失败语义。
  * @param fs 文件系统
  * @param target 目标
  * @returns 文本或 null
  */
-export async function readText(fs: any, target: any): Promise<string | null> {
+export async function readText(fs: any, target: any, signal?: AbortSignal): Promise<string | null> {
   try {
-    return String(await fs.readText(target))
+    if (typeof fs.readBytes === 'function') {
+      return rawText(rawReviewFile(await fs.readBytes(target, signal, MAX_TEXT)))
+    }
+    throw new Error('Raw byte capture unavailable')
   } catch (error) {
     const code = (error as { code?: string }).code
-    if (code === 'ENOENT' || code === 'FS_NOT_FOUND' || code === 'FS_TOO_LARGE') return null
+    if (code === 'ENOENT' || code === 'FS_NOT_FOUND') return null
     throw error
   }
 }

package/src/pending/persist.ts

@@ -107,8 +107,20 @@ export function loadEntries(cwd: string): StoredEntry[] {
  * @returns 无
  */
 export function saveEntry(cwd: string, stored: StoredEntry): void {
+  upsertEntry(pendingDb(cwd), stored)
+}
+
+/**
+ * @private
+ * @author ddj 2026年11月03号
+ * @description: 在给定连接上写入或更新一条条目（含标记），供单条与批量两个入口复用。
+ * @param db 已迁移连接（可能已在事务中）
+ * @param stored 条目与标记
+ * @returns 无
+ */
+function upsertEntry(db: DatabaseSync, stored: StoredEntry): void {
   const { entry, flags } = stored
-  pendingDb(cwd).prepare(`INSERT INTO pending_entries
+  db.prepare(`INSERT INTO pending_entries
     (id,path,earlier,old_text,new_text,updated_at,unseen,missing,diverged,oversized,revision,session_id,session_ids,lineage)
     VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)
     ON CONFLICT(id) DO UPDATE SET path=excluded.path,earlier=excluded.earlier,old_text=excluded.old_text,
@@ -165,9 +177,7 @@ export function saveBlocks(cwd: string, entryId: string, blocks: { id: string; d
   const db = pendingDb(cwd)
   db.exec('BEGIN IMMEDIATE')
   try {
-    db.prepare('DELETE FROM pending_blocks WHERE entry_id=?').run(entryId)
-    const insert = db.prepare('INSERT INTO pending_blocks VALUES(?,?,?)')
-    for (const block of blocks) insert.run(entryId, block.id, block.decision)
+    writeBlocks(db, entryId, blocks)
     db.exec('COMMIT')
   } catch (error) {
     if (db.isTransaction) db.exec('ROLLBACK')
@@ -175,6 +185,21 @@ export function saveBlocks(cwd: string, entryId: string, blocks: { id: string; d
   }
 }
 
+/**
+ * @private
+ * @author ddj 2026年11月03号
+ * @description: 在给定连接上覆盖某条目的块决定集合，供单条与批量两个入口复用。
+ * @param db 已迁移连接（可能已在事务中）
+ * @param entryId 条目身份
+ * @param blocks 块决定
+ * @returns 无
+ */
+function writeBlocks(db: DatabaseSync, entryId: string, blocks: { id: string; decision: string }[]): void {
+  db.prepare('DELETE FROM pending_blocks WHERE entry_id=?').run(entryId)
+  const insert = db.prepare('INSERT INTO pending_blocks VALUES(?,?,?)')
+  for (const block of blocks) insert.run(entryId, block.id, block.decision)
+}
+
 
 /**
  * @author ddj 2026年10月29号
@@ -222,7 +247,21 @@ export function writeOp(
  * @returns 无
  */
 export function pushHistory(cwd: string, kind: string, entryId: string, snapshot: string, now: number): void {
-  const db = pendingDb(cwd)
+  insertHistory(pendingDb(cwd), kind, entryId, snapshot, now)
+}
+
+/**
+ * @private
+ * @author ddj 2026年11月03号
+ * @description: 在给定连接上追加撤销栈记录并截断重做分支，供单条与批量两个入口复用。
+ * @param db 已迁移连接（可能已在事务中）
+ * @param kind 操作种类
+ * @param entryId 涉及的条目
+ * @param snapshot 可重放快照
+ * @param now 时间
+ * @returns 无
+ */
+function insertHistory(db: DatabaseSync, kind: string, entryId: string, snapshot: string, now: number): void {
   db.prepare("DELETE FROM pending_history WHERE state='undone'").run()
   db.prepare("INSERT INTO pending_history(kind,entry_id,snapshot,created_at,state) VALUES(?,?,?,?,'applied')")
     .run(kind, entryId, snapshot, now)
@@ -327,3 +366,53 @@ function flagsOfRow(row: Row): PendingFlags {
     revision: Number(row.revision),
   }
 }
+
+/** 批量 Keep 的一条落库记录：stored 提供 CAS 依据与撤销快照 before，next 是推进后的条目。 */
+export interface KeepRecord {
+  entryId: string
+  stored: StoredEntry
+  next: StoredEntry
+  blocks: { id: string; decision: string }[]
+  snapshot: string
+}
+
+/**
+ * @public
+ * @author ddj 2026年11月03号
+ * @description: 在一次事务内批量推进多条待审条目（批量 Keep 用）。每条按 revision 做 CAS，
+ * 只跳过冲突的那一条，不牵连整批；块决定与撤销快照与单条路径同口径。
+ * @param cwd 工作区
+ * @param records 待落库记录
+ * @returns 因版本已变被跳过的条目
+ * @throws 事务级异常（SQL/程序错误）整体回滚后抛出
+ */
+export function saveDecisions(cwd: string, records: KeepRecord[]): { id: string; reason: string }[] {
+  const db = pendingDb(cwd)
+  const skipped: { id: string; reason: string }[] = []
+  const advance = db.prepare(`UPDATE pending_entries SET path=?,earlier=?,old_text=?,new_text=?,updated_at=?,unseen=?,
+    missing=?,diverged=?,oversized=?,revision=?,session_id=?,session_ids=?,lineage=? WHERE id=? AND revision=?`)
+
+  db.exec('BEGIN IMMEDIATE')
+  try {
+    for (const record of records) {
+      const { entry, flags } = record.next
+      const expected = record.stored.flags.revision
+      const changed = advance.run(entry.path, entry.earlierVersion, entry.oldText, entry.newText, entry.updatedAt,
+        entry.unseen === true ? 1 : 0, flags.missing ? 1 : 0, flags.diverged ? 1 : 0, flags.oversized ? 1 : 0,
+        flags.revision, entry.sessionId, JSON.stringify(entry.sessionIds),
+        entry.lineage ? JSON.stringify(entry.lineage) : null, record.entryId, expected)
+      // 读条目到落库之间被别的决定推进过：只放弃这一条
+      if (changed.changes !== 1) {
+        skipped.push({ id: record.entryId, reason: '待审条目已变化，请重试' })
+        continue
+      }
+      writeBlocks(db, record.entryId, record.blocks)
+      insertHistory(db, 'decide', record.entryId, record.snapshot, Date.now())
+    }
+    db.exec('COMMIT')
+    return skipped
+  } catch (error) {
+    if (db.isTransaction) db.exec('ROLLBACK')
+    throw error
+  }
+}