@joekytc/dsh-swarm 0.1.2 → 0.2.0

package/skills/llm-wiki-skill/packages/graph-engine/src/render/renderer-surface.ts

@@ -0,0 +1,75 @@
+import type { NodeId } from "../types";
+import type { PaintedGraphDom } from "./render-context";
+import type { GraphSearchNodeView } from "./search";
+
+export interface GraphRendererSurface {
+  focusRoot(options?: FocusOptions): void;
+  focusNode(id: NodeId, options?: FocusOptions): void;
+  setNodeDragging(id: NodeId, dragging: boolean): void;
+  clearNodeDragging(): void;
+  setViewportDragging(dragging: boolean): void;
+  setDragTarget(id: NodeId | null): void;
+  setFocusDataset(active: boolean): void;
+  setSearchOpen(open: boolean): void;
+  setSearchState(input: {
+    query: string;
+    focusedNodeId: NodeId | null;
+    nodes: readonly GraphSearchNodeView[];
+  }): void;
+}
+
+export function createDomSvgRendererSurface(input: {
+  root: HTMLElement;
+  dom: () => PaintedGraphDom;
+}): GraphRendererSurface {
+  return {
+    focusRoot(options) {
+      input.root.focus(options);
+    },
+    focusNode(id, options) {
+      input.dom().nodeElements.get(id)?.focus(options);
+    },
+    setNodeDragging(id, dragging) {
+      input.dom().nodeElements.get(id)?.classList.toggle("is-dragging", dragging);
+    },
+    clearNodeDragging() {
+      for (const node of input.dom().nodeElements.values()) node.classList.remove("is-dragging");
+    },
+    setViewportDragging(dragging) {
+      if (dragging) input.root.dataset.viewportDragging = "true";
+      else delete input.root.dataset.viewportDragging;
+    },
+    setDragTarget(id) {
+      if (id) input.root.dataset.dragging = id;
+      else delete input.root.dataset.dragging;
+    },
+    setFocusDataset(active) {
+      if (active) input.root.dataset.focus = "true";
+      else delete input.root.dataset.focus;
+    },
+    setSearchOpen(open) {
+      input.root.dataset.searchOpen = open ? "true" : "false";
+      const { searchElement } = input.dom();
+      if (searchElement) searchElement.dataset.state = open ? "open" : "closed";
+    },
+    setSearchState(state) {
+      input.root.dataset.searchActive = state.query ? "true" : "false";
+      input.root.dataset.searchQuery = state.query;
+      const focusedNodeId = state.focusedNodeId;
+      for (const node of state.nodes) {
+        const element = input.dom().nodeElements.get(node.id);
+        if (!element) continue;
+        element.dataset.searchState = node.searchState;
+        element.dataset.searchFocus = node.id === focusedNodeId ? "true" : "false";
+        element.dataset.searchBoost = node.searchState === "match" || node.id === focusedNodeId ? "true" : "false";
+        element.dataset.traceable = element.dataset.coreAnchor === "true" ||
+          element.dataset.temporaryBoost === "true" ||
+          element.dataset.searchBoost === "true" ||
+          element.dataset.pinned === "true" ||
+          element.getAttribute("aria-pressed") === "true"
+          ? "true"
+          : "false";
+      }
+    }
+  };
+}

package/skills/llm-wiki-skill/packages/graph-engine/src/render/search.ts

@@ -0,0 +1,57 @@
+import { applySearchToNodeIds, buildSearchIndex } from "../model/legacy-helpers";
+import type { GraphNode, NodeId } from "../types";
+
+export type GraphSearchNodeState = "none" | "match" | "faded";
+
+export interface GraphSearchNodeView {
+  id: NodeId;
+  searchState: GraphSearchNodeState;
+}
+
+export interface GraphSearchState {
+  query: string;
+  matchIds: NodeId[];
+  nodes: GraphSearchNodeView[];
+  searchIndex: Array<{ node: GraphNode; haystack: string }>;
+}
+
+export interface GraphSearchFocus {
+  id: NodeId | null;
+  index: number;
+}
+
+export function resolveGraphSearchState(
+  nodes: GraphNode[],
+  query: string,
+  cachedIndex?: Array<{ node: GraphNode; haystack: string }>
+): GraphSearchState {
+  const searchIndex = cachedIndex ?? buildSearchIndex(nodes);
+  const normalizedQuery = query.trim();
+  // 空查询表示“没有搜索”，命中集应为空（而非全部）。否则它作为“搜索命中集”
+  // 被全局视图当成 searchHit，会让无搜索时所有节点被标成命中（橙色）。
+  const matchIds = normalizedQuery ? applySearchToNodeIds(searchIndex, normalizedQuery) : [];
+  const matches = new Set(matchIds);
+  return {
+    query: normalizedQuery,
+    matchIds,
+    nodes: nodes.map((node) => ({
+      id: node.id,
+      searchState: normalizedQuery ? (matches.has(node.id) ? "match" : "faded") : "none"
+    })),
+    searchIndex
+  };
+}
+
+export function resolveNextGraphSearchFocus(matchIds: NodeId[], currentId: NodeId | null | undefined): GraphSearchFocus {
+  if (!matchIds.length) return { id: null, index: -1 };
+  const currentIndex = currentId ? matchIds.indexOf(currentId) : -1;
+  const nextIndex = (currentIndex + 1) % matchIds.length;
+  return { id: matchIds[nextIndex], index: nextIndex };
+}
+
+export function resolvePreviousGraphSearchFocus(matchIds: NodeId[], currentId: NodeId | null | undefined): GraphSearchFocus {
+  if (!matchIds.length) return { id: null, index: -1 };
+  const currentIndex = currentId ? matchIds.indexOf(currentId) : -1;
+  const previousIndex = currentIndex <= 0 ? matchIds.length - 1 : currentIndex - 1;
+  return { id: matchIds[previousIndex], index: previousIndex };
+}

