@p-dsh-market/conversation-knowledge-map 0.1.0

package/lib/session-source.js

@@ -0,0 +1,188 @@
+import path from 'node:path'
+
+import { errorMessage, eventMessageText, shortText } from './protocol.js'
+
+const WINDOWS_PATH = process.platform === 'win32'
+
+export function normalizeWorkspacePath(value) {
+  const raw = String(value || '').trim()
+  if (!raw) return ''
+  const absolute = path.resolve(raw)
+  const normalized = path.normalize(absolute)
+  const root = path.parse(normalized).root
+  return normalized.length > root.length ? normalized.replace(/[\\/]$/, '') : normalized
+}
+
+export function sameWorkspacePath(left, right) {
+  const a = normalizeWorkspacePath(left)
+  const b = normalizeWorkspacePath(right)
+  if (!a || !b) return false
+  return WINDOWS_PATH ? a.toLowerCase() === b.toLowerCase() : a === b
+}
+
+function headerOf(record) {
+  return record?.header || record?.session || record || null
+}
+
+function titleOf(value) {
+  const title = value?.title ?? value?.value?.title ?? value
+  if (typeof title === 'string') return shortText(title, 160)
+  if (typeof title?.title === 'string') return shortText(title.title, 160)
+  if (typeof title?.text === 'string') return shortText(title.text, 160)
+  return ''
+}
+
+function titleResultsById(results) {
+  const map = new Map()
+  for (const item of results || []) {
+    if (item?.status === 'fulfilled') map.set(String(item.sessionId), titleOf(item.value))
+  }
+  return map
+}
+
+export function sessionRecordView(record, title = '', currentSessionId = '') {
+  const header = headerOf(record)
+  const id = String(header?.id || record?.id || '')
+  return {
+    id,
+    title: title || `未命名对话 ${id.slice(0, 8)}`,
+    createdAt: Number(header?.createdAt || 0),
+    cwd: String(header?.cwd || ''),
+    parentSession: String(header?.parentSession || ''),
+    origin: String(header?.origin || ''),
+    live: record?.live !== false,
+    persisted: record?.persisted !== false,
+    current: id === currentSessionId
+  }
+}
+
+export async function resolveAnchorSession({ sessionQuery, sessions }, sessionId) {
+  const id = String(sessionId || '').trim()
+  if (!id || id === 'active') return null
+  const live = sessions?.get?.(id)
+  if (live?.header?.id || live?.id === id) {
+    return { header: live.header || live, live: true, persisted: true }
+  }
+  if (typeof sessionQuery?.filterSessions === 'function') {
+    const records = await sessionQuery.filterSessions([{ kind: 'id', values: [id] }])
+    return records?.find((record) => String(headerOf(record)?.id || '') === id) || null
+  }
+  if (typeof sessionQuery?.listSessions === 'function') {
+    const records = await sessionQuery.listSessions()
+    return records?.find((record) => String(headerOf(record)?.id || '') === id) || null
+  }
+  return null
+}
+
+export async function listWorkspaceSessions({ sessionQuery, sessions }, cwd, currentSessionId = '', includeSubagents = false) {
+  const normalizedCwd = normalizeWorkspacePath(cwd)
+  if (!normalizedCwd) return []
+  let records = []
+  if (typeof sessionQuery?.filterSessions === 'function') {
+    records = await sessionQuery.filterSessions([{ kind: 'cwd', values: [cwd] }])
+  } else if (typeof sessionQuery?.listSessions === 'function') {
+    records = await sessionQuery.listSessions()
+  } else if (typeof sessions?.list === 'function') {
+    records = await sessions.list()
+  }
+  records = (records || []).filter((record) => {
+    const header = headerOf(record)
+    return sameWorkspacePath(header?.cwd, normalizedCwd) && (includeSubagents || header?.origin !== 'subagent')
+  })
+  const ids = records.map((record) => String(headerOf(record)?.id || record?.id || '')).filter(Boolean)
+  let titleResults = []
+  if (typeof sessionQuery?.readTitleSnapshots === 'function' && ids.length) {
+    titleResults = await sessionQuery.readTitleSnapshots(ids)
+  }
+  const titles = titleResultsById(titleResults)
+  return records
+    .map((record) => sessionRecordView(record, titles.get(String(headerOf(record)?.id || '')), currentSessionId))
+    .filter((record) => record.id)
+    .sort((left, right) => right.createdAt - left.createdAt || left.id.localeCompare(right.id))
+}
+
+function eventRole(type) {
+  if (type === 'user/message') return 'user'
+  if (type === 'assistant/message') return 'assistant'
+  return ''
+}
+
+function sourceSeqsOf(event) {
+  const value = event?.sourceEventSeqs || event?.data?.sourceEventSeqs || []
+  return Array.isArray(value) ? value.filter((item) => Number.isInteger(item) && item >= 0) : []
+}
+
+export function surfaceEventView(event) {
+  const role = eventRole(String(event?.type || ''))
+  const text = shortText(eventMessageText(event), 12000)
+  if (!role || !text) return null
+  return {
+    seq: Number.isInteger(event?.seq) ? event.seq : 0,
+    type: String(event.type),
+    role,
+    text,
+    sourceEventSeqs: sourceSeqsOf(event)
+  }
+}
+
+export async function readSelectedSurfaces({ sessionQuery, sessions }, { cwd, sessionIds, includeSubagents = false }) {
+  const selected = [...new Set((sessionIds || []).map((id) => String(id || '').trim()).filter(Boolean))]
+  if (selected.length === 0) throw new Error('至少选择一个对话。')
+  const normalizedCwd = normalizeWorkspacePath(cwd)
+  if (!normalizedCwd) throw new Error('当前工作路径无效。')
+  const records = []
+  if (typeof sessionQuery?.filterSessions === 'function') {
+    records.push(...await sessionQuery.filterSessions([{ kind: 'id', values: selected }]))
+  } else if (typeof sessionQuery?.listSessions === 'function') {
+    const all = await sessionQuery.listSessions()
+    records.push(...all.filter((record) => selected.includes(String(headerOf(record)?.id || ''))))
+  }
+  const recordMap = new Map(records.map((record) => [String(headerOf(record)?.id || record?.id || ''), record]))
+  const sources = []
+  for (const id of selected) {
+    const record = recordMap.get(id)
+    const header = headerOf(record) || sessions?.get?.(id)?.header
+    if (!header?.id) throw new Error(`所选对话不存在或已不可读：${id}`)
+    if (!sameWorkspacePath(header.cwd, normalizedCwd)) throw new Error(`所选对话不属于当前工作路径：${id}`)
+    if (!includeSubagents && header.origin === 'subagent') throw new Error(`不能选择子 Agent 对话：${id}`)
+    if (typeof sessionQuery?.readSurface !== 'function') throw new Error('当前 DSH Runtime 未提供 sessionQuery.readSurface。')
+    let surface
+    try {
+      surface = await sessionQuery.readSurface(id)
+    } catch (error) {
+      throw new Error(`读取对话“${id}”失败：${errorMessage(error)}`)
+    }
+    const events = (surface?.events || []).map(surfaceEventView).filter(Boolean)
+    sources.push({
+      sessionId: id,
+      title: `对话 ${id.slice(0, 8)}`,
+      cwd: normalizeWorkspacePath(surface?.session?.cwd || header.cwd),
+      capturedThroughSeq: Number.isInteger(surface?.capturedThroughSeq) ? surface.capturedThroughSeq : null,
+      events,
+      text: events.map((event) => `${event.role === 'user' ? '用户' : '助手'}：${event.text}`).join('\n\n')
+    })
+  }
+  if (typeof sessionQuery?.readTitleSnapshots === 'function' && sources.length) {
+    const results = await sessionQuery.readTitleSnapshots(sources.map((source) => source.sessionId))
+    const titles = titleResultsById(results)
+    for (const source of sources) source.title = titles.get(source.sessionId) || source.title
+  }
+  return sources
+}
+
+export function chunkSourceText(source, maxChars = 9000) {
+  const text = String(source?.text || '')
+  if (!text) return [{ text: '', sourceRefs: [] }]
+  const chunks = []
+  let start = 0
+  while (start < text.length) {
+    const end = Math.min(text.length, start + maxChars)
+    const chunkText = text.slice(start, end)
+    const refs = (source.events || [])
+      .filter((event) => event.text && text.indexOf(event.text, start) >= start && text.indexOf(event.text, start) < end)
+      .map((event) => ({ sessionId: source.sessionId, eventSeqs: [event.seq] }))
+    chunks.push({ text: chunkText, sourceRefs: refs })
+    start = end
+  }
+  return chunks
+}

