@joekytc/dsh-swarm 0.1.2 → 0.3.0

package/skills/llm-wiki-skill/packages/graph-engine/test/node-drag-lifecycle.test.ts

@@ -0,0 +1,166 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { createLiveGraphSimulation, PinState } from "../src/sim";
+import { buildRenderableGraph } from "../src/render";
+import { cancelGraphNodeDrag, commitGraphNodeDrag, type GraphNodeDragSession } from "../src/render/node-drag-lifecycle";
+import type { GraphData, PinMap } from "../src/types";
+
+describe("graph node drag lifecycle", () => {
+  it("commits a real drag by pinning the final world position", () => {
+    const graph = buildRenderableGraph(sampleGraph(), { theme: "shan-shui" });
+    const simulation = createLiveGraphSimulation(graph);
+    const pinState = new PinState(graph);
+
+    simulation.beginDrag("drag");
+    simulation.dragTo("drag", { x: 460, y: 300 });
+
+    const result = commitGraphNodeDrag({ nodeId: "drag", simulation, pinState });
+
+    assert.deepEqual(result.pinPosition, { x: 460, y: 300 });
+    assert.deepEqual(result.pins, {
+      "wiki/drag.md": { x: 460, y: 300, coordinateSpace: "world" }
+    });
+    assert.deepEqual(result.pinnedNodeIds, ["drag"]);
+    assert.equal(simulation.nodes.find((node) => node.id === "drag")?.fx, 460);
+    assert.equal(simulation.nodes.find((node) => node.id === "drag")?.fy, 300);
+    simulation.destroy();
+  });
+
+  it("commits a fast release by applying the final pointer target before pinning", () => {
+    const graph = buildRenderableGraph(sampleGraph(), { theme: "shan-shui" });
+    const simulation = createLiveGraphSimulation(graph);
+    const pinState = new PinState(graph);
+
+    simulation.beginDrag("drag");
+    simulation.dragTo("drag", { x: 460, y: 300 });
+
+    const result = commitGraphNodeDrag({
+      nodeId: "drag",
+      simulation,
+      pinState,
+      finalWorldPoint: { x: 620, y: 410 }
+    });
+
+    assert.deepEqual(result.pinPosition, { x: 620, y: 410 });
+    assert.deepEqual(result.pins, {
+      "wiki/drag.md": { x: 620, y: 410, coordinateSpace: "world" }
+    });
+    assert.equal(simulation.nodes.find((node) => node.id === "drag")?.fx, 620);
+    assert.equal(simulation.nodes.find((node) => node.id === "drag")?.fy, 410);
+    simulation.destroy();
+  });
+
+  it("commits a drag outside the old default world instead of clamping it back", () => {
+    const graph = buildRenderableGraph(sampleGraph(), { theme: "shan-shui" });
+    const simulation = createLiveGraphSimulation(graph);
+    const pinState = new PinState(graph);
+
+    simulation.beginDrag("drag");
+    simulation.dragTo("drag", { x: 1240, y: 816 });
+
+    const result = commitGraphNodeDrag({ nodeId: "drag", simulation, pinState });
+
+    assert.deepEqual(result.pinPosition, { x: 1240, y: 816 });
+    assert.deepEqual(result.pins, {
+      "wiki/drag.md": { x: 1240, y: 816, coordinateSpace: "world" }
+    });
+    assert.equal(simulation.nodes.find((node) => node.id === "drag")?.fx, 1240);
+    assert.equal(simulation.nodes.find((node) => node.id === "drag")?.fy, 816);
+    simulation.destroy();
+  });
+
+  it("cancels an unpinned drag by restoring the start position without writing a pin", () => {
+    const graph = buildRenderableGraph(sampleGraph(), { theme: "shan-shui" });
+    const simulation = createLiveGraphSimulation(graph);
+    const pinState = new PinState(graph);
+    const startWorldPoint = graph.nodes.find((node) => node.id === "drag")?.point;
+    assert.ok(startWorldPoint);
+
+    simulation.beginDrag("drag");
+    simulation.dragTo("drag", { x: 540, y: 420 });
+    const result = cancelGraphNodeDrag({
+      simulation,
+      pinState,
+      session: session({ startWorldPoint, wasPinned: false })
+    });
+
+    assert.deepEqual(result.pins, {});
+    assert.deepEqual(result.pinnedNodeIds, []);
+    assert.deepEqual(result.restoredPosition, startWorldPoint);
+    assert.equal(result.restoredFixed, false);
+    assert.deepEqual(result.positions.drag, startWorldPoint);
+    assert.equal(simulation.nodes.find((node) => node.id === "drag")?.fx, null);
+    assert.equal(simulation.nodes.find((node) => node.id === "drag")?.fy, null);
+    simulation.destroy();
+  });
+
+  it("cancels a pinned drag by restoring the previous pin and keeping it fixed", () => {
+    const pins: PinMap = {
+      "wiki/drag.md": { x: 320, y: 240, coordinateSpace: "world" }
+    };
+    const graph = buildRenderableGraph(sampleGraph(), { theme: "shan-shui", pins });
+    const simulation = createLiveGraphSimulation(graph);
+    const pinState = new PinState(graph, pins);
+    const startWorldPoint = pins["wiki/drag.md"];
+    assert.ok(startWorldPoint);
+    assert.deepEqual(startWorldPoint, { x: 320, y: 240, coordinateSpace: "world" });
+
+    simulation.beginDrag("drag");
+    simulation.dragTo("drag", { x: 700, y: 500 });
+    const result = cancelGraphNodeDrag({
+      simulation,
+      pinState,
+      session: session({ startWorldPoint, wasPinned: true })
+    });
+
+    assert.deepEqual(result.pins, pins);
+    assert.deepEqual(result.pinnedNodeIds, ["drag"]);
+    assert.deepEqual(result.positions.drag, { x: 320, y: 240 });
+    assert.equal(result.restoredFixed, true);
+    assert.equal(simulation.nodes.find((node) => node.id === "drag")?.fx, 320);
+    assert.equal(simulation.nodes.find((node) => node.id === "drag")?.fy, 240);
+    simulation.destroy();
+  });
+});
+
+function session(options: { startWorldPoint: { x: number; y: number }; wasPinned: boolean }): GraphNodeDragSession {
+  return {
+    pointerId: 1,
+    nodeId: "drag",
+    startWorldPoint: options.startWorldPoint,
+    wasPinned: options.wasPinned
+  };
+}
+
+function sampleGraph(): GraphData {
+  return {
+    meta: {
+      build_date: "2026-06-12T00:00:00.000Z",
+      wiki_title: "Drag Lifecycle Fixture",
+      total_nodes: 3,
+      total_edges: 1
+    },
+    nodes: [
+      { id: "drag", label: "Drag", type: "topic", community: "c1", source_path: "wiki/drag.md", weight: 80, x: 20, y: 50 },
+      { id: "near", label: "Near", type: "entity", community: "c1", source_path: "wiki/near.md", weight: 50, x: 32, y: 50 },
+      { id: "far", label: "Far", type: "entity", community: "c2", source_path: "wiki/far.md", weight: 20, x: 85, y: 50 }
+    ],
+    edges: [
+      { id: "drag-near", from: "drag", to: "near", type: "EXTRACTED", weight: 1 }
+    ],
+    learning: {
+      version: 1,
+      entry: { recommended_start_node_id: "drag", recommended_start_reason: "community_hub", default_mode: "global" },
+      views: {
+        path: { enabled: false, start_node_id: null, node_ids: [], degraded: true },
+        community: { enabled: false, community_id: null, label: null, node_ids: [], is_weak: false, degraded: true },
+        global: { enabled: true, node_ids: ["drag", "near", "far"], degraded: false }
+      },
+      communities: [
+        { id: "c1", label: "Core", node_count: 2, color_index: 0, recommended_start_node_id: "drag" },
+        { id: "c2", label: "Edge", node_count: 1, color_index: 1 }
+      ]
+    }
+  };
+}

