dsh-vscode-mode 0.21.4 → 0.23.0

package/src/missingReview.ts

@@ -3,7 +3,7 @@ import { createHash, randomUUID } from 'node:crypto'
 import { resolve } from 'node:path'
 import type { DiffRecord, MissingReview } from './shared/types.js'
 import type { Ctx, Session } from './store.js'
-import { archiveRecords, policyOf, READ_CAP, resolveTargetIn } from './store.js'
+import { archiveRecords, policyOf, READ_CAP, resolveTargetIn, targetPathOf } from './store.js'
 import { hasOfficial } from './reviewDb.js'
 import { recordResolved } from './model.js'
 
@@ -31,13 +31,20 @@ function revisionOf(records: DiffRecord[]): string {
   return createHash('sha256').update(JSON.stringify(evidence)).digest('hex')
 }
 
+/** @private @author ddj 2026年10月30号 @param ctx Host capability. @param target Resolve 结果：宿主路径字符串或不透明 FsTarget。 @returns 平台一致的物理身份；无法还原时返回空串。 */
+function fileKeyOf(ctx: Ctx, target: unknown): string {
+  const path = targetPathOf(ctx, target)
+  return path ? fileKey(path) : ''
+}
+
 /** @private @author ddj 2026年10月28号 @param ctx Host capability. @param cwd Workspace. @param bucket Records. @param target Resolved file. @returns Records for the same physical path spelling, oldest first. */
 async function fileRecords(ctx: Ctx, cwd: string, bucket: Map<string, DiffRecord>, target: string): Promise<DiffRecord[]> {
   const matches: DiffRecord[] = []
-  const identity = fileKey(target)
+  // 解析结果可能是不透明对象，比较前必须先统一还原成宿主路径。
+  const identity = fileKeyOf(ctx, target)
   for (const record of bucket.values()) {
     if (record.superseded) continue
-    if (fileKey(await resolveTargetIn(ctx, cwd, record.path)) === identity) matches.push(record)
+    if (fileKeyOf(ctx, await resolveTargetIn(ctx, cwd, record.path)) === identity) matches.push(record)
   }
   return matches.sort((left, right) => left.at.localeCompare(right.at))
 }
