dsh-vscode-mode 0.4.2 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-vscode-mode",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "DSH 上的类 VSCode 编码体验：Monaco 编辑器（文件页签/QuickOpen/状态栏，可驻 DSH 0.1.5+ 官方右侧 Sidebar 与对话同屏）+ 命令栏（Ctrl+Shift+P）与可扩展指令系统 + VS Code 兼容代码片段（.code-snippets 全局/项目，IntelliSense 展开）+ Agent 编辑差异审查（整文件差异/采纳/拒绝/归档/回滚）+ 语言服务器（LSP）智能（跳转定义/引用/hover/大纲 + VSIX 扩展市场安装），状态持久化到工作区旁车",
   "keywords": [
     "dsh",

package/src/client/diffDock.ts

@@ -38,6 +38,18 @@ export function editorDockMode(activePath: string | null | undefined): 'editor'
   return activePath ? 'editor' : 'editor-empty'
 }
 
+/**
+ * 文件是否仍可执行 Keep/Undo：可定位差异与无法定位的冲突差异都算待处理。
+ * 冲突差异的 newText 已不在文件中（被后续修改覆盖），由 host 按"已不存在"记录决策。
+ * @author ddj 2026年09月15号
+ * @param pendingCount 可定位的待处理差异数
+ * @param staleCount 无法定位（冲突）的待处理差异数
+ * @returns 两者任一大于 0 时为 true
+ */
+export function canDecideFile(pendingCount: number, staleCount: number): boolean {
+  return Math.max(0, pendingCount) + Math.max(0, staleCount) > 0
+}
+
 /**
  * 获取切换文件期间稳定展示的文件内差异数量。
  * @author ddj 2026年08月26号

package/src/client/ui/DiffBox.ts

@@ -6,7 +6,7 @@
  */
 import React from 'react'
 import { callIdAttr } from '../state/records.js'