package/skills/llm-wiki-skill/packages/graph-engine/test/overlays.test.ts

@@ -0,0 +1,115 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  graphEdgeHoverAnchor,
+  graphNodeHoverAnchor,
+  resolveGraphHoverPreviewPosition,
+  worldPointToScreenPoint
+} from "../src/render";
+import type { RendererViewport, RendererViewportSize } from "../src/render";
+
+const VIEWPORT_SIZE: RendererViewportSize = { width: 1000, height: 680 };
+
+function assertNear(actual: number, expected: number, message?: string): void {
+  assert.ok(Math.abs(actual - expected) < 0.001, `${message ?? "number"} expected ${expected}, got ${actual}`);
+}
+
+function assertPointNear(actual: { x: number; y: number }, expected: { x: number; y: number }): void {
+  assertNear(actual.x, expected.x, "x");
+  assertNear(actual.y, expected.y, "y");
+}
+
+describe("graph overlay anchors", () => {
+  it("positions node hover anchors from projected screen points", () => {
+    const viewport: RendererViewport = { x: -140, y: 82, scale: 2.25 };
+    const node = { point: { x: 620, y: 260 } };
+
+    assertPointNear(
+      graphNodeHoverAnchor(node, viewport, VIEWPORT_SIZE),
+      worldPointToScreenPoint(node.point, viewport, VIEWPORT_SIZE)
+    );
+  });
+
+  it("keeps node hover anchors tied to expanded world bounds", () => {
+    const viewport: RendererViewport = { x: 84, y: -36, scale: 1.7 };
+    const viewportSize: RendererViewportSize = { width: 760, height: 520 };
+    const worldBounds = { minX: -240, minY: -120, maxX: 1260, maxY: 900, width: 1500, height: 1020 };
+    const node = { point: { x: -80, y: 820 } };
+
+    assertPointNear(
+      graphNodeHoverAnchor(node, viewport, viewportSize, worldBounds),
+      worldPointToScreenPoint(node.point, viewport, viewportSize, worldBounds)
+    );
+  });
+
+  it("reprojects hover anchors when drawer resize changes the graph viewport", () => {
+    const viewport: RendererViewport = { x: -320, y: -180, scale: 2.4 };
+    const node = { point: { x: 460, y: 220 } };
+    const wideSize: RendererViewportSize = { width: 1000, height: 680 };
+    const drawerSize: RendererViewportSize = { width: 640, height: 680 };
+
+    const wideAnchor = graphNodeHoverAnchor(node, viewport, wideSize);
+    const drawerAnchor = graphNodeHoverAnchor(node, viewport, drawerSize);
+
+    assert.notDeepEqual(drawerAnchor, wideAnchor);
+    assertPointNear(
+      drawerAnchor,
+      worldPointToScreenPoint(node.point, viewport, drawerSize)
+    );
+  });
+
+  it("positions edge hover anchors from the projected midpoint of both endpoints", () => {
+    const viewport: RendererViewport = { x: 120, y: -64, scale: 1.8 };
+    const source = { point: { x: 200, y: 190 } };
+    const target = { point: { x: 760, y: 430 } };
+    const sourceScreen = worldPointToScreenPoint(source.point, viewport, VIEWPORT_SIZE);
+    const targetScreen = worldPointToScreenPoint(target.point, viewport, VIEWPORT_SIZE);
+
+    assertPointNear(
+      graphEdgeHoverAnchor({ source, target }, viewport, VIEWPORT_SIZE),
+      {
+        x: (sourceScreen.x + targetScreen.x) / 2,
+        y: (sourceScreen.y + targetScreen.y) / 2
+      }
+    );
+  });
+
+  it("positions edge hover anchors through expanded bounds", () => {
+    const viewport: RendererViewport = { x: 40, y: -88, scale: 1.25 };
+    const viewportSize: RendererViewportSize = { width: 900, height: 620 };
+    const worldBounds = { minX: -400, minY: -200, maxX: 1400, maxY: 1040, width: 1800, height: 1240 };
+    const source = { point: { x: -200, y: 920 } };
+    const target = { point: { x: 1180, y: -40 } };
+    const sourceScreen = worldPointToScreenPoint(source.point, viewport, viewportSize, worldBounds);
+    const targetScreen = worldPointToScreenPoint(target.point, viewport, viewportSize, worldBounds);
+
+    assertPointNear(
+      graphEdgeHoverAnchor({ source, target }, viewport, viewportSize, worldBounds),
+      {
+        x: (sourceScreen.x + targetScreen.x) / 2,
+        y: (sourceScreen.y + targetScreen.y) / 2
+      }
+    );
+  });
+
+  it("uses the viewport center when an edge endpoint is unavailable", () => {
+    assert.deepEqual(
+      graphEdgeHoverAnchor({ source: null, target: { point: { x: 760, y: 430 } } }, { x: 0, y: 0, scale: 1 }, VIEWPORT_SIZE),
+      { x: 500, y: 340 }
+    );
+  });
+
+  it("keeps preview cards inside the graph viewport", () => {
+    assert.deepEqual(
+      resolveGraphHoverPreviewPosition({
+        anchorScreenPoint: { x: 990, y: 12 },
+        previewSize: { width: 240, height: 150 },
+        viewportSize: VIEWPORT_SIZE,
+        offset: { x: 18, y: -174 },
+        margin: 12
+      }),
+      { x: 748, y: 12 }
+    );
+  });
+});

