dsh-quote-annotate-pro 0.3.1 → 0.3.3

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 本项目的所有重要变更都记在这里。版本号遵循 [SemVer](https://semver.org/lang/zh-CN/)。
 
+## 0.3.3 — 修复「输入框无法显示字」
+
+- **根因**：0.3.2 的输入框装饰只**加** class、从不**删**。Lexical 会复用行 DOM：
+  用户删掉位置行文字、再从同一个行元素里继续打字时，残留的 `.dshq-cmp-header{display:none}` 会把新打的字一起藏掉
+  （用户实测反馈「输入框无法显示字」）
+- **修复**：装饰改为**完整对账**（逐行同时做加类与删类），行元素不再匹配位置行/引用行时立刻恢复可见
+- **光标保护**：光标停在位置行里时，该行临时以半透明显示（`.dshq-cmp-header-active`），移开后再隐藏 —— 编辑位置行也能看见自己打的字
+- **空白兜底**：若整个输入框内容全是位置行且光标就在里面，一律不隐藏（避免输入框看起来是空的）
+- **行识别**：逐层展开含块级子元素的容器（最多 4 层），单行草稿时不会再把整个容器当成一行处理
+- `npm test` 8/8、`node --check`、`check-manifest` 全绿
+
+## 0.3.2 — 输入框装饰支持一条消息里多条批注
+
+- **修复**：输入框里的「隐藏位置行 + 紧凑引用块」装饰改为**状态机逐行扫描**。此前实现遇到位置行后的第一个空行就 `break`，
+  导致同一条消息里**只有第一条批注被装饰**，第二条开始位置行 `【批注 2 · …】` 仍然露在输入框里（用户实测截图确认）
+- 现在按 `位置行 → 正文行 → 空行收尾` 循环扫描，多条批注全部折叠为紧凑引用块；空行、非单行内容都不会误判
+- 编辑器若在 `contenteditable` 里再包一层容器，会自动向下一层找行元素（兼容不同 Lexical 挂载结构）
+- 诊断通道改进：ping 失败后每 5 秒自动重试一次（此前一次探测失败就永久静默，接收端后启动时看不到任何事件）
+- `npm test` 8/8、`node --check`、`check-manifest` 全绿
+
 ## 0.3.1 — 引用管线懒重试：页面刷新后不再退化成纯文本
 
 - **根因**：页面刷新时插件 `apply` 早于宿主 `inputTriggers` 服务就绪，`ctx.get('inputTriggers')` 拿到空值后

package/lib/client.js

@@ -51,13 +51,23 @@ window.__ModuleLoader__.load({
       } catch (e) { /* diagnostics must never throw */ }
     }
     if (DIAG_ENABLED && typeof fetch === 'function') {
+      const pingOnce = () => {
+        try {
+          fetch(DIAG_URL + '/ping', { method: 'POST', body: 'ping' }).then(() => {
+            if (diagReady === true) return
+            diagReady = true
+            const pending = diagQueue.splice(0)
+            for (const text of pending) sendReport(text)
+          }).catch(() => { diagReady = false })
+        } catch (e) { diagReady = false }
+      }
+      pingOnce()
+      // 接收端比页面晚启动也来得及：探测未成功时每 5 秒重试（成功一次即停）
       try {
-        fetch(DIAG_URL + '/ping', { method: 'POST', body: 'ping' }).then(() => {
-          diagReady = true
-          const pending = diagQueue.splice(0)
-          for (const text of pending) sendReport(text)
-        }).catch(() => { diagReady = false })
-      } catch (e) { diagReady = false }
+        const retryTimer = setInterval(() => { if (diagReady !== true) pingOnce() }, 5000)
+        // Node（自检脚本里 import 本模块）不会自己退出 → 解除引用；浏览器里返回的是数字，跳过
+        if (retryTimer && typeof retryTimer.unref === 'function') retryTimer.unref()
+      } catch (e) { /* ignore */ }
     } else {
       diagReady = false
     }
