dsh-quote-annotate-pro 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 本项目的所有重要变更都记在这里。版本号遵循 [SemVer](https://semver.org/lang/zh-CN/)。
 
+## 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')` 拿到空值后
+  `pipelineAvailable` 被永久置为 `false` → 之后每次批注插入都走「纯文本回退」，输入框里出现 `【批注 1 …】` 裸文本块
+  （实测证据：localStorage 草稿记录为 `{"draft":{"text":"【批注 1 · …】\n钟）\n\n批注：1…","references":[]}}`，即没有 chip）
+- **修复**：引用源注册改为幂等懒加载 `ensureQuoteSource()`，服务未就绪时按 500ms × 20 次（≈10s）自动重试，
+  每次插入前也会先试一次；重试成功即恢复正常 chip 插入，无需用户刷新页面或重启
+- **可观测性**：`insert:draft` 诊断补充 `draftLen` / `pipeline`；`insert:fallback-plaintext` 补充 `draftLen` / `bodyLen` / `pipeline`；
+  编辑器提示按状态区分（`null` = 正在初始化引用管线，`false` = 回退为纯文本）
+- 自检照旧：`npm test`（8 组纯函数断言）、`node --check`、`check-manifest` 全绿
+
 ## 0.3.0 — 编号批注 + 回复逐条对照
 
 - **批注自动编号**：同一条消息里每次插入批注都会编号（`批注 1`、`批注 2`…，删掉中间某条不会重号，见 `nextAnnotationNo()`）；

package/README.en.md

@@ -104,6 +104,7 @@ Official surfaces used: `slots` (`shell.overlay`, `conversation.chat.turnTail`,
 
 ```sh
 npm run check    # manifest self-check (package.json / patch / bundle registration id)
+npm test         # pure-function self-check for the client bundle (numbering, block parsing, snippets — no browser/network)
 npm run diag     # local diagnostics sink (http://127.0.0.1:47821)
 ```
 

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
     }
@@ -215,6 +225,8 @@ window.__ModuleLoader__.load({
     let currentSessionId = null
     let refSeq = 0
     let pipelineAvailable = null // null=未知 false=不可用 true=可用
+    // 引用 source 的注册函数（懒加载 + 重试）：服务晚就绪、HMR 重载后仍能恢复 chip 插入
+    let ensureQuoteSource = null
     // ref -> { sessionId, anchorKey, body, label } 用于点击 chip 跳回原文 / 悬停显示原文
     const refTargets = new Map()
     // ref -> { body, clipboardText } 提交时经 codec 序列化
@@ -910,6 +922,8 @@ window.__ModuleLoader__.load({
             refCodecs.delete(oldest)
             refTargets.delete(oldest)
           }
+          // 懒重试：若 apply 时 inputTriggers 还没就绪，插入前再试一次（常见于"刚启动就点批注"）
+          try { if (typeof ensureQuoteSource === 'function') ensureQuoteSource() } catch (e) { /* ignore */ }
           // 事件派发目标：优先用 sessions.scope()（社区插件在本版本已验证的路径），退回 binding.ctx
           let emitCtx = binding.ctx
           try {
@@ -929,10 +943,13 @@ window.__ModuleLoader__.load({
             try {
               const snap2 = input.state.getSnapshot()
               const occ2 = (snap2 && snap2.occurrences) || []
+              const draft2 = String((snap2 && snap2.draft) || '')
               report('insert:draft', {
-                draft: String((snap2 && snap2.draft) || '').replace(/\s+/g, ' ').slice(0, 120),
+                draft: draft2.replace(/\s+/g, ' ').slice(0, 400),
+                draftLen: draft2.length,
                 occ: occ2.length,
                 occLabels: occ2.map((o) => (o && o.label) || '').join('|').slice(0, 80),
+                pipeline: pipelineAvailable,
               })
             } catch (e) { /* ignore */ }
             report('insert:chip', { ref, anchorKey: item.anchorKey || null, header, chars: item.text.length })
@@ -950,7 +967,9 @@ window.__ModuleLoader__.load({
           refTargets.delete(ref)
           refCodecs.delete(ref)
           input.setDraft(base === '' ? quoteBody : base + '\n\n' + quoteBody)
-          report('insert:fallback-plaintext', { ref, header })
+          let draftLen = 0
+          try { draftLen = String((input.state.getSnapshot() || {}).draft || '').length } catch (e) { /* ignore */ }
+          report('insert:fallback-plaintext', { ref, header, draftLen, bodyLen: quoteBody.length, pipeline: pipelineAvailable })
           setStatus({ ok: false, text: 'chip 插入未生效，已回退为纯文本引用' })
           editorStore.close()
         } catch (e) {
@@ -1183,9 +1202,21 @@ window.__ModuleLoader__.load({
         available: pipelineAvailable,
         hasInsertReference: !!(inputTriggers && typeof inputTriggers.insertReference === 'function'),
       })
-      if (pipelineAvailable) {
+      // 注册机：幂等、可重试。宿主服务可能晚于插件就绪（或 HMR 重载后旧注册仍在），
+      // 一次性判定会让整页退化成"纯文本回退"，因此这里允许后续再次调用。
+      let quoteSourceRegistered = false
+      ensureQuoteSource = () => {
+        if (quoteSourceRegistered) return true
+        let triggers = inputTriggers
+        if (!triggers) {
+          try { triggers = ctx.get('inputTriggers') } catch (e) { triggers = undefined }
+        }
+        if (!triggers || typeof triggers.registerSource !== 'function') {
+          pipelineAvailable = false
+          return false
+        }
         try {
-          ctx.effect(() => inputTriggers.registerSource({
+          ctx.effect(() => triggers.registerSource({
             trigger: '@',
             name: 'quote-ref',
             order: 100,
@@ -1196,12 +1227,42 @@ window.__ModuleLoader__.load({
               serialize: (ref) => Promise.resolve(refCodecs.get(ref) ? refCodecs.get(ref).body : ''),
             },
           }), 'dsh-quote-annotate-pro: quote-ref source')
+          quoteSourceRegistered = true
+          pipelineAvailable = true
           report('register:quote-ref-source', 'ok')
+          return true
         } catch (e) {
+          const msg = String((e && e.stack) || (e && e.message) || e)
+          // 已注册（HMR 重载后宿主保留旧注册）不算失败：序列化仍会路由到当前模块的 codec
+          if (/already|duplicate|exist|注册/i.test(msg)) {
+            quoteSourceRegistered = true
+            pipelineAvailable = true
+            report('register:quote-ref-source', 'already')
+            return true
+          }
           pipelineAvailable = false
-          report('register:quote-ref-source', 'throw ' + String((e && e.stack) || (e && e.message) || e))
+          report('register:quote-ref-source', 'throw ' + msg)
+          return false
         }
       }
+      if (!ensureQuoteSource()) {
+        // 退避重试：最多 20 次、间隔 500ms（约 10s），把启动时序造成的退化救回来
+        try {
+          ctx.effect(() => {
+            let tries = 0
+            let timer = null
+            const tick = () => {
+              timer = null
+              if (quoteSourceRegistered || tries >= 20) return
+              tries += 1
+              if (!ensureQuoteSource()) timer = setTimeout(tick, 500)
+            }
+            timer = setTimeout(tick, 500)
+            report('register:quote-ref-source', 'retry-scheduled')
+            return () => { if (timer !== null) clearTimeout(timer) }
+          }, 'dsh-quote-annotate-pro: quote-ref retry')
+        } catch (e) { /* ignore */ }
+      }
       // 全局监听（选区气泡 / chip 点击跳转 / chip 悬停提示；ctx.effect 保证卸载时全部清理）
       try {
         ctx.effect(() => {
@@ -1678,52 +1739,58 @@ 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]*】$/
+          // 编辑器根下的"行元素"：通常是 <p>，个别宿主会再包一层容器
+          const lineList = (ed) => {
+            let kids = Array.from(ed.children || [])
+            if (kids.length === 1 && kids[0] && kids[0].children && kids[0].children.length > 1) {
+              kids = Array.from(kids[0].children)
+            }
+            return kids
+          }
+          /**
+           * 把输入框里的正文"装饰"成紧凑块：
+           * - 位置行 → `.dshq-cmp-header`（display:none，界面上看不到，但文本仍然在 → 发送后模型拿得到）
+           * - 位置行后面紧跟的引用正文行 → `.dshq-cmp-quote`（浅色块；首行/末行分别圆角）
+           * 一条消息里可以有多条批注，所以这里按"状态机"逐行扫描，遇到空行即结束当前块，
+           * 然后继续扫后面的块（早期版本遇到第一个空行就 break，导致第二条批注不再装饰）。
+           */
           const decorate = () => {
-            timer = null
             try {
               for (const ed of document.querySelectorAll('[contenteditable="true"]')) {
-                const kids = Array.from(ed.children || [])
-                let headerEl = null
-                const quoteEls = []
+                const kids = lineList(ed)
+                let block = null
+                let changed = 0
+                const flush = () => {
+                  if (block && block.lines.length > 0) {
+                    const lines = block.lines
+                    lines.forEach((el, i) => {
+                      if (!el.classList.contains('dshq-cmp-quote')) changed++
+                      el.classList.add('dshq-cmp-quote')
+                      el.classList.toggle('dshq-cmp-quote-first', i === 0)
+                      el.classList.toggle('dshq-cmp-quote-last', i === lines.length - 1)
+                    })
+                  }
+                  block = null
+                }
                 for (const el of kids) {
                   const t = String(el.textContent || '').trim()
-                  if (!headerEl) {
-                    // 位置行必须"整行且只有一行"，避免误把整个编辑器当成头部
-                    if (isSingleLine(t) && /^【(?:引用|批注)[^\n]*】$/.test(t)) headerEl = el
+                  const single = t !== '' && t.indexOf('\n') === -1
+                  if (single && HEADER_RE.test(t)) {
+                    flush()
+                    if (!el.classList.contains('dshq-cmp-header')) changed++
+                    el.classList.add('dshq-cmp-header')
+                    block = { lines: [] }
                     continue
                   }
-                  if (t === '') break
-                  if (!isSingleLine(t)) break
-                  quoteEls.push(el)
+                  if (!block) continue
+                  if (t === '' || !single) { flush(); continue }
+                  block.lines.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),
-                      })
-                    }
-                  }
-                  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 })
+                flush()
+                if (changed > 0) report('cmp:decorated', { changed })
               }
             } catch (e) { report('cmp:scan-throw', String((e && e.message) || e)) }
           }
@@ -1738,7 +1805,6 @@ window.__ModuleLoader__.load({
           } catch (e) { report('cmp:observer-throw', String((e && e.message) || e)) }
           return () => {
             if (composerDecorateNow === decorate) composerDecorateNow = null
-            if (timer !== null) clearTimeout(timer)
             if (observer) { try { observer.disconnect() } catch (e) { /* ignore */ } }
           }
         }, 'dsh-quote-annotate-pro: composer quote decoration')

package/package.json

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