dsh-vscode-mode 0.20.0 → 0.20.2

package/src/reviewRpc.ts

@@ -1,6 +1,7 @@
 /** Session-scoped official review RPC. @author ddj 2026年10月26号 */
 import type { RpcHandlerMap } from './shared/rpc.js'
 import { decideReview, reviewDetail, reviewPage } from './reviewDb.js'
+import { undoReview } from './reviewUndo.js'
 import { bucketOf, cwdOfSession, sessionOf } from './registry.js'
 import type { Registry } from './registry.js'
 import type { Ctx } from './store.js'
@@ -27,7 +28,15 @@ export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandler
     },
     'edrv.review.decide': async (args) => {
       const cwd = await workspace(args.sessionId)
-      return { ok: true, ...decideReview(cwd, args) }
+      try {
+        const result = args.decision === 'rejected'
+          ? await undoReview(ctx, sessionOf(ctx, args.sessionId), cwd, args)
+          : decideReview(cwd, args)
+        return { ok: true, ...result }
+      } catch (error) {
+        // Guard failures are review results, not transport failures: preserve their reason.
+        return { ok: false, error: error instanceof Error ? error.message : String(error) }
+      }
     },
   }
 }

package/src/reviewUndo.ts

@@ -0,0 +1,104 @@
+/** Guarded official undo with a durable write-intent journal. @author ddj 2026年10月27号 */
+import { changeBlocks, reviewDb, reviewDetail } from './reviewDb.js'
+import { evidenceBlocks, evidenceText, rawReviewFile } from './reviewEvidence.js'
+import type { ReviewEvidence } from './reviewEvidence.js'
+import type { DecideReview } from './shared/review.js'
+import type { Ctx, Session } from './store.js'
+import { policyOf, resolveTarget } from './store.js'
+
+type OperationRow = { request: string; state: string; result: string | null; evidence: string }
+interface UndoJournal { before: string; after: string }
+const writes = new Map<string, Promise<unknown>>()
+
+/** @public @author ddj 2026年10月27号 @param ctx Host capability. @param session Authenticated caller. @param cwd Workspace. @param request Frozen file/block version. @returns Durable decision; retries reconcile disk hashes and never blindly repeat a write. @throws Missing evidence, stale state, policy or uncertain write failure. */
+export async function undoReview(ctx: Ctx, session: Session, cwd: string, request: DecideReview): Promise<{ revision: number }> {
+  const detail = reviewDetail(cwd, request.id)
+  const key = JSON.stringify([cwd, detail?.item.currentPath ?? request.id])
+  const prior = writes.get(key) ?? Promise.resolve()
+  const operation = prior.catch(() => undefined).then(() => runUndo(ctx, session, cwd, request))
+  writes.set(key, operation)
+  try { return await operation }
+  finally { if (writes.get(key) === operation) writes.delete(key) }
+}
+
+/** @private @author ddj 2026年10月27号 @param ctx Host. @param session Caller. @param cwd Workspace. @param request Frozen decision. @returns Serialized guarded mutation and journal reconciliation. @throws Conflicting bytes or decisions. */
+async function runUndo(ctx: Ctx, session: Session, cwd: string, request: DecideReview): Promise<{ revision: number }> {
+  const db = reviewDb(cwd)
+  const encoded = JSON.stringify(request)
+  if (!request.operationId || request.operationId.length > 128) throw new Error('operationId 无效')
+  const prior = db.prepare('SELECT * FROM review_ops WHERE operation_id=?').get(request.operationId) as OperationRow | undefined
+  if (prior && prior.request !== encoded) throw new Error('operationId 已用于其他请求')
+  if (prior?.state === 'committed') return JSON.parse(prior.result!)
+  const detail = reviewDetail(cwd, request.id)
+  if (!detail || !detail.item.current || detail.item.seq !== request.seq || detail.item.revision !== request.revision
+    || detail.item.decision !== 'pending') throw new Error('审查版本冲突，请刷新后重试')
+  const fs = ctx.get('fs')
+  if (!fs?.readBytes || !fs?.writeText || !fs?.stat) throw new Error('后端缺少受控回滚能力')
+  const target = await resolveTarget(ctx, session, detail.item.currentPath)
+  const info = await fs.stat(target)
+  if (!info || info.type !== 'file' || !info.version) throw new Error('文件不存在或缺少版本守卫，不能安全 Undo')
+  const bytes = await fs.readBytes(target, undefined, 8 * 1024 * 1024)
+  const current = rawReviewFile(bytes)
+  const observed = await fs.stat(target)
+  if (observed?.version !== info.version) throw new Error('文件在回滚读取期间变化，未修改文件')
+  if (prior) {
+    const journal = JSON.parse(prior.evidence) as UndoJournal
+    if (current.hash === journal.after) return finishUndo(cwd, request)
+    if (current.hash !== journal.before) throw new Error('上次 Undo 状态不确定：磁盘既非写前也非写后，禁止重复执行')
+  }
+  const unresolved = db.prepare("SELECT operation_id FROM review_ops WHERE state='prepared' AND json_extract(request,'$.id')=? AND operation_id<>?")
+    .get(request.id, request.operationId)
+  if (unresolved) throw new Error('存在未核对的 Undo，请使用原操作重试，不能创建另一项写入')
+  const row = db.prepare('SELECT payload FROM review_evidence WHERE file_id=?').get(request.id) as { payload: string } | undefined
+  if (!row) throw new Error('该历史记录缺少可信原始字节证据，不能 Undo；差异仍可展示和 Keep')
+  const evidence = JSON.parse(row.payload) as ReviewEvidence
+  const segments = evidenceBlocks(detail.diff, evidence)
+  const texts = evidenceText(evidence)
+  if (!evidence.before.present || !evidence.after.present) throw new Error('当前后端未提供受控原子删除/重建能力')
+  const selected = detail.blocks.filter((block) => block.decision === 'pending' && (request.scope !== 'hunk' || block.id === request.blockId))
+  if (!selected.length) throw new Error('差异块不存在或已处理')
+  // Build the expected disk version by removing only previously rejected blocks.
+  const rejected = new Set(detail.blocks.filter((block) => block.decision === 'rejected').map((block) => block.id))
+  const expected = reverseBlocks(texts.after, segments, rejected)
+  if (rawReviewFile(Buffer.from(expected)).hash !== current.hash) throw new Error('当前文件已被后续编辑，版本与回滚证据冲突，未修改文件')
+  const undo = new Set([...rejected, ...selected.map((block) => block.id)])
+  const next = reverseBlocks(texts.after, segments, undo)
+  const journal = { before: current.hash, after: rawReviewFile(Buffer.from(next)).hash }
+  const latest = reviewDetail(cwd, request.id)
+  if (!latest?.item.current || latest.item.revision !== request.revision || latest.item.decision !== 'pending') {
+    throw new Error('审查版本在回滚校验期间变化，未修改文件')
+  }
+  db.prepare("INSERT INTO review_ops VALUES(?,?,'prepared',NULL,?) ON CONFLICT(operation_id) DO NOTHING")
+    .run(request.operationId, encoded, JSON.stringify(journal))
+  // Provider checks the exact observation inside its atomic mutation critical section.
+  await fs.writeText(target, next, { kind: 'replaceIfVersion', version: info.version }, undefined, policyOf(ctx, session))
+  const written = rawReviewFile(await fs.readBytes(target, undefined, 8 * 1024 * 1024))
+  if (written.hash !== journal.after) throw new Error('Undo 写后内容不确定，请保留原操作重试核对')
+  return finishUndo(cwd, request)
+}
+
+/** @private @author ddj 2026年10月27号 @param text Captured result. @param segments Validated raw ranges. @param rejected Blocks to reverse. @returns Raw storage text preserving unselected blocks. */
+function reverseBlocks(text: string, segments: ReturnType<typeof evidenceBlocks>, rejected: Set<string>): string {
+  let result = text
+  for (const segment of [...segments].reverse()) {
+    if (!rejected.has(segment.id)) continue
+    result = result.slice(0, segment.offset) + segment.before + result.slice(segment.offset + segment.after.length)
+  }
+  return result
+}
+
+/** @private @author ddj 2026年10月27号 @param cwd Workspace. @param request Frozen action. @returns Transactionally committed status, or a retryable prepared journal if the database fails. */
+function finishUndo(cwd: string, request: DecideReview): { revision: number } {
+  const db = reviewDb(cwd)
+  db.exec('BEGIN IMMEDIATE')
+  try {
+    const updated = db.prepare("UPDATE review_files SET revision=revision+1 WHERE id=? AND seq=? AND revision=? AND current=1 AND decision='pending'")
+      .run(request.id, request.seq, request.revision)
+    if (updated.changes !== 1) throw new Error('审查版本冲突，请核对已执行 Undo')
+    changeBlocks(db, request)
+    const result = { revision: request.revision + 1 }
+    db.prepare("UPDATE review_ops SET state='committed',result=? WHERE operation_id=?").run(JSON.stringify(result), request.operationId)
+    db.exec('COMMIT')
+    return result
+  } catch (error) { if (db.isTransaction) db.exec('ROLLBACK'); throw error }
+}