package/skills/llm-wiki-skill/packages/graph-engine/src/render/sigma-coordinates.ts

@@ -0,0 +1,44 @@
+import { rootClientPointToScreenPoint, screenPointToWorldPoint, worldPointToCssPercentPoint, type GraphScreenPoint } from "./geometry";
+import { DEFAULT_RENDERER_VIEWPORT } from "./viewport";
+import type { SigmaGlobalRendererCreateOptions, SigmaGlobalSigmaLike } from "./sigma-global-renderer";
+
+export function overlayPointerScreenPoint(event: MouseEvent | PointerEvent, root: HTMLElement): GraphScreenPoint {
+  return rootClientPointToScreenPoint({
+    x: event.clientX,
+    y: event.clientY
+  }, root.getBoundingClientRect());
+}
+
+export function sigmaScreenPointToWorldPoint(
+  sigma: SigmaGlobalSigmaLike,
+  point: GraphScreenPoint,
+  options: Pick<SigmaGlobalRendererCreateOptions, "viewport" | "viewportSize" | "adapterData">
+): { x: number; y: number } {
+  const projected = sigma.viewportToGraph?.(point);
+  if (projected && Number.isFinite(projected.x) && Number.isFinite(projected.y)) {
+    return projected;
+  }
+  return screenPointToWorldPoint(
+    point,
+    options.viewport ?? DEFAULT_RENDERER_VIEWPORT,
+    options.viewportSize ?? { width: 1, height: 1 },
+    options.adapterData.renderable.worldBounds
+  );
+}
+
+export function sigmaWorldPointToScreenPoint(
+  sigma: SigmaGlobalSigmaLike,
+  point: { x: number; y: number },
+  options: Pick<SigmaGlobalRendererCreateOptions, "viewport" | "viewportSize" | "adapterData">
+): GraphScreenPoint {
+  const projected = sigma.graphToViewport?.(point);
+  if (projected && Number.isFinite(projected.x) && Number.isFinite(projected.y)) {
+    return projected;
+  }
+  const percent = worldPointToCssPercentPoint(point, options.adapterData.renderable.worldBounds);
+  const size = options.viewportSize ?? { width: 1, height: 1 };
+  return {
+    x: (percent.x / 100) * size.width,
+    y: (percent.y / 100) * size.height
+  };
+}

package/skills/llm-wiki-skill/packages/graph-engine/src/render/sigma-global-drag.ts