package/lib/workspace-storage.js

@@ -0,0 +1,224 @@
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import { randomUUID } from 'node:crypto'
+
+import { DATA_DIR, shortText } from './protocol.js'
+import { normalizeWorkspacePath } from './session-source.js'
+
+const FILES = {
+  manifest: 'manifest.json',
+  mindMap: 'mind-map.json',
+  knowledgeGraph: 'knowledge-graph.json',
+  navigationHistory: 'navigation-history.json'
+}
+
+export const WORKSPACE_SCHEMA_VERSION = 1
+
+function compatibilityOf(manifest) {
+  if (Number(manifest?.schemaVersion) === WORKSPACE_SCHEMA_VERSION) {
+    return { supported: true, state: 'current', schemaVersion: WORKSPACE_SCHEMA_VERSION, message: '' }
+  }
+  const version = Number.isInteger(manifest?.schemaVersion) ? manifest.schemaVersion : null
+  return {
+    supported: false,
+    state: 'legacy',
+    schemaVersion: version,
+    message: '当前工作区知识视图来自旧版本 Schema，暂不直接加载；请确认后重新生成。'
+  }
+}
+
+function isNotFound(error) {
+  return error?.code === 'ENOENT'
+}
+
+async function readJsonIfExists(filePath) {
+  try {
+    return JSON.parse(await readFile(filePath, 'utf8'))
+  } catch (error) {
+    if (isNotFound(error)) return null
+    throw new Error(`读取知识视图数据失败：${filePath}：${error.message}`)
+  }
+}
+
+async function writeJson(filePath, value) {
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+}
+
+async function replaceBundle(dataDir, values) {
+  const id = randomUUID()
+  const stagingDir = path.join(dataDir, `.staging-${id}`)
+  const finals = Object.entries(values).map(([key, value]) => ({
+    key,
+    temp: path.join(stagingDir, FILES[key]),
+    final: path.join(dataDir, FILES[key]),
+    value
+  }))
+  const backups = []
+  const installed = []
+  await mkdir(stagingDir, { recursive: true })
+  try {
+    for (const item of finals) await writeJson(item.temp, item.value)
+    for (const item of finals) {
+      const backup = `${item.final}.backup-${id}`
+      let hadOld = false
+      try {
+        await rename(item.final, backup)
+        hadOld = true
+      } catch (error) {
+        if (!isNotFound(error)) throw error
+      }
+      backups.push({ final: item.final, backup, hadOld })
+      await rename(item.temp, item.final)
+      installed.push(item.final)
+    }
+    for (const backup of backups) if (backup.hadOld) await rm(backup.backup, { force: true })
+    await rm(stagingDir, { recursive: true, force: true })
+  } catch (error) {
+    for (const filePath of installed) await rm(filePath, { force: true }).catch(() => {})
+    for (const backup of backups) {
+      if (backup.hadOld) await rename(backup.backup, backup.final).catch(() => {})
+    }
+    await rm(stagingDir, { recursive: true, force: true }).catch(() => {})
+    throw error
+  }
+}
+
+function workspaceKey(cwd) {
+  return process.platform === 'win32' ? cwd.toLowerCase() : cwd
+}
+
+export class WorkspaceRevisionError extends Error {
+  constructor(expected, actual) {
+    super(`工作区结果已被其他窗口更新（期望 revision ${expected}，当前 revision ${actual}），请重新确认后再生成。`)
+    this.name = 'WorkspaceRevisionError'
+    this.expected = expected
+    this.actual = actual
+  }
+}
+
+export class WorkspaceStorage {
+  constructor({ now = () => Date.now() } = {}) {
+    this.now = now
+    this.locks = new Map()
+  }
+
+  resolveDataDir(cwd) {
+    const normalized = normalizeWorkspacePath(cwd)
+    if (!normalized || !path.isAbsolute(normalized)) throw new Error('工作路径必须是绝对路径。')
+    const dataDir = path.resolve(normalized, DATA_DIR)
+    if (path.dirname(dataDir) !== normalized) throw new Error('工作区数据目录解析失败。')
+    return dataDir
+  }
+
+  async readState(cwd) {
+    const dataDir = this.resolveDataDir(cwd)
+    const manifest = await readJsonIfExists(path.join(dataDir, FILES.manifest))
+    if (!manifest) return {
+      exists: false,
+      dataDir,
+      revision: 0,
+      manifest: null,
+      mindMap: null,
+      knowledgeGraph: null,
+      navigationHistory: [],
+      compatibility: { supported: true, state: 'empty', schemaVersion: WORKSPACE_SCHEMA_VERSION, message: '' }
+    }
+    const compatibility = compatibilityOf(manifest)
+    if (!compatibility.supported) return {
+      exists: true,
+      dataDir,
+      revision: Number.isInteger(manifest.revision) ? manifest.revision : 0,
+      manifest,
+      mindMap: null,
+      knowledgeGraph: null,
+      navigationHistory: [],
+      compatibility
+    }
+    const [mindMap, knowledgeGraph, navigationHistory] = await Promise.all([
+      readJsonIfExists(path.join(dataDir, FILES.mindMap)),
+      readJsonIfExists(path.join(dataDir, FILES.knowledgeGraph)),
+      readJsonIfExists(path.join(dataDir, FILES.navigationHistory))
+    ])
+    return {
+      exists: true,
+      dataDir,
+      revision: Number.isInteger(manifest.revision) ? manifest.revision : 0,
+      manifest,
+      mindMap,
+      knowledgeGraph,
+      navigationHistory: Array.isArray(navigationHistory) ? navigationHistory : [],
+      compatibility
+    }
+  }
+
+  async saveBundle({ cwd, expectedRevision = 0, generationId, sourceSessionIds, prompt, strict, outputMode, model, mindMap, knowledgeGraph }) {
+    const normalizedCwd = normalizeWorkspacePath(cwd)
+    const key = workspaceKey(normalizedCwd)
+    const previous = this.locks.get(key) || Promise.resolve()
+    const operation = previous.catch(() => {}).then(async () => {
+      const current = await this.readState(normalizedCwd)
+      if (Number(expectedRevision) !== current.revision) throw new WorkspaceRevisionError(expectedRevision, current.revision)
+      const revision = current.revision + 1
+      const manifest = {
+        schemaVersion: WORKSPACE_SCHEMA_VERSION,
+        plugin: '@p-dsh-market/conversation-knowledge-map',
+        generationId: String(generationId || ''),
+        revision,
+        cwd: normalizedCwd,
+        sourceSessionIds: [...new Set((sourceSessionIds || []).map(String))],
+        promptSummary: shortText(prompt, 500),
+        strict: strict === true,
+        outputMode: String(outputMode || 'both'),
+        model: model ? { provider: String(model.provider || ''), model: String(model.model || '') } : null,
+        generatedAt: this.now()
+      }
+      const navigationHistory = current.navigationHistory || []
+      await replaceBundle(this.resolveDataDir(normalizedCwd), {
+        manifest,
+        mindMap: mindMap || null,
+        knowledgeGraph: knowledgeGraph || null,
+        navigationHistory
+      })
+      return { revision, manifest, dataDir: this.resolveDataDir(normalizedCwd) }
+    })
+    this.locks.set(key, operation)
+    try {
+      return await operation
+    } finally {
+      if (this.locks.get(key) === operation) this.locks.delete(key)
+    }
+  }
+
+  async appendNavigation({ cwd, expectedRevision, navigation }) {
+    const normalizedCwd = normalizeWorkspacePath(cwd)
+    const key = workspaceKey(normalizedCwd)
+    const previous = this.locks.get(key) || Promise.resolve()
+    const operation = previous.catch(() => {}).then(async () => {
+      const current = await this.readState(normalizedCwd)
+      if (expectedRevision !== undefined && Number(expectedRevision) !== current.revision) {
+        throw new WorkspaceRevisionError(expectedRevision, current.revision)
+      }
+      const history = [...(current.navigationHistory || []), {
+        id: String(navigation.id || randomUUID()),
+        nodeId: String(navigation.nodeId || ''),
+        targetSessionId: String(navigation.targetSessionId || ''),
+        questionSummary: shortText(navigation.question, 500),
+        confirmedAt: this.now()
+      }].slice(-100)
+      if (!current.manifest) throw new Error('当前工作路径还没有已保存的知识视图。')
+      await replaceBundle(current.dataDir, {
+        manifest: current.manifest,
+        mindMap: current.mindMap,
+        knowledgeGraph: current.knowledgeGraph,
+        navigationHistory: history
+      })
+      return { revision: current.revision, navigation: history.at(-1) }
+    })
+    this.locks.set(key, operation)
+    try {
+      return await operation
+    } finally {
+      if (this.locks.get(key) === operation) this.locks.delete(key)
+    }
+  }
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@p-dsh-market/conversation-knowledge-map",
+  "version": "0.1.0",
+  "description": "DSH 多对话思维导图与静态知识图谱",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "p-dsh-market",
+    "conversation",
+    "mind-map",
+    "knowledge-graph"
+  ],
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./protocol": "./lib/protocol.js",
+    "./session-source": "./lib/session-source.js",
+    "./generation-orchestrator": "./lib/generation-orchestrator.js",
+    "./mind-map-schema": "./lib/mind-map-schema.js",
+    "./knowledge-graph-schema": "./lib/knowledge-graph-schema.js",
+    "./workspace-storage": "./lib/workspace-storage.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "lib/protocol.js",
+    "lib/session-source.js",
+    "lib/generation-orchestrator.js",
+    "lib/mind-map-schema.js",
+    "lib/knowledge-graph-schema.js",
+    "lib/workspace-storage.js",
+    "skills/conversation-knowledge-map/SKILL.md",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dsh": {
+    "protocolVersion": 1,
+    "client": {
+      "platform": "web"
+    },
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "market": {
+      "displayName": "知识视图",
+      "capabilities": ["skills", "host", "client", "desktop-shell"]
+    },
+    "desktop": {
+      "permissions": ["shell:titlebar", "shell:page", "workspace:read", "workspace:write-plugin-data"],
+      "contributes": {
+        "titlebarActions": [
+          {
+            "id": "open-conversation-knowledge-map",
+            "slot": "desktop.titlebar.workspaceActions",
+            "label": "知识视图",
+            "order": 140,
+            "when": ["dshRunning", "pluginActive", "restartNotRequired"],
+            "action": {
+              "type": "pluginRpc",
+              "method": "conversationKnowledgeMap.open"
+            }
+          }
+        ]
+      }
+    }
+  }
+}

package/skills/conversation-knowledge-map/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: conversation-knowledge-map
+description: 在用户明确要求整理多个同工作路径对话、生成思维导图或静态知识图谱时，使用知识视图插件的结构化生成、来源引用、严格约束和工作区持久化流程。
+---
+
+# 知识视图生成约束
+
+- 只有用户明确点击确认后，才能读取所选对话正文、调用模型或写入 `.g-dsh-market-knowledge`。
+- 只使用锚点 Session 的 `header.cwd` 和用户从同一 `cwd` 选择的 Session；默认排除 `origin: subagent`。
+- 默认读取 `sessionQuery.readSurface()`，不要读取或复制完整原始 JSONL。
+- 思维导图节点必须包含标题、阶段性说明和来源引用；知识图谱关系必须包含证据和置信度。
+- 知识图谱是静态结果，不自动更新、不在图上编辑、不从节点发散。
+- 思维导图节点只生成后续问题；导航确认后不自动发送。