@p-dsh-market/conversation-knowledge-map 0.1.14 → 0.1.16

package/README.md

@@ -11,7 +11,7 @@ DSH 的“知识视图”插件，把同一工作路径下用户明确选择的
 
 配置面板会列出运行时可用的 Provider / Model，并默认带入 DSH 默认模型；本次选择会绑定到确认令牌、Agent 调用和 `manifest.json`，不会因为默认模型变化而被静默替换。提交任务后配置对话框立即关闭，失败原因会显示在知识视图页的任务条中。
 
-摘要阶段按对话并行处理，并发上限固定为 3；每个对话按约 5000 字、优先在完整段落边界分段，只有单段本身超长时才按句末或硬边界拆分。同一对话的分段保持顺序处理，随后先合并为一份对话摘要，再统一生成思维导图或知识图谱。结构化输出失败时会完全重置并最多重试 3 次；单个对话连续失败后只跳过该对话，不阻断其他对话和最终报告。“同时生成”模式下，一个最终视图失败也不会阻断另一个视图保存。进度区域和最终知识视图都会按时间线显示读取、摘要、具体失败原因、重试、跳过、合并、生成及保存过程。模型可以保留 thinking，但结果提取只读取最终文本并过滤 reasoning 内容；摘要和最终视图分别预留 12000 与 24000 个输出 Token。知识图谱最多生成 20 个实体、30 条关系。最终模型若返回未选择的 Session 引用，会过滤该引用；严格模式下无有效来源的内容项会被跳过，最终页面列出实际总结的对话、失败对话和过滤数量。
+摘要阶段按对话并行处理，并发上限固定为 3；每个对话按约 5000 字、优先在完整段落边界分段，只有单段本身超长时才按句末或硬边界拆分。同一对话的分段保持顺序处理。思维导图使用合并后的会话摘要；知识图谱直接使用保留来源的分段摘要，避免长对话在二次压缩后丢失实体。知识图谱按证据分段多次生成，最多 2 批并行；单批限制在 10–18 个实体、最多 24 条关系，若达到输出 Token 上限则只降低并重试当前批次。所有成功批次由 Host 按实体类型与名称、关系起点/终点/类型确定性去重并合并来源，最终结果再根据已读取文本量和有效分段数裁剪为 30–100 个实体、最多 200 条关系。单个批次连续失败只跳过该批，不会推翻其他成功批次。结构化输出失败时会完全重置并最多重试 3 次；单个对话摘要连续失败后只跳过该对话，不阻断其他对话和最终报告。“同时生成”模式下，一个最终视图失败也不会阻断另一个视图保存。进度区域和最终知识视图都会按时间线显示读取、摘要、具体失败原因、重试、跳过、合并、生成及保存过程；知识图谱时间线还会显示批次数、模型返回数量和合并去重后的保留数量。模型可以保留 thinking，但结果提取只读取最终文本并过滤 reasoning 内容；摘要和每次图谱调用分别预留 12000 与 24000 个输出 Token。最终模型若返回未选择的 Session 引用，会过滤该引用；严格模式下无有效来源的内容项会被跳过，最终页面列出实际总结的对话、失败对话和过滤数量。
 
 生成过程时间线支持折叠和展开：进行中的任务默认展开，已完成结果中的历史时间线默认折叠。思维导图使用递归树形布局并绘制父子连接线。知识图谱按关联度使用中心节点与内外双环布局，节点卡片内显示类型和最多两行名称，关系以带方向箭头的弱化曲线呈现，并通过描边区分推测或冲突内容；画布提供 50%–200% 缩放和一键恢复 100%，缩放不会影响实体筛选、点击和详情查看，也不会产生横向滚动条。
 

package/lib/generation-orchestrator.js

@@ -10,6 +10,12 @@ const SUMMARY_MAX_TOKENS = 12000
 const VIEW_MAX_TOKENS = 24000
 const SUMMARY_CONCURRENCY = 3
 const MAX_MODEL_RETRIES = 3