@@ -0,0 +1,246 @@
+import type { PinPosition } from "../types";
+import type { GraphRendererAdapterData, GraphRendererAdapterNode } from "./adapter";
+import type { GraphScreenPoint } from "./geometry";
+import type { GraphGestureTarget } from "./gestures";
+
+export type SigmaGlobalRenderedObject =
+  | { kind: "node"; id: string }
+  | { kind: "edge"; id: string }
+  | { kind: "community-wash"; id: string }
+  | { kind: "aggregation-container"; id: string; communityId?: string | null };
+
+export const SIGMA_GLOBAL_NODE_DRAG_START_THRESHOLD = 2;
+
+export interface SigmaGlobalNodeDragSession {
+  nodeId: string;
+  pinKey: string;
+  startPoint: { x: number; y: number };
+  currentPoint: { x: number; y: number };
+  initiallyPinned: boolean;
+  initialPinPosition: PinPosition | null;
+  pointerStart: GraphScreenPoint;
+  grabOffset: { x: number; y: number };
+  previousCameraPanning: unknown;
+  moved: boolean;
+}
+
+export function createSigmaGlobalNodeDragSession(input: {
+  nodeId: string;
+  pinKey: string;
+  startPoint: { x: number; y: number };
+  pointerStart: GraphScreenPoint;
+  pointerWorldPoint: { x: number; y: number };
+  initiallyPinned: boolean;
+  initialPinPosition: PinPosition | null;
+  previousCameraPanning: unknown;
+}): SigmaGlobalNodeDragSession {
+  return {
+    nodeId: input.nodeId,
+    pinKey: input.pinKey,
+    startPoint: input.startPoint,
+    currentPoint: input.startPoint,
+    initiallyPinned: input.initiallyPinned,
+    initialPinPosition: input.initialPinPosition,
+    pointerStart: input.pointerStart,
+    grabOffset: {
+      x: input.pointerWorldPoint.x - input.startPoint.x,
+      y: input.pointerWorldPoint.y - input.startPoint.y
+    },
+    previousCameraPanning: input.previousCameraPanning,
+    moved: false
+  };
+}
+
+export function moveSigmaGlobalNodeDragSession(
+  drag: SigmaGlobalNodeDragSession,
+  screenPoint: GraphScreenPoint,
+  pointerWorldPoint: { x: number; y: number }
+): void {
+  if (!drag.moved) {
+    const dx = screenPoint.x - drag.pointerStart.x;
+    const dy = screenPoint.y - drag.pointerStart.y;
+    drag.moved = Math.hypot(dx, dy) >= SIGMA_GLOBAL_NODE_DRAG_START_THRESHOLD;
+  }
+  drag.currentPoint = {
+    x: pointerWorldPoint.x - drag.grabOffset.x,
+    y: pointerWorldPoint.y - drag.grabOffset.y
+  };
+}
+
+export function sigmaAdapterDataWithNodePoint(
+  adapterData: GraphRendererAdapterData,
+  nodeId: string,
+  point: { x: number; y: number },
+  pinned: boolean,
+  pinPosition: PinPosition | null
+): GraphRendererAdapterData {
+  let changed = false;
+  const nodes = adapterData.nodes.map((node) => {
+    if (node.id !== nodeId) return node;
+    changed = true;
+    return sigmaAdapterNodeWithPoint(node, point, pinned, pinPosition);
+  });
+  if (!changed) return adapterData;
+
+  const nodeById = new Map(nodes.map((node) => [node.id, node]));
+  const pinnedNodeIds = new Set(nodes.filter((node) => node.pinHint.pinned).map((node) => node.id));
+  const pinHintsForNodeIds = (nodeIds: readonly string[]) => nodeIds
+    .map((id) => nodeById.get(id)?.pinHint)
+    .filter((hint): hint is GraphRendererAdapterNode["pinHint"] => Boolean(hint?.pinned));
+
+  return {
+    ...adapterData,
+    nodes,
+    communities: adapterData.communities.map((community) => ({
+      ...community,
+      pinHints: community.pinHints.some((hint) => hint.nodeId === nodeId) || pinned
+        ? pinHintsForNodeIds(community.nodeIds)
+        : community.pinHints
+    })),
+    aggregations: adapterData.aggregations.map((aggregation) => ({
+      ...aggregation,
+      pinnedNodeIds: aggregation.nodeIds.filter((id) => pinnedNodeIds.has(id)),
+      pinHints: pinHintsForNodeIds(aggregation.nodeIds)
+    })),
+    renderable: {
+      ...adapterData.renderable,
+      nodes: adapterData.renderable.nodes.map((node) => (
+        node.id === nodeId
+          ? { ...node, x: point.x, y: point.y, point: { x: point.x, y: point.y } }
+          : node
+      )),
+      aggregationContainers: adapterData.renderable.aggregationContainers.map((aggregation) => ({
+        ...aggregation,
+        pinnedNodeIds: aggregation.nodeIds.filter((id) => pinnedNodeIds.has(id)),
+        pinHints: pinHintsForNodeIds(aggregation.nodeIds),
+        pinnedCount: aggregation.nodeIds.filter((id) => pinnedNodeIds.has(id)).length
+      }))
+    }
+  };
+}
+
+export function bindSigmaGlobalOverlayPointerDrag(input: {
+  ownerDocument: Document;
+  element: HTMLElement;
+  nodeId: string;
+  pointerId: number;
+  isActive: (nodeId: string) => boolean;
+  screenPointFromEvent: (event: PointerEvent) => GraphScreenPoint;
+  onMove: (point: GraphScreenPoint, event: PointerEvent) => void;
+  onEnd: (point: GraphScreenPoint, event: PointerEvent) => void;
+  onCancel: () => void;
+}): () => void {
+  input.element.setPointerCapture?.(input.pointerId);
+  const move = (event: PointerEvent): void => {
+    if (event.pointerId !== input.pointerId || !input.isActive(input.nodeId)) return;
+    event.preventDefault();
+    event.stopPropagation();
+    input.onMove(input.screenPointFromEvent(event), event);
+  };
+  const up = (event: PointerEvent): void => {
+    if (event.pointerId !== input.pointerId || !input.isActive(input.nodeId)) return;
+    event.preventDefault();
+    event.stopPropagation();
+    input.element.releasePointerCapture?.(input.pointerId);
+    input.onEnd(input.screenPointFromEvent(event), event);
+  };
+  const cancel = (event: PointerEvent): void => {
+    if (event.pointerId !== input.pointerId || !input.isActive(input.nodeId)) return;
+    event.preventDefault();
+    event.stopPropagation();
+    input.element.releasePointerCapture?.(input.pointerId);
+    input.onCancel();
+  };
+  input.ownerDocument.addEventListener("pointermove", move, true);
+  input.ownerDocument.addEventListener("pointerup", up, true);
+  input.ownerDocument.addEventListener("pointercancel", cancel, true);
+  return () => {
+    input.ownerDocument.removeEventListener("pointermove", move, true);
+    input.ownerDocument.removeEventListener("pointerup", up, true);
+    input.ownerDocument.removeEventListener("pointercancel", cancel, true);
+  };
+}
+
+export function bindSigmaGlobalOverlayMouseDrag(input: {
+  ownerDocument: Document;
+  nodeId: string;
+  isActive: (nodeId: string) => boolean;
+  screenPointFromEvent: (event: MouseEvent) => GraphScreenPoint;
+  onMove: (point: GraphScreenPoint, event: MouseEvent) => void;
+  onEnd: (point: GraphScreenPoint, event: MouseEvent) => void;
+}): () => void {
+  const move = (event: MouseEvent): void => {
+    if (!input.isActive(input.nodeId)) return;
+    event.preventDefault();
+    event.stopPropagation();
+    input.onMove(input.screenPointFromEvent(event), event);
+  };
+  const up = (event: MouseEvent): void => {
+    if (!input.isActive(input.nodeId)) return;
+    event.preventDefault();
+    event.stopPropagation();
+    input.onEnd(input.screenPointFromEvent(event), event);
+  };
+  input.ownerDocument.addEventListener("mousemove", move, true);
+  input.ownerDocument.addEventListener("mouseup", up, true);
+  return () => {
+    input.ownerDocument.removeEventListener("mousemove", move, true);
+    input.ownerDocument.removeEventListener("mouseup", up, true);
+  };
+}
+
+function sigmaAdapterNodeWithPoint(
+  node: GraphRendererAdapterNode,
+  point: { x: number; y: number },
+  pinned: boolean,
+  pinPosition: PinPosition | null
+): GraphRendererAdapterNode {
+  return {
+    ...node,
+    point: { x: point.x, y: point.y },
+    pinHint: {
+      ...node.pinHint,
+      pinned,
+      position: pinned ? (pinPosition ?? { x: point.x, y: point.y, coordinateSpace: "world" }) : null
+    }
+  };
+}
+
+export function sigmaCommunityLabels(adapterData: GraphRendererAdapterData, limit: number): GraphRendererAdapterData["renderable"]["communities"] {
+  const selectedCommunityIds = new Set(adapterData.communities.filter((community) => community.selected).map((community) => community.id));
+  return adapterData.renderable.communities
+    .filter((community) => community.wash)
+    .map((community, index) => ({
+      community,
+      index,
+      selected: selectedCommunityIds.has(community.id)
+    }))
+    .sort((left, right) => {
+      if (left.selected !== right.selected) return left.selected ? -1 : 1;
+      if (left.community.nodeCount !== right.community.nodeCount) return right.community.nodeCount - left.community.nodeCount;
+      return left.index - right.index;
+    })
+    .slice(0, limit)
+    .map((candidate) => candidate.community);
+}
+
+export function gestureTargetFromSigmaRenderedObject(
+  object: SigmaGlobalRenderedObject,
+  adapterData: GraphRendererAdapterData
+): GraphGestureTarget | null {
+  switch (object.kind) {
+    case "node":
+      return adapterData.nodes.some((node) => node.id === object.id) ? { kind: "node", id: object.id } : null;
+    case "edge":
+      return adapterData.edges.some((edge) => edge.id === object.id) ? { kind: "edge", id: object.id } : null;
+    case "community-wash":
+      return adapterData.communities.some((community) => community.id === object.id) ? { kind: "community-wash", id: object.id } : null;
+    case "aggregation-container": {
+      const aggregation = adapterData.aggregations.find((item) => item.id === object.id);
+      if (!aggregation) return null;
+      return { kind: "aggregation-container", id: object.id, communityId: object.communityId ?? aggregation.communityId };
+    }
+    default:
+      return null;
+  }
+}