clawvault 3.0.0 → 3.2.0

package/dashboard/lib/graph-diff.js

@@ -0,0 +1,104 @@
+function toNodeSignature(node) {
+  return JSON.stringify({
+    title: node.title,
+    category: node.category,
+    tags: Array.isArray(node.tags) ? [...node.tags].sort() : [],
+    path: node.path,
+    missing: Boolean(node.missing),
+    degree: Number(node.degree ?? 0)
+  });
+}
+
+function toEdgeKey(edge) {
+  const type = edge.type ?? '';
+  const label = edge.label ?? '';
+  return `${edge.source}=>${edge.target}:${type}:${label}`;
+}
+
+/**
+ * Compute an efficient patch between graph snapshots.
+ * @param {{nodes: Array<object>, edges: Array<object>, stats?: object}} previousGraph
+ * @param {{nodes: Array<object>, edges: Array<object>, stats?: object}} nextGraph
+ */
+export function diffGraphs(previousGraph, nextGraph) {
+  const previousNodes = previousGraph?.nodes ?? [];
+  const nextNodes = nextGraph?.nodes ?? [];
+  const previousEdges = previousGraph?.edges ?? [];
+  const nextEdges = nextGraph?.edges ?? [];
+
+  const previousNodeById = new Map(previousNodes.map((node) => [node.id, node]));
+  const nextNodeById = new Map(nextNodes.map((node) => [node.id, node]));
+
+  const addedNodes = [];
+  const updatedNodes = [];
+  const removedNodeIds = [];
+
+  for (const [nodeId, nextNode] of nextNodeById.entries()) {
+    const previousNode = previousNodeById.get(nodeId);
+    if (!previousNode) {
+      addedNodes.push(nextNode);
+      continue;
+    }
+    if (toNodeSignature(previousNode) !== toNodeSignature(nextNode)) {
+      updatedNodes.push(nextNode);
+    }
+  }
+
+  for (const nodeId of previousNodeById.keys()) {
+    if (!nextNodeById.has(nodeId)) {
+      removedNodeIds.push(nodeId);
+    }
+  }
+
+  const previousEdgeByKey = new Map(previousEdges.map((edge) => [toEdgeKey(edge), edge]));
+  const nextEdgeByKey = new Map(nextEdges.map((edge) => [toEdgeKey(edge), edge]));
+  const addedEdges = [];
+  const removedEdges = [];
+
+  for (const [edgeKey, edge] of nextEdgeByKey.entries()) {
+    if (!previousEdgeByKey.has(edgeKey)) {
+      addedEdges.push(edge);
+    }
+  }
+
+  for (const [edgeKey, edge] of previousEdgeByKey.entries()) {
+    if (!nextEdgeByKey.has(edgeKey)) {
+      removedEdges.push(edge);
+    }
+  }
+
+  const touchedNodeIds = new Set();
+  for (const node of addedNodes) {
+    touchedNodeIds.add(node.id);
+  }
+  for (const node of updatedNodes) {
+    touchedNodeIds.add(node.id);
+  }
+  for (const nodeId of removedNodeIds) {
+    touchedNodeIds.add(nodeId);
+  }
+  for (const edge of addedEdges) {
+    touchedNodeIds.add(edge.source);
+    touchedNodeIds.add(edge.target);
+  }
+  for (const edge of removedEdges) {
+    touchedNodeIds.add(edge.source);
+    touchedNodeIds.add(edge.target);
+  }
+
+  return {
+    addedNodes,
+    updatedNodes,
+    removedNodeIds,
+    addedEdges,
+    removedEdges,
+    changedNodeIds: Array.from(touchedNodeIds).sort((a, b) => a.localeCompare(b)),
+    stats: nextGraph?.stats ?? null,
+    hasChanges:
+      addedNodes.length > 0 ||
+      updatedNodes.length > 0 ||
+      removedNodeIds.length > 0 ||
+      addedEdges.length > 0 ||
+      removedEdges.length > 0
+  };
+}

package/dashboard/lib/graph-diff.test.js

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest';
+import { diffGraphs } from './graph-diff.js';
+
+describe('diffGraphs', () => {
+  it('detects node and edge additions, updates, and removals', () => {
+    const previous = {
+      nodes: [
+        { id: 'a', title: 'A', category: 'root', tags: [], path: 'a.md', missing: false, degree: 1 },
+        { id: 'b', title: 'B', category: 'root', tags: ['x'], path: 'b.md', missing: false, degree: 1 },
+        { id: 'c', title: 'C', category: 'root', tags: [], path: null, missing: true, degree: 0 }
+      ],
+      edges: [{ source: 'a', target: 'b' }],
+      stats: { nodeCount: 3, edgeCount: 1 }
+    };
+
+    const next = {
+      nodes: [
+        { id: 'a', title: 'A Updated', category: 'root', tags: [], path: 'a.md', missing: false, degree: 1 },
+        { id: 'b', title: 'B', category: 'root', tags: ['x'], path: 'b.md', missing: false, degree: 2 },
+        { id: 'd', title: 'D', category: 'projects', tags: [], path: 'd.md', missing: false, degree: 1 }
+      ],
+      edges: [
+        { source: 'a', target: 'b' },
+        { source: 'b', target: 'd' }
+      ],
+      stats: { nodeCount: 3, edgeCount: 2 }
+    };
+
+    const patch = diffGraphs(previous, next);
+
+    expect(patch.addedNodes).toEqual([next.nodes[2]]);
+    expect(patch.updatedNodes).toEqual(expect.arrayContaining([next.nodes[0], next.nodes[1]]));
+    expect(patch.removedNodeIds).toEqual(['c']);
+    expect(patch.addedEdges).toEqual([{ source: 'b', target: 'd' }]);
+    expect(patch.removedEdges).toEqual([]);
+    expect(patch.changedNodeIds).toEqual(['a', 'b', 'c', 'd']);
+    expect(patch.hasChanges).toBe(true);
+  });
+
+  it('returns hasChanges=false for equivalent graphs', () => {
+    const graph = {
+      nodes: [{ id: 'a', title: 'A', category: 'root', tags: ['t'], path: 'a.md', missing: false, degree: 0 }],
+      edges: [],
+      stats: { nodeCount: 1, edgeCount: 0 }
+    };
+
+    const patch = diffGraphs(graph, structuredClone(graph));
+
+    expect(patch.hasChanges).toBe(false);
+    expect(patch.addedNodes).toEqual([]);
+    expect(patch.updatedNodes).toEqual([]);
+    expect(patch.removedNodeIds).toEqual([]);
+    expect(patch.addedEdges).toEqual([]);
+    expect(patch.removedEdges).toEqual([]);
+  });
+
+  it('treats edge type changes as edge diff', () => {
+    const previous = {
+      nodes: [
+        { id: 'a', title: 'A', category: 'root', tags: [], path: 'a.md', missing: false, degree: 1 },
+        { id: 'b', title: 'B', category: 'root', tags: [], path: 'b.md', missing: false, degree: 1 }
+      ],
+      edges: [{ source: 'a', target: 'b', type: 'wiki_link' }]
+    };
+    const next = {
+      nodes: previous.nodes,
+      edges: [{ source: 'a', target: 'b', type: 'frontmatter_relation', label: 'related' }]
+    };
+
+    const patch = diffGraphs(previous, next);
+    expect(patch.addedEdges).toEqual([{ source: 'a', target: 'b', type: 'frontmatter_relation', label: 'related' }]);
+    expect(patch.removedEdges).toEqual([{ source: 'a', target: 'b', type: 'wiki_link' }]);
+    expect(patch.hasChanges).toBe(true);
+  });
+});