-import { diffDockText } from '../diffDock.js'
+import { canDecideFile, diffDockText } from '../diffDock.js'
 import { badgeOf } from './shared.js'
 
 /**
@@ -48,6 +48,8 @@ export function DiffBox(props) {
   const [detailsOpen, setDetailsOpen] = React.useState(false)
   const detailsId = React.useId()
   const canAct = pendingRegions.length > 0
+  // Keep/Undo 覆盖无法定位的冲突差异：它们仍占待处理列表，但不在 pendingRegions 内
+  const canDecide = canDecideFile(pendingRegions.length, staleRegions.length)
 
   const base = String(activePath || '').split(/[\\/]/).pop() || ''
 
@@ -114,8 +116,8 @@ export function DiffBox(props) {
           React.createElement('span', { className: 'edrv-diffbar-file edrv-diffbar-summary', title: activePath || '' }, base)),
 
         React.createElement('div', { className: 'edrv-diffbar-actions' },
-          React.createElement('button', { className: 'edrv-pill edrv-pill-keep', title: '采纳当前文件的全部差异', disabled: !canAct, onClick: onAcceptFile }, '✓ Keep'),
-          React.createElement('button', { className: 'edrv-pill edrv-pill-undo', title: '不采纳当前文件的全部差异（回滚）', disabled: !canAct, onClick: onUndoFile }, '↩ Undo'),
+          React.createElement('button', { className: 'edrv-pill edrv-pill-keep', title: '采纳当前文件的全部差异', disabled: !canDecide, onClick: onAcceptFile }, '✓ Keep'),
+          React.createElement('button', { className: 'edrv-pill edrv-pill-undo', title: '不采纳当前文件的全部差异（回滚）', disabled: !canDecide, onClick: onUndoFile }, '↩ Undo'),
           React.createElement('button', {
             className: 'edrv-pill edrv-pill-ghost edrv-diff-details-toggle',
             title: detailsOpen ? '收起差异操作' : '展开差异操作',

package/src/client/ui/EditorView.ts

@@ -226,6 +226,8 @@ export function EditorView(props) {
   // useMemo 稳定引用：否则 hover 等重渲染会让 view zone effect 反复重建（- 号闪烁）
   const pendingRegions = React.useMemo(() => regions.filter((r) => r.status === ST.PENDING && !r.stale), [regions])
   const staleRegions = React.useMemo(() => regions.filter((r) => r.status === ST.PENDING && r.stale), [regions])
+  // 单文件 Keep/Undo 的作用域：可定位差异 + 无法定位的冲突差异（后者否则永久留在待处理列表）
+  const decideRegions = React.useMemo(() => [...pendingRegions, ...staleRegions], [pendingRegions, staleRegions])
   hoverRegionsRef.current = pendingRegions
   // 行 → 差异区域 映射（hover O(1) 命中；每行归属其区域）
   const lineRegionMap = React.useMemo(() => {
@@ -1591,21 +1593,23 @@ export function EditorView(props) {
    * 单次 setRecords 合并全部结果，避免逐条往返读写整个 sidecar。
    * @author ddj 2026年08月25号
    * @param items 决策项数组（callId/scope/hunkIndex/decision）
-   * @returns Promise<{ok:number; fail:number}> 成功/失败计数
+   * @returns Promise<{ok:number; fail:number; stale:number}> 成功/失败/已不存在计数
    */
   const actMany = (items) => {
-    if (!items.length) return Promise.resolve({ ok: 0, fail: 0 })
+    if (!items.length) return Promise.resolve({ ok: 0, fail: 0, stale: 0 })
     return rpc('edrv.decideBatch', { sessionId, items }).then((res) => {
       if (!res || !res.ok || !Array.isArray(res.results)) {
         setError(res?.error ? String(res.error) : '批量处理失败')
-        return { ok: 0, fail: items.length }
+        return { ok: 0, fail: items.length, stale: 0 }
       }
       let ok = 0
       let fail = 0
+      let stale = 0
       const next = {}
       for (const item of res.results) {
         if (item && item.ok) {
           ok++
+          if (item.stale === true) stale++
           if (item.record) next[item.callId] = item.record
         } else {
           fail++
@@ -1614,13 +1618,25 @@ export function EditorView(props) {
       // 合并结果无变化（批量全部失败/重复点击）时不 setRecords：避免 records 换引用
       // → pendingRegions 换引用 → diff 全量重渲染（内容相同，纯空转）
       if (Object.keys(next).length) setRecords((prev) => Object.assign({}, prev, next))
-      return { ok, fail }
+      return { ok, fail, stale }
     }).catch((e) => {
       setError('批量处理异常:' + String(e))
-      return { ok: 0, fail: items.length }
+      return { ok: 0, fail: items.length, stale: 0 }
     })
   }
 
+  /**
+   * 批量决策状态文案（含"差异已不存在于文件"提示）。
+   * @author ddj 2026年09月15号
+   * @param prefix 动作前缀（已采纳/已不采纳）
+   * @param result 批量决策计数
+   * @returns 状态栏文案
+   */
+  const decideStatus = (prefix, result) => {
+    const text = prefix + result.ok + ' 处差异' + (result.fail ? '，' + result.fail + ' 处失败' : '')
+    return result.stale ? text + '（其中 ' + result.stale + ' 处已不存在于文件，未改动）' : text
+  }
+
   /**
    * 决策项构造（与单条 actHunk 的 scope 语义一致：create 记录走 call 作用域）。
    * @author ddj 2026年08月25号
@@ -1631,25 +1647,25 @@ export function EditorView(props) {
   const itemOf = (r, reject) => ({ callId: r.callId, scope: r.create ? 'call' : 'hunk', hunkIndex: r.idx, decision: reject ? 'rejected' : 'accepted' })
 
   const acceptFile = () => {
-    if (batchBusyRef.current || !pendingRegions.length) return
+    if (batchBusyRef.current || !decideRegions.length) return
     batchBusyRef.current = true
-    actMany(pendingRegions.map((r) => itemOf(r, false))).then(({ ok, fail }) => {
+    actMany(decideRegions.map((r) => itemOf(r, false))).then((result) => {
       batchBusyRef.current = false
       reloadFile(true)
       emitRefresh()
-      setStatus('已采纳 ' + ok + ' 处差异' + (fail ? '，' + fail + ' 处失败' : ''))
-      if (fail) setError(fail + ' 处差异处理失败（可能已被后续修改影响），可刷新后重试')
+      setStatus(decideStatus('已采纳 ', result))
+      if (result.fail) setError(result.fail + ' 处差异处理失败（可能已被后续修改影响），可刷新后重试')
     }).catch(() => { batchBusyRef.current = false })
   }
   const undoFile = () => {
-    if (batchBusyRef.current || !pendingRegions.length) return
+    if (batchBusyRef.current || !decideRegions.length) return
     batchBusyRef.current = true
-    actMany([...pendingRegions].reverse().map((r) => itemOf(r, true))).then(({ ok, fail }) => {
+    actMany([...decideRegions].reverse().map((r) => itemOf(r, true))).then((result) => {
       batchBusyRef.current = false
       reloadFile(true)
       emitRefresh()
-      setStatus('已不采纳 ' + ok + ' 处差异' + (fail ? '，' + fail + ' 处失败' : ''))
-      if (fail) setError(fail + ' 处差异处理失败（可能已被后续修改影响），可刷新后重试')
+      setStatus(decideStatus('已不采纳 ', result))
+      if (result.fail) setError(result.fail + ' 处差异处理失败（可能已被后续修改影响），可刷新后重试')
     }).catch(() => { batchBusyRef.current = false })
   }
 
@@ -1677,12 +1693,12 @@ export function EditorView(props) {
     if (batchBusyRef.current || !allPending.length) return
     batchBusyRef.current = true
     const list = reject ? [...allPending].sort((a, b) => (a.at < b.at ? 1 : a.at > b.at ? -1 : b.idx - a.idx)) : allPending
-    actMany(list.map((r) => itemOf(r, reject))).then(({ ok, fail }) => {
+    actMany(list.map((r) => itemOf(r, reject))).then((result) => {
       batchBusyRef.current = false
       reloadFile(true)
       emitRefresh()
-      setStatus((reject ? '已不采纳 ' : '已采纳 ') + ok + ' 处差异' + (fail ? '，' + fail + ' 处失败' : ''))
-      if (fail) setError(fail + ' 处差异处理失败（可能已被后续修改影响），可刷新后重试')
+      setStatus(decideStatus(reject ? '已不采纳 ' : '已采纳 ', result))
+      if (result.fail) setError(result.fail + ' 处差异处理失败（可能已被后续修改影响），可刷新后重试')
     }).catch(() => { batchBusyRef.current = false })
   }
   const acceptAllFiles = () => actAllPending(false)

package/src/revert.ts

@@ -8,7 +8,8 @@ import type { Ctx, Session } from './store.js'
 import { policyOf, resolveTarget } from './store.js'
 import { applyLocations, locateHunks, preciseHunk } from './shared/diff.js'
 
-export type Result = { ok: true } | { ok: false; error: string }
+/** 回滚结果；stale=true 表示该 hunk 的新文本已不在文件中（无可回滚内容，不算失败）。 */
+export type Result = { ok: true } | { ok: false; error: string; stale?: boolean }
 
 /**
  * 删除新建文件（拒绝创建时）：subprocess 删除，路径先经 fs.contains 校验工作区边界。
@@ -81,7 +82,8 @@ export async function revertHunk(ctx: Ctx, session: Session, record: DiffRecord,
     if ((info.size ?? 0) > 8 * 1024 * 1024) return { ok: false, error: '回滚失败：文件过大，无法安全定位' }
     const content = await fs.readText(target)
     const location = locateHunks(content, [precise])[0]
-    if (!location?.matched) return { ok: false, error: '回滚失败：该区域可能已被后续修改影响' }
+    // 新文本已不在文件中（被后续修改覆盖/撤销）：不采纳的目标已达成，标记 stale 供调用方按"已回滚"记录决策
+    if (!location?.matched) return { ok: false, stale: true, error: '回滚失败：该区域在文件中已不存在（可能已被后续修改覆盖）' }
     const result = applyLocations(content, [location], true)
     await fs.writeText(target, result.content, void 0, void 0, policyOf(ctx, session))
     return { ok: true }

package/src/rpc.ts

@@ -137,8 +137,9 @@ async function afterManualSave(
 
 /**
  * 批量决策核心：一次会话/桶解析 + 逐项处理 + 统一落盘（accept/reject 单条与 decideBatch 共用）。
- * rejected 项先做回滚，失败记入该项 error 且不改决策；本批次新增"已解决"记录一次性归档，
- * 有任何成功项则整桶只写盘一次，避免逐条读写整个 sidecar。
+ * rejected 项先做回滚，失败记入该项 error 且不改决策；hunk 的新文本已不在文件中
+ * （被后续修改覆盖/撤销）时不算失败：不写文件，按已回滚记录决策并归档（结果项带 stale）。
+ * 本批次新增"已解决"记录一次性归档，有任何成功项则整桶只写盘一次，避免逐条读写整个 sidecar。
  * @author ddj 2026年08月25号
  * @param items 决策项（按数组顺序处理，rejected 的先后即回滚顺序）
  * @returns 逐项结果（ok 项含更新后的记录视图）
@@ -159,19 +160,25 @@ async function applyDecisions(
       results.push({ callId: item.callId, ok: false, error: '记录不存在' })
       continue
     }
+    let revertedStale = false
     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
+        if (scope !== 'hunk' || outcome.stale !== true) {
+          results.push({ callId: item.callId, ok: false, error: outcome.error })
+          continue
+        }
+        revertedStale = true
       }
     }
     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) })
+    const result: DecideResult = { callId: item.callId, ok: true, record: recView(record) }
+    if (revertedStale) result.stale = true
+    results.push(result)
   }
   if (resolved.length) {
     const reason = items.some((item) => item.decision === 'rejected') ? '已处理（回滚）' : '已处理'

package/src/shared/rpc.ts

@@ -151,6 +151,8 @@ export interface DecideResult {
   ok: boolean
   error?: string
   record?: RecordView
+  /** 不采纳时该 hunk 的新文本已不在文件中（未改动文件，仅记录决策）。 */
+  stale?: boolean
 }
 
 /** 每个方法的请求参数（sessionId 为公共可选字段）。 */