@@ -57,9 +64,12 @@ export async function fileAbsent(ctx: Ctx, cwd: string, path: string): Promise<b
 /** @public @author ddj 2026年10月28号 @param ctx Host. @param session Live session. @param cwd Workspace. @param bucket Records. @param path Requested file. @returns Frozen complete snapshot; never constructs text from hunks or writes files. @throws Missing evidence or nonmissing target. */
 export async function missingReview(ctx: Ctx, session: Session, cwd: string, bucket: Map<string, DiffRecord>, path: string): Promise<MissingReview> {
   const target = await resolveTargetIn(ctx, cwd, path)
-  if (hasOfficial(cwd, path) || hasOfficial(cwd, target)) throw new Error('该文件已有官方审查记录，请使用官方审查入口')
-  if (!await fileAbsent(ctx, cwd, target)) throw new Error('文件已重新出现，请刷新')
-  const records = await fileRecords(ctx, cwd, bucket, target)
+  // 解析结果可能是不透明 FsTarget，凡按路径字符串使用的分支都必须先还原。
+  const abs = targetPathOf(ctx, target)
+  if (!abs) throw new Error('无法解析目标文件路径')
+  if (hasOfficial(cwd, path) || hasOfficial(cwd, abs)) throw new Error('该文件已有官方审查记录，请使用官方审查入口')
+  if (!await fileAbsent(ctx, cwd, abs)) throw new Error('文件已重新出现，请刷新')
+  const records = await fileRecords(ctx, cwd, bucket, abs)
   const latest = records.at(-1)
   if (!records.some((record) => !record.archived && !recordResolved(record))) throw new Error('没有待审历史记录')
   if (!latest || typeof latest.after !== 'string') throw new Error('缺少可靠的完整历史快照，无法展示或恢复；不会用局部差异拼接文件')
@@ -88,33 +98,45 @@ async function applyDisk(ctx: Ctx, item: FrozenReview, target: string, undo: boo
   if (await fs.readText(target) !== item.view.content) throw new Error('恢复内容校验失败，未结清记录')
 }
 
+/**
+ * @author ddj 2026年10月29号
+ * @description: 取删除预览对应的文件路径，供服务端判定该路径是否已由待审投影接管。
+ * @param token 冻结预览 token
+ * @returns 文件路径，token 无效时为 undefined
+ */
+export function missingPath(token: string): string | undefined {
+  return frozen.get(token)?.view.path
+}
+
 /** @public @author ddj 2026年10月28号 @param ctx Host. @param session Requesting session. @param cwd Workspace. @param bucket Records. @param token Frozen preview token. @param operationId Stable retry ID. @param undo True restores shown snapshot; false keeps deletion. @returns Covered call IDs. @throws Changed evidence, concurrent action or sandbox/IO failure. */
 export async function missingDecide(ctx: Ctx, session: Session, cwd: string, bucket: Map<string, DiffRecord>, token: string, operationId: string, undo: boolean): Promise<string[]> {
   const item = frozen.get(token)
   if (!item || item.expires < Date.now() || item.cwd !== cwd || item.session.id !== session.id) throw new Error('删除预览已过期，请刷新后重试')
   if (!operationId || operationId.length > 128) throw new Error('缺少有效操作 ID')
   const target = await resolveTargetIn(ctx, cwd, item.view.path)
-  const key = JSON.stringify([cwd, fileKey(target)])
+  const abs = targetPathOf(ctx, target)
+  if (!abs) throw new Error('无法解析目标文件路径')
+  const key = JSON.stringify([cwd, fileKey(abs)])
   if (locks.has(key)) throw new Error('该文件正在处理，请稍后重试')
   locks.add(key)
   item.session = session
-  try { return await commitMissing(ctx, item, bucket, target, operationId, undo) }
+  try { return await commitMissing(ctx, item, bucket, target, abs, operationId, undo) }
   finally { locks.delete(key) }
 }
 
-/** @private @author ddj 2026年10月28号 @param ctx Host. @param item Frozen preview. @param bucket Live records. @param target Resolved target. @param operationId Retry identity. @param undo Restore action. @returns Archived pending call IDs; disk success survives bookkeeping failure in the same Host lifetime. */
-async function commitMissing(ctx: Ctx, item: FrozenReview, bucket: Map<string, DiffRecord>, target: string, operationId: string, undo: boolean): Promise<string[]> {
+/** @private @author ddj 2026年10月28号 @param ctx Host. @param item Frozen preview. @param bucket Live records. @param target Resolved target. @param abs Host path of the target. @param operationId Retry identity. @param undo Restore action. @returns Archived pending call IDs; disk success survives bookkeeping failure in the same Host lifetime. */
+async function commitMissing(ctx: Ctx, item: FrozenReview, bucket: Map<string, DiffRecord>, target: string, abs: string, operationId: string, undo: boolean): Promise<string[]> {
   const previous = item.operation
   if (previous && (previous.id !== operationId || previous.undo !== undo)) throw new Error('已有不同操作，请刷新后重试')
   if (previous?.done) return item.view.callIds
-  if (hasOfficial(item.cwd, target) || hasOfficial(item.cwd, item.view.path)) throw new Error('该文件已有官方审查记录，请刷新')
-  const records = await fileRecords(ctx, item.cwd, bucket, target)
+  if (hasOfficial(item.cwd, abs) || hasOfficial(item.cwd, item.view.path)) throw new Error('该文件已有官方审查记录，请刷新')
+  const records = await fileRecords(ctx, item.cwd, bucket, abs)
   if (revisionOf(records) !== item.revision) throw new Error('历史记录已变化，请刷新删除预览')
   item.operation ??= { id: operationId, undo, restored: false, done: false }
-  await applyDisk(ctx, item, target, undo)
+  await applyDisk(ctx, item, abs, undo)
 
   // Recheck after awaited IO: capture/another review must not silently join this decision.
-  const current = await fileRecords(ctx, item.cwd, bucket, target)
+  const current = await fileRecords(ctx, item.cwd, bucket, abs)
   if (revisionOf(current) !== item.revision) throw new Error('历史记录已变化，未结清记录，请刷新')
   const pending = current.filter((record) => item.view.callIds.includes(record.callId))
   const decisions = pending.map((record) => record.decisions)

package/src/paths.ts

@@ -204,6 +204,16 @@ export function archiveDbFile(cwd: string, home = dshHome()): string {
   return join(home, PLUGIN_ID, 'data', 'archive', hashOf(cwd) + '.sqlite')
 }
 
+/**
+ * 快捷菜单配置文本（用户数据，不受缓存清理预算约束，跨工作区共享一份）。
+ * @author ddj 2026年10月30号
+ * @param home DSH home（测试可注入）
+ * @returns 快捷菜单配置绝对路径
+ */
+export function quickMenuFile(home = dshHome()): string {
+  return join(home, PLUGIN_ID, 'data', 'quick-menu.json')
+}
+
 /** 插件包 assets 目录（import.meta.url 派生；config.imageDir 可覆盖，见 imageDirOf）。 */
 export function assetsDirOf(moduleUrl: string): string {
   return join(dirname(fileURLToPath(moduleUrl)), '..', 'assets')

package/src/pending/capture.ts

@@ -0,0 +1,165 @@
+/**
+ * 待审差异采集：环绕一次文件写入读取真实前后内容，只有内容确实变化才落库。
+ * @author ddj 2026年10月29号
+ */
+import { cwdOf } from '../registry.js'
+import { resolveTarget } from '../store.js'
+import type { Ctx } from '../store.js'
+import { log } from '../log.js'
+
+/** 可被采信为待审来源的写文件工具。 */
+const WRITE_TOOLS = ['edit', 'write', 'str_replace_editor']
+/** 单文件文本上限：超过即标注 oversized，不静默截断。 */
+const MAX_TEXT = 1024 * 1024
+
+/** 一次已确认的写入。 */
+export interface PendingWrite {
+  cwd: string
+  sessionId: string
+  path: string
+  identity: string
+  before: string | null
+  after: string | null
+  now: number
+}
+
+/** 采集器。 */
+export interface PendingCapture {
+  /** 释放监听并丢弃暂存。 */
+  dispose(): void
+}
+
+/** 采集器的进程内状态：同一目标并发写入时只采信最外层那一次。 */
+interface CaptureState {
+  busy: Set<string>
+  stopped: boolean
+}
+
+/** 工具的写工具参数形状；只取本采集关心的字段。 */
+interface WriteExec {
+  name?: string
+  arguments?: { file_path?: unknown; path?: unknown }
+  agent?: { session?: { id?: string; cwd?: string } }
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 安装写文件采集；读写失败只影响待审来源，绝不影响用户工具本身。
+ * @param ctx Host 生命周期
+ * @param sink 已确认写入的接收方
+ * @returns 可释放的采集器
+ */
+export function installPending(ctx: Ctx, sink: (write: PendingWrite) => void): PendingCapture {
+  const state: CaptureState = { busy: new Set<string>(), stopped: false }
+  ctx.on('tools/execute', (exec: WriteExec, next: () => Promise<unknown>) => aroundTool(ctx, state, sink, exec, next))
+  return {
+    dispose(): void {
+      state.stopped = true
+      state.busy.clear()
+    },
+  }
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 判定本次调用是否值得采集；不值得时返回 null，调用方直接透传原始分发。
+ * @param ctx Host 生命周期
+ * @param state 采集状态
+ * @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)
+  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 }
+}
+
+/** 一次采集所需的固定信息。 */
+interface CapturePlan {
+  cwd: string
+  sessionId: string
+  path: string
+  identity: string
+  before: string | null
+  session: never
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 写工具执行前后各读一次，内容变化才上报；任何采集异常都不改变工具结果。
+ * @param ctx Host 生命周期
+ * @param state 采集状态
+ * @param sink 已确认写入的接收方
+ * @param exec 工具分发上下文
+ * @param next 原始分发
+ * @returns 原始工具结果
+ */
+async function aroundTool(
+  ctx: Ctx, state: CaptureState, sink: (write: PendingWrite) => void,
+  exec: WriteExec, next: () => Promise<unknown>,
+): Promise<unknown> {
+  let plan: CapturePlan | null = null
+  try {
+    plan = await planOf(ctx, state, exec)
+  } catch (error) {
+    log.debug('待审采集跳过：' + String(error))
+  }
+  if (!plan) return next()
+
+  state.busy.add(plan.identity)
+  try {
+    return await next()
+  } finally {
+    state.busy.delete(plan.identity)
+    try {
+      reportWrite(ctx, sink, plan)
+    } catch (error) {
+      log.debug('待审上报失败：' + String(error))
+    }
+  }
+}
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: 写后读回并比较，内容一致视为无净变化不产生条目。
+ * @param ctx Host 生命周期
+ * @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)))
+}
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: 读取全文；缺失或不可读按"无内容"处理，交由上层决定语义。
+ * @param fs 文件系统
+ * @param target 目标
+ * @returns 文本或 null
+ */
+export async function readText(fs: any, target: any): Promise<string | null> {
+  try {
+    return String(await fs.readText(target))
+  } catch (error) {
+    const code = (error as { code?: string }).code
+    if (code === 'ENOENT' || code === 'FS_NOT_FOUND' || code === 'FS_TOO_LARGE') return null
+    throw error
+  }
+}

