dsh-vscode-mode 0.1.45 → 0.1.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-vscode-mode",
-  "version": "0.1.45",
+  "version": "0.1.46",
   "description": "DSH 上的类 VSCode 编码体验：Monaco 编辑器（文件页签/QuickOpen/状态栏，可驻 dsh-better-sidebar 侧边栏与对话同屏）+ Agent 编辑差异审查（整文件差异/采纳/拒绝/归档/回滚）+ 语言服务器（LSP）智能（跳转定义/引用/hover/大纲 + VSIX 扩展市场安装），状态持久化到工作区旁车",
   "keywords": [
     "dsh",

package/src/client/monaco/lsp/providers.ts

@@ -197,7 +197,16 @@ export async function gotoRefsAt(ed, position) {
   if (!path || !position) return
   const all = await findReferences(path, model.getValue(), position, false)
   const others = filterOtherRefs(all, path, position)
-  if (!others.length) return
+  if (!others.length) {
+    // 0 条「其它」引用：降级查定义（参数/局部变量只被声明时引用为空，定义可经 host 降级链推导）
+    const defs = await findDefinition(path, model.getValue(), position)
+    const first = defs[0]
+    if (!first) return
+    const lspPos = monoToLsp(position.lineNumber, position.column)
+    if (sameFile(targetOpenPath(first), path) && posInRange(lspPos, first.lspRange)) return // 定义即自身：无其它可跳，保持静默
+    jumpToLocation(first)
+    return
+  }
   if (others.length === 1) {
     jumpToLocation(others[0])
     return

package/src/client/monaco/lsp/underline.ts

@@ -0,0 +1,101 @@
+// @ts-nocheck
+/**
+ * dsh-vscode-mode client — Ctrl+hover 可导航标识符下划线提示。
+ * 背景：内嵌 Monaco 构建（0.42.0-dev）无 linkDetection contrib，原生不产生 ctrl+hover 下划线，
+ * 插件自绘：Ctrl/Meta 按住悬停在"语义 token 标识符"上时给词加下划线装饰，移出/松开即清除。
+ * 数据来源于语义 token（每 model+version 缓存 60s），不做逐词 LSP 查询。
+ * 作者 ddj 2026-09-02
+ */
+import { pathOfModel, fetchSemanticTokens } from './lspClient.js'
+import { decodeSemanticTokens, isNavigableTokenType } from '../../../shared/lsp.js'
+
+const CACHE_TTL_MS = 60_000
+
+/**
+ * 给一个 Monaco 编辑器绑定 Ctrl+hover 下划线提示（幂等）。
+ * @author ddj 2026年09月02号
+ * @param ed Monaco 编辑器
+ * @param monaco Monaco 实例
+ */
+export function bindLspUnderline(ed, monaco) {
+  if (!ed || !monaco || ed.__edrvUnderline) return
+  ed.__edrvUnderline = true
+  let decoIds = []
+  let lastKey = null
+  let hoverSeq = 0
+  let cache = { path: null, version: -1, ranges: null, at: 0 }
+
+  const clear = () => {
+    if (decoIds.length) {
+      ed.deltaDecorations(decoIds, [])
+      decoIds = []
+    }
+    lastKey = null
+  }
+
+  /** 取当前文档语义 token 范围（模型版本 + TTL 缓存）。 */
+  const rangesOf = async (model) => {
+    const path = pathOfModel(model)
+    const version = model.getVersionId?.() ?? 0
+    if (cache.path === path && cache.version === version && cache.ranges && Date.now() - cache.at < CACHE_TTL_MS) {
+      return cache.ranges
+    }
+    const res = await fetchSemanticTokens(path, model.getValue()).catch(() => null)
+    const ranges = res && Array.isArray(res.data) ? decodeSemanticTokens(res.data) : []
+    cache = { path, version, ranges, at: Date.now() }
+    return ranges
+  }
+
+  ed.onMouseMove((event) => {
+    const native = event?.event
+    const ctrl = native?.ctrlKey ?? false
+    const meta = native?.metaKey ?? false
+    if (!ctrl && !meta) {
+      clear()
+      hoverSeq++
+      return
+    }
+    const pos = event?.target?.position
+    const model = ed.getModel()
+    if (!pos || !model) {
+      clear()
+      hoverSeq++
+      return
+    }
+    const word = model.getWordAtPosition(pos)
+    if (!word) {
+      clear()
+      hoverSeq++
+      return
+    }
+    const seq = ++hoverSeq
+    const path = pathOfModel(model)
+    void rangesOf(model).then((ranges) => {
+      if (seq !== hoverSeq) return // 鼠标已移走，忽略过期结果
+      const lineIndex = Math.max(0, word.startLineNumber - 1)
+      const startCol = Math.max(0, word.startColumn - 1)
+      const endCol = Math.max(startCol, word.endColumn - 1)
+      const hit = ranges.some((r) => {
+        if (r.start.line !== lineIndex) return false
+        return isNavigableTokenType(r.type) && r.start.character <= startCol && r.end.character >= endCol
+      })
+      if (!hit) {
+        if (lastKey !== null) clear()
+        return
+      }
+      const key = String(path) + ':' + word.startColumn + ':' + word.endColumn
+      if (key === lastKey) return
+      lastKey = key
+      decoIds = ed.deltaDecorations(decoIds, [{
+        range: new monaco.Range(word.startLineNumber, word.startColumn, word.endLineNumber, word.endColumn),
+        options: { inlineClassName: 'edrv-nav-underline' },
+      }])
+    })
+  })
+
+  ed.onMouseLeave(() => clear())
+  ed.onDidBlurEditorText?.(() => clear())
+}
+
+/** 兼容占位（与 providers 的 hideReferencesOverlay 对称，无需真正释放）。 */
+export function disposeLspUnderline() {}

package/src/client/styles/editor.css

@@ -40,6 +40,8 @@
 [data-edrv-view] .edrv-lsp-status-dot.ready { background: var(--dsw-alias-state-success-primary, #0f9d58); }
 [data-edrv-view] .edrv-lsp-status-dot.busy { background: var(--dsw-alias-state-warn-primary, #d97706); animation: edrv-lsp-pulse 1.2s ease-in-out infinite; }
 @keyframes edrv-lsp-pulse { 50% { opacity: .45; } }
+/* Ctrl+hover 可导航标识符下划线提示（绑定 Monaco inlineClassName 装饰） */
+[data-edrv-view] .edrv-nav-underline { text-decoration: underline; text-decoration-color: var(--dsw-alias-interactive-primary, #4fc1ff); text-underline-offset: 1px; cursor: pointer; }
 [data-edrv-view] .edrv-diffchip { font-size: 11px; padding: 2px 10px; border: 1px solid var(--dsw-alias-border-l1, #333); border-radius: 999px; background: var(--dsw-alias-bg-layer-2, transparent); color: var(--dsw-alias-state-warn-primary, #b7791f); cursor: pointer; white-space: nowrap; flex-shrink: 0; }
 [data-edrv-view] .edrv-chip-btn { font-size: 12px; padding: 2px 6px; border: none; background: transparent; color: var(--dsw-alias-label-secondary, #aaa); cursor: pointer; border-radius: 4px; flex-shrink: 0; }
 [data-edrv-view] .edrv-chip-btn:hover { background: var(--dsw-alias-interactive-bg-hover, rgba(255,255,255,.06)); }

package/src/client/ui/EditorView.ts

@@ -26,6 +26,7 @@ import { bindingsOf, chordOf, matchEvent, useKeybindingsVersion } from '../keybi
 import { createNavHistory } from '../navHistory.js'
 import { CACHE_KEY } from '../paths.js'
 import { bindLspEditor, runGoToDefinition, runFindReferences, hideReferencesOverlay } from '../monaco/lsp/providers.js'
+import { bindLspUnderline } from '../monaco/lsp/underline.js'
 import { onLspProgress, refreshStatus } from '../monaco/lsp/index.js'
 
 /**
@@ -841,6 +842,7 @@ export function EditorView(props) {
     })
     ed.addCommand(m.KeyCode.F12, () => { void runGoToDefinition(ed) })
     bindLspEditor(ed)
+    bindLspUnderline(ed, m)
     // hover 差异块 → 浮出 Keep/Undo（req：鼠标移到编辑区差异块时显示）
     // 防闪烁：① 区域不变不 setState（浮窗锚定差异块起始行，不跟随鼠标）；② 延迟隐藏；
     // ③ 浮窗自身 onMouseEnter 取消隐藏计时（鼠标在浮窗与编辑器间移动不闪）。

package/src/lsp/client.ts

@@ -56,6 +56,7 @@ export function createLspClient(
   const pending = new Map<number, { resolve: (v: unknown) => void; reject: (e: Error) => void; timer: ReturnType<typeof setTimeout> }>()
   let serverCapabilities: LspServerCapabilities = {
     definition: false,
+    declaration: false,
     references: false,
     documentSymbol: false,
     workspaceSymbol: false,
@@ -158,6 +159,7 @@ export function createLspClient(
       const init = await client.request<{
         capabilities?: {
           definitionProvider?: unknown
+          declarationProvider?: unknown
           referencesProvider?: unknown
           documentSymbolProvider?: unknown
           workspaceSymbolProvider?: unknown
@@ -179,6 +181,7 @@ export function createLspClient(
           textDocument: {
             synchronization: { dynamicRegistration: false, willSave: false, didSave: true },
             definition: { dynamicRegistration: false },
+            declaration: { dynamicRegistration: false },
             references: { dynamicRegistration: false },
             documentSymbol: { dynamicRegistration: false },
             hover: { dynamicRegistration: false },
@@ -196,6 +199,7 @@ export function createLspClient(
       const legend = caps.semanticTokensProvider?.legend
       serverCapabilities = {
         definition: Boolean(caps.definitionProvider),
+        declaration: Boolean(caps.declarationProvider),
         references: Boolean(caps.referencesProvider),
         documentSymbol: Boolean(caps.documentSymbolProvider),
         workspaceSymbol: Boolean(caps.workspaceSymbolProvider),

package/src/lsp/derive.ts

@@ -0,0 +1,96 @@
+/**
+ * dsh-vscode-mode host — 定义查找降级链的纯推导函数。
+ * 背景：EmmyLua 对局部变量/参数/表字段的 textDocument/definition 常返回空，
+ * 但 references(includeDeclaration) 能给出包含声明的条目。
+ * 本函数从引用列表推导"声明位置"：同文件、词文本与点击处一致，且点击位置落在某条目内时，
+ * 取列表首个（EmmyLua 对局部/参数把声明排在引用首位；点击处即首个时按"点击了声明"处理）。
+ * 词文本必须与点击词一致，否则拒绝（宁可空，不误跳）。
+ * 作者 ddj 2026-09-02
+ */
+import type { LspLocation, LspPosition, LspRange } from '../shared/lsp.js'
+
+/** file:// URI（或裸路径）→ 归一化绝对路径（小写、/ 分隔）。 */
+function normAbs(uri: string): string {
+  const path = String(uri ?? '').replace(/^file:\/\/\/?/, '')
+  return decodeURIComponent(path).replace(/\\/g, '/').replace(/^\/([A-Za-z]:)/, '$1').toLowerCase()
+}
+
+/** 取文档 text 在 LSP range（0-based）内的切片。 */
+function sliceRange(text: string, range: LspRange): string {
+  const lines = text.split(/\r\n|\r|\n/)
+  const start = range.start
+  const end = range.end
+  const startLine = Math.max(0, start.line)
+  const endLine = Math.max(startLine, end.line)
+  if (startLine >= lines.length || endLine >= lines.length) return ''
+  const startChar = Math.max(0, start.character)
+  if (startLine === endLine) {
+    return lines[startLine].slice(startChar, Math.max(startChar, end.character))
+  }
+  const first = lines[startLine].slice(startChar)
+  const middle = lines.slice(startLine + 1, endLine)
+  const last = lines[endLine].slice(0, Math.max(0, end.character))
+  return [first, ...middle, last].join('\n')
+}
+
+/** LSP position 是否落在 range 内（start 包含、end 排除；零宽按点匹配）。 */
+function posInLspRange(pos: LspPosition, range: LspRange): boolean {
+  const start = range.start
+  const end = range.end ?? start
+  if (start.line === end.line && start.character === end.character) {
+    return pos.line === start.line && pos.character === start.character
+  }
+  if (pos.line < start.line || pos.line > end.line) return false
+  if (pos.line === start.line && pos.character < start.character) return false
+  if (pos.line === end.line && pos.character >= end.character) return false
+  return true
+}
+
+/** 两个 range 是否完全一致。 */
+function sameRange(a: LspRange, b: LspRange): boolean {
+  return a.start.line === b.start.line && a.start.character === b.start.character &&
+    a.end.line === b.end.line && a.end.character === b.end.character
+}
+
+/** range 长度（行/列均按 0-based 差估算，仅用于取"最小包裹"排序）。 */
+function rangeSize(r: LspRange): number {
+  return (r.end.line - r.start.line) * 1_000_000 + (r.end.line === r.start.line ? r.end.character - r.start.character : r.end.character)
+}
+
+/**
+ * 从引用列表推导定义位置。
+ * @author ddj 2026年09月02号
+ * @param queryPos 查询位置（LSP 0-based）
+ * @param locations references(includeDeclaration) 结果
+ * @param docText 当前文档全文（词文本一致校验）
+ * @param docAbsPath 当前文档绝对路径（root+相对路径，与 loc.uri 归一化后比较）
+ * @returns 推导出的定义位置；无法确定返回 null
+ */
+export function deriveDefinitionFromLocations(
+  queryPos: LspPosition,
+  locations: LspLocation[],
+  docText: string,
+  docAbsPath: string,
+): LspLocation | null {
+  if (!locations.length) return null
+  const docAbs = normAbs(docAbsPath)
+
+  // 点击位置落在的条目（多个时取最小包裹 = 最贴近词的 range）
+  const containing = locations
+    .filter((loc) => posInLspRange(queryPos, loc.range))
+    .sort((a, b) => rangeSize(a.range) - rangeSize(b.range))[0]
+  if (!containing) return null
+  const queryWord = sliceRange(docText, containing.range)
+  if (!queryWord) return null
+
+  // 同文件 + 词文本一致的候选（按服务器返回顺序）
+  const candidates = locations.filter((loc) => {
+    return normAbs(loc.uri) === docAbs && sliceRange(docText, loc.range) === queryWord
+  })
+  if (!candidates.length) return null
+
+  // 点击处即候选首个（且与查询词重合）→ 点击的就是声明，返回自身
+  // 否则取首个（EmmyLua 对局部/参数把声明排在引用首位）
+  const first = candidates[0]
+  return sameRange(first.range, containing.range) ? containing : first
+}

package/src/lsp/server.ts

@@ -7,6 +7,7 @@
 import { spawnServer, type Transport } from './transport.js'
 import { createLspClient, type LspClient } from './client.js'
 import { pathToFileUri } from './uri.js'
+import { deriveDefinitionFromLocations } from './derive.js'
 import type { LspProviderSpec } from './providers.js'
 import { LSP_SEMANTIC_TOKEN_MODIFIERS, LSP_SEMANTIC_TOKEN_TYPES } from '../shared/lsp.js'
 import type {
@@ -64,6 +65,7 @@ export function createLspServer(spec: LspProviderSpec, root: string, languageId:
   let client: LspClient | null = null
   let capabilities: LspServerCapabilities = {
     definition: false,
+    declaration: false,
     references: false,
     documentSymbol: false,
     workspaceSymbol: false,
@@ -231,11 +233,55 @@ export function createLspServer(spec: LspProviderSpec, root: string, languageId:
     async definition(path: string, line: number, character: number): Promise<LspLocation[]> {
       const doc = docs.get(path)
       if (!doc || !(await readyWait)) return []
-      const result = await ensureClient().request<unknown>(
-        'textDocument/definition',
-        { textDocument: { uri: doc.uri }, position: { line, character } },
+      const client = ensureClient()
+      const position = { line, character }
+      // ① 标准定义（方法/跨文件命名空间等）
+      const direct = normalizeLocations(
+        await client.request<unknown>(
+          'textDocument/definition',
+          { textDocument: { uri: doc.uri }, position },
+        ),
       )
-      return normalizeLocations(result)
+      if (direct.length) return direct
+      // ② 声明（服务器能力支持时）：EmmyLua 对局部变量/参数/表字段 definition 常返回空，declaration 更准
+      if (capabilities.declaration) {
+        try {
+          const decl = normalizeLocations(
+            await client.request<unknown>(
+              'textDocument/declaration',
+              { textDocument: { uri: doc.uri }, position },
+            ),
+          )
+          if (decl.length) {
+            log('definition fallback → declaration (' + path + ':' + line + ':' + character + ')')
+            return decl
+          }
+        } catch (error) {
+          log('declaration request failed: ' + String(error))
+        }
+      }
+      // ③ 引用推导：definition/declaration 均空时，从 references(includeDeclaration) 推导声明
+      // （EmmyLua 局部/参数把声明排在引用首位；词文本不一致则拒绝，宁可空不误跳）
+      try {
+        const refs = normalizeLocations(
+          await client.request<unknown>(
+            'textDocument/references',
+            {
+              textDocument: { uri: doc.uri },
+              position,
+              context: { includeDeclaration: true },
+            },
+          ),
+        )
+        const derived = deriveDefinitionFromLocations(position, refs, doc.text, doc.uri)
+        if (derived) {
+          log('definition fallback → references-derived (' + path + ':' + line + ':' + character + ')')
+          return [derived]
+        }
+      } catch (error) {
+        log('references fallback failed: ' + String(error))
+      }
+      return []
     },
 
     async references(path: string, line: number, character: number, includeDeclaration: boolean): Promise<LspLocation[]> {

package/src/shared/lsp.ts

@@ -69,9 +69,66 @@ export interface LspSemanticTokens {
   resultId?: string
 }
 
+/** 语义 token 解码后的绝对范围（LSP 0-based；type 为插件固定 legend 与 type 名）。 */
+export interface LspSemanticTokenRange {
+  start: LspPosition
+  end: LspPosition
+  type: string
+  modifiers: number
+}
+
+/** 语义 token 中可作为"可导航标识符"的类型（ctrl+hover 下划线判定用）。 */
+export const LSP_NAVIGABLE_TOKEN_TYPES: ReadonlySet<string> = new Set([
+  'variable', 'parameter', 'property', 'function', 'method', 'class', 'enum',
+  'struct', 'interface', 'namespace', 'typeParameter', 'enumMember', 'event', 'type',
+])
+
+/**
+ * 语义 token 是否属于可导航标识符。
+ * @author ddj 2026年09月02号
+ * @param type 语义 token 类型名（插件固定 legend）
+ * @returns 是否可导航
+ */
+export function isNavigableTokenType(type: string): boolean {
+  return LSP_NAVIGABLE_TOKEN_TYPES.has(type)
+}
+
+/**
+ * 解码 LSP delta 编码的语义 token 流为绝对范围数组。
+ * @author ddj 2026年09月02号
+ * @param data 5 元组 delta 流（host normalizeSemanticData 产物，类型索引对应固定 legend）
+ * @param types 固定 legend 类型表（缺省 LSP_SEMANTIC_TOKEN_TYPES）
+ * @returns 绝对范围列表（保持文档顺序）
+ */
+export function decodeSemanticTokens(
+  data: number[],
+  types: readonly string[] = LSP_SEMANTIC_TOKEN_TYPES,
+): LspSemanticTokenRange[] {
+  const out: LspSemanticTokenRange[] = []
+  let line = 0
+  let character = 0
+  for (let i = 0; i + 4 < data.length; i += 5) {
+    const deltaLine = data[i] ?? 0
+    const deltaCharacter = data[i + 1] ?? 0
+    const length = Math.max(0, data[i + 2] ?? 0)
+    const typeIndex = data[i + 3] ?? 0
+    const modifiers = data[i + 4] ?? 0
+    line += deltaLine
+    character = deltaLine === 0 ? character + deltaCharacter : deltaCharacter
+    out.push({
+      start: { line, character },
+      end: { line, character: character + length },
+      type: types[typeIndex] ?? 'variable',
+      modifiers,
+    })
+  }
+  return out
+}
+
 /** LSP 服务器能力子集：本插件会用到的方法。 */
 export interface LspServerCapabilities {
   definition: boolean
+  declaration: boolean
   references: boolean
   documentSymbol: boolean
   workspaceSymbol: boolean