package/skills/llm-wiki-skill/packages/graph-engine/test/preview.test.ts

@@ -0,0 +1,56 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { buildHoverPreview, firstUsefulParagraph, previewSummary } from "../src/render";
+
+describe("hover preview helpers", () => {
+  it("extracts the first useful paragraph after frontmatter and headings", () => {
+    const paragraph = firstUsefulParagraph(`---
+title: Demo
+---
+# Demo
+
+第一段说明 [[wiki/entities/A.md|节点A]] 和 [链接](https://example.com)。
+
+第二段不应该出现。`);
+
+    assert.equal(paragraph, "第一段说明 节点A 和 链接。");
+  });
+
+  it("uses explicit summary before content", () => {
+    assert.equal(
+      previewSummary({
+        summary: "显式摘要优先。",
+        content: "# 标题\n\n正文不应该出现。"
+      }),
+      "显式摘要优先。"
+    );
+  });
+
+  it("handles wikilinks, code fences, empty content, and truncation", () => {
+    assert.equal(
+      previewSummary({
+        content: "```js\nconsole.log('skip')\n```\n\n## 标题\n\n包含 [[Target|标签]] 和 `代码`。"
+      }),
+      "包含 标签 和 代码。"
+    );
+
+    assert.equal(previewSummary({ content: "" }), "");
+
+    const long = previewSummary({ content: `# 标题\n\n${"长".repeat(180)}` });
+    assert.equal(long.length <= 143, true);
+    assert.equal(long.endsWith("..."), true);
+  });
+
+  it("builds a title and type even when content is empty", () => {
+    assert.deepEqual(
+      buildHoverPreview({ id: "a", label: "节点A", type: "topic", content: "" }),
+      {
+        id: "a",
+        title: "节点A",
+        typeLabel: "主题",
+        summary: ""
+      }
+    );
+  });
+});