package/src/pending/decide.ts

@@ -0,0 +1,213 @@
+/**
+ * 待审判定内核：Keep 只推进投影，Revert 才写磁盘；写盘由注入的 writer 完成以便测试零写断言。
+ * @author ddj 2026年10月29号
+ */
+import type { PendingDecide } from '../shared/pendingReview.js'
+import type { ReviewBlock, ReviewBlockState } from '../shared/reviewRegions.js'
+import { reviewBlocks } from '../shared/reviewRegions.js'
+import type { OfficialDiff } from '../shared/review.js'
+import { keepBlock, revertBlock, textDiff } from './hunks.js'
+import type { PendingEntry } from './kernel.js'
+import { applyUpdate, isSettled } from './kernel.js'
+import type { PendingFlags } from './persist.js'
+
+/** 写盘结果：`content` 是读回校验通过后的最终内容，null 表示删除。 */
+export type WriteResult = { ok: true; content: string | null } | { ok: false; reason: string }
+
+/** 写盘能力，由 host 侧实现；纯判定层只调用它一次。 */
+export type WriteBack = (content: string | null) => Promise<WriteResult>
+
+/** 一次判定的输入。 */
+export interface DecideInput {
+  request: PendingDecide
+  entry: PendingEntry
+  flags: PendingFlags
+  blocks: ReviewBlockState[]
+  now: number
+  write: WriteBack
+}
+
+/** 一次判定的输出。 */
+export interface DecideOutcome {
+  ok: boolean
+  reason: string
+  entry: PendingEntry
+  flags: PendingFlags
+  blocks: ReviewBlockState[]
+  /** 是否真正写过磁盘（Keep 恒为 false）。 */
+  wrote: boolean
+}
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: 执行一次 Keep/Revert；失败时返回原状态，调用方不得落库。
+ * @param input 判定输入
+ * @returns 判定结果
+ */
+export async function decide(input: DecideInput): Promise<DecideOutcome> {
+  const failed = (reason: string): DecideOutcome => ({
+    ok: false, reason, entry: input.entry, flags: input.flags, blocks: input.blocks, wrote: false,
+  })
+  if (input.request.revision !== input.flags.revision) return failed('revision-mismatch')
+  if (input.flags.oversized) return failed('oversized')
+  if (input.entry.oldText === input.entry.newText) return failed('settled')
+
+  const diff = textDiff(input.entry.path, input.entry.path, input.entry.oldText, input.entry.newText)
+  const targets = pickBlocks(reviewBlocks(diff), input)
+  if (targets === null) return failed('unknown-block')
+  if (input.request.scope !== 'file' && input.request.scope !== 'all' && targets.length === 0) {
+    return failed('no-block')
+  }
+  const isKeep = input.request.decision === 'accepted'
+  const whole = input.request.scope === 'file' || input.request.scope === 'all'
+  return isKeep ? keep(input, targets, whole) : revert(input, targets, whole)
+}
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: Keep：只把目标块或整文件的新内容并入基线，绝不写目标文件。
+ * @param input 判定输入
+ * @param targets 目标块（整文件时为空）
+ * @param whole 是否整文件
+ * @returns 判定结果
+ */
+function keep(input: DecideInput, targets: ReviewBlock[], whole: boolean): DecideOutcome {
+  if (whole) {
+    const entry = applyUpdate(input.entry, { oldText: input.entry.newText }, input.now)
+    return {
+      ok: true, reason: '', entry, wrote: false,
+      flags: { ...input.flags, revision: input.flags.revision + 1 },
+      blocks: markAll(input.blocks, targets, 'accepted'),
+    }
+  }
+  let oldText = input.entry.oldText
+  for (const block of targets) {
+    const next = keepBlock(oldText, block)
+    if (next === null) {
+      return { ok: false, reason: 'ambiguous-block', entry: input.entry, flags: input.flags, blocks: input.blocks, wrote: false }
+    }
+    oldText = next
+  }
+  const entry = applyUpdate(input.entry, { oldText }, input.now)
+  return {
+    ok: true, reason: '', entry, wrote: false,
+    flags: { ...input.flags, revision: input.flags.revision + 1 },
+    blocks: markAll(input.blocks, targets, 'accepted'),
+  }
+}
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: Revert：合成回退内容后交给 writer 写盘并读回，写失败则状态不变。
+ * @param input 判定输入
+ * @param targets 目标块（整文件时为空）
+ * @param whole 是否整文件
+ * @returns 判定结果
+ */
+async function revert(input: DecideInput, targets: ReviewBlock[], whole: boolean): Promise<DecideOutcome> {
+  const failed = (reason: string): DecideOutcome => ({
+    ok: false, reason, entry: input.entry, flags: input.flags, blocks: input.blocks, wrote: false,
+  })
+  const next = whole ? wholeRevert(input.entry) : blockRevert(input.entry, targets)
+  if (next === undefined) return failed('ambiguous-block')
+
+  const written = await input.write(next)
+  if (!written.ok) return failed(written.reason)
+
+  const entry = applyUpdate(input.entry, { newText: written.content ?? '' }, input.now)
+  return {
+    ok: true, reason: '', entry, wrote: true,
+    flags: { ...input.flags, revision: input.flags.revision + 1, missing: written.content === null },
+    blocks: markAll(input.blocks, targets, 'rejected'),
+  }
+}
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: 整文件回退目标：基线为"文件不存在"时删除，否则写回基线全文。
+ * @param entry 待审条目
+ * @returns 目标内容，null 表示删除
+ */
+function wholeRevert(entry: PendingEntry): string | null {
+  return entry.earlierVersion === 'none' ? null : entry.oldText
+}
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: 块级回退：在最新内容里依次换回目标块，任一不可定位即整体放弃。
+ * @param entry 待审条目
+ * @param targets 目标块
+ * @returns 新内容或 undefined
+ */
+function blockRevert(entry: PendingEntry, targets: ReviewBlock[]): string | null | undefined {
+  let newText = entry.newText
+  for (const block of targets) {
+    const next = revertBlock(newText, block)
+    if (next === null) return undefined
+    newText = next
+  }
+  return newText
+}
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: 按请求粒度挑出目标块；块不存在时返回 null 以区分"没有块"。
+ * @param blocks 当前差异块
+ * @param input 判定输入
+ * @returns 目标块，未知块 ID 时为 null
+ */
+function pickBlocks(blocks: ReviewBlock[], input: DecideInput): ReviewBlock[] | null {
+  const scope = input.request.scope
+  if (scope === 'file' || scope === 'all') return []
+  if (scope === 'block') {
+    const block = blocks.find((item) => item.id === input.request.blockId)
+    return block ? [block] : null
+  }
+  const start = input.request.startLine ?? 0
+  const end = input.request.endLine ?? start
+  return blocks.filter((block) => block.newStart <= end && block.newStart + Math.max(block.newLines.length, 1) >= start)
+}
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: 把目标块标记为已决定；整文件时把全部块一起标记。
+ * @param states 已存块决定
+ * @param targets 目标块
+ * @param decision 决定
+ * @returns 新的块决定列表
+ */
+function markAll(states: ReviewBlockState[], targets: ReviewBlock[], decision: 'accepted' | 'rejected'): ReviewBlockState[] {
+  const next = states.slice()
+  for (const block of targets) {
+    const at = next.findIndex((state) => state.id === block.id)
+    if (at >= 0) next[at] = { id: block.id, decision }
+    else next.push({ id: block.id, decision })
+  }
+  return next
+}
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: 能力口径：Keep 恒可；Revert 受超大/缺失/已解决限制，拒绝原因要能展示。
+ * @param entry 待审条目
+ * @param flags 持久标记
+ * @returns 能力与原因
+ */
+export function capabilityOf(entry: PendingEntry, flags: PendingFlags): { keep: boolean; revert: boolean; reason: string } {
+  if (isSettled(entry)) return { keep: false, revert: false, reason: 'settled' }
+  if (flags.oversized) return { keep: false, revert: false, reason: 'oversized' }
+  if (entry.earlierVersion === 'none' && entry.newText.length === 0) {
+    return { keep: true, revert: false, reason: 'empty-create' }
+  }
+  return { keep: true, revert: true, reason: '' }
+}
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: 供详情接口复用的差异构造。
+ * @param entry 待审条目
+ * @returns 官方差异
+ */
+export function diffOf(entry: PendingEntry): OfficialDiff {
+  return textDiff(entry.path, entry.path, entry.oldText, entry.newText)
+}