dsh-plugin-mind-tree 0.0.0-stage → 0.3.0

package/lib/reduce.js

@@ -0,0 +1,182 @@
+// 过程信息削减层:把"事件日志式"的完整树压缩成"对话结构式"的思维树。
+// Copyright (c) 2026 ShOpenMind · https://github.com/ShOpenMind/dsh-plugin-mind-tree · MIT
+// 纯函数、无 DSH 依赖,客户端渲染与导出共用,可独立单测。
+import { buildHierarchy, isInjectedLabel } from './format.js';
+
+/**
+ * 三档信息量:
+ * - compact (默认):只留 轮次 + 用户真实发言 + 分支节点 + 每轮工具活动聚合 1 行 + 每轮最终助手回复;
+ * - standard:在 compact 基础上保留实质性助手过程文本(≥ MIN_ASSISTANT_STANDARD 字)与工具明细行,去掉工具结果;
+ * - full:不做任何削减(与事件日志一一对应)。
+ */
+export const DETAIL_LEVELS = ['compact', 'standard', 'full'];
+
+/** standard 档保留的助手文本最小字数。 */
+export const MIN_ASSISTANT_STANDARD = 60;
+/** 工具聚合行里展示的工具名个数。 */
+const GROUP_NAME_LIMIT = 4;
+
+const charLength = (text) => [...String(text ?? '')].length;
+
+/** 工具名:去掉"工具 "前缀与参数部分。 */
+function toolName(label) {
+  return String(label ?? '工具')
+    .replace(/^工具\s*/, '')
+    .split(/[\s(（:：]/)[0] || '工具';
+}
+
+/** 每轮最后一条助手消息(视为该轮答复)。 */
+function lastAssistantIds(nodes) {
+  const byTurn = new Map();
+  for (const node of nodes) {
+    if (node.kind !== 'assistant') continue;
+    const key = node.turn ?? -1;
+    if (!byTurn.has(key)) byTurn.set(key, []);
+    byTurn.get(key).push(node);
+  }
+  const ids = new Set();
+  for (const list of byTurn.values()) ids.add(list[list.length - 1].id);
+  return ids;
+}
+
+/**
+ * 削减思维树。
+ * @param tree - { sessionId, title, nodes, edges, turnCount }
+ * @param level - compact | standard | full
+ * @returns 与原结构同形的新对象;full 档原样返回。附 `reduction` 统计与 `grouped` 折叠信息。
+ */
+export function reduceGraph(tree, level = 'compact') {
+  if (tree === null || tree === undefined) return tree;
+  if (level === 'full') return tree;
+  const nodes = tree.nodes ?? [];
+  const keepIds = new Set();
+  const isCompact = level === 'compact';
+  const minAssistant = isCompact ? Number.POSITIVE_INFINITY : MIN_ASSISTANT_STANDARD;
+  const lastOfTurn = lastAssistantIds(nodes);
+  /** 归入工具聚合行的节点(turn -> 节点数组)。 */
+  const groupBuckets = new Map();
+
+  for (const node of nodes) {
+    // 根节点与轮次节点始终保留(树骨架)。
+    if (node.id === 'root' || node.kind === 'turn') { keepIds.add(node.id); continue; }
+    // 分支节点(决策点)始终保留,哪怕它是工具调用或助手消息。
+    if (node.branch) { keepIds.add(node.id); continue; }
+    switch (node.kind) {
+      case 'result':
+        continue; // 工具输出:折叠掉(可在工具行详情中查看)
+      case 'info':
+        continue; // system / developer 注入内容
+      case 'user':
+        if (isInjectedLabel(node.label)) continue; // 模型切换、运行时上下文、后台任务通知
+        break;
+      case 'assistant':
+        if (!(lastOfTurn.has(node.id) || charLength(node.label) >= minAssistant)) continue;
+        break;
+      case 'tool': {
+        if (!isCompact) break; // standard 保留工具明细行
+        const key = node.turn ?? -1;
+        if (!groupBuckets.has(key)) groupBuckets.set(key, []);
+        groupBuckets.get(key).push(node);
+        continue;
+      }
+      default:
+        break;
+    }
+    keepIds.add(node.id);
+  }
+
+  // 生成每轮的"工具活动"聚合行。
+  const synthetic = [];
+  for (const [turn, list] of groupBuckets) {
+    if (list.length === 0) continue;
+    const counts = new Map();
+    for (const item of list) {
+      const name = toolName(item.label);
+      counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    const top = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, GROUP_NAME_LIMIT)
+      .map(([name, count]) => (count > 1 ? `${name}×${count}` : name));
+    const rest = counts.size - top.length;
+    synthetic.push({
+      id: `tg:${turn}`,
+      seq: list[0].seq,
+      type: 'tool/group',
+      kind: 'toolgroup',
+      ...(turn >= 0 ? { turn } : {}),
+      label: `工具活动 ×${list.length} · ${top.join(' ')}${rest > 0 ? ` +${rest}` : ''}`,
+      surface: 'current',
+      // 自带折叠清单(含标签与序号),这样聚合行在"精简"档下也能独立展示与搜索。
+      grouped: list.map((item) => ({ id: item.id, label: item.label, seq: item.seq, kind: item.kind })),
+    });
+  }
+
+  const reducedNodes = [...nodes.filter((n) => keepIds.has(n.id)), ...synthetic];
+  const keptIds = new Set(reducedNodes.map((n) => n.id));
+  const { children, parentOf } = buildHierarchy(tree);
+
+  // 重新挂接:每个保留节点挂到"最近的保留祖先";找不到则挂到所属轮次,再退到根。
+  const nearestKeptAncestor = (node) => {
+    let cursor = parentOf.get(node.id);
+    const seen = new Set([node.id]);
+    while (cursor !== undefined && !seen.has(cursor)) {
+      if (keptIds.has(cursor)) return cursor;
+      seen.add(cursor);
+      cursor = parentOf.get(cursor);
+    }
+    return undefined;
+  };
+  const turnIdOf = (node) => (node.turn != null && keptIds.has(`t${node.turn}`) ? `t${node.turn}` : undefined);
+  const fallbackParent = (node) => turnIdOf(node)
+    ?? (keptIds.has('root') ? 'root' : undefined);
+
+  const edges = [];
+  const roots = reducedNodes.filter((n) => n.kind === 'turn' || n.id === 'root');
+  const rootId = reducedNodes.find((n) => n.id === 'root')?.id;
+  const turns = reducedNodes.filter((n) => n.kind === 'turn').sort((a, b) => (a.turn ?? 0) - (b.turn ?? 0));
+  let previous = rootId;
+  for (const turn of turns) {
+    edges.push({ from: previous ?? turn.id, to: turn.id, kind: 'next' });
+    previous = turn.id;
+  }
+  for (const node of reducedNodes) {
+    if (node.id === 'root' || node.kind === 'turn') continue;
+    const parent = node.kind === 'toolgroup'
+      ? (fallbackParent(node) ?? rootId)
+      : (nearestKeptAncestor(node) ?? fallbackParent(node) ?? rootId);
+    if (parent === undefined || parent === node.id) continue;
+    edges.push({ from: parent, to: node.id, kind: 'step' });
+  }
+  // 次级边(被替换 / 派生):两端都保留才保留。
+  for (const edge of tree.edges ?? []) {
+    if (edge.kind !== 'replaced-by' && edge.kind !== 'derived') continue;
+    if (!keptIds.has(edge.from) || !keptIds.has(edge.to)) continue;
+    if (edge.from === edge.to) continue;
+    edges.push({ from: edge.from, to: edge.to, kind: edge.kind });
+  }
+
+  return {
+    ...tree,
+    nodes: reducedNodes,
+    edges,
+    reduction: {
+      level,
+      before: nodes.length,
+      after: reducedNodes.length,
+      grouped: synthetic.length,
+      foldedTools: [...groupBuckets.values()].reduce((sum, list) => sum + list.length, 0),
+    },
+  };
+}
+
+/** 便于 UI 显示:三档的中文/英文标签与说明。 */
+export const DETAIL_LABELS = {
+  compact: { zh: '精简', en: 'Compact' },
+  standard: { zh: '标准', en: 'Standard' },
+  full: { zh: '完整', en: 'Full' },
+};
+
+/** 统计:树里有多少"过程信息"节点(用于提示可以精简)。 */
+export function processNodeCount(tree) {
+  return (tree?.nodes ?? []).filter((n) => n.kind === 'result' || n.kind === 'info'
+    || (n.kind === 'tool' && !n.branch) || (n.kind === 'user' && isInjectedLabel(n.label))).length;
+}

package/lib/remote.js

@@ -0,0 +1,178 @@
+// dsh-plugin-mind-tree 远程契约:主机(host)与网页客户端(client)之间唯一的数据面。
+// Copyright (c) 2026 ShOpenMind · https://github.com/ShOpenMind/dsh-plugin-mind-tree · MIT
+// 本文件同时被宿主加载器(经 ./typert)与客户端构建工具(打包进 lib/client.js)引用,
+// 因此只依赖 zod,不依赖任何 DSH 实现代码。
+import z from 'zod';
+
+export const PACKAGE = 'dsh-plugin-mind-tree';
+export const NAMESPACE = 'mindTree';
+
+export const MindNodeSchema = z.object({
+  sessionId: z.string(),
+  title: z.string().optional(),
+  parentSessionId: z.string().nullable().optional(),
+  origin: z.string().nullable().optional(),
+  delegationDepth: z.number().optional(),
+  live: z.boolean(),
+  persisted: z.boolean(),
+  createdAt: z.number(),
+  cwd: z.string().optional(),
+});
+
+export const MindEdgeSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  kind: z.string(),
+  spawnSeq: z.number().optional(),
+  spawnLabel: z.string().optional(),
+});
+
+export const ForestViewSchema = z.object({
+  nodes: z.array(MindNodeSchema),
+  edges: z.array(MindEdgeSchema),
+  roots: z.array(z.string()),
+  warnings: z.array(z.string()).optional(),
+});
+
+export const LineageViewSchema = z.object({
+  complete: z.boolean(),
+  unresolvedParentId: z.string().optional(),
+  target: z.string(),
+  root: z.string().optional(),
+  nodes: z.array(MindNodeSchema),
+  edges: z.array(MindEdgeSchema),
+});
+
+export const BranchNodeSchema = z.object({
+  id: z.string(),
+  seq: z.number(),
+  type: z.string(),
+  kind: z.string(),
+  turn: z.number().optional(),
+  step: z.number().optional(),
+  label: z.string(),
+  summary: z.string().optional(), // 轮次摘要(约 6–15 字)
+  text: z.string().optional(),
+  usage: z
+    .object({
+      input: z.number(),
+      output: z.number(),
+      total: z.number(),
+      cacheRead: z.number().optional(),
+      cacheWrite: z.number().optional(),
+      reasoning: z.number().optional(),
+      messageCount: z.number().optional(),
+      durationMs: z.number().optional(),
+    })
+    .optional(), // 轮次 token 消耗聚合
+  surface: z.string(),
+  branch: z
+    .object({
+      kind: z.string(),
+      detail: z.unknown().optional(),
+    })
+    .optional(),
+  sessionId: z.string().optional(),
+  origin: z.string().optional(),
+  error: z.boolean().optional(),
+});
+
+export const BranchEdgeSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  kind: z.string(),
+});
+
+export const ThoughtTreeSchema = z.object({
+  sessionId: z.string(),
+  title: z.string().optional(),
+  nodes: z.array(BranchNodeSchema),
+  edges: z.array(BranchEdgeSchema),
+  turnCount: z.number(),
+  warnings: z.array(z.string()).optional(),
+});
+
+export const EventWindowSchema = z.object({
+  sessionId: z.string(),
+  seq: z.number(),
+  startSeq: z.number(),
+  endSeq: z.number(),
+  inheritedEventCount: z.number(),
+  target: z.unknown(),
+  events: z.array(z.unknown()),
+});
+
+export const FollowFrameSchema = z.object({
+  sessionId: z.string(),
+  seq: z.number(),
+});
+
+export const FOREST_DESCRIPTOR = {
+  id: `${PACKAGE}#mindTree/forest`,
+  service: NAMESPACE,
+  namespace: NAMESPACE,
+  method: 'forest',
+  invocation: { kind: 'direct' },
+  parameters: [],
+  cancellation: { parameter: 'signal' },
+  result: { mode: 'strict', typeSymbol: `${PACKAGE}#ForestView`, create: () => ForestViewSchema },
+};
+
+export const LINEAGE_DESCRIPTOR = {
+  id: `${PACKAGE}#mindTree/lineage`,
+  service: NAMESPACE,
+  namespace: NAMESPACE,
+  method: 'lineage',
+  invocation: { kind: 'direct' },
+  parameters: [
+    { name: 'sessionId', wire: 'sessionId', source: 'json', codec: { mode: 'strict', typeSymbol: `${PACKAGE}#SessionId`, create: () => z.string() } },
+  ],
+  cancellation: { parameter: 'signal' },
+  result: { mode: 'strict', typeSymbol: `${PACKAGE}#LineageView`, create: () => LineageViewSchema },
+};
+
+export const TREE_DESCRIPTOR = {
+  id: `${PACKAGE}#mindTree/tree`,
+  service: NAMESPACE,
+  namespace: NAMESPACE,
+  method: 'tree',
+  invocation: { kind: 'direct' },
+  parameters: [
+    { name: 'sessionId', wire: 'sessionId', source: 'json', codec: { mode: 'strict', typeSymbol: `${PACKAGE}#SessionId`, create: () => z.string() } },
+  ],
+  cancellation: { parameter: 'signal' },
+  result: { mode: 'strict', typeSymbol: `${PACKAGE}#ThoughtTree`, create: () => ThoughtTreeSchema },
+};
+
+export const DETAIL_DESCRIPTOR = {
+  id: `${PACKAGE}#mindTree/detail`,
+  service: NAMESPACE,
+  namespace: NAMESPACE,
+  method: 'detail',
+  invocation: { kind: 'direct' },
+  parameters: [
+    { name: 'sessionId', wire: 'sessionId', source: 'json', codec: { mode: 'strict', typeSymbol: `${PACKAGE}#SessionId`, create: () => z.string() } },
+    { name: 'seq', wire: 'seq', source: 'json', codec: { mode: 'strict', typeSymbol: `${PACKAGE}#Seq`, create: () => z.number() } },
+    { name: 'before', wire: 'before', source: 'json', codec: { mode: 'strict', typeSymbol: `${PACKAGE}#Seq`, create: () => z.number() } },
+    { name: 'after', wire: 'after', source: 'json', codec: { mode: 'strict', typeSymbol: `${PACKAGE}#Seq`, create: () => z.number() } },
+  ],
+  cancellation: { parameter: 'signal' },
+  result: { mode: 'strict', typeSymbol: `${PACKAGE}#EventWindow`, create: () => EventWindowSchema },
+};
+
+export const FOLLOW_DESCRIPTOR = {
+  id: `${PACKAGE}#mindTree/follow`,
+  service: NAMESPACE,
+  namespace: NAMESPACE,
+  method: 'follow',
+  mode: 'stream',
+  invocation: { kind: 'direct' },
+  parameters: [],
+  cancellation: { parameter: 'signal' },
+  result: { mode: 'strict', typeSymbol: `${PACKAGE}#FollowFrame`, create: () => FollowFrameSchema },
+};
+
+export const TYPERT_REMOTE = {
+  package: PACKAGE,
+  descriptors: [FOREST_DESCRIPTOR, LINEAGE_DESCRIPTOR, TREE_DESCRIPTOR, DETAIL_DESCRIPTOR, FOLLOW_DESCRIPTOR],
+};