package/skills/llm-wiki-skill/packages/graph-engine/test/queue.test.ts

@@ -0,0 +1,114 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  getWikiStorageNamespace,
+  defaultQueue,
+  normalizeQueue,
+  toggleQueueFavorite,
+  appendQueueNote,
+  summarizeQueue
+} from "../src/model";
+
+describe("getWikiStorageNamespace", () => {
+  it("returns a stable namespace for the same wiki", () => {
+    const a = getWikiStorageNamespace({ wiki_title: "AI知识图谱Demo" }, "/wiki/graph.html");
+    const b = getWikiStorageNamespace({ wiki_title: "AI知识图谱Demo" }, "/wiki/graph.html");
+    assert.equal(a, b);
+    assert.match(a, /^llm-wiki:/);
+  });
+
+  it("changes namespace when pathname changes", () => {
+    const a = getWikiStorageNamespace({ wiki_title: "AI知识图谱Demo" }, "/wiki-a/graph.html");
+    const b = getWikiStorageNamespace({ wiki_title: "AI知识图谱Demo" }, "/wiki-b/graph.html");
+    assert.notEqual(a, b);
+  });
+});
+
+describe("defaultQueue and normalizeQueue", () => {
+  it("returns an empty queue by default", () => {
+    assert.deepEqual(defaultQueue(), {
+      version: 1,
+      favorites: [],
+      notes: [],
+      recentNoteIds: []
+    });
+  });
+
+  it("normalizes malformed queue data", () => {
+    const queue = normalizeQueue({
+      favorites: ["n1", "n1", 2, null],
+      notes: [
+        { id: "a", node_id: "n1", label: "节点 A", text: "摘录", created_at: "2026-04-24T00:00:00Z" },
+        { bad: true }
+      ],
+      recentNoteIds: ["a", "missing", "a"]
+    });
+
+    assert.deepEqual(queue.favorites, ["n1", "2"]);
+    assert.equal(queue.notes.length, 1);
+    assert.deepEqual(queue.recentNoteIds, ["a"]);
+  });
+});
+
+describe("toggleQueueFavorite", () => {
+  it("adds and removes favorites", () => {
+    let queue = defaultQueue();
+    queue = toggleQueueFavorite(queue, "n1");
+    assert.deepEqual(queue.favorites, ["n1"]);
+
+    queue = toggleQueueFavorite(queue, "n2");
+    assert.deepEqual(queue.favorites, ["n2", "n1"]);
+
+    queue = toggleQueueFavorite(queue, "n1");
+    assert.deepEqual(queue.favorites, ["n2"]);
+  });
+});
+
+describe("appendQueueNote", () => {
+  it("prepends note and updates recent ids", () => {
+    let queue = defaultQueue();
+    queue = appendQueueNote(queue, {
+      id: "note-1",
+      node_id: "n1",
+      label: "节点一",
+      text: "第一条",
+      created_at: "2026-04-24T00:00:00Z"
+    });
+    queue = appendQueueNote(queue, {
+      id: "note-2",
+      node_id: "n2",
+      label: "节点二",
+      text: "第二条",
+      created_at: "2026-04-24T00:01:00Z"
+    });
+
+    assert.deepEqual(queue.notes.map((note) => note.id), ["note-2", "note-1"]);
+    assert.deepEqual(queue.recentNoteIds, ["note-2", "note-1"]);
+  });
+});
+
+describe("summarizeQueue", () => {
+  it("summarizes counts and recent items", () => {
+    let queue = defaultQueue();
+    queue = toggleQueueFavorite(queue, "n3");
+    queue = appendQueueNote(queue, {
+      id: "note-1",
+      node_id: "n1",
+      label: "节点一",
+      text: "摘录一",
+      created_at: "2026-04-24T00:00:00Z"
+    });
+
+    const summary = summarizeQueue(queue, {
+      n1: { id: "n1", label: "节点一" },
+      n3: { id: "n3", label: "节点三" }
+    }, 4);
+
+    assert.equal(summary.favorite_count, 1);
+    assert.equal(summary.note_count, 1);
+    assert.deepEqual(summary.recent_items, [
+      { kind: "note", node_id: "n1", label: "节点一", text: "摘录一" },
+      { kind: "favorite", node_id: "n3", label: "节点三", text: "" }
+    ]);
+  });
+});

