dsh-vscode-mode 0.14.2 → 0.14.4

package/src/shared/diff.ts

@@ -127,18 +127,43 @@ export function lineBefore(text: string, index: number): number {
   return n
 }
 
-/** 找出文本的全部非重叠出现位置。 */
-function allMatches(content: string, needle: string): TextRange[] {
-  if (!needle.length) return []
-  const out: TextRange[] = []
-  let from = 0
-  while (from <= content.length - needle.length) {
-    const at = content.indexOf(needle, from)
-    if (at < 0) break
-    out.push({ start: at, end: at + needle.length })
-    from = at + Math.max(1, needle.length)
+/** 每种搜索串只推进一次，保持原来从头开始的非重叠匹配顺序。 */
+interface MatchState {
+  ranges: TextRange[]
+  next: number
+  done: boolean
+}
+
+/**
+ * 懒扫描候选：先找 cursor 后未占用项，找不到再回退至首个未占用项。
+ * @author ddj 2026年09月29号
+ * @param content 当前内容
+ * @param needle 搜索串
+ * @param cursor 前一块的结束位置
+ * @param occupied 已选区间
+ * @param state 此搜索串已扫描的候选
+ * @returns 与完整候选列表双轮查找相同的匹配
+ */
+function findCandidate(content: string, needle: string, cursor: number, occupied: TextRange[], state: MatchState): TextRange | undefined {
+  if (!needle.length) return undefined
+  let fallback: TextRange | undefined
+  for (let i = 0; i < state.ranges.length; i++) {
+    const range = state.ranges[i]
+    if (occupied.some((used) => overlaps(range, used))) continue
+    if (range.start >= cursor) return range
+    if (!fallback) fallback = range
+  }
+  while (!state.done) {
+    const at = content.indexOf(needle, state.next)
+    if (at < 0) { state.done = true; break }
+    const range = { start: at, end: at + needle.length }
+    state.ranges.push(range)
+    state.next = range.end
+    if (occupied.some((used) => overlaps(range, used))) continue
+    if (range.start >= cursor) return range
+    if (!fallback) fallback = range
   }
-  return out
+  return fallback
 }
 
 /**
@@ -153,6 +178,7 @@ export function locateHunks(content: string, hunks: Hunk[]): HunkLocation[] {
   const locations: HunkLocation[] = []
   let cursor = 0
   const occupied: TextRange[] = []
+  const matches = new Map<string, MatchState>()
   for (let idx = 0; idx < hunks.length; idx++) {
     const hunk = hunks[idx]
     const newText = hunk.newText
@@ -163,9 +189,14 @@ export function locateHunks(content: string, hunks: Hunk[]): HunkLocation[] {
       && (newText.length === 0 || content.slice(snapshot.start, snapshot.end) === newText)
       ? snapshot
       : null
-    const candidates = snapshotMatches ? [snapshotMatches] : allMatches(content, newText)
-    const candidate = candidates.find((range) => range.start >= cursor && !occupied.some((used) => overlaps(range, used)))
-      ?? candidates.find((range) => !occupied.some((used) => overlaps(range, used)))
+    let candidate: TextRange | undefined
+    if (snapshotMatches) {
+      if (!occupied.some((used) => overlaps(snapshotMatches, used))) candidate = snapshotMatches
+    } else if (newText.length) {
+      let state = matches.get(newText)
+      if (!state) { state = { ranges: [], next: 0, done: false }; matches.set(newText, state) }
+      candidate = findCandidate(content, newText, cursor, occupied, state)
+    }
     if (candidate) {
       locations.push({ idx, hunk, ...candidate, matched: true })
       occupied.push(candidate)
@@ -205,15 +236,33 @@ export function replaceRange(content: string, location: HunkLocation, reverse =
   return content.slice(0, location.start) + replacement + content.slice(location.end)
 }
 
-/** 按当前内容中出现的位置从后向前应用 hunk，避免前块长度变化影响后块。 */
+/**
+ * 按位置倒序收集片段，最后一次拼接；非互斥区间退回原替换语义。
+ * @author ddj 2026年09月29号
+ * @param content 当前文件内容
+ * @param locations 已定位区间
+ * @param reverse 是否反向应用
+ * @returns 合成内容及失效块索引
+ */
 export function applyLocations(content: string, locations: HunkLocation[], reverse = false): { content: string; stale: number[] } {
   const stale = locations.filter((location) => !location.matched).map((location) => location.idx)
-  let out = content
   const matched = locations.filter((location) => location.matched).sort((a, b) => b.start - a.start)
+  const parts: string[] = []
+  let end = content.length
   for (const location of matched) {
-    const next = replaceRange(out, location, reverse)
-    if (next === null) stale.push(location.idx)
-    else out = next
+    if (location.start < 0 || location.end > end) {
+      let out = content
+      for (const item of matched) {
+        const next = replaceRange(out, item, reverse)
+        if (next === null) stale.push(item.idx)
+        else out = next
+      }
+      return { content: out, stale: stale.sort((a, b) => a - b) }
+    }
+    parts.push(content.slice(location.end, end), reverse ? (location.hunk.oldText ?? '') : location.hunk.newText)
+    end = location.start
   }
-  return { content: out, stale: stale.sort((a, b) => a - b) }
+  parts.push(content.slice(0, end))
+  parts.reverse()
+  return { content: parts.join(''), stale: stale.sort((a, b) => a - b) }
 }

package/src/shared/mcpStatus.ts

@@ -0,0 +1,30 @@
+import type { MpcServer } from './mcp.js'
+
+type ServerStatus = Pick<MpcServer, 'enabled' | 'status'>
+export type McpTone = 'connected' | 'connecting' | 'disabled' | 'error' | 'neutral'
+
+/**
+ * @public
+ * @author ddj 2026年10月08号
+ * @description Display lifecycle evidence; enabled only expresses configuration intent, not connectivity.
+ * @param server Server lifecycle snapshot.
+ * @returns User-facing status label.
+ */
+export function statusOf(server: ServerStatus): string {
+  if (!server.enabled || server.status === 'disabled') return '已禁用'
+  const labels = { connected: '在线', connecting: '装配中', configured: '已配置，等待会话', unverified: '已加载，连接未确认', error: '错误' }
+  return labels[server.status] ?? '状态未知'
+}
+
+/**
+ * @public
+ * @author ddj 2026年10月08号
+ * @description Use neutral styling unless lifecycle evidence explicitly identifies online, loading or error.
+ * @param server Server lifecycle snapshot.
+ * @returns CSS tone, independent of configuration-enabled state.
+ */
+export function statusTone(server: ServerStatus): McpTone {
+  if (!server.enabled || server.status === 'disabled') return 'disabled'
+  if (server.status === 'connected' || server.status === 'connecting' || server.status === 'error') return server.status
+  return 'neutral'
+}

package/src/shared/rpc.ts

@@ -275,7 +275,12 @@ export interface PerfMoveFailure {
 export interface SidecarPerfSummary {
   active: number
   pendingByFile: { path: string; pending: number }[]
+  /** 新版 SQLite 主库 + WAL 文件字节数。 */
   archiveBytes: number
+  /** 旧 JSON 历史体积；不计入新归档。 */
+  legacyArchiveBytes: number
+  /** 旧活跃 JSON 只读快照体积。 */
+  legacyActiveBytes: number
 }
 // --endregion
 
@@ -362,7 +367,8 @@ export interface RpcRequestMap {
   'edrv.save': { sessionId?: string; path: string; content: string; rev?: string }
   'edrv.saveBinary': { sessionId?: string; path: string; content: string; encoding: 'base64' }
   'edrv.archiveList': { sessionId?: string }
-  'edrv.archiveRead': { sessionId?: string; path?: string }
+  'edrv.archivePage': { sessionId?: string; cursor?: string; limit?: number }
+  'edrv.archiveRead': { sessionId?: string; path?: string; batch?: number | null }
   'edrv.rollback': { sessionId?: string; path: string; batch?: number }
   'edrv.debug': { sessionId?: string; text: string; level?: LoggerLevel }
   'edrv.dlog.list': { sessionId?: string }
@@ -380,6 +386,7 @@ export interface RpcRequestMap {
   'edrv.fsCopy': { sessionId?: string; from: string; toDir: string }
   'edrv.fsMove': { sessionId?: string; from: string; toDir: string }
   'mcp.list': {}
+  'mcp.snapshot': {}
   'mcp.save': { config: MpcConfig }
   'mcp.remove': { id: string }
   'mcp.toggle': { id: string; enabled: boolean }
@@ -520,6 +527,7 @@ export interface RpcOkMap {
   'edrv.save': { rev?: string; conflict?: boolean }
   'edrv.saveBinary': object
   'edrv.archiveList': { entries: ArchiveEntry[] }
+  'edrv.archivePage': { entries: ArchiveEntry[]; nextCursor: string | null }
   'edrv.archiveRead': { batches: ArchiveBatch[] }
   'edrv.rollback': { path: string; batch: number | null }
   'edrv.debug': object
@@ -538,6 +546,7 @@ export interface RpcOkMap {
   'edrv.fsCopy': { from: string; to: string }
   'edrv.fsMove': { from: string; to: string }
   'mcp.list': { servers: MpcServer[] }
+  'mcp.snapshot': { servers: MpcServer[]; projects: MpcProject[] }
   'mcp.save': { server: MpcServer }
   'mcp.remove': object
   'mcp.toggle': { server: MpcServer }

package/src/store.ts

@@ -3,17 +3,21 @@
  * 迁移自原 src/index.ts 的 fs/ctx IO 部分，语义一字不改。
  * 作者 ddj 2026-08-20
  */
-import type { ArchiveBatch, ArchiveData, DiffRecord, SidecarData } from './shared/types.js'
+import type { ArchiveBatch, DiffRecord, SidecarData } from './shared/types.js'
 import type { ReadState } from './shared/diff.js'
 import { fingerprint, isNoopHunk, locateHunks, normalizeForCompare, normalizeHunk, preciseHunk } from './shared/diff.js'
-import { archiveEntryFor, groupByBatch, normalizeRecord } from './model.js'
+import { archiveEntryFor, normalizeRecord } from './model.js'
 import { SIDECAR, SIDECAR_ARCHIVE } from './paths.js'
 import { log } from './log.js'
+import { debugRecord } from './debugLog.js'
+import { activeReady, appendArchive, checkActiveSource, commitActive, committedRecord, migrateActive, restoreReverts, type ActiveChange } from './archiveDb.js'
 
 export { SIDECAR, SIDECAR_ARCHIVE }
 export const READ_CAP = 8 * 1024 * 1024
 /** 二进制预览/写回上限（PDF 等整文件 base64 传输；文本侧仍用 READ_CAP）。 */
 export const BINARY_READ_CAP = 32 * 1024 * 1024
+/** 旧文件首次全量指纹核验后，每次操作优先检查 DSH fs stat 身份。 */
+const sourceStats = new Map<string, string>()
 
 /** DSH 上下文与会话类型较宽松：本地无 dsh 类型声明，显式 any + 文档约束。 */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -76,33 +80,88 @@ export function parseSidecar(text: string | null): SidecarData | null {
   }
 }
 
-/** 加载某工作区的记录桶（内存 Map；缺失 → 空）。 */
+/**
+ * 严格读取旧 sidecar：仅确认确实不存在时才允许从空记录迁移。
+ * @author ddj 2026年09月30号
+ * @param ctx DSH 上下文
+ * @param cwd 工作区
+ * @returns 旧文件内容或确认缺失
+ */
+async function migrationText(ctx: Ctx, cwd: string): Promise<string | null> {
+  const fs = ctx.get('fs')
+  if (!fs) throw new Error('无法迁移差异记录：缺少 fs')
+  const target = await fs.resolve(SIDECAR, { cwd })
+  const info = await fs.stat(target)
+  if (!info) return null
+  if (info.type !== 'file') throw new Error('旧活跃 sidecar 非文件')
+  return fs.readText(target)
+}
+
+/**
+ * 读取旧 sidecar 文件的版本身份；缺少可靠版本令牌时返回 null 走全文核验。
+ * @author ddj 2026年09月30号
+ * @param ctx DSH 上下文
+ * @param cwd 工作区
+ * @returns 文件身份或 null
+ */
+async function sourceStat(ctx: Ctx, cwd: string): Promise<string | null> {
+  const fs = ctx.get('fs')
+  if (!fs) throw new Error('无法核验旧 sidecar：缺少 fs')
+  const info = await fs.stat(await fs.resolve(SIDECAR, { cwd }))
+  if (!info) return 'absent'
+  const version = info.version ?? info.rev
+  return typeof version === 'string' && version.length ? version : null
+}
+
+/**
+ * 首次读取旧文件全文确认数据库来源，后续只在 stat 版本变动时重新核验。
+ * @author ddj 2026年09月30号
+ * @param ctx DSH 上下文
+ * @param cwd 工作区
+ */
+async function checkSource(ctx: Ctx, cwd: string): Promise<void> {
+  const now = await sourceStat(ctx, cwd)
+  if (now !== null && sourceStats.get(cwd) === now) return
+  checkActiveSource(cwd, await migrationText(ctx, cwd))
+  if (now !== null) sourceStats.set(cwd, now)
+}
+
+/** 加载某工作区的记录桶（内存 Map；首次在隔离切换窗口严格迁移）。 */
 export async function loadBucket(ctx: Ctx, cwd: string): Promise<Map<string, DiffRecord>> {
-  const text = await readSidecarText(ctx, cwd)
-  const data = parseSidecar(text)
-  const map = new Map<string, DiffRecord>()
-  if (data && data.workspaces[cwd] && typeof data.workspaces[cwd].records === 'object') {
-    for (const rec of Object.values(data.workspaces[cwd].records)) {
-      const n = normalizeRecord(rec)
-      if (n) map.set(n.callId, n)
+  const source = await migrationText(ctx, cwd)
+  const map = await migrateActive(cwd, source, () => migrationText(ctx, cwd))
+  await checkSource(ctx, cwd)
+  for (const rec of map.values()) {
+    if (rec.archived) continue
+    const previous = JSON.stringify(rec)
+    restoreReverts(cwd, rec)
+    const committed = committedRecord(cwd, rec.callId, rec.path, rec.batch ?? null)
+    if (committed) {
+      rec.decisions = committed.decisions
+      rec.superseded = committed.superseded
+      rec.archived = true
     }
+    if (JSON.stringify(rec) !== previous) commitActive(cwd, { upserts: [rec], removed: [] })
   }
   return map
 }
 
-/** 保存某工作区的记录桶（写前合并，不覆盖其他工作区）。 */
-export async function saveBucket(ctx: Ctx, cwd: string, recsMap: Map<string, DiffRecord>, session?: Session): Promise<void> {
-  const fs = ctx.get('fs')
-  if (!fs || !cwd) return
+/**
+ * 仅把明确变动的记录行写入 SQLite；旧 sidecar 不再写入。
+ * @author ddj 2026年09月30号
+ * @param ctx DSH 上下文
+ * @param cwd 工作区
+ * @param recsMap 供当前调用点核对的记录桶
+ * @param session 会话（保留旧 API）
+ * @param changes 明确的更新和删除集合
+ */
+export async function saveBucket(ctx: Ctx, cwd: string, recsMap: Map<string, DiffRecord>, session?: Session, changes?: ActiveChange): Promise<void> {
+  if (!changes) throw new Error('增量保存缺少变更集合')
+  for (const rec of changes.upserts) if (recsMap.get(rec.callId) !== rec) throw new Error('增量记录不在工作区桶内')
   try {
-    const target = await fs.resolve(SIDECAR, { cwd })
-    const existing = parseSidecar(await readSidecarText(ctx, cwd)) ?? { version: 2, updatedAt: '', workspaces: {} } as SidecarData
-    existing.workspaces[cwd] = { at: Date.now(), records: Object.fromEntries(recsMap) }
-    existing.updatedAt = new Date().toISOString()
-    await fs.writeText(target, JSON.stringify(existing), void 0, void 0, policyOf(ctx, session))
-  } catch (error) {
-    log.error('saveBucket failed: ' + String(error))
-  }
+    await checkSource(ctx, cwd)
+    commitActive(cwd, changes)
+  } catch (error) { log.error('saveBucket failed: ' + String(error)); throw error }
 }
 
 /**
@@ -172,8 +231,18 @@ export async function autoArchiveStale(ctx: Ctx, session: Session, cwd: string,
     if (await recordIsStale(ctx, session, cache, rec)) stale.push(rec)
   }
   if (!stale.length) return 0
+  const original = stale.map((rec) => ({ rec, at: rec.at, superseded: rec.superseded }))
   for (const r of stale) { r.superseded = true; r.at = new Date().toISOString() }
-  await archiveRecords(ctx, session, cwd, bucket, stale, '差异无法定位（已被后续修改覆盖），自动归档')
+  try {
+    await archiveRecords(ctx, session, cwd, bucket, stale, '差异无法定位（已被后续修改覆盖），自动归档')
+  } catch (error) {
+    for (const item of original) {
+      if (item.rec.archived) continue
+      item.rec.superseded = item.superseded
+      item.rec.at = item.at
+    }
+    throw error
+  }
   return stale.length
 }
 
@@ -198,40 +267,49 @@ export function parseArchive(text: string | null): ArchiveBatch[] {
   return []
 }
 
-/** 追加归档条目（按 cwd+path+batch 合并，同 callId 去重）。 */
-export async function appendArchiveEntries(ctx: Ctx, cwd: string, entries: Array<ReturnType<typeof archiveEntryFor>>, session?: Session): Promise<void> {
-  const fs = ctx.get('fs')
-  if (!fs || !cwd) return
+/**
+ * 追加归档条目（按 cwd+path+batch 合并，同 callId 去重）。
+ * @author ddj 2026年09月30号
+ * @param ctx DSH 上下文
+ * @param cwd 工作区
+ * @param entries 待归档批次
+ * @param session 会话
+ * @param traceId 可选诊断追踪标识；有值时输出分段耗时
+ */
+export async function appendArchiveEntries(ctx: Ctx, cwd: string, entries: Array<ReturnType<typeof archiveEntryFor>>, session?: Session, traceId?: string): Promise<void> {
+  if (!cwd || !entries.length) return
+  // #region debug log
+  const started = traceId ? performance.now() : 0
+  // #endregion
   try {
-    const target = await fs.resolve(SIDECAR_ARCHIVE, { cwd })
-    const existing = parseArchive(await readArchiveText(ctx, cwd))
-    for (const e of entries) {
-      const idx = existing.findIndex((x) => x.cwd === e.cwd && x.path === e.path && x.batch === e.batch)
-      if (idx >= 0) {
-        const exist = existing[idx]
-        const seen = new Set((exist.records || []).map((r) => r.callId))
-        for (const rec of e.records) {
-          if (!seen.has(String(rec.callId))) {
-            exist.records.push(rec as unknown as ArchiveBatch['records'][number])
-            seen.add(String(rec.callId))
-          }
-        }
-        exist.lastAt = e.at
-        exist.reason = e.reason
-      } else {
-        existing.push(e as unknown as ArchiveBatch)
-      }
-    }
-    const data: ArchiveData = { version: 1, updatedAt: new Date().toISOString(), batches: existing }
-    await fs.writeText(target, JSON.stringify(data), void 0, void 0, policyOf(ctx, session))
+    await checkSource(ctx, cwd)
+    const added = appendArchive(cwd, entries as unknown as ArchiveBatch[])
+    // #region debug log
+    try {
+      if (traceId) debugRecord(ctx, cwd, `[DEBUG diffArchive] trace=${traceId} stage=done mode=sqlite entries=${entries.length} insertedBatches=${added} dbMs=${(performance.now() - started).toFixed(1)} totalMs=${(performance.now() - started).toFixed(1)}`)
+    } catch { /* 诊断不可影响归档 */ }
+    // #endregion
   } catch (error) {
+    // #region debug log
+    try {
+      if (traceId) debugRecord(ctx, cwd, `[DEBUG diffArchive] trace=${traceId} stage=error mode=sqlite totalMs=${(performance.now() - started).toFixed(1)}`)
+    } catch { /* 诊断不可影响归档 */ }
+    // #endregion
     log.error('appendArchiveEntries failed: ' + String(error))
+    throw error
   }
 }
 
 /**
  * 归档记录：标记 archived、按批次写入归档、落盘工作区桶。
- * @param opts.deferSave 为 true 时只写归档、不落盘桶（由批量调用方统一 saveBucket 一次）
+ * @author ddj 2026年09月30号
+ * @param ctx DSH 上下文
+ * @param session 会话
+ * @param cwd 工作区
+ * @param bucket 当前工作区记录桶
+ * @param recs 待归档记录
+ * @param reason 归档原因
+ * @param opts deferSave 为 true 时只写归档、不落盘桶；traceId 用于可选分段计时
  */
 export async function archiveRecords(
   ctx: Ctx,
@@ -240,13 +318,34 @@ export async function archiveRecords(
   bucket: Map<string, DiffRecord>,
   recs: DiffRecord[],
   reason: string,
-  opts?: { deferSave?: boolean },
+  opts?: { deferSave?: boolean; traceId?: string; changed?: DiffRecord[] },
 ): Promise<void> {
   if (!recs.length) return
   const fresh = recs.filter((r) => !r.archived)
-  for (const r of recs) r.archived = true
-  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 && !opts?.deferSave) await saveBucket(ctx, cwd, bucket, session)
+  const byFile = new Map<string, DiffRecord[]>()
+  for (const rec of recs) {
+    const key = JSON.stringify([rec.path, Number.isInteger(rec.batch) ? rec.batch : null])
+    const list = byFile.get(key) ?? []
+    list.push(rec)
+    byFile.set(key, list)
+  }
+  const entries = [...byFile.values()].map((list) => archiveEntryFor(list, cwd, reason))
+  const changed = new Map((opts?.changed ?? []).map((rec) => [rec.callId, rec]))
+  for (const rec of recs) changed.set(rec.callId, rec)
+  const start = opts?.traceId ? performance.now() : 0
+  await checkSource(ctx, cwd)
+  const original = recs.map((rec) => rec.archived)
+  for (const rec of recs) rec.archived = true
+  try {
+    const added = commitActive(cwd, { upserts: [...changed.values()], removed: [] }, entries as unknown as ArchiveBatch[])
+    // #region debug log
+    try {
+      if (opts?.traceId) debugRecord(ctx, cwd, `[DEBUG diffArchive] trace=${opts.traceId} stage=done mode=sqlite entries=${entries.length} insertedBatches=${added} dbMs=${(performance.now() - start).toFixed(1)} totalMs=${(performance.now() - start).toFixed(1)}`)
+    } catch { /* 诊断不可影响归档 */ }
+    // #endregion
+  } catch (error) {
+    recs.forEach((rec, idx) => { rec.archived = original[idx] })
+    throw error
+  }
+  if (fresh.length && !opts?.deferSave) return
 }