@p-dsh-market/conversation-knowledge-map 0.1.8 → 0.1.10

package/README.md

@@ -11,6 +11,8 @@ DSH 的“知识视图”插件，把同一工作路径下用户明确选择的
 
 配置面板会列出运行时可用的 Provider / Model，并默认带入 DSH 默认模型；本次选择会绑定到确认令牌、Agent 调用和 `manifest.json`，不会因为默认模型变化而被静默替换。提交任务后配置对话框立即关闭，失败原因会显示在知识视图页的任务条中。
 
+摘要阶段按对话并行处理，并发上限固定为 3；同一对话的超长分段保持顺序处理，随后先合并为一份对话摘要，再统一生成思维导图或知识图谱。结构化生成关闭推理输出以减少等待和 Token 消耗；知识图谱最多生成 20 个实体、30 条关系。
+
 节点“继续对话”只形成一个可编辑的后续问题。确认导航后，插件使用公开的 Session 导航入口；如果当前 Runtime 没有向该槽位暴露草稿镜像，则提供“打开并复制问题”的安全降级，不自动发送消息。
 
 ## 生成失败诊断
@@ -25,4 +27,4 @@ node --check market/conversation-knowledge-map/lib/index.js
 node --check market/conversation-knowledge-map/lib/client.js
 ```
 
-本地实现未执行 `npm pack`、发布或真实 Profile 安装；真实 DSH Web 视觉回放仍需在插件安装后验证。
+仓库测试通过后可同步到 DSH Web Profile；真实 DSH Web 视觉回放仍需重启 Runtime 后验证。

package/lib/generation-orchestrator.js

@@ -8,6 +8,7 @@ import { chunkSourceText, readSelectedSurfaces } from './session-source.js'
 const MAX_SUMMARY_CHARS = 2400
 const SUMMARY_MAX_TOKENS = 8000
 const VIEW_MAX_TOKENS = 12000
+const SUMMARY_CONCURRENCY = 3
 
 function modelLabel(selection) {
   const provider = String(selection?.provider || '').trim()
@@ -68,7 +69,16 @@ function textFromContent(value) {
   return ''
 }
 
-function findJsonObject(text) {
+function expectedObject(value, kind = '') {
+  if (!kind) return true
+  if (kind === 'summary') return typeof value?.summary === 'string' || typeof value?.narrative === 'string' || typeof value?.text === 'string'
+  if (kind === 'mind-map') return Array.isArray(value?.nodes)
+  if (kind === 'knowledge-graph') return Array.isArray(value?.entities) && Array.isArray(value?.relations)
+  if (kind === 'follow-up') return typeof value?.question === 'string'
+  return true
+}
+
+function findJsonObject(text, kind = '') {
   const candidates = []
   const fenced = String(text || '').match(/```(?:json)?\s*([\s\S]*?)```/i)
   if (fenced) candidates.push(fenced[1])
@@ -98,7 +108,7 @@ function findJsonObject(text) {
             const fragment = candidate.slice(start, index + 1)
             try {
               const parsed = JSON.parse(fragment)
-              if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed
+              if (parsed && typeof parsed === 'object' && !Array.isArray(parsed) && expectedObject(parsed, kind)) return parsed
             } catch {
               // Try the next opening brace in case prose contained an example.
             }
@@ -111,11 +121,11 @@ function findJsonObject(text) {
   return null
 }
 
-export function parseStructuredOutput(value) {
+export function parseStructuredOutput(value, kind = '') {
   const object = asObject(value)
-  if (object) return object
+  if (object && expectedObject(object, kind)) return object
   const text = textFromContent(value).replace(/^\uFEFF/, '').trim()
-  const parsed = findJsonObject(text)
+  const parsed = findJsonObject(text, kind)
   if (parsed) return parsed
   if (!text) throw new Error('模型没有返回 JSON 对象。')
   throw new Error('模型返回了文本，但其中没有可解析的 JSON 对象。')
@@ -155,6 +165,39 @@ function normalizeSummary(value, source, chunk) {
   }
 }
 
+function mergeSourceSummaries(source, chunkSummaries) {
+  if (chunkSummaries.length === 1) return chunkSummaries[0]
+  const summary = shortText(chunkSummaries.map((item) => item.summary).filter(Boolean).join('\n'), MAX_SUMMARY_CHARS)
+  const keyPoints = [...new Set(chunkSummaries.flatMap((item) => item.keyPoints || []).map((item) => shortText(item, 500)).filter(Boolean))].slice(0, 12)
+  const eventSeqs = [...new Set(chunkSummaries.flatMap((item) => item.sourceRefs || [])
+    .filter((ref) => ref.sessionId === source.sessionId)
+    .flatMap((ref) => ref.eventSeqs || []))].slice(0, 24)
+  const sourceRefs = eventSeqs.length ? [{ sessionId: source.sessionId, eventSeqs }] : []
+  return { sessionId: source.sessionId, title: source.title, summary, keyPoints, sourceRefs }
+}
+
+async function mapWithConcurrency(items, limit, mapper) {
+  const results = new Array(items.length)
+  let nextIndex = 0
+  let failure = null
+  const worker = async () => {
+    while (!failure) {
+      const index = nextIndex
+      nextIndex += 1
+      if (index >= items.length) return
+      try {
+        results[index] = await mapper(items[index], index)
+      } catch (error) {
+        failure ||= error
+      }
+    }
+  }
+  const workerCount = Math.min(Math.max(1, limit), items.length)
+  await Promise.all(Array.from({ length: workerCount }, () => worker()))
+  if (failure) throw failure
+  return results
+}
+
 function assertOutputSourceRefs(value, sources) {
   const allowed = new Map(sources.map((source) => [source.sessionId, new Set((source.events || []).flatMap((event) => [event.seq, ...(event.sourceEventSeqs || [])]))]))
   const check = (ref, label) => {
@@ -187,6 +230,7 @@ function outputPrompt(kind, summaries, prompt, strict) {
   }
   return [
     '请根据以下多个对话摘要生成静态知识图谱。抽取实体、概念、模块、接口、决策、风险和外部系统，并只建立有依据的关系。',
+    '最多生成 20 个实体、30 条关系；实体 summary 控制在 220 字以内。不要输出 schema 之外的字段。确保最终内容是可被 JSON.parse 直接解析的完整 JSON。',
     'JSON 形状：{"entities":[{"id":"...","type":"...","name":"...","summary":"...","confidence":"confirmed|inferred|conflicted","sourceRefs":[{"sessionId":"...","eventSeqs":[1]}]}],"relations":[{"id":"...","from":"...","to":"...","type":"depends_on|calls|supports|constrains|belongs_to|derived_from","confidence":"confirmed|inferred|conflicted","evidence":[{"sessionId":"...","eventSeqs":[1]}]}]}。',
     ...rules,
     `额外要求：${shortText(prompt, 2000) || '没有额外要求。'}`,
@@ -198,6 +242,7 @@ function summaryPrompt(source, chunk, strict) {
   return [
     '请把一段 DSH 对话整理成带来源的结构化摘要。不要复述完整聊天，不要添加对话中没有的事实。',
     '只输出 JSON：{"summary":"完整阶段性说明","keyPoints":["..."],"sourceRefs":[{"sessionId":"...","eventSeqs":[1]}]}。',
+    'summary 控制在 1200 字以内；keyPoints 最多 8 条，每条不超过 160 字。不要增加其他字段。字符串中的双引号必须正确转义，确保整个输出可以被 JSON.parse 直接解析。',
     strict ? '严格模式：每个关键点都要能回指给定事件。' : '允许标记尚未确认的冲突，但不能编造事件序号。',
     `Session：${source.sessionId}`,
     `标题：${source.title}`,
@@ -484,31 +529,43 @@ export class KnowledgeGenerationOrchestrator {
       this.assertNotCancelled(task)
       logMessage(this.logger, 'info', 'generation sources loaded id=%s sources=%d events=%d', logId(task.id), sources.length, sources.reduce((total, source) => total + (Array.isArray(source.events) ? source.events.length : 0), 0))
       this.update(task, 'summarizing', { sourceCount: sources.length, progress: { percent: 10, current: 0, total: sources.length, label: '准备整理对话' } })
-      const summaries = []
-      for (let sourceIndex = 0; sourceIndex < sources.length; sourceIndex += 1) {
-        const source = sources[sourceIndex]
+      let completedSources = 0
+      logMessage(this.logger, 'info', 'summary batch start id=%s sources=%d concurrency=%d', logId(task.id), sources.length, Math.min(SUMMARY_CONCURRENCY, sources.length))
+      const summaries = await mapWithConcurrency(sources, SUMMARY_CONCURRENCY, async (source, sourceIndex) => {
         this.update(task, 'summarizing', {
           sourceCount: sources.length,
-          progress: { percent: 10 + Math.floor(60 * sourceIndex / sources.length), current: sourceIndex, total: sources.length, label: source.title }
+          progress: { percent: 10 + Math.floor(60 * completedSources / sources.length), current: completedSources, total: sources.length, label: `并行整理：${source.title}` }
         })
+        const chunkSummaries = []
         for (const chunk of chunkSourceText(source)) {
           this.assertNotCancelled(task)
-          const value = await this.runModel({
-            kind: 'summary',
-            prompt: summaryPrompt(source, chunk, request.strict === true),
-            cwd: request.cwd,
-            strict: request.strict === true,
-            selectedSessionIds: sourceSessionIds,
-            model: request.model,
-            signal: task.controller.signal
+          const prompt = summaryPrompt(source, chunk, request.strict === true)
+          const generateSummary = async (summaryInput) => this.runModel({
+            kind: 'summary', prompt: summaryInput, cwd: request.cwd, strict: request.strict === true,
+            selectedSessionIds: sourceSessionIds, model: request.model, signal: task.controller.signal
           })
-          summaries.push(normalizeSummary(value, source, chunk))
+          try {
+            const value = await generateSummary(prompt)
+            chunkSummaries.push(normalizeSummary(value, source, chunk))
+          } catch (error) {
+            this.assertNotCancelled(task)
+            logMessage(this.logger, 'warn', 'summary first attempt invalid id=%s session=%s error=%s', logId(task.id), logId(source.sessionId), errorMessage(error))
+            this.update(task, 'summarizing', {
+              message: `对话 ${sourceIndex + 1}/${sources.length} 摘要结构无效，正在自动修复…`,
+              progress: { percent: 10 + Math.floor(60 * sourceIndex / sources.length), current: sourceIndex, total: sources.length, label: `自动修复：${source.title}` }
+            })
+            const retryPrompt = `${prompt}\n\n上一次输出未通过校验：${shortText(errorMessage(error), 500)}。请从头重新整理，缩短内容，只输出严格合法的顶层摘要 JSON。`
+            const retryValue = await generateSummary(retryPrompt)
+            chunkSummaries.push(normalizeSummary(retryValue, source, chunk))
+          }
         }
+        completedSources += 1
         this.update(task, 'summarizing', {
           sourceCount: sources.length,
-          progress: { percent: 10 + Math.floor(60 * (sourceIndex + 1) / sources.length), current: sourceIndex + 1, total: sources.length, label: source.title }
+          progress: { percent: 10 + Math.floor(60 * completedSources / sources.length), current: completedSources, total: sources.length, label: source.title }
         })
-      }
+        return mergeSourceSummaries(source, chunkSummaries)
+      })
       this.assertNotCancelled(task)
       let mindMap = null
       let knowledgeGraph = null
@@ -581,7 +638,7 @@ export class KnowledgeGenerationOrchestrator {
   async runModel(input) {
     const parseModelOutput = (value, source, diagnostics = {}) => {
       try {
-        const result = parseStructuredOutput(value)
+        const result = parseStructuredOutput(value, input.kind)
         logMessage(this.logger, 'info', 'agent output parsed kind=%s source=%s value=%s result=%s', input.kind, source, diagnosticSummary(value), diagnosticSummary(result))
         return result
       } catch (error) {
@@ -666,7 +723,7 @@ export class KnowledgeGenerationOrchestrator {
       handle = await this.agents.create({
         sessionId,
         meta: { cwd: input.cwd, origin: 'subagent' },
-        agentOptions: { provider, model, maxTokens: input.kind === 'summary' ? SUMMARY_MAX_TOKENS : VIEW_MAX_TOKENS },
+        agentOptions: { provider, model, reasoningEffort: 'off', maxTokens: input.kind === 'summary' ? SUMMARY_MAX_TOKENS : VIEW_MAX_TOKENS },
         signal: input.signal,
         setup: async (agentCtx) => {
           agentCtx?.systemPrompt?.section?.({

package/lib/session-source.js

@@ -206,7 +206,7 @@ export async function readSelectedSurfaces({ sessionQuery, sessions }, { cwd, se
   return sources
 }
 
-export function chunkSourceText(source, maxChars = 9000) {
+export function chunkSourceText(source, maxChars = 16000) {
   const text = String(source?.text || '')
   if (!text) return [{ text: '', sourceRefs: [] }]
   const chunks = []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@p-dsh-market/conversation-knowledge-map",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "DSH 多对话思维导图与静态知识图谱",
   "keywords": [
     "dsh",