@joekytc/dsh-swarm 0.1.2 → 0.2.0

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

@@ -0,0 +1,420 @@
+import type { GraphData, GraphEdge, GraphNode, PinMap } from "../src/types";
+
+export type LargeGraphFixtureId =
+  | "real-snapshot-proxy"
+  | "nodes-1000-sparse"
+  | "nodes-1000-dense"
+  | "nodes-5000-sparse"
+  | "nodes-5000-dense"
+  | "nodes-10000-aggregation"
+  | "nodes-10000-high-edge"
+  | "oversized-community"
+  | "many-small-communities"
+  | "many-search-hits"
+  | "many-pin-nodes";
+
+export interface LargeGraphFixtureSpec {
+  id: LargeGraphFixtureId;
+  nodes: number;
+  edges: number;
+  communities: number;
+  largestCommunity: number;
+  searchHits: number;
+  pinCount: number;
+  oversizedCommunity: boolean;
+  seed: number;
+  communitySizes?: number[];
+}
+
+export interface LargeGraphFixtureMetadata {
+  id: LargeGraphFixtureId;
+  nodes: number;
+  edges: number;
+  communities: number;
+  largest_community: number;
+  largest_connected_density: number;
+  search_hits: number;
+  pin_count: number;
+  oversized_community: boolean;
+}
+
+export interface LargeGraphFixture {
+  id: LargeGraphFixtureId;
+  data: GraphData;
+  pins: PinMap;
+  metadata: LargeGraphFixtureMetadata;
+}
+
+export const LARGE_GRAPH_FIXTURE_SPECS: LargeGraphFixtureSpec[] = [
+  {
+    id: "real-snapshot-proxy",
+    nodes: 1000,
+    edges: 1600,
+    communities: 16,
+    largestCommunity: 63,
+    searchHits: 40,
+    pinCount: 20,
+    oversizedCommunity: false,
+    seed: 11
+  },
+  {
+    id: "nodes-1000-sparse",
+    nodes: 1000,
+    edges: 1400,
+    communities: 20,
+    largestCommunity: 50,
+    searchHits: 25,
+    pinCount: 25,
+    oversizedCommunity: false,
+    seed: 101
+  },
+  {
+    id: "nodes-1000-dense",
+    nodes: 1000,
+    edges: 12000,
+    communities: 20,
+    largestCommunity: 50,
+    searchHits: 100,
+    pinCount: 50,
+    oversizedCommunity: false,
+    seed: 102
+  },
+  {
+    id: "nodes-5000-sparse",
+    nodes: 5000,
+    edges: 6500,
+    communities: 50,
+    largestCommunity: 100,
+    searchHits: 100,
+    pinCount: 100,
+    oversizedCommunity: false,
+    seed: 501
+  },
+  {
+    id: "nodes-5000-dense",
+    nodes: 5000,
+    edges: 60000,
+    communities: 50,
+    largestCommunity: 100,
+    searchHits: 250,
+    pinCount: 250,
+    oversizedCommunity: false,
+    seed: 502
+  },
+  {
+    id: "nodes-10000-aggregation",
+    nodes: 10000,
+    edges: 14000,
+    communities: 100,
+    largestCommunity: 100,
+    searchHits: 200,
+    pinCount: 200,
+    oversizedCommunity: false,
+    seed: 1001
+  },
+  {
+    id: "nodes-10000-high-edge",
+    nodes: 10000,
+    edges: 90000,
+    communities: 100,
+    largestCommunity: 100,
+    searchHits: 300,
+    pinCount: 300,
+    oversizedCommunity: false,
+    seed: 1002
+  },
+  {
+    id: "oversized-community",
+    nodes: 3000,
+    edges: 7000,
+    communities: 15,
+    largestCommunity: 1800,
+    searchHits: 120,
+    pinCount: 120,
+    oversizedCommunity: true,
+    seed: 3001,
+    communitySizes: [1800, 86, 86, 86, 86, 86, 86, 86, 86, 86, 85, 85, 85, 85, 86]
+  },
+  {
+    id: "many-small-communities",
+    nodes: 5000,
+    edges: 6000,
+    communities: 1000,
+    largestCommunity: 5,
+    searchHits: 100,
+    pinCount: 100,
+    oversizedCommunity: false,
+    seed: 4001
+  },
+  {
+    id: "many-search-hits",
+    nodes: 5000,
+    edges: 7000,
+    communities: 50,
+    largestCommunity: 100,
+    searchHits: 1200,
+    pinCount: 100,
+    oversizedCommunity: false,
+    seed: 5001
+  },
+  {
+    id: "many-pin-nodes",
+    nodes: 5000,
+    edges: 7000,
+    communities: 50,
+    largestCommunity: 100,
+    searchHits: 100,
+    pinCount: 1200,
+    oversizedCommunity: false,
+    seed: 5002
+  }
+];
+
+export function generateLargeGraphFixture(id: LargeGraphFixtureId): LargeGraphFixture {
+  const spec = LARGE_GRAPH_FIXTURE_SPECS.find((item) => item.id === id);
+  if (!spec) throw new Error(`Unknown large graph fixture: ${id}`);
+  const communitySizes = spec.communitySizes || evenCommunitySizes(spec.nodes, spec.communities);
+  const nodeCommunity = new Map<string, string>();
+  const nodes: GraphNode[] = [];
+  let nodeIndex = 0;
+  for (let communityIndex = 0; communityIndex < communitySizes.length; communityIndex += 1) {
+    const community = `c${communityIndex}`;
+    for (let localIndex = 0; localIndex < communitySizes[communityIndex]; localIndex += 1) {
+      const id = `n${nodeIndex}`;
+      const searchHit = nodeIndex < spec.searchHits;
+      const labelPrefix = searchHit ? "needle" : "node";
+      const type = nodeIndex % 11 === 0 ? "source" : nodeIndex % 7 === 0 ? "topic" : "entity";
+      nodes.push({
+        id,
+        label: `${labelPrefix} ${nodeIndex} community ${communityIndex}`,
+        type,
+        community,
+        source_path: `wiki/generated/${spec.id}/${id}.md`,
+        weight: 100 - (nodeIndex % 83),
+        x: coordinate(nodeIndex, 997),
+        y: coordinate(nodeIndex, 463)
+      });
+      nodeCommunity.set(id, community);
+      nodeIndex += 1;
+    }
+  }
+
+  const edges = generateEdges(spec, nodes, nodeCommunity);
+  const pins = generatePins(spec, nodes);
+  const metadata = summarizeLargeGraphFixture(spec.id, {
+    meta: {
+      build_date: "2026-06-18T00:00:00.000Z",
+      wiki_title: `Large graph fixture ${spec.id}`,
+      total_nodes: nodes.length,
+      total_edges: edges.length,
+      initial_view: nodes.slice(0, Math.min(250, nodes.length)).map((node) => node.id),
+      degraded: spec.nodes >= 5000
+    },
+    nodes,
+    edges,
+    learning: {
+      version: 1,
+      entry: {
+        recommended_start_node_id: nodes[0]?.id ?? null,
+        recommended_start_reason: "fixture_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: nodes.map((node) => node.id), degraded: spec.nodes >= 5000 }
+      },
+      communities: communitySizes.map((size, index) => ({
+        id: `c${index}`,
+        label: `Community ${index}`,
+        node_count: size,
+        color_index: index,
+        recommended_start_node_id: firstNodeIdForCommunity(communitySizes, index)
+      }))
+    }
+  }, pins);
+
+  return {
+    id: spec.id,
+    data: {
+      meta: {
+        build_date: "2026-06-18T00:00:00.000Z",
+        wiki_title: `Large graph fixture ${spec.id}`,
+        total_nodes: nodes.length,
+        total_edges: edges.length,
+        initial_view: nodes.slice(0, Math.min(250, nodes.length)).map((node) => node.id),
+        degraded: spec.nodes >= 5000
+      },
+      nodes,
+      edges,
+      learning: {
+        version: 1,
+        entry: {
+          recommended_start_node_id: nodes[0]?.id ?? null,
+          recommended_start_reason: "fixture_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: nodes.map((node) => node.id), degraded: spec.nodes >= 5000 }
+        },
+        communities: communitySizes.map((size, index) => ({
+          id: `c${index}`,
+          label: `Community ${index}`,
+          node_count: size,
+          color_index: index,
+          recommended_start_node_id: firstNodeIdForCommunity(communitySizes, index)
+        }))
+      }
+    },
+    pins,
+    metadata
+  };
+}
+
+export function summarizeLargeGraphFixture(id: LargeGraphFixtureId, data: GraphData, pins: PinMap): LargeGraphFixtureMetadata {
+  const communityCounts = new Map<string, number>();
+  for (const node of data.nodes) {
+    const community = String(node.community ?? "_none");
+    communityCounts.set(community, (communityCounts.get(community) || 0) + 1);
+  }
+  const nodeCommunity = new Map(data.nodes.map((node) => [node.id, String(node.community ?? "_none")]));
+  const internalEdgesByCommunity = new Map<string, number>();
+  for (const edge of data.edges) {
+    const fromCommunity = nodeCommunity.get(edge.from);
+    const toCommunity = nodeCommunity.get(edge.to);
+    if (!fromCommunity || fromCommunity !== toCommunity) continue;
+    internalEdgesByCommunity.set(fromCommunity, (internalEdgesByCommunity.get(fromCommunity) || 0) + 1);
+  }
+  const largestCommunity = Math.max(...communityCounts.values());
+  let largestConnectedDensity = 0;
+  for (const [community, count] of communityCounts) {
+    const possible = count > 1 ? (count * (count - 1)) / 2 : 0;
+    const density = possible ? (internalEdgesByCommunity.get(community) || 0) / possible : 0;
+    largestConnectedDensity = Math.max(largestConnectedDensity, density);
+  }
+  return {
+    id,
+    nodes: data.nodes.length,
+    edges: data.edges.length,
+    communities: communityCounts.size,
+    largest_community: largestCommunity,
+    largest_connected_density: Number(largestConnectedDensity.toFixed(4)),
+    search_hits: data.nodes.filter((node) => node.label.includes("needle")).length,
+    pin_count: Object.keys(pins).length,
+    oversized_community: largestCommunity >= 1000
+  };
+}
+
+function evenCommunitySizes(nodes: number, communities: number): number[] {
+  const base = Math.floor(nodes / communities);
+  const remainder = nodes % communities;
+  return Array.from({ length: communities }, (_, index) => base + (index < remainder ? 1 : 0));
+}
+
+function generateEdges(
+  spec: LargeGraphFixtureSpec,
+  nodes: GraphNode[],
+  nodeCommunity: Map<string, string>
+): GraphEdge[] {
+  const edges: GraphEdge[] = [];
+  const seen = new Set<string>();
+  const byCommunity = new Map<string, string[]>();
+  for (const node of nodes) {
+    const community = String(node.community ?? "_none");
+    const list = byCommunity.get(community) || [];
+    list.push(node.id);
+    byCommunity.set(community, list);
+  }
+
+  for (const members of byCommunity.values()) {
+    for (let index = 1; index < members.length && edges.length < spec.edges; index += 1) {
+      addEdge(edges, seen, members[index - 1], members[index], "EXTRACTED");
+    }
+  }
+
+  let cursor = 0;
+  const orderedCommunities = [...byCommunity.values()];
+  while (edges.length < spec.edges && cursor < orderedCommunities.length * 3) {
+    const fromMembers = orderedCommunities[cursor % orderedCommunities.length];
+    const toMembers = orderedCommunities[(cursor + 1) % orderedCommunities.length];
+    addEdge(
+      edges,
+      seen,
+      fromMembers[cursor % fromMembers.length],
+      toMembers[(cursor * 7) % toMembers.length],
+      "INFERRED"
+    );
+    cursor += 1;
+  }
+
+  const random = mulberry32(spec.seed);
+  let attempts = 0;
+  const maxAttempts = spec.edges * 20;
+  while (edges.length < spec.edges && attempts < maxAttempts) {
+    const from = nodes[Math.floor(random() * nodes.length)];
+    const sameCommunity = random() < 0.74;
+    let to: GraphNode;
+    if (sameCommunity) {
+      const members = byCommunity.get(nodeCommunity.get(from.id) || "") || nodes.map((node) => node.id);
+      to = nodes[Number(members[Math.floor(random() * members.length)].slice(1))] || nodes[Math.floor(random() * nodes.length)];
+    } else {
+      to = nodes[Math.floor(random() * nodes.length)];
+    }
+    addEdge(edges, seen, from.id, to.id, random() < 0.15 ? "INFERRED" : "EXTRACTED");
+    attempts += 1;
+  }
+  if (edges.length !== spec.edges) throw new Error(`Could not generate ${spec.edges} unique edges for ${spec.id}`);
+  return edges;
+}
+
+function addEdge(edges: GraphEdge[], seen: Set<string>, from: string, to: string, type: "EXTRACTED" | "INFERRED"): void {
+  if (from === to) return;
+  const key = from < to ? `${from}:${to}` : `${to}:${from}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  edges.push({
+    id: `e${edges.length}`,
+    from,
+    to,
+    type,
+    confidence: type,
+    relation_type: type === "EXTRACTED" ? "实现" : "衍生",
+    weight: type === "EXTRACTED" ? 1 : 0.55
+  });
+}
+
+function generatePins(spec: LargeGraphFixtureSpec, nodes: GraphNode[]): PinMap {
+  const pins: PinMap = {};
+  for (const node of nodes.slice(0, spec.pinCount)) {
+    if (!node.source_path) continue;
+    pins[node.source_path] = {
+      x: Number(node.x) * 10,
+      y: Number(node.y) * 6.8,
+      coordinateSpace: "world"
+    };
+  }
+  return pins;
+}
+
+function firstNodeIdForCommunity(communitySizes: number[], communityIndex: number): string {
+  let offset = 0;
+  for (let index = 0; index < communityIndex; index += 1) offset += communitySizes[index];
+  return `n${offset}`;
+}
+
+function coordinate(index: number, salt: number): number {
+  return Math.round((((index * salt) % 1000) / 10) * 100) / 100;
+}
+
+function mulberry32(seed: number): () => number {
+  let value = seed >>> 0;
+  return () => {
+    value += 0x6D2B79F5;
+    let next = value;
+    next = Math.imul(next ^ (next >>> 15), next | 1);
+    next ^= next + Math.imul(next ^ (next >>> 7), next | 61);
+    return ((next ^ (next >>> 14)) >>> 0) / 4294967296;
+  };
+}

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

@@ -0,0 +1,259 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  defaultLearning,
+  normalizeLearning,
+  resolveInitialMode,
+  getCommunityNodeIds,
+  getVisibleNodeIds,
+  getVisibleLinks,
+  buildSearchIndex,
+  applySearchToNodeIds,
+  filterLinksByTypes,
+  applyFocusMode,
+  resolveVisibleSnapshot,
+  shouldAutoOpenDrawer
+} from "../src/model";
+
+describe("defaultLearning", () => {
+  it("returns a stable empty learning structure", () => {
+    const d = defaultLearning();
+    assert.equal(d.version, 1);
+    assert.equal(d.entry.default_mode, "global");
+    assert.equal(d.entry.recommended_start_node_id, null);
+    assert.equal(d.views.path.enabled, false);
+    assert.equal(d.views.path.degraded, true);
+    assert.equal(d.views.community.enabled, false);
+    assert.equal(d.views.community.degraded, true);
+    assert.equal(d.views.global.enabled, true);
+    assert.equal(d.views.global.degraded, false);
+    assert.deepEqual(d.communities, []);
+    assert.equal(d.degraded.path_to_community, true);
+    assert.equal(d.degraded.community_to_global, true);
+  });
+});
+
+describe("normalizeLearning", () => {
+  it("returns default when input is null", () => {
+    const n = normalizeLearning(null);
+    assert.equal(n.version, 1);
+    assert.equal(n.entry.default_mode, "global");
+  });
+
+  it("returns default when input is undefined", () => {
+    const n = normalizeLearning(undefined);
+    assert.equal(n.version, 1);
+  });
+
+  it("preserves valid learning data", () => {
+    const raw = {
+      version: 1,
+      entry: { recommended_start_node_id: "A", recommended_start_reason: "community_hub", default_mode: "path" },
+      views: {
+        path: { enabled: true, start_node_id: "A", node_ids: ["A", "B"], degraded: false },
+        community: { enabled: true, community_id: "c1", label: "Community 1", node_ids: ["A", "B", "C"], is_weak: false, degraded: false },
+        global: { enabled: true, node_ids: ["A", "B", "C"], degraded: false }
+      },
+      communities: [{ id: "c1", label: "Community 1", node_count: 3, source_count: 1, is_primary: true }],
+      degraded: { path_to_community: false, community_to_global: false }
+    };
+    const n = normalizeLearning(raw);
+    assert.equal(n.entry.recommended_start_node_id, "A");
+    assert.deepEqual(n.views.path.node_ids, ["A", "B"]);
+    assert.equal(n.communities.length, 1);
+  });
+
+  it("fills missing views with defaults", () => {
+    const n = normalizeLearning({ version: 1 });
+    assert.equal(n.views.path.enabled, false);
+    assert.equal(n.views.community.enabled, false);
+    assert.equal(n.views.global.enabled, true);
+  });
+
+  it("handles missing node_ids arrays", () => {
+    const n = normalizeLearning({ views: { path: { enabled: true }, community: {}, global: {} } });
+    assert.deepEqual(n.views.path.node_ids, []);
+  });
+});
+
+describe("resolveInitialMode", () => {
+  it("returns global when learning is null", () => {
+    assert.equal(resolveInitialMode(null), "global");
+  });
+
+  it("keeps the first paint global even when path is available", () => {
+    const learning = { entry: { default_mode: "path" }, views: { path: { degraded: false }, community: { degraded: false } } };
+    assert.equal(resolveInitialMode(learning), "global");
+  });
+
+  it("keeps the first paint global when community is available", () => {
+    const learning = { entry: { default_mode: "community" }, views: { path: { degraded: true }, community: { degraded: false } } };
+    assert.equal(resolveInitialMode(learning), "global");
+  });
+});
+
+describe("getCommunityNodeIds", () => {
+  it("returns sorted node ids for a matching community", () => {
+    const nodes = [
+      { id: "B", community: "c2" },
+      { id: "A", community: "c1" },
+      { id: "C", community: "c1" },
+      { id: "D", community: null }
+    ];
+    assert.deepEqual(getCommunityNodeIds(nodes, "c1"), ["A", "C"]);
+  });
+
+  it("returns empty array for missing community", () => {
+    const nodes = [{ id: "A", community: "c1" }];
+    assert.deepEqual(getCommunityNodeIds(nodes, "c9"), []);
+  });
+
+  it("returns empty array when community id is absent", () => {
+    const nodes = [{ id: "A", community: "c1" }];
+    assert.deepEqual(getCommunityNodeIds(nodes, null), []);
+  });
+});
+
+describe("getVisibleNodeIds", () => {
+  it("returns empty array when learning is null", () => {
+    assert.deepEqual(getVisibleNodeIds(null, "path"), []);
+  });
+
+  it("returns node_ids for valid mode", () => {
+    const learning = { views: { path: { enabled: true, node_ids: ["A", "B"] } } };
+    assert.deepEqual(getVisibleNodeIds(learning, "path"), ["A", "B"]);
+  });
+
+  it("returns empty when view is disabled", () => {
+    const learning = { views: { path: { enabled: false, node_ids: ["A"] } } };
+    assert.deepEqual(getVisibleNodeIds(learning, "path"), []);
+  });
+
+  it("returns empty for global mode when view node_ids is empty", () => {
+    const learning = { views: { global: { enabled: true, node_ids: [] } } };
+    assert.deepEqual(getVisibleNodeIds(learning, "global"), []);
+  });
+});
+
+describe("getVisibleLinks", () => {
+  it("returns all links when visibleIds is empty", () => {
+    const links = [{ source: "A", target: "B" }];
+    assert.deepEqual(getVisibleLinks(links, []), links);
+  });
+
+  it("filters links to only those with both endpoints visible", () => {
+    const links = [
+      { source: { id: "A" }, target: { id: "B" } },
+      { source: { id: "A" }, target: { id: "C" } },
+      { source: { id: "B" }, target: { id: "C" } }
+    ];
+    const result = getVisibleLinks(links, ["A", "B"]);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].source.id, "A");
+    assert.equal(result[0].target.id, "B");
+  });
+});
+
+describe("search helpers", () => {
+  it("builds searchable haystacks and finds matches", () => {
+    const nodes = [
+      { id: "A", label: "Transformer", content: "attention and language" },
+      { id: "B", label: "CNN", content: "vision only" }
+    ];
+    const index = buildSearchIndex(nodes);
+    assert.equal(index.length, 2);
+    assert.deepEqual(applySearchToNodeIds(index, "attention"), ["A"]);
+    assert.deepEqual(applySearchToNodeIds(index, ""), ["A", "B"]);
+  });
+});
+
+describe("filterLinksByTypes", () => {
+  it("keeps only enabled edge types", () => {
+    const links = [
+      { id: "e1", type: "EXTRACTED" },
+      { id: "e2", type: "INFERRED" },
+      { id: "e3", type: "AMBIGUOUS" }
+    ];
+    const result = filterLinksByTypes(links, { EXTRACTED: true, INFERRED: false, AMBIGUOUS: false });
+    assert.deepEqual(result.map((link) => link.id), ["e1"]);
+  });
+});
+
+describe("applyFocusMode", () => {
+  const nodes = [
+    { id: "A", degree: 3 },
+    { id: "B", degree: 2 },
+    { id: "C", degree: 2 },
+    { id: "D", degree: 1 }
+  ];
+  const links = [
+    { source: "A", target: "B", weight: 0.95 },
+    { source: "A", target: "C", weight: 0.82 },
+    { source: "C", target: "D", weight: 0.45 }
+  ];
+  const nodeIds = ["A", "B", "C", "D"];
+
+  it("returns scoped nodes unchanged for all mode", () => {
+    const result = applyFocusMode({ mode: "all", nodes, links, nodeIds });
+    assert.deepEqual(result.node_ids, nodeIds);
+    assert.equal(result.links.length, 3);
+  });
+
+  it("keeps anchor and one-hop neighbors for one_hop mode", () => {
+    const result = applyFocusMode({ mode: "one_hop", nodes, links, nodeIds, anchorNodeId: "A" });
+    assert.deepEqual(result.node_ids, ["A", "B", "C"]);
+    assert.equal(result.links.length, 2);
+  });
+
+  it("keeps only strong links for high_confidence mode", () => {
+    const result = applyFocusMode({ mode: "high_confidence", nodes, links, nodeIds, anchorNodeId: "A", highConfidenceThreshold: 0.8 });
+    assert.deepEqual(result.node_ids, ["A", "B", "C"]);
+    assert.equal(result.links.length, 2);
+  });
+
+  it("prefers high-score nodes for core mode", () => {
+    const result = applyFocusMode({ mode: "core", nodes, links, nodeIds, coreLimit: 2 });
+    assert.deepEqual(result.node_ids, ["A", "C"]);
+    assert.equal(result.links.length, 1);
+  });
+});
+
+describe("resolveVisibleSnapshot", () => {
+  it("applies search after focus mode", () => {
+    const nodes = [
+      { id: "A", label: "Transformer", content: "attention", degree: 3 },
+      { id: "B", label: "Attention", content: "weights", degree: 2 },
+      { id: "C", label: "CNN", content: "vision", degree: 1 }
+    ];
+    const links = [
+      { source: "A", target: "B", type: "EXTRACTED", weight: 0.95 },
+      { source: "A", target: "C", type: "INFERRED", weight: 0.4 }
+    ];
+    const result = resolveVisibleSnapshot({
+      nodes,
+      links,
+      baseNodeIds: ["A", "B", "C"],
+      filters: { EXTRACTED: true, INFERRED: false, AMBIGUOUS: false },
+      focusMode: "high_confidence",
+      searchQuery: "attention",
+      anchorNodeId: "A",
+      highConfidenceThreshold: 0.8
+    });
+    assert.deepEqual(result.node_ids, ["A", "B"]);
+    assert.equal(result.links.length, 1);
+  });
+});
+
+describe("shouldAutoOpenDrawer", () => {
+  it("returns true for path mode after explicit path entry", () => {
+    assert.equal(shouldAutoOpenDrawer("path"), true);
+  });
+
+  it("returns false for community mode", () => {
+    assert.equal(shouldAutoOpenDrawer("community"), false);
+  });
+
+  it("returns false for global mode", () => {
+    assert.equal(shouldAutoOpenDrawer("global"), false);
+  });
+});