clawvault 2.5.2 → 2.5.4

package/bin/test-helpers/cli-command-fixtures.js

@@ -1,119 +1,119 @@
-import { Command } from 'commander';
-import * as fs from 'fs';
-import * as path from 'path';
-import { registerCoreCommands } from '../register-core-commands.js';
-import { registerMaintenanceCommands } from '../register-maintenance-commands.js';
-import { registerQueryCommands } from '../register-query-commands.js';
-import { registerResilienceCommands } from '../register-resilience-commands.js';
-import { registerSessionLifecycleCommands } from '../register-session-lifecycle-commands.js';
-import { registerTemplateCommands } from '../register-template-commands.js';
-import { registerVaultOperationsCommands } from '../register-vault-operations-commands.js';
-import { registerConfigCommands } from '../register-config-commands.js';
-import { registerRouteCommands } from '../register-route-commands.js';
-import { registerTaskCommands } from '../register-task-commands.js';
-import { registerKanbanCommands } from '../register-kanban-commands.js';
-import { registerProjectCommands } from '../register-project-commands.js';
-
-export const chalkStub = {
-  cyan: (value) => value,
-  green: (value) => value,
-  red: (value) => value,
-  dim: (value) => value,
-  yellow: (value) => value,
-  white: (value) => value
-};
-
-export function stubResolveVaultPath(value) {
-  return value ?? '/vault';
-}
-
-export function createVaultStub(overrides = {}) {
-  return {
-    store: async () => ({}),
-    capture: async () => ({}),
-    find: async () => [],
-    vsearch: async () => [],
-    list: async () => [],
-    get: async () => null,
-    stats: async () => ({ tags: [], categories: {} }),
-    sync: async () => ({ copied: [], deleted: [], unchanged: [], errors: [] }),
-    reindex: async () => 0,
-    remember: async () => ({ id: '' }),
-    getQmdCollection: () => '',
-    createHandoff: async () => ({ id: '', path: '' }),
-    generateRecap: async () => ({}),
-    formatRecap: () => '',
-    ...overrides
-  };
-}
-
-export function createGetVaultStub(overrides = {}) {
-  return async () => createVaultStub(overrides);
-}
-
-export function registerAllCommandModules(program = new Command()) {
-  const getVault = createGetVaultStub();
-
-  registerCoreCommands(program, {
-    chalk: chalkStub,
-    path,
-    fs,
-    createVault: async () => ({ getCategories: () => [], getQmdRoot: () => '', getQmdCollection: () => '' }),
-    getVault,
-    runQmd: async () => {}
-  });
-
-  registerQueryCommands(program, {
-    chalk: chalkStub,
-    getVault,
-    resolveVaultPath: stubResolveVaultPath,
-    QmdUnavailableError: class extends Error {},
-    printQmdMissing: () => {}
-  });
-
-  registerVaultOperationsCommands(program, {
-    chalk: chalkStub,
-    fs,
-    getVault,
-    runQmd: async () => {},
-    resolveVaultPath: stubResolveVaultPath,
-    path
-  });
-
-  registerMaintenanceCommands(program, { chalk: chalkStub });
-  registerResilienceCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath
-  });
-  registerSessionLifecycleCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath,
-    QmdUnavailableError: class extends Error {},
-    printQmdMissing: () => {},
-    getVault,
-    runQmd: async () => {}
-  });
-  registerTemplateCommands(program, { chalk: chalkStub });
-  registerConfigCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath
-  });
-  registerRouteCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath
-  });
-  registerTaskCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath
-  });
-  registerKanbanCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath
-  });
-  registerProjectCommands(program, {
-    chalk: chalkStub,
-    resolveVaultPath: stubResolveVaultPath
-  });
-
-  return program;
-}
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { registerCoreCommands } from '../register-core-commands.js';
+import { registerMaintenanceCommands } from '../register-maintenance-commands.js';
+import { registerQueryCommands } from '../register-query-commands.js';
+import { registerResilienceCommands } from '../register-resilience-commands.js';
+import { registerSessionLifecycleCommands } from '../register-session-lifecycle-commands.js';
+import { registerTemplateCommands } from '../register-template-commands.js';
+import { registerVaultOperationsCommands } from '../register-vault-operations-commands.js';
+import { registerConfigCommands } from '../register-config-commands.js';
+import { registerRouteCommands } from '../register-route-commands.js';
+import { registerTaskCommands } from '../register-task-commands.js';
+import { registerKanbanCommands } from '../register-kanban-commands.js';
+import { registerProjectCommands } from '../register-project-commands.js';
+
+export const chalkStub = {
+  cyan: (value) => value,
+  green: (value) => value,
+  red: (value) => value,
+  dim: (value) => value,
+  yellow: (value) => value,
+  white: (value) => value
+};
+
+export function stubResolveVaultPath(value) {
+  return value ?? '/vault';
+}
+
+export function createVaultStub(overrides = {}) {
+  return {
+    store: async () => ({}),
+    capture: async () => ({}),
+    find: async () => [],
+    vsearch: async () => [],
+    list: async () => [],
+    get: async () => null,
+    stats: async () => ({ tags: [], categories: {} }),
+    sync: async () => ({ copied: [], deleted: [], unchanged: [], errors: [] }),
+    reindex: async () => 0,
+    remember: async () => ({ id: '' }),
+    getQmdCollection: () => '',
+    createHandoff: async () => ({ id: '', path: '' }),
+    generateRecap: async () => ({}),
+    formatRecap: () => '',
+    ...overrides
+  };
+}
+
+export function createGetVaultStub(overrides = {}) {
+  return async () => createVaultStub(overrides);
+}
+
+export function registerAllCommandModules(program = new Command()) {
+  const getVault = createGetVaultStub();
+
+  registerCoreCommands(program, {
+    chalk: chalkStub,
+    path,
+    fs,
+    createVault: async () => ({ getCategories: () => [], getQmdRoot: () => '', getQmdCollection: () => '' }),
+    getVault,
+    runQmd: async () => {}
+  });
+
+  registerQueryCommands(program, {
+    chalk: chalkStub,
+    getVault,
+    resolveVaultPath: stubResolveVaultPath,
+    QmdUnavailableError: class extends Error {},
+    printQmdMissing: () => {}
+  });
+
+  registerVaultOperationsCommands(program, {
+    chalk: chalkStub,
+    fs,
+    getVault,
+    runQmd: async () => {},
+    resolveVaultPath: stubResolveVaultPath,
+    path
+  });
+
+  registerMaintenanceCommands(program, { chalk: chalkStub });
+  registerResilienceCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
+  registerSessionLifecycleCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath,
+    QmdUnavailableError: class extends Error {},
+    printQmdMissing: () => {},
+    getVault,
+    runQmd: async () => {}
+  });
+  registerTemplateCommands(program, { chalk: chalkStub });
+  registerConfigCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
+  registerRouteCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
+  registerTaskCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
+  registerKanbanCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
+  registerProjectCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
+
+  return program;
+}

package/dashboard/lib/graph-diff.js

@@ -1,104 +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
-  };
-}
+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

@@ -1,75 +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);
-  });
-});
+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);
+  });
+});