package/lib/typert.host.js

@@ -0,0 +1,30 @@
+// 严格反射清单,由 DSH Typert 加载器校验。
+// Copyright (c) 2026 ShOpenMind · https://github.com/ShOpenMind/dsh-plugin-mind-tree · MIT
+import { PACKAGE, NAMESPACE, FOREST_DESCRIPTOR, LINEAGE_DESCRIPTOR, TREE_DESCRIPTOR, DETAIL_DESCRIPTOR, FOLLOW_DESCRIPTOR } from './remote.js';
+
+export const TYPERT = {
+  package: PACKAGE,
+  face: 'host',
+  schemas: [],
+  invocations: [FOREST_DESCRIPTOR, LINEAGE_DESCRIPTOR, TREE_DESCRIPTOR, DETAIL_DESCRIPTOR, FOLLOW_DESCRIPTOR],
+  model: {
+    services: [{
+      key: NAMESPACE,
+      exportName: 'MindTreeService',
+      description: '只读的对话分支分析服务:遍历会话事件日志,识别分支节点(替换、重试、提问、批准、派生、目标、待办、计划、压缩),并提供会话血统(派生/子代理)追踪与思维树数据。不写入会话,不发起模型调用。',
+      summary: '对话上下文分支节点与思维树分析',
+      tags: ['mind-map', 'tree', 'session', 'branch'],
+      members: [
+        { kind: 'method', name: 'forest', signature: 'forest(signal?: AbortSignal): Promise<ForestView>' },
+        { kind: 'method', name: 'lineage', signature: 'lineage(sessionId: string, signal?: AbortSignal): Promise<LineageView>' },
+        { kind: 'method', name: 'tree', signature: 'tree(sessionId: string, signal?: AbortSignal): Promise<ThoughtTree>' },
+        { kind: 'method', name: 'detail', signature: 'detail(sessionId: string, seq: number, before: number, after: number, signal?: AbortSignal): Promise<EventWindow>' },
+        { kind: 'method', name: 'follow', signature: 'follow(signal?: AbortSignal): AsyncIterable<FollowFrame>' },
+      ],
+      types: [],
+    }],
+    events: [],
+    objects: [],
+  },
+};
+export default TYPERT;