package/skills/llm-wiki-skill/packages/graph-engine/test/relation-focus.test.ts

@@ -0,0 +1,115 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { resolveGraphRelationFocus } from "../src/render/relation-focus";
+
+describe("graph relation focus", () => {
+  it("classifies focus, first-degree, second-degree, and unrelated nodes", () => {
+    const focus = resolveGraphRelationFocus({
+      activeNodeId: "A",
+      nodes: [
+        { id: "A" },
+        { id: "B" },
+        { id: "C" },
+        { id: "D" },
+        { id: "E" },
+        { id: "F" }
+      ],
+      edges: [
+        { id: "A-B", source: "A", target: "B" },
+        { id: "A-C", source: "A", target: "C" },
+        { id: "B-D", source: "B", target: "D" },
+        { id: "C-E", source: "C", target: "E" },
+        { id: "D-F", source: "D", target: "F" }
+      ]
+    });
+
+    assert.equal(focus.activeNodeId, "A");
+    assert.equal(focus.nodeDepthById.get("A"), "focus");
+    assert.equal(focus.nodeDepthById.get("B"), "first");
+    assert.equal(focus.nodeDepthById.get("C"), "first");
+    assert.equal(focus.nodeDepthById.get("D"), "second");
+    assert.equal(focus.nodeDepthById.get("E"), "second");
+    assert.equal(focus.nodeDepthById.get("F"), "unrelated");
+    assert.equal(focus.edgeDepthById.get("A-B"), "first");
+    assert.equal(focus.edgeDepthById.get("A-C"), "first");
+    assert.equal(focus.edgeDepthById.get("B-D"), "second");
+    assert.equal(focus.edgeDepthById.get("C-E"), "second");
+    assert.equal(focus.edgeDepthById.get("D-F"), "unrelated");
+  });
+
+  it("keeps first-neighbor cross links as faint second-degree context", () => {
+    const focus = resolveGraphRelationFocus({
+      activeNodeId: "A",
+      nodes: [{ id: "A" }, { id: "B" }, { id: "C" }],
+      edges: [
+        { id: "A-B", source: "A", target: "B" },
+        { id: "A-C", source: "A", target: "C" },
+        { id: "B-C", source: "B", target: "C" }
+      ]
+    });
+
+    assert.equal(focus.edgeDepthById.get("A-B"), "first");
+    assert.equal(focus.edgeDepthById.get("A-C"), "first");
+    assert.equal(focus.edgeDepthById.get("B-C"), "second");
+  });
+
+  it("handles an isolated active node without inventing relations", () => {
+    const focus = resolveGraphRelationFocus({
+      activeNodeId: "A",
+      nodes: [{ id: "A" }, { id: "B" }, { id: "C" }],
+      edges: []
+    });
+
+    assert.equal(focus.activeNodeId, "A");
+    assert.equal(focus.nodeDepthById.get("A"), "focus");
+    assert.equal(focus.nodeDepthById.get("B"), "unrelated");
+    assert.equal(focus.nodeDepthById.get("C"), "unrelated");
+    assert.deepEqual([...focus.edgeDepthById.values()], []);
+  });
+
+  it("returns none states when there is no active node or the node is missing", () => {
+    const graph = {
+      nodes: [{ id: "A" }, { id: "B" }],
+      edges: [{ id: "A-B", source: "A", target: "B" }]
+    };
+
+    const inactive = resolveGraphRelationFocus({ ...graph, activeNodeId: null });
+    const missing = resolveGraphRelationFocus({ ...graph, activeNodeId: "missing" });
+
+    assert.equal(inactive.activeNodeId, null);
+    assert.deepEqual([...inactive.nodeDepthById.values()], ["none", "none"]);
+    assert.deepEqual([...inactive.edgeDepthById.values()], ["none"]);
+    assert.equal(missing.activeNodeId, null);
+    assert.deepEqual([...missing.nodeDepthById.values()], ["none", "none"]);
+    assert.deepEqual([...missing.edgeDepthById.values()], ["none"]);
+  });
+
+  it("treats a self-loop on the active node as a direct first-degree edge", () => {
+    const focus = resolveGraphRelationFocus({
+      activeNodeId: "A",
+      nodes: [{ id: "A" }, { id: "B" }],
+      edges: [{ id: "A-A", source: "A", target: "A" }]
+    });
+
+    assert.equal(focus.activeNodeId, "A");
+    assert.equal(focus.nodeDepthById.get("A"), "focus");
+    assert.equal(focus.nodeDepthById.get("B"), "unrelated");
+    assert.equal(focus.edgeDepthById.get("A-A"), "first");
+  });
+
+  it("treats parallel edges between the same pair as first-degree", () => {
+    const focus = resolveGraphRelationFocus({
+      activeNodeId: "A",
+      nodes: [{ id: "A" }, { id: "B" }],
+      edges: [
+        { id: "A-B-1", source: "A", target: "B" },
+        { id: "B-A-2", source: "B", target: "A" }
+      ]
+    });
+
+    assert.equal(focus.nodeDepthById.get("B"), "first");
+    assert.equal(focus.edgeDepthById.get("A-B-1"), "first");
+    assert.equal(focus.edgeDepthById.get("B-A-2"), "first");
+  });
+});