@joekytc/dsh-swarm 0.1.2 → 0.2.0

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

@@ -0,0 +1,222 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { GraphSpatialIndex, createGraphSpatialIndex } from "../src/layout";
+import type { GraphSpatialNodeLike } from "../src/layout";
+
+function baseNodes(): GraphSpatialNodeLike[] {
+  return [
+    { id: "a", label: "Alpha", type: "entity", point: { x: 100, y: 100 }, hitBounds: { x: 70, y: 80, width: 60, height: 40 } },
+    { id: "b", label: "Beta", type: "entity", point: { x: 260, y: 100 }, hitBounds: { x: 230, y: 80, width: 60, height: 40 } }
+  ];
+}
+
+describe("GraphSpatialIndex", () => {
+  it("hits nodes through spatial bounds instead of DOM targets", () => {
+    const index = createGraphSpatialIndex({ nodes: baseNodes() });
+
+    assert.deepEqual(index.hitTest({ x: 126, y: 118 }), { kind: "node", id: "a" });
+    assert.deepEqual(index.hitTest({ x: 131, y: 121 }), { kind: "graph-blank" });
+  });
+
+  it("hits edges with a world-space tolerance", () => {
+    const index = createGraphSpatialIndex({
+      nodes: baseNodes(),
+      edges: [{ id: "a-b", source: "a", target: "b", curveOffset: 0 }]
+    });
+
+    assert.deepEqual(index.hitTest({ x: 180, y: 88 }), { kind: "edge", id: "a-b" });
+    assert.deepEqual(index.hitTest({ x: 180, y: 125 }), { kind: "graph-blank" });
+  });
+
+  it("hits community washes with ellipse geometry", () => {
+    const index = createGraphSpatialIndex({
+      nodes: [],
+      communities: [{ id: "c1", wash: { cx: 400, cy: 300, rx: 90, ry: 50 } }]
+    });
+
+    assert.deepEqual(index.hitTest({ x: 450, y: 315 }), { kind: "community-wash", id: "c1" });
+    assert.deepEqual(index.hitTest({ x: 500, y: 315 }), { kind: "graph-blank" });
+  });
+
+  it("keeps node priority above edge and community overlap", () => {
+    const index = createGraphSpatialIndex({
+      nodes: [
+        { id: "node", point: { x: 200, y: 200 }, hitBounds: { x: 190, y: 190, width: 20, height: 20 } },
+        { id: "left", point: { x: 120, y: 200 }, hitBounds: { x: 110, y: 190, width: 20, height: 20 } },
+        { id: "right", point: { x: 280, y: 200 }, hitBounds: { x: 270, y: 190, width: 20, height: 20 } }
+      ],
+      edges: [{ id: "left-right", source: "left", target: "right", curveOffset: 0 }],
+      communities: [{ id: "community", wash: { cx: 200, cy: 200, rx: 120, ry: 80 } }]
+    });
+
+    assert.deepEqual(index.hitTest({ x: 200, y: 200 }), { kind: "node", id: "node" });
+  });
+
+  it("keeps edge priority above community overlap when no node is hit", () => {
+    const index = createGraphSpatialIndex({
+      nodes: [
+        { id: "left", point: { x: 120, y: 200 }, hitBounds: { x: 110, y: 190, width: 20, height: 20 } },
+        { id: "right", point: { x: 280, y: 200 }, hitBounds: { x: 270, y: 190, width: 20, height: 20 } }
+      ],
+      edges: [{ id: "left-right", source: "left", target: "right", curveOffset: 0 }],
+      communities: [{ id: "community", wash: { cx: 200, cy: 200, rx: 120, ry: 80 } }]
+    });
+
+    assert.deepEqual(index.hitTest({ x: 200, y: 188 }), { kind: "edge", id: "left-right" });
+  });
+
+  it("orders node, edge, community wash, and blank hits through one spatial path", () => {
+    const index = createGraphSpatialIndex({
+      nodes: [
+        { id: "node", point: { x: 200, y: 200 }, hitBounds: { x: 190, y: 190, width: 20, height: 20 } },
+        { id: "left", point: { x: 120, y: 200 }, hitBounds: { x: 110, y: 190, width: 20, height: 20 } },
+        { id: "right", point: { x: 280, y: 200 }, hitBounds: { x: 270, y: 190, width: 20, height: 20 } }
+      ],
+      edges: [{ id: "left-right", source: "left", target: "right", curveOffset: 0 }],
+      communities: [{ id: "community", wash: { cx: 200, cy: 200, rx: 120, ry: 80 } }]
+    });
+
+    assert.deepEqual(index.hitTest({ x: 200, y: 200 }), { kind: "node", id: "node" });
+    assert.deepEqual(index.hitTest({ x: 200, y: 188 }), { kind: "edge", id: "left-right" });
+    assert.deepEqual(index.hitTest({ x: 200, y: 250 }), { kind: "community-wash", id: "community" });
+    assert.deepEqual(index.hitTest({ x: 200, y: 330 }), { kind: "graph-blank" });
+  });
+
+  it("returns blank when no graph object owns the point", () => {
+    const index = createGraphSpatialIndex({
+      nodes: baseNodes(),
+      edges: [{ id: "a-b", source: "a", target: "b" }],
+      communities: [{ id: "c1", wash: { cx: 180, cy: 100, rx: 120, ry: 45 } }]
+    });
+
+    assert.deepEqual(index.hitTest({ x: -120, y: 900 }), { kind: "graph-blank" });
+  });
+
+  it("supports nodes outside the old 1000x680 world", () => {
+    const index = createGraphSpatialIndex({
+      nodes: [
+        { id: "outlier", point: { x: 1320, y: -180 }, hitBounds: { x: 1280, y: -205, width: 80, height: 50 } }
+      ],
+      communities: [{ id: "far", wash: { cx: 1320, cy: -180, rx: 110, ry: 70 } }]
+    });
+
+    assert.deepEqual(index.hitTest({ x: 1335, y: -170 }), { kind: "node", id: "outlier" });
+  });
+
+  it("requires rebuild after drag or pin movement instead of mutating quadtree coordinates in place", () => {
+    const nodes = baseNodes();
+    const original = createGraphSpatialIndex({ nodes });
+
+    nodes[0] = { ...nodes[0], point: { x: 500, y: 460 }, hitBounds: { x: 470, y: 440, width: 60, height: 40 } };
+    assert.deepEqual(original.hitTest({ x: 100, y: 100 }), { kind: "node", id: "a" });
+    assert.deepEqual(original.hitTest({ x: 500, y: 460 }), { kind: "graph-blank" });
+
+    const rebuilt = original.rebuild({ nodes });
+    assert.deepEqual(rebuilt.hitTest({ x: 500, y: 460 }), { kind: "node", id: "a" });
+    assert.deepEqual(rebuilt.hitTest({ x: 100, y: 100 }), { kind: "graph-blank" });
+  });
+
+  it("keeps dense node lookup on the spatial index path", () => {
+    const nodes = denseNodes(1000);
+    const edges = nodes.slice(1).map((node, index) => ({
+      id: `edge-${index}`,
+      source: nodes[index].id,
+      target: node.id
+    }));
+    const index = createGraphSpatialIndex({ nodes, edges });
+
+    assert.deepEqual(index.hitTest({ x: 520, y: 328 }), { kind: "node", id: "node-500" });
+    assert.deepEqual(index.hitTest({ x: 40, y: 40 }), { kind: "node", id: "node-0" });
+  });
+
+  it("prefilters dense edge lookups without losing edge hits", () => {
+    const nodes = denseNodes(1000);
+    const edges = nodes.slice(1).map((node, index) => ({
+      id: `edge-${index}`,
+      source: nodes[index].id,
+      target: node.id
+    }));
+    const index = createGraphSpatialIndex({ nodes, edges });
+
+    assert.deepEqual(index.hitTest({ x: 52, y: 29 }), { kind: "edge", id: "edge-0" });
+    assert.deepEqual(index.hitTest({ x: 5000, y: 5000 }), { kind: "graph-blank" });
+  });
+
+  it("uses the edge spatial index before curved-edge distance checks", () => {
+    const nodes = denseNodes(1200);
+    const edges = nodes.slice(1).map((node, index) => ({
+      id: `edge-${index}`,
+      source: nodes[index].id,
+      target: node.id
+    }));
+    const index = new GraphSpatialIndex({ nodes, edges });
+
+    assert.equal(index.edgeCandidateCount({ x: 5000, y: 5000 }), 0);
+    assert.deepEqual(index.hitTest({ x: 5000, y: 5000 }), { kind: "graph-blank" });
+
+    const nearCandidateCount = index.edgeCandidateCount({ x: 52, y: 29 });
+    assert.ok(
+      nearCandidateCount > 0 && nearCandidateCount < edges.length / 5,
+      `dense edge lookup should visit a bounded candidate set, visited ${nearCandidateCount} of ${edges.length}`
+    );
+    assert.deepEqual(index.hitTest({ x: 52, y: 29 }), { kind: "edge", id: "edge-0" });
+  });
+
+  it("keeps local edge candidates bounded when a long edge is present", () => {
+    const localNodes = denseNodes(600);
+    const farNodes = Array.from({ length: 600 }, (_, index) => {
+      const x = 8000 + index % 30 * 36;
+      const y = 8000 + Math.floor(index / 30) * 36;
+      return {
+        id: `far-${index}`,
+        label: `Far ${index}`,
+        type: "entity",
+        point: { x, y },
+        hitBounds: { x: x - 8, y: y - 8, width: 16, height: 16 }
+      };
+    });
+    const nodes = [
+      ...localNodes,
+      ...farNodes,
+      { id: "long-a", point: { x: -5000, y: -5000 }, hitBounds: { x: -5010, y: -5010, width: 20, height: 20 } },
+      { id: "long-b", point: { x: 12000, y: 12000 }, hitBounds: { x: 11990, y: 11990, width: 20, height: 20 } }
+    ];
+    const localEdges = localNodes.slice(1).map((node, index) => ({
+      id: `local-edge-${index}`,
+      source: localNodes[index].id,
+      target: node.id
+    }));
+    const farEdges = farNodes.slice(1).map((node, index) => ({
+      id: `far-edge-${index}`,
+      source: farNodes[index].id,
+      target: node.id
+    }));
+    const edges = [
+      ...localEdges,
+      ...farEdges,
+      { id: "long-edge", source: "long-a", target: "long-b" }
+    ];
+    const index = new GraphSpatialIndex({ nodes, edges });
+
+    const candidateCount = index.edgeCandidateCount({ x: 52, y: 29 });
+    assert.ok(
+      candidateCount > 0 && candidateCount < 20,
+      `long edge should not force unrelated edges into a local lookup, visited ${candidateCount} of ${edges.length}`
+    );
+    assert.deepEqual(index.hitTest({ x: 52, y: 29 }), { kind: "edge", id: "local-edge-0" });
+  });
+});
+
+function denseNodes(count: number): GraphSpatialNodeLike[] {
+  return Array.from({ length: count }, (_, index) => {
+    const x = 40 + index % 40 * 24;
+    const y = 40 + Math.floor(index / 40) * 24;
+    return {
+      id: `node-${index}`,
+      label: `Node ${index}`,
+      type: index % 5 === 0 ? "topic" : "entity",
+      point: { x, y },
+      hitBounds: { x: x - 12, y: y - 10, width: 24, height: 20 }
+    };
+  });
+}

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

