@research-copilot/plugin 1.1.17 → 1.1.19

package/dist/skills/llm-wiki/packages/graph-engine/test/helpers.test.ts

@@ -0,0 +1,275 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  splitLabelGraphemes,
+  labelCharWidth,
+  measureLabelWidth,
+  truncateLabel,
+  cardDims,
+  createSafeStorage
+} from "../src/model";
+
+const LABEL_CJK_WIDTH = 15;
+const LABEL_LATIN_WIDTH = 8.5;
+const LABEL_MIN_WIDTH = 72;
+const LABEL_MAX_WIDTH = 180;
+const LABEL_ELLIPSIS = "…";
+async function loadHelpersWithoutSegmenter() {
+  const originalIntl = globalThis.Intl;
+  Object.defineProperty(globalThis, "Intl", { value: {}, configurable: true });
+  try {
+    return await import(`../src/model/legacy-helpers.ts?fallback=${Date.now()}`);
+  } finally {
+    Object.defineProperty(globalThis, "Intl", { value: originalIntl, configurable: true });
+  }
+}
+
+// --- splitLabelGraphemes ---
+
+describe("splitLabelGraphemes", () => {
+  it("splits empty string", () => {
+    assert.deepEqual(splitLabelGraphemes(""), []);
+  });
+
+  it("splits ASCII", () => {
+    assert.deepEqual(splitLabelGraphemes("abc"), ["a", "b", "c"]);
+  });
+
+  it("splits CJK characters", () => {
+    assert.deepEqual(splitLabelGraphemes("中文"), ["中", "文"]);
+  });
+
+  it("does not corrupt emoji with surrogate pairs", () => {
+    const result = splitLabelGraphemes("a👨‍👩‍👧‍👦b");
+    assert.ok(result.includes("👨‍👩‍👧‍👦"), "family emoji kept as single grapheme");
+    assert.equal(result[0], "a");
+    assert.equal(result[result.length - 1], "b");
+  });
+
+  it("does not corrupt surrogate pairs", () => {
+    const result = splitLabelGraphemes("𠮷");
+    // Whether it's 1 grapheme (with Intl.Segmenter) or split into code points,
+    // the result must not contain unmatched surrogate halves
+    assert.ok(!/[\uD800-\uDBFF](?![\uDC00-\uDFFF])/.test(result.join("")));
+  });
+
+  it("falls back when Intl.Segmenter is unavailable", async () => {
+    const fallbackHelpers = await loadHelpersWithoutSegmenter();
+
+    assert.deepEqual(Array.from(fallbackHelpers.splitLabelGraphemes("abc")), ["a", "b", "c"]);
+    assert.deepEqual(Array.from(fallbackHelpers.splitLabelGraphemes("中文")), ["中", "文"]);
+    assert.deepEqual(Array.from(fallbackHelpers.splitLabelGraphemes("👨‍👩‍👧‍👦")), ["👨‍👩‍👧‍👦"]);
+
+    const truncated = fallbackHelpers.truncateLabel("节点A👨‍👩‍👧‍👦AlphaBeta超长标签" + "超".repeat(20), 120);
+    assert.equal(truncated.truncated, true);
+    assert.ok(truncated.text.endsWith(LABEL_ELLIPSIS));
+    assert.ok(
+      !/\uD800(?![\uDC00-\uDFFF])|(?:^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(truncated.text),
+      "fallback path keeps surrogate pairs intact"
+    );
+
+    const emojiBoundary = fallbackHelpers.truncateLabel("节点A👨‍👩‍👧‍👦AlphaBeta超长标签" + "超".repeat(20), 90);
+    assert.ok(emojiBoundary.text.endsWith(LABEL_ELLIPSIS));
+    assert.ok(
+      !emojiBoundary.text.startsWith("‍") && !emojiBoundary.text.includes("‍" + LABEL_ELLIPSIS),
+      "fallback path should not cut through a ZWJ sequence"
+    );
+    assert.ok(
+      !emojiBoundary.text.includes("👨‍") || emojiBoundary.text.includes("👨‍👩‍👧‍👦"),
+      "fallback path should keep the family emoji intact if it is included"
+    );
+  });
+});
+
+// --- labelCharWidth ---
+
+describe("labelCharWidth", () => {
+  it("returns CJK width for CJK character", () => {
+    assert.equal(labelCharWidth("中"), LABEL_CJK_WIDTH);
+  });
+
+  it("returns Latin width for Latin character", () => {
+    assert.equal(labelCharWidth("a"), LABEL_LATIN_WIDTH);
+  });
+
+  it("returns Latin width for digit", () => {
+    assert.equal(labelCharWidth("5"), LABEL_LATIN_WIDTH);
+  });
+
+  it("returns Latin width for punctuation", () => {
+    assert.equal(labelCharWidth("-"), LABEL_LATIN_WIDTH);
+  });
+});
+
+// --- measureLabelWidth ---
+
+describe("measureLabelWidth", () => {
+  it("returns 0 for empty array", () => {
+    assert.equal(measureLabelWidth([]), 0);
+  });
+
+  it("returns correct width for single grapheme", () => {
+    assert.equal(measureLabelWidth(["a"]), LABEL_LATIN_WIDTH);
+  });
+
+  it("sums mixed CJK and Latin widths", () => {
+    const width = measureLabelWidth(["中", "a", "文"]);
+    assert.equal(width, LABEL_CJK_WIDTH * 2 + LABEL_LATIN_WIDTH);
+  });
+});
+
+// --- truncateLabel ---
+
+describe("truncateLabel", () => {
+  it("handles empty string", () => {
+    const r = truncateLabel("", 100);
+    assert.equal(r.text, "");
+    assert.equal(r.truncated, false);
+  });
+
+  it("handles null", () => {
+    const r = truncateLabel(null, 100);
+    assert.equal(r.text, "");
+    assert.equal(r.truncated, false);
+  });
+
+  it("handles undefined", () => {
+    const r = truncateLabel(undefined, 100);
+    assert.equal(r.text, "");
+    assert.equal(r.truncated, false);
+  });
+
+  it("does not truncate short label", () => {
+    const r = truncateLabel("短标签", 120);
+    assert.equal(r.truncated, false);
+    assert.equal(r.text, "短标签");
+  });
+
+  it("truncates long label with ellipsis", () => {
+    const longLabel = "超".repeat(30);
+    const r = truncateLabel(longLabel, 100);
+    assert.equal(r.truncated, true);
+    assert.ok(r.text.endsWith(LABEL_ELLIPSIS));
+  });
+
+  it("does not corrupt emoji when truncating", () => {
+    const r = truncateLabel("节点A👨‍👩‍👧‍👦AlphaBeta超长标签" + "超".repeat(20), 120);
+    assert.equal(r.truncated, true);
+    assert.ok(!r.text.includes("undefined"));
+    assert.ok(
+      !/\uD800(?![\uDC00-\uDFFF])|(?:^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(r.text),
+      "no unmatched surrogate halves"
+    );
+  });
+
+  it("handles CJK + Latin mix", () => {
+    const r = truncateLabel("中文English混合标签" + "超".repeat(20), 120);
+    assert.equal(r.truncated, true);
+    assert.ok(r.text.endsWith(LABEL_ELLIPSIS));
+  });
+
+  it("respects maxWidth exactly at boundary", () => {
+    const label = "a".repeat(10);
+    const r = truncateLabel(label, 1000);
+    assert.equal(r.truncated, false);
+    assert.equal(r.text, label);
+  });
+});
+
+// --- cardDims ---
+
+describe("cardDims", () => {
+  it("returns dimensions for short label", () => {
+    const r = cardDims({ id: "1", label: "短", type: "entity" });
+    assert.ok(r.w >= LABEL_MIN_WIDTH);
+    assert.ok(r.w <= LABEL_MAX_WIDTH);
+    assert.equal(r.h, 36);
+  });
+
+  it("caps width at LABEL_MAX_WIDTH for long label", () => {
+    const r = cardDims({ id: "1", label: "超".repeat(30), type: "entity" });
+    assert.equal(r.w, LABEL_MAX_WIDTH);
+  });
+
+  it("enforces LABEL_MIN_WIDTH for empty label", () => {
+    const r = cardDims({ id: "1", label: "", type: "entity" });
+    assert.equal(r.w, LABEL_MIN_WIDTH);
+  });
+
+  it("taller for topic type", () => {
+    const r = cardDims({ id: "1", label: "T", type: "topic" });
+    assert.equal(r.h, 40);
+  });
+
+  it("shorter for source type", () => {
+    const r = cardDims({ id: "1", label: "S", type: "source" });
+    assert.equal(r.h, 32);
+  });
+
+  it("returns dimensions for generic entity", () => {
+    const r = cardDims({ id: "1", label: "X", type: "entity" });
+    assert.ok(r.w > 0);
+    assert.ok(r.h > 0);
+  });
+});
+
+// --- module export ---
+
+describe("module export", () => {
+  it("exports helpers from the model entry", async () => {
+    const model = await import("../src/model");
+
+    assert.equal(typeof model.truncateLabel, "function");
+    assert.equal(typeof model.cardDims, "function");
+    assert.equal(typeof model.createSafeStorage, "function");
+  });
+});
+
+// --- createSafeStorage ---
+
+describe("createSafeStorage", () => {
+  it("gets and sets normally", () => {
+    const store = {};
+    const storage = createSafeStorage({
+      getItem: (k) => store[k],
+      setItem: (k, v) => { store[k] = v; }
+    });
+    storage.set("k", "v");
+    assert.equal(storage.get("k"), "v");
+  });
+
+  it("returns null when get throws", () => {
+    const logs = [];
+    const storage = createSafeStorage({
+      getItem: () => { throw new Error("boom"); },
+      setItem: () => {}
+    }, (...args) => logs.push(args));
+    assert.equal(storage.get("k"), null);
+    assert.equal(logs.length, 1);
+  });
+
+  it("swallows set errors", () => {
+    const logs = [];
+    const storage = createSafeStorage({
+      getItem: () => null,
+      setItem: () => { throw new Error("boom"); }
+    }, (...args) => logs.push(args));
+    storage.set("k", "v");
+    assert.equal(logs.length, 1);
+  });
+
+  it("handles null logger", () => {
+    const storage = createSafeStorage({
+      getItem: () => { throw new Error("boom"); },
+      setItem: () => { throw new Error("boom"); }
+    }, null);
+    assert.equal(storage.get("k"), null);
+    storage.set("k", "v");
+  });
+
+  it("handles null storage", () => {
+    const storage = createSafeStorage(null, null);
+    assert.equal(storage.get("k"), null);
+    storage.set("k", "v");
+  });
+});

package/dist/skills/llm-wiki/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);
+  });
+});

package/dist/skills/llm-wiki/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: ""
+      }
+    );
+  });
+});