@@ -1155,6 +1165,8 @@ window.__ModuleLoader__.load({
 .dshq-sent-quote-text{display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden;white-space:pre-wrap;word-break:break-word}
 /* 输入框里的引用：隐藏位置行，正文显示为紧凑块（输入框与消息观感一致） */
 .dshq-cmp-header{display:none !important}
+/* 光标停在位置行里时临时显示（否则打字看不见字）；必须排在上一行之后才能覆盖 !important */
+.dshq-cmp-header-active{display:block !important;opacity:.55}
 .dshq-cmp-quote{background:rgba(127,127,127,.10);border-radius:8px;padding:2px 10px;margin:2px 0}
 .dshq-cmp-quote-first{margin-top:4px}
 .dshq-cmp-quote-last{margin-bottom:4px}
@@ -1729,52 +1741,106 @@ window.__ModuleLoader__.load({
       // 编辑器重渲染会丢掉 class，因此用 MutationObserver 重新贴上。
       try {
         ctx.effect(() => {
-          let timer = null
           let observer = null
-          const isSingleLine = (t) => t !== '' && t.indexOf('\n') === -1
-          let lastSig = ''
+          // 位置行：`【引用 · 第N轮 · DSH 回复】` 或 `【批注 N · 第N轮 · DSH 回复（…）】`
+          const HEADER_RE = /^【(?:引用|批注)[^\n]*】$/
+          const isBlockEl = (el) => !!el && el.nodeType === 1 && /^(DIV|P|LI)$/.test(el.tagName)
+          /**
+           * 编辑器根下的"行元素"：通常是 <div>/<p>；个别宿主会再包一层容器。
+           * 逐层向下展开"含块级子元素"的容器（最多 4 层），叶子层就是真正的行。
+           * （早期版本只在"单容器且子元素 >1"时展开一层，单行草稿时会把整个容器当成一行处理）
+           */
+          const lineElements = (ed) => {
+            let cur = [ed]
+            for (let depth = 0; depth < 4; depth++) {
+              const next = []
+              let descended = false
+              for (const el of cur) {
+                const blocks = Array.from(el.children || []).filter(isBlockEl)
+                if (blocks.length > 0) { descended = true; for (const b of blocks) next.push(b) } else next.push(el)
+              }
+              if (!descended) return cur
+              cur = next
+            }
+            return cur
+          }
+          // 光标所在行：装饰时不能把光标那行藏起来，否则用户打字"看不见字"
+          const caretLineOf = (ed, lines) => {
+            try {
+              const sel = window.getSelection()
+              if (!sel || sel.rangeCount === 0 || !sel.anchorNode) return null
+              let el = sel.anchorNode.nodeType === 1 ? sel.anchorNode : sel.anchorNode.parentElement
+              while (el && el !== ed) {
+                if (lines.indexOf(el) !== -1) return el
+                el = el.parentElement
+              }
+            } catch (e) { /* ignore */ }
+            return null
+          }
+          /**
+           * 把输入框里的正文"装饰"成紧凑块：
+           * - 位置行 → `.dshq-cmp-header`（display:none，界面上看不到，但文本仍然在 → 发送后模型拿得到）
+           * - 位置行后面紧跟的引用正文行 → `.dshq-cmp-quote`（浅色块；首行/末行分别圆角）
+           * 一条消息里可以有多条批注，所以这里按"状态机"逐行扫描，遇到空行即结束当前块，
+           * 然后继续扫后面的块（早期版本遇到第一个空行就 break，导致第二条批注不再装饰）。
+           *
+           * 关键：**完整对账**（既加类、也删类）。Lexical 会复用行 DOM，删掉位置行文字后新打的字
+           * 若落回同一个行元素，残留的 `.dshq-cmp-header` 会让新文字看不见（用户反馈"输入框无法显示字"）。
+           */
           const decorate = () => {
-            timer = null
             try {
               for (const ed of document.querySelectorAll('[contenteditable="true"]')) {
-                const kids = Array.from(ed.children || [])
-                let headerEl = null
-                const quoteEls = []
-                for (const el of kids) {
-                  const t = String(el.textContent || '').trim()
-                  if (!headerEl) {
-                    // 位置行必须"整行且只有一行"，避免误把整个编辑器当成头部
-                    if (isSingleLine(t) && /^【(?:引用|批注)[^\n]*】$/.test(t)) headerEl = el
-                    continue
+                const lines = lineElements(ed)
+                const headerSet = new Set()
+                const quoteMap = new Map()
+                let block = null
+                const flush = () => {
+                  if (block && block.length > 0) {
+                    block.forEach((el, i) => quoteMap.set(el, { first: i === 0, last: i === block.length - 1 }))
                   }
-                  if (t === '') break
-                  if (!isSingleLine(t)) break
-                  quoteEls.push(el)
+                  block = null
+                }
+                for (const el of lines) {
+                  const t = String(el.textContent || '').trim()
+                  const single = t !== '' && t.indexOf('\n') === -1
+                  if (single && HEADER_RE.test(t)) { flush(); headerSet.add(el); block = []; continue }
+                  if (!block) continue
+                  if (t === '' || !single) { flush(); continue }
+                  block.push(el)
                 }
-                if (!headerEl) {
-                  // 诊断：编辑器里出现了"【引用/【批注"但没能匹配成"位置行 + 正文行"时，把结构打出来
-                  const raw = String(ed.textContent || '')
-                  if (raw.indexOf('【引用') >= 0 || raw.indexOf('【批注') >= 0) {
-                    const sig = raw.slice(0, 40) + '|' + kids.length
-                    if (sig !== lastSig) {
-                      lastSig = sig
-                      report('cmp:probe', {
-                        ms: lastInsertAt ? Math.round((typeof performance !== 'undefined' ? performance.now() : Date.now()) - lastInsertAt) : null,
-                        kids: kids.length,
-                        singles: kids.map((el) => (isSingleLine(String(el.textContent || '').trim()) ? 1 : 0)).join(''),
-                        first: String((kids[0] && kids[0].textContent) || '').slice(0, 24),
-                      })
-                    }
+                flush()
+                // 兜底：如果整段内容都是位置行（用户把正文删光了），并且光标就在里面，
+                // 不隐藏任何行 —— 否则输入框看起来是空的，用户会以为"打不出字"。
+                try {
+                  const focused = ed === document.activeElement || ed.contains(document.activeElement)
+                  if (focused && lines.length > 0 && headerSet.size === lines.length) headerSet.clear()
+                } catch (e) { /* ignore */ }
+                const caret = caretLineOf(ed, lines)
+                let changed = 0
+                for (const el of lines) {
+                  const cls = el.classList
+                  const isHeader = headerSet.has(el)
+                  const isActive = isHeader && el === caret
+                  if (isHeader && !isActive) {
+                    if (!cls.contains('dshq-cmp-header')) { cls.add('dshq-cmp-header'); changed++ }
+                  } else if (cls.contains('dshq-cmp-header')) { cls.remove('dshq-cmp-header'); changed++ }
+                  if (isActive) {
+                    if (!cls.contains('dshq-cmp-header-active')) { cls.add('dshq-cmp-header-active'); changed++ }
+                  } else if (cls.contains('dshq-cmp-header-active')) { cls.remove('dshq-cmp-header-active'); changed++ }
+                  const q = quoteMap.get(el)
+                  if (q) {
+                    if (!cls.contains('dshq-cmp-quote')) changed++
+                    cls.add('dshq-cmp-quote')
+                    cls.toggle('dshq-cmp-quote-first', q.first)
+                    cls.toggle('dshq-cmp-quote-last', q.last)
+                  } else if (cls.contains('dshq-cmp-quote')) {
+                    cls.remove('dshq-cmp-quote')
+                    cls.remove('dshq-cmp-quote-first')
+                    cls.remove('dshq-cmp-quote-last')
+                    changed++
                   }
-                  continue
                 }
-                headerEl.classList.add('dshq-cmp-header')
-                quoteEls.forEach((el, idx) => {
-                  el.classList.add('dshq-cmp-quote')
-                  el.classList.toggle('dshq-cmp-quote-first', idx === 0)
-                  el.classList.toggle('dshq-cmp-quote-last', idx === quoteEls.length - 1)
-                })
-                report('cmp:decorated', { lines: quoteEls.length })
+                if (changed > 0) report('cmp:decorated', { changed })
               }
             } catch (e) { report('cmp:scan-throw', String((e && e.message) || e)) }
           }
@@ -1787,10 +1853,13 @@ window.__ModuleLoader__.load({
             observer = new MutationObserver(() => { decorate() })
             observer.observe(document.body, { childList: true, subtree: true, characterData: true })
           } catch (e) { report('cmp:observer-throw', String((e && e.message) || e)) }
+          // 光标进出位置行时立即更新（光标在位置行里时临时显示该行，避免"打字看不见"）
+          const onSelectionChange = () => { try { decorate() } catch (e) { /* ignore */ } }
+          try { document.addEventListener('selectionchange', onSelectionChange) } catch (e) { /* ignore */ }
           return () => {
             if (composerDecorateNow === decorate) composerDecorateNow = null
-            if (timer !== null) clearTimeout(timer)
             if (observer) { try { observer.disconnect() } catch (e) { /* ignore */ } }
+            try { document.removeEventListener('selectionchange', onSelectionChange) } catch (e) { /* ignore */ }
           }
         }, 'dsh-quote-annotate-pro: composer quote decoration')
       } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-quote-annotate-pro",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "划词批注与引用锚点：划词 → 批注（自动编号）→ 引用；引用块在输入框和已发送消息里始终可见（最多 3 行、位置行隐藏），点一下跳回原文并高亮；模型按「Annotation N：」逐条回应，回复里的标签可悬浮看原文与评语。纯客户端，锚点存本地 localStorage。",
   "keywords": ["dsh", "dsh-plugin", "deepseek-harness", "quote", "annotate", "selection", "reference", "anchor"],
   "license": "MIT",