package/src/shared/review.ts

@@ -35,6 +35,7 @@ export interface ReviewSnapshot {
   files: { identity: string; diff: OfficialDiff }[]
 }
 export type ReviewDecision = 'pending' | 'accepted' | 'rejected'
+export type ReviewFileDecision = ReviewDecision | 'mixed'
 export interface ReviewItem {
   id: string
   sessionId: string
@@ -46,7 +47,7 @@ export interface ReviewItem {
   added: number
   deleted: number
   kind: OfficialDiff['kind']
-  decision: ReviewDecision
+  decision: ReviewFileDecision
   revision: number
   current: boolean
 }
@@ -54,6 +55,7 @@ export interface ReviewDetail {
   item: ReviewItem
   diff: OfficialDiff
   capturedAt: string
+  blocks: import('./reviewRegions.js').ReviewBlockState[]
   capability: { keep: boolean; undo: boolean; reason: string }
 }
 export interface CaptureGap {
@@ -86,6 +88,8 @@ export interface DecideReview extends ReviewRequest {
   seq: number
   revision: number
   operationId: string
+  scope?: 'file' | 'hunk'
+  blockId?: string
   decision: 'accepted' | 'rejected'
 }
 export type ReviewResult<T> = ({ ok: true } & T) | { ok: false; error: string }

package/src/shared/reviewRegions.ts

@@ -0,0 +1,74 @@
+/** Official patch parsing shared by review decisions and editor display. @author ddj 2026年10月27号 */
+import type { OfficialDiff, ReviewDecision } from './review.js'
+
+export interface ReviewBlock {
+  id: string
+  hunkIndex: number
+  oldStart: number
+  newStart: number
+  oldLines: string[]
+  newLines: string[]
+  contextBefore: string[]
+  contextAfter: string[]
+}
+export interface ReviewBlockState { id: string; decision: ReviewDecision }
+export interface ReviewRegion extends ReviewBlock {
+  sourceKind: 'official'
+  recordId: string
+  idx: number
+  status: ReviewDecision
+  stale: boolean
+  start?: number
+  end?: number
+}
+
+/** @public @author ddj 2026年10月27号 @param diff Immutable official patch. @returns Contiguous change runs with stable source-coordinate identities. */
+export function reviewBlocks(diff: OfficialDiff): ReviewBlock[] {
+  if (diff.kind !== 'text') return []
+  const blocks: ReviewBlock[] = []
+  for (const [hunkIndex, hunk] of diff.hunks.entries()) {
+    let oldLine = hunk.oldStart, newLine = hunk.newStart
+    let before: string[] = []
+    let current: ReviewBlock | undefined
+    for (const line of hunk.lines) {
+      const marker = line[0], text = line.slice(1)
+      if (marker === ' ') {
+        if (current) { current.contextAfter.push(text); current = undefined }
+        else if (blocks.at(-1)?.hunkIndex === hunkIndex) blocks.at(-1)!.contextAfter.push(text)
+        before.push(text); oldLine++; newLine++
+        continue
+      }
+      if (marker !== '+' && marker !== '-') continue
+      if (!current) {
+        current = { id: `${hunkIndex}:${oldLine}:${newLine}`, hunkIndex, oldStart: oldLine, newStart: newLine,
+          oldLines: [], newLines: [], contextBefore: before.slice(-3), contextAfter: [] }
+        blocks.push(current); before = []
+      }
+      if (marker === '-') { current.oldLines.push(text); oldLine++ }
+      else { current.newLines.push(text); newLine++ }
+    }
+  }
+  return blocks
+}
+
+/** @public @author ddj 2026年10月27号 @param diff Source patch. @param recordId Official record, not a tool call. @param states Persisted per-block decisions. @param content Current editor text; null has no current-file location. @returns Regions only located by unique full contextual matches, never by guessed history line numbers. */
+export function reviewRegions(diff: OfficialDiff, recordId: string, states: ReviewBlockState[], content: string | null): ReviewRegion[] {
+  const lines = content === null ? null : content.replace(/^\uFEFF/, '').replace(/\r\n/g, '\n').split('\n')
+  return reviewBlocks(diff).map((block, idx) => {
+    const status = states.find((state) => state.id === block.id)?.decision ?? 'pending'
+    const region: ReviewRegion = { ...block, sourceKind: 'official', recordId, idx, status, stale: true }
+    if (!lines) return region
+    const pattern = [...block.contextBefore, ...block.newLines, ...block.contextAfter]
+    if (!pattern.length) return region
+    const matches: number[] = []
+    for (let offset = 0; offset + pattern.length <= lines.length; offset++) {
+      if (pattern.every((text, index) => lines[offset + index] === text)) matches.push(offset)
+      if (matches.length > 1) break
+    }
+    if (matches.length !== 1) return region
+    region.start = matches[0] + block.contextBefore.length + 1
+    region.end = region.start + block.newLines.length
+    region.stale = false
+    return region
+  })
+}