@@ -0,0 +1,189 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { createGraphRuntimeState, DEFAULT_RENDERER_VIEWPORT } from "../src/render";
+
+describe("GraphRuntimeState", () => {
+  it("starts with explicit graph-local state defaults", () => {
+    const state = createGraphRuntimeState();
+
+    assert.deepEqual(state.snapshot(), {
+      viewport: DEFAULT_RENDERER_VIEWPORT,
+      positions: {},
+      pins: {},
+      hover: null,
+      selection: null,
+      selectionSurface: null,
+      focus: null,
+      activeGesture: null
+    });
+  });
+
+  it("updates viewport, hover, selection, focus, pins, positions, and active gesture through one owner", () => {
+    const state = createGraphRuntimeState({
+      positions: { a: { x: 100, y: 200 } },
+      pins: { "wiki/a.md": { x: 100, y: 200 } }
+    });
+
+    state.setViewport({ x: -120, y: 64, scale: 1.75 });
+    state.setHover({ kind: "node", id: "a" });
+    state.setSelection({ kind: "node", id: "a" }, "reader");
+    state.setFocus({ kind: "community", id: "c1" });
+    state.commitPosition("a", { x: 130, y: 215 });
+    state.setPins({ "wiki/a.md": { x: 130, y: 215 } });
+    state.setActiveGesture({
+      kind: "node-drag",
+      pointerId: 7,
+      nodeId: "a",
+      grabOffset: { x: 12, y: -4 },
+      startWorldPoint: { x: 100, y: 200 },
+      wasPinned: true,
+      locked: true
+    });
+
+    assert.deepEqual(state.snapshot(), {
+      viewport: { x: -120, y: 64, scale: 1.75 },
+      positions: { a: { x: 130, y: 215 } },
+      pins: { "wiki/a.md": { x: 130, y: 215 } },
+      hover: { kind: "node", id: "a" },
+      selection: { kind: "node", id: "a" },
+      selectionSurface: "reader",
+      focus: { kind: "community", id: "c1" },
+      activeGesture: {
+        kind: "node-drag",
+        pointerId: 7,
+        nodeId: "a",
+        grabOffset: { x: 12, y: -4 },
+        startWorldPoint: { x: 100, y: 200 },
+        wasPinned: true,
+        locked: true
+      }
+    });
+  });
+
+  it("supports multi selection, community hover, viewport pan gesture, and subscribers", () => {
+    const state = createGraphRuntimeState();
+    const snapshots: unknown[] = [];
+    const unsubscribe = state.subscribe((snapshot) => snapshots.push(snapshot));
+
+    state.setSelection({ kind: "nodes", ids: ["a", "b"] });
+    state.setHover({ kind: "community", id: "c1" });
+    state.setActiveGesture({
+      kind: "viewport-pan",
+      pointerId: 12,
+      lastScreenPoint: { x: 320, y: 240 },
+      locked: false
+    });
+    unsubscribe();
+    state.setHover({ kind: "edge", id: "edge-1" });
+
+    assert.equal(snapshots.length, 3);
+    assert.deepEqual(state.snapshot().selection, { kind: "nodes", ids: ["a", "b"] });
+    assert.equal(state.snapshot().selectionSurface, "selection-panel");
+    assert.deepEqual(state.snapshot().hover, { kind: "edge", id: "edge-1" });
+    assert.deepEqual(state.snapshot().activeGesture, {
+      kind: "viewport-pan",
+      pointerId: 12,
+      lastScreenPoint: { x: 320, y: 240 },
+      locked: false
+    });
+  });
+
+  it("keeps simulation proposals out of committed positions until explicitly committed", () => {
+    const state = createGraphRuntimeState({
+      positions: { a: { x: 100, y: 200 } }
+    });
+    const proposal = { a: { x: 300, y: 400 } };
+
+    assert.deepEqual(state.snapshot().positions, { a: { x: 100, y: 200 } });
+    state.setPositions(proposal);
+    proposal.a.x = 999;
+
+    assert.deepEqual(state.snapshot().positions, { a: { x: 300, y: 400 } });
+    state.commitPosition("a", { x: 320, y: 420 });
+    assert.deepEqual(state.snapshot().positions, { a: { x: 320, y: 420 } });
+  });
+
+  it("returns cloned snapshots so callers cannot mutate hidden state", () => {
+    const state = createGraphRuntimeState({
+      positions: { a: { x: 100, y: 200 } },
+      pins: { "wiki/a.md": { x: 100, y: 200, coordinateSpace: "world" } },
+      selection: { kind: "nodes", ids: ["a"] },
+      activeGesture: {
+        kind: "node-drag",
+        pointerId: 1,
+        nodeId: "a",
+        grabOffset: { x: 4, y: 5 },
+        startWorldPoint: { x: 100, y: 200 },
+        wasPinned: true,
+        locked: true
+      }
+    });
+    const snapshot = state.snapshot();
+
+    snapshot.positions.a.x = 999;
+    snapshot.pins["wiki/a.md"].x = 999;
+    if (snapshot.selection?.kind === "nodes") snapshot.selection.ids.push("b");
+    if (snapshot.activeGesture?.kind === "node-drag") snapshot.activeGesture.grabOffset.x = 999;
+    if (snapshot.activeGesture?.kind === "node-drag") snapshot.activeGesture.startWorldPoint.x = 999;
+
+    assert.deepEqual(state.snapshot().positions, { a: { x: 100, y: 200 } });
+    assert.deepEqual(state.snapshot().pins, { "wiki/a.md": { x: 100, y: 200, coordinateSpace: "world" } });
+    assert.deepEqual(state.snapshot().selection, { kind: "nodes", ids: ["a"] });
+    assert.equal(state.snapshot().selectionSurface, "selection-panel");
+    assert.deepEqual(state.snapshot().activeGesture, {
+      kind: "node-drag",
+      pointerId: 1,
+      nodeId: "a",
+      grabOffset: { x: 4, y: 5 },
+      startWorldPoint: { x: 100, y: 200 },
+      wasPinned: true,
+      locked: true
+    });
+  });
+
+  it("clears graph interaction state without changing viewport, positions, or pins", () => {
+    const state = createGraphRuntimeState({
+      viewport: { x: -20, y: 10, scale: 1.5 },
+      positions: { a: { x: 100, y: 200 } },
+      pins: { "wiki/a.md": { x: 100, y: 200 } },
+      hover: { kind: "node", id: "a" },
+      selection: { kind: "node", id: "a" },
+      selectionSurface: "reader",
+      focus: { kind: "community", id: "c1" },
+      activeGesture: { kind: "community-click", pointerId: 9, communityId: "c1", locked: false }
+    });
+
+    state.clearInteraction();
+
+    assert.deepEqual(state.snapshot(), {
+      viewport: { x: -20, y: 10, scale: 1.5 },
+      positions: { a: { x: 100, y: 200 } },
+      pins: { "wiki/a.md": { x: 100, y: 200 } },
+      hover: null,
+      selection: null,
+      selectionSurface: null,
+      focus: null,
+      activeGesture: null
+    });
+  });
+
+  it("preserves pin coordinate space markers across runtime snapshots", () => {
+    const state = createGraphRuntimeState({
+      pins: {
+        "wiki/world.md": { x: 8, y: -12, coordinateSpace: "world" },
+        "wiki/legacy.md": { x: 80, y: 50, coordinateSpace: "legacy-percent" }
+      }
+    });
+
+    state.setPins({
+      "wiki/world.md": { x: 9, y: -13, coordinateSpace: "world" },
+      "wiki/old.md": { x: 75, y: 40 }
+    });
+
+    assert.deepEqual(state.snapshot().pins, {
+      "wiki/world.md": { x: 9, y: -13, coordinateSpace: "world" },
+      "wiki/old.md": { x: 75, y: 40 }
+    });
+  });
+});