+const GRAPH_CONCURRENCY = 2
+const GRAPH_BATCH_MAX_ENTITIES = 18
+const GRAPH_BATCH_MAX_RELATIONS = 24
+const MIN_GRAPH_ENTITIES = 30
+const MAX_GRAPH_ENTITIES = 100
+const MAX_GRAPH_RELATIONS = 200
 
 function modelLabel(selection) {
   const provider = String(selection?.provider || '').trim()
@@ -154,7 +160,7 @@ function normalizeSummary(value, source, chunk) {
   const summary = shortText(result.summary || result.narrative || result.text, MAX_SUMMARY_CHARS)
   if (!summary) throw new Error(`对话 ${source.sessionId} 的摘要为空。`)
   const keyPoints = Array.isArray(result.keyPoints)
-    ? result.keyPoints.map((item) => shortText(item, 500)).filter(Boolean).slice(0, 12)
+    ? result.keyPoints.map((item) => shortText(item, 500)).filter(Boolean).slice(0, 24)
     : []
   const sourceRefs = sanitizeSourceRefs(result.sourceRefs, source, sourceRefsFromChunk(source, chunk))
   return {
@@ -177,6 +183,129 @@ function mergeSourceSummaries(source, chunkSummaries) {
   return { sessionId: source.sessionId, title: source.title, summary, keyPoints, sourceRefs }
 }
 
+function graphGenerationContext(successfulResults) {
+  return successfulResults.flatMap((result) => (result.chunkSummaries || []).map((summary, index) => ({
+    sessionId: summary.sessionId,
+    title: summary.title,
+    chunk: index + 1,
+    summary: summary.summary,
+    keyPoints: summary.keyPoints,
+    sourceRefs: summary.sourceRefs
+  })))
+}
+
+function graphGenerationBudget(sources, context) {
+  const sourceChars = sources.reduce((total, source) => total + String(source?.text || '').length, 0)
+  const evidenceUnits = Math.max(sources.length, context.length)
+  const entities = Math.min(MAX_GRAPH_ENTITIES, Math.max(
+    MIN_GRAPH_ENTITIES,
+    Math.ceil(sourceChars / 1200),
+    evidenceUnits * 6
+  ))
+  return {
+    entities,
+    relations: Math.min(MAX_GRAPH_RELATIONS, Math.max(entities, Math.ceil(entities * 1.8)))
+  }
+}
+
+function graphBatchBudget(context, attempt = 0) {
+  const contextChars = JSON.stringify(context || []).length
+  const reduction = Math.max(0.5, 1 - attempt * 0.2)
+  const entities = Math.max(8, Math.floor(Math.min(GRAPH_BATCH_MAX_ENTITIES, Math.max(10, Math.ceil(contextChars / 500))) * reduction))
+  return {
+    entities,
+    relations: Math.max(entities, Math.floor(Math.min(GRAPH_BATCH_MAX_RELATIONS, Math.ceil(entities * 1.35)) * reduction))
+  }
+}
+
+function mergeRefs(...groups) {
+  const bySession = new Map()
+  for (const ref of groups.flat()) {
+    const sessionId = String(ref?.sessionId || '')
+    if (!sessionId) continue
+    const seqs = bySession.get(sessionId) || new Set()
+    for (const seq of ref?.eventSeqs || []) if (Number.isInteger(seq) && seq >= 0) seqs.add(seq)
+    bySession.set(sessionId, seqs)
+  }
+  return [...bySession.entries()].slice(0, 12).map(([sessionId, seqs]) => ({ sessionId, eventSeqs: [...seqs].slice(0, 48) }))
+}
+
+function mergedConfidence(left, right) {
+  const values = new Set([left, right])
+  if (values.has('conflicted')) return 'conflicted'
+  if (values.has('inferred')) return 'inferred'
+  return 'confirmed'
+}
+
+function entityMergeKey(entity) {
+  const normalize = (value) => String(value || '').normalize('NFKC').trim().toLowerCase().replace(/\s+/g, ' ')
+  return `${normalize(entity?.type || 'concept')}\u0000${normalize(entity?.name)}`
+}
+
+function mergeKnowledgeGraphs(graphs, budget) {
+  const entitiesByKey = new Map()
+  const idMaps = []
+  let nextEntityId = 1
+  const usedEntityIds = new Set()
+  graphs.forEach((graph, graphIndex) => {
+    const idMap = new Map()
+    for (const entity of graph.entities || []) {
+      const key = entityMergeKey(entity)
+      let merged = entitiesByKey.get(key)
+      if (!merged) {
+        const requestedId = String(entity.id || '').trim()
+        let id = requestedId && !usedEntityIds.has(requestedId) ? requestedId : `entity-${nextEntityId++}`
+        while (usedEntityIds.has(id)) id = `entity-${nextEntityId++}`
+        usedEntityIds.add(id)
+        merged = { ...entity, id, sourceRefs: mergeRefs(entity.sourceRefs), order: entitiesByKey.size }
+        entitiesByKey.set(key, merged)
+      } else {
+        merged.sourceRefs = mergeRefs(merged.sourceRefs, entity.sourceRefs)
+        merged.confidence = mergedConfidence(merged.confidence, entity.confidence)
+        if (String(entity.summary || '').length > String(merged.summary || '').length) merged.summary = entity.summary
+      }
+      idMap.set(String(entity.id), merged.id)
+    }
+    idMaps[graphIndex] = idMap
+  })
+
+  const relationsByKey = new Map()
+  graphs.forEach((graph, graphIndex) => {
+    const idMap = idMaps[graphIndex]
+    for (const relation of graph.relations || []) {
+      const from = idMap.get(String(relation.from))
+      const to = idMap.get(String(relation.to))
+      if (!from || !to || from === to) continue
+      const type = String(relation.type || 'related_to').trim()
+      const key = `${from}\u0000${to}\u0000${type.toLowerCase()}`
+      const existing = relationsByKey.get(key)
+      if (existing) {
+        existing.evidence = mergeRefs(existing.evidence, relation.evidence)
+        existing.confidence = mergedConfidence(existing.confidence, relation.confidence)
+      } else {
+        relationsByKey.set(key, { ...relation, from, to, type, evidence: mergeRefs(relation.evidence), order: relationsByKey.size })
+      }
+    }
+  })
+
+  const degree = new Map()
+  for (const relation of relationsByKey.values()) {
+    degree.set(relation.from, (degree.get(relation.from) || 0) + 1)
+    degree.set(relation.to, (degree.get(relation.to) || 0) + 1)
+  }
+  const entities = [...entitiesByKey.values()]
+    .sort((left, right) => (degree.get(right.id) || 0) - (degree.get(left.id) || 0) || right.sourceRefs.length - left.sourceRefs.length || left.order - right.order)
+    .slice(0, budget.entities)
+    .map(({ order, ...entity }) => entity)
+  const retainedIds = new Set(entities.map((entity) => entity.id))
+  const relations = [...relationsByKey.values()]
+    .filter((relation) => retainedIds.has(relation.from) && retainedIds.has(relation.to))
+    .sort((left, right) => right.evidence.length - left.evidence.length || left.order - right.order)
+    .slice(0, budget.relations)
+    .map(({ order, ...relation }, index) => ({ ...relation, id: `relation-${index + 1}` }))
+  return { entities, relations }
+}
+
 async function mapWithConcurrency(items, limit, mapper) {
   const results = new Array(items.length)
   let nextIndex = 0
@@ -300,7 +429,7 @@ function assertOutputSourceRefs(value, sources) {
   for (const relation of value?.knowledgeGraph?.relations || []) for (const ref of relation.evidence || []) check(ref, `知识图谱关系 ${relation.id}`)
 }
 
-function outputPrompt(kind, summaries, prompt, strict) {
+function outputPrompt(kind, summaries, prompt, strict, options = {}) {
   const rules = [
     '只输出一个 JSON 对象，不要 Markdown 代码围栏，不要额外解释。',
     '所有 sourceRefs/evidence 必须使用给定的 sessionId 和 eventSeqs，不能虚构来源。',
@@ -317,13 +446,16 @@ function outputPrompt(kind, summaries, prompt, strict) {
       `对话摘要：${context}`
     ].join('\n\n')
   }
+  const graphBudget = options.graphBudget || { entities: MIN_GRAPH_ENTITIES, relations: Math.ceil(MIN_GRAPH_ENTITIES * 1.8) }
   return [
-    '请根据以下多个对话摘要生成静态知识图谱。抽取实体、概念、模块、接口、决策、风险和外部系统，并只建立有依据的关系。',
-    '最多生成 20 个实体、30 条关系；实体 summary 控制在 220 字以内。不要输出 schema 之外的字段。确保最终内容是可被 JSON.parse 直接解析的完整 JSON。',
+    '请根据以下多个对话分段证据生成高召回的静态知识图谱。系统性抽取人物/组织、实体、概念、模块、接口、数据对象、工具、外部系统、需求、约束、决策、结论、风险、问题和行动项，并只建立有依据的关系。',
+    `本次内容规模对应的上限为 ${graphBudget.entities} 个实体、${graphBudget.relations} 条关系。这是防止输出失控的上限，不是要求凑数；在有依据的前提下应尽量完整覆盖每个对话和分段，不要只保留少数总括性主题。实体 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) || '没有额外要求。'}`,
-    `对话摘要：${context}`
+    `对话分段证据：${context}`
   ].join('\n\n')
 }
 
@@ -331,7 +463,7 @@ function summaryPrompt(source, chunk, strict) {
   return [
     '请把一段 DSH 对话整理成带来源的结构化摘要。不要复述完整聊天，不要添加对话中没有的事实。',
     '只输出 JSON：{"summary":"完整阶段性说明","keyPoints":["..."],"sourceRefs":[{"sessionId":"...","eventSeqs":[1]}]}。',
-    'summary 控制在 1200 字以内；keyPoints 最多 8 条，每条不超过 160 字。不要增加其他字段。字符串中的双引号必须正确转义，确保整个输出可以被 JSON.parse 直接解析。',
+    'summary 控制在 1200 字以内；keyPoints 最多 16 条，每条不超过 160 字。keyPoints 要优先保留具名的人物/组织、模块、接口、数据对象、工具、外部系统、需求、约束、决策、风险、问题、行动项以及它们之间的关系，不要只写总括性主题。不要增加其他字段。字符串中的双引号必须正确转义，确保整个输出可以被 JSON.parse 直接解析。',
     strict ? '严格模式：每个关键点都要能回指给定事件。' : '允许标记尚未确认的冲突，但不能编造事件序号。',
     `Session：${source.sessionId}`,
     `标题：${source.title}`,
@@ -684,7 +816,7 @@ export class KnowledgeGenerationOrchestrator {
           sourceCount: sources.length,
           progress: { percent: 10 + Math.floor(60 * completedSources / sources.length), current: completedSources, total: sources.length, label: `已完成摘要：${source.title}` }
         })
-        return { source, error: '', summary: mergeSourceSummaries(source, chunkSummaries) }
+        return { source, error: '', summary: mergeSourceSummaries(source, chunkSummaries), chunkSummaries }
       })
       this.assertNotCancelled(task)
       const successfulResults = summaryResults.filter((result) => result?.summary)
@@ -694,6 +826,8 @@ export class KnowledgeGenerationOrchestrator {
       if (!successfulResults.length) throw new Error(`所选 ${sources.length} 个对话均未能生成合法摘要，已分别重试 ${MAX_MODEL_RETRIES} 次。`)
       const summarizedSources = successfulResults.map((result) => result.source)
       const summaries = successfulResults.map((result) => result.summary)
+      const graphContext = graphGenerationContext(successfulResults)
+      const graphBudget = graphGenerationBudget(summarizedSources, graphContext)
       const sourceSessionIds = summarizedSources.map((source) => source.sessionId)
       this.recordTimeline(task, 'merge', `已合并 ${summaries.length} 个对话摘要${failedSources.length ? `，跳过 ${failedSources.length} 个失败对话` : ''}，开始生成最终视图。`)
       let mindMap = null
@@ -738,39 +872,53 @@ export class KnowledgeGenerationOrchestrator {
         }
       }
       if (request.outputMode === 'knowledge-graph' || request.outputMode === 'both') {
-        this.recordTimeline(task, 'view-start', '开始生成知识图谱。')
-        this.update(task, 'building-knowledge-graph', { progress: { percent: 86, current: sources.length, total: sources.length, label: '生成知识图谱' } })
-        const baseGraphPrompt = outputPrompt('knowledge-graph', summaries, request.prompt, request.strict === true)
-        let graphError = null
-        for (let attempt = 0; attempt <= MAX_MODEL_RETRIES; attempt += 1) {
-          try {
-            const prompt = attempt === 0 ? baseGraphPrompt : `${baseGraphPrompt}\n\n第 ${attempt} 次输出未通过校验：${shortText(errorMessage(graphError), 500)}。请完全重置并从头生成，只输出完整、严格合法且更精简的 JSON。`
-            const value = await this.runModel({
-              kind: 'knowledge-graph', prompt, cwd: request.cwd, strict: request.strict === true,
-              selectedSessionIds: sourceSessionIds, model: request.model, signal: task.controller.signal
-            })
-            const sanitized = sanitizeKnowledgeGraphSources(value, summarizedSources, request.strict === true)
-            knowledgeGraph = validateKnowledgeGraph(sanitized.value, { selectedSessionIds: sourceSessionIds, strict: request.strict === true })
-            sourceWarnings.skippedRefs += sanitized.skippedRefs
-            sourceWarnings.skippedItems += sanitized.skippedItems
-            graphError = null
-            this.recordTimeline(task, 'view-complete', '知识图谱生成完成。')
-            break
-          } catch (error) {
-            this.assertNotCancelled(task)
-            graphError = error
-            logMessage(this.logger, 'warn', 'knowledge graph attempt invalid id=%s attempt=%d error=%s', logId(task.id), attempt + 1, errorMessage(error))
-            if (attempt < MAX_MODEL_RETRIES) {
-              this.recordTimeline(task, 'retry', `知识图谱生成失败（${shortText(errorMessage(graphError), 160)}），重置重试 ${attempt + 1}/${MAX_MODEL_RETRIES}。`)
-              this.update(task, 'building-knowledge-graph', {
-                message: `知识图谱结构无效，正在重置重试 ${attempt + 1}/${MAX_MODEL_RETRIES}…`,
-                progress: { percent: 88, current: sources.length, total: sources.length, label: `知识图谱重试 ${attempt + 1}/${MAX_MODEL_RETRIES}` }
+        const graphBatches = graphContext.map((item) => [item])
+        this.recordTimeline(task, 'view-start', `开始分 ${graphBatches.length} 批生成知识图谱（最多 ${GRAPH_CONCURRENCY} 批并行）。`)
+        this.update(task, 'building-knowledge-graph', { progress: { percent: 86, current: 0, total: graphBatches.length, label: '分批生成知识图谱' } })
+        let completedGraphBatches = 0
+        const graphBatchResults = await mapWithConcurrency(graphBatches, GRAPH_CONCURRENCY, async (batch, batchIndex) => {
+          let graphError = null
+          for (let attempt = 0; attempt <= MAX_MODEL_RETRIES; attempt += 1) {
+            try {
+              const batchBudget = graphBatchBudget(batch, attempt)
+              const baseGraphPrompt = outputPrompt('knowledge-graph', batch, request.prompt, request.strict === true, { graphBudget: batchBudget })
+              const prompt = attempt === 0 ? baseGraphPrompt : `${baseGraphPrompt}\n\n本批第 ${attempt} 次输出未通过校验：${shortText(errorMessage(graphError), 500)}。请完全重置并从头生成；本次预算已降低，优先保留有明确关系和来源的实体。只输出完整、严格合法的 JSON。`
+              const value = await this.runModel({
+                kind: 'knowledge-graph', prompt, cwd: request.cwd, strict: request.strict === true,
+                selectedSessionIds: sourceSessionIds, model: request.model, signal: task.controller.signal
               })
+              const sanitized = sanitizeKnowledgeGraphSources(value, summarizedSources, request.strict === true)
+              const graph = validateKnowledgeGraph(sanitized.value, { selectedSessionIds: sourceSessionIds, strict: request.strict === true })
+              sourceWarnings.skippedRefs += sanitized.skippedRefs
+              sourceWarnings.skippedItems += sanitized.skippedItems
+              completedGraphBatches += 1
+              this.recordTimeline(task, 'graph-batch-complete', `知识图谱第 ${batchIndex + 1}/${graphBatches.length} 批完成：保留 ${graph.entities.length} 个实体、${graph.relations.length} 条关系。`, { batch: batchIndex + 1, totalBatches: graphBatches.length })
+              this.update(task, 'building-knowledge-graph', { progress: { percent: 86 + Math.floor(4 * completedGraphBatches / graphBatches.length), current: completedGraphBatches, total: graphBatches.length, label: `知识图谱批次 ${completedGraphBatches}/${graphBatches.length}` } })
+              return { graph, rawEntities: Array.isArray(value?.entities) ? value.entities.length : 0, rawRelations: Array.isArray(value?.relations) ? value.relations.length : 0, error: null }
+            } catch (error) {
+              this.assertNotCancelled(task)
+              graphError = error
+              logMessage(this.logger, 'warn', 'knowledge graph batch invalid id=%s batch=%d attempt=%d error=%s', logId(task.id), batchIndex + 1, attempt + 1, errorMessage(error))
+              if (attempt < MAX_MODEL_RETRIES) {
+                this.recordTimeline(task, 'retry', `知识图谱第 ${batchIndex + 1}/${graphBatches.length} 批失败（${shortText(errorMessage(graphError), 160)}），降低本批输出预算后重试 ${attempt + 1}/${MAX_MODEL_RETRIES}。`)
+              }
             }
           }
-        }
-        if (graphError) {
-          this.recordTimeline(task, 'view-failed', `知识图谱连续重试 ${MAX_MODEL_RETRIES} 次后仍失败，已跳过该视图。`)
+          completedGraphBatches += 1
+          this.recordTimeline(task, 'graph-batch-skipped', `知识图谱第 ${batchIndex + 1}/${graphBatches.length} 批连续失败，已跳过本批。`)
+          return { graph: null, rawEntities: 0, rawRelations: 0, error: graphError }
+        })
+        const successfulGraphBatches = graphBatchResults.filter((result) => result.graph)
+        if (successfulGraphBatches.length) {
+          const mergedGraph = mergeKnowledgeGraphs(successfulGraphBatches.map((result) => result.graph), graphBudget)
+          knowledgeGraph = validateKnowledgeGraph(mergedGraph, { selectedSessionIds: sourceSessionIds, strict: request.strict === true })
+          const rawEntities = successfulGraphBatches.reduce((total, result) => total + result.rawEntities, 0)
+          const rawRelations = successfulGraphBatches.reduce((total, result) => total + result.rawRelations, 0)
+          this.recordTimeline(task, 'graph-coverage', `知识图谱 ${successfulGraphBatches.length}/${graphBatches.length} 批成功，模型共返回 ${rawEntities} 个实体、${rawRelations} 条关系；合并去重后保留 ${knowledgeGraph.entities.length} 个实体、${knowledgeGraph.relations.length} 条关系。`, { entityLimit: graphBudget.entities, relationLimit: graphBudget.relations })
+          this.recordTimeline(task, 'view-complete', '知识图谱分批生成与合并完成。')
+        } else {
+          const graphError = graphBatchResults.find((result) => result.error)?.error || new Error('所有知识图谱批次均生成失败。')
+          this.recordTimeline(task, 'view-failed', `知识图谱 ${graphBatches.length} 个批次均失败，已跳过该视图。`)
           if (request.outputMode === 'knowledge-graph') throw graphError
         }
       }

package/package.json

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