package/package.json

@@ -1,6 +1,92 @@
 {
   "name": "dsh-plugin-mind-tree",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "遍历对话上下文，识别分支节点并渲染思维树/会话树的 DeepSeek Harness 插件（右侧栏 GUI + mind_tree 工具 + Obsidian 导出）。",
+  "type": "module",
+  "license": "MIT",
+  "author": {
+    "name": "ShOpenMind",
+    "email": "ShOpenMind@users.noreply.github.com",
+    "url": "https://github.com/ShOpenMind/dsh-plugin-mind-tree"
+  },
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./format": "./lib/format.js",
+    "./typert": "./lib/typert.host.js",
+    "./remote": "./lib/remote.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": ["lib", "cordis.patch.yml", "README.md", "LICENSE"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShOpenMind/dsh-plugin-mind-tree.git"
+  },
+  "homepage": "https://github.com/ShOpenMind/dsh-plugin-mind-tree#readme",
+  "bugs": {
+    "url": "https://github.com/ShOpenMind/dsh-plugin-mind-tree/issues"
+  },
+  "keywords": ["dsh", "deepseek-harness", "plugin", "mindmap", "session-tree", "observability", "dsh-plugin", "dsh-bundle", "dsh-market"],
+  "dependencies": {
+    "zod": "^4.4.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.0",
+    "happy-dom": "^20.14.6",
+    "mermaid": "^12.1.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "scripts": {
+    "build": "node tools/build.mjs",
+    "test": "node tools/run-all.mjs",
+    "test:host": "node tools/host-test.mjs",
+    "test:reduce": "node tools/reduce-test.mjs",
+    "test:client": "node tools/client-test.mjs",
+    "test:mount": "node tools/mount-test.mjs",
+    "test:render": "node tools/render-test.mjs",
+    "test:mermaid": "node tools/mermaid-check.mjs",
+    "test:integration": "node tools/integration-test.mjs"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh": ">=0.2.0-rc.2 <0.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh": {
+      "optional": true
+    }
+  },
+  "engines": { "node": ">=22" },
+  "dsh": {
+    "bundle": { "patch": "./cordis.patch.yml" },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-api-gateway",
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-api-session-controller",
+        "@deepseek-ai/dsh-client-ui-session",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-primitives",
+        "@deepseek-ai/dsh-client-ui-sidebar-right",
+        "@deepseek-ai/dsh-client-ui-workspace"
+      ],
+      "external": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-api-gateway",
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-api-session-controller",
+        "@deepseek-ai/dsh-client-ui-session",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-primitives",
+        "@deepseek-ai/dsh-client-ui-sidebar-right",
+        "@deepseek-ai/dsh-client-ui-workspace"
+      ]
+    }
+  }
+}