clawvault 3.5.0 → 3.5.2

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

@@ -0,0 +1,120 @@
+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 () => ({}),
+    patch: 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.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);
+  });
+});

package/dashboard/lib/vault-parser.test.js

@@ -0,0 +1,254 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { buildVaultGraph } from './vault-parser.js';
+
+function makeTempVault() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'clawvault-dashboard-'));
+}
+
+function writeVaultFile(root, relativePath, content) {
+  const fullPath = path.join(root, relativePath);
+  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+  fs.writeFileSync(fullPath, content, 'utf8');
+}
+
+describe('buildVaultGraph', () => {
+  it('builds nodes and edges from markdown wiki-links', async () => {
+    const vaultPath = makeTempVault();
+    try {
+      writeVaultFile(
+        vaultPath,
+        'decisions/use-clawvault.md',
+        `---
+title: Use ClawVault
+tags: [architecture, memory]
+---
+Linked to [[projects/clawvault|ClawVault Project]] and [[missing-note]].
+`
+      );
+      writeVaultFile(vaultPath, 'projects/clawvault.md', '# ClawVault');
+
+      const graph = await buildVaultGraph(vaultPath);
+      const decisionNode = graph.nodes.find((node) => node.id === 'decisions/use-clawvault');
+      const unresolvedNode = graph.nodes.find((node) => node.id === 'missing-note');
+
+      expect(decisionNode).toMatchObject({
+        title: 'Use ClawVault',
+        category: 'decisions',
+        tags: ['architecture', 'memory'],
+        type: 'decision'
+      });
+      expect(graph.edges).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+          source: 'decisions/use-clawvault',
+          target: 'projects/clawvault',
+          type: 'wiki_link'
+        }),
+        expect.objectContaining({
+          source: 'decisions/use-clawvault',
+          target: 'missing-note',
+          type: 'wiki_link'
+        }),
+        expect.objectContaining({
+          source: 'decisions/use-clawvault',
+          target: 'tag:architecture',
+          type: 'tag'
+        })
+      ]));
+      expect(unresolvedNode).toMatchObject({
+        missing: true,
+        category: 'unresolved'
+      });
+      expect(graph.stats.edgeTypeCounts.wiki_link).toBeGreaterThanOrEqual(2);
+      expect(graph.stats.edgeTypeCounts.tag).toBeGreaterThanOrEqual(1);
+    } finally {
+      fs.rmSync(vaultPath, { recursive: true, force: true });
+    }
+  });
+
+  it('resolves basename links when there is a unique match', async () => {
+    const vaultPath = makeTempVault();
+    try {
+      writeVaultFile(vaultPath, 'research/notes.md', 'See [[clawvault]].');
+      writeVaultFile(vaultPath, 'projects/clawvault.md', '# ClawVault');
+
+      const graph = await buildVaultGraph(vaultPath);
+
+      expect(graph.edges).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+          source: 'research/notes',
+          target: 'projects/clawvault',
+          type: 'wiki_link'
+        })
+      ]));
+    } finally {
+      fs.rmSync(vaultPath, { recursive: true, force: true });
+    }
+  });
+
+  it('emits frontmatter relation edges with labels', async () => {
+    const vaultPath = makeTempVault();
+    try {
+      writeVaultFile(
+        vaultPath,
+        'decisions/db.md',
+        `---
+related:
+  - projects/clawvault
+owner: people/alice
+---
+Decision details`
+      );
+      writeVaultFile(vaultPath, 'projects/clawvault.md', '# ClawVault');
+      writeVaultFile(vaultPath, 'people/alice.md', '# Alice');
+
+      const graph = await buildVaultGraph(vaultPath);
+      expect(graph.edges).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+          source: 'decisions/db',
+          target: 'projects/clawvault',
+          type: 'frontmatter_relation',
+          label: 'related'
+        }),
+        expect.objectContaining({
+          source: 'decisions/db',
+          target: 'people/alice',
+          type: 'frontmatter_relation',
+          label: 'owner'
+        })
+      ]));
+    } finally {
+      fs.rmSync(vaultPath, { recursive: true, force: true });
+    }
+  });
+
+  it('loads graph data from memory graph index when present', async () => {
+    const vaultPath = makeTempVault();
+    try {
+      writeVaultFile(vaultPath, 'decisions/use-clawvault.md', '# Placeholder');
+      writeVaultFile(vaultPath, 'projects/clawvault.md', '# Placeholder project');
+      const decisionMtime = fs.statSync(path.join(vaultPath, 'decisions/use-clawvault.md')).mtimeMs;
+      const projectMtime = fs.statSync(path.join(vaultPath, 'projects/clawvault.md')).mtimeMs;
+      const indexPath = path.join(vaultPath, '.clawvault', 'graph-index.json');
+      fs.mkdirSync(path.dirname(indexPath), { recursive: true });
+      fs.writeFileSync(
+        indexPath,
+        JSON.stringify({
+          schemaVersion: 1,
+          files: {
+            'decisions/use-clawvault.md': {
+              relativePath: 'decisions/use-clawvault.md',
+              mtimeMs: decisionMtime
+            },
+            'projects/clawvault.md': {
+              relativePath: 'projects/clawvault.md',
+              mtimeMs: projectMtime
+            }
+          },
+          graph: {
+            nodes: [
+              {
+                id: 'note:decisions/use-clawvault',
+                title: 'Use ClawVault',
+                type: 'decision',
+                category: 'decisions',
+                tags: ['architecture'],
+                path: 'decisions/use-clawvault.md',
+                missing: false,
+                degree: 1
+              },
+              {
+                id: 'note:projects/clawvault',
+                title: 'ClawVault Project',
+                type: 'project',
+                category: 'projects',
+                tags: [],
+                path: 'projects/clawvault.md',
+                missing: false,
+                degree: 1
+              }
+            ],
+            edges: [
+              {
+                source: 'note:decisions/use-clawvault',
+                target: 'note:projects/clawvault',
+                type: 'frontmatter_relation',
+                label: 'related'
+              }
+            ],
+            stats: { generatedAt: '2026-02-13T00:00:00.000Z' }
+          }
+        }),
+        'utf8'
+      );
+
+      const graph = await buildVaultGraph(vaultPath);
+      expect(graph.nodes.find((node) => node.id === 'decisions/use-clawvault')).toBeTruthy();
+      expect(graph.edges).toEqual([
+        {
+          source: 'decisions/use-clawvault',
+          target: 'projects/clawvault',
+          type: 'frontmatter_relation',
+          label: 'related'
+        }
+      ]);
+      expect(graph.stats.fileCount).toBe(2);
+    } finally {
+      fs.rmSync(vaultPath, { recursive: true, force: true });
+    }
+  });
+
+  it('falls back to markdown parsing when memory graph index is stale', async () => {
+    const vaultPath = makeTempVault();
+    try {
+      writeVaultFile(vaultPath, 'projects/clawvault.md', '# ClawVault');
+      writeVaultFile(vaultPath, 'decisions/use-clawvault.md', 'See [[projects/clawvault]].');
+
+      const indexPath = path.join(vaultPath, '.clawvault', 'graph-index.json');
+      fs.mkdirSync(path.dirname(indexPath), { recursive: true });
+      fs.writeFileSync(
+        indexPath,
+        JSON.stringify({
+          schemaVersion: 1,
+          generatedAt: '2026-02-13T00:00:00.000Z',
+          files: {
+            'decisions/use-clawvault.md': { relativePath: 'decisions/use-clawvault.md', mtimeMs: 1 },
+            'projects/clawvault.md': { relativePath: 'projects/clawvault.md', mtimeMs: 1 }
+          },
+          graph: {
+            nodes: [
+              {
+                id: 'note:decisions/use-clawvault',
+                title: 'Old node',
+                type: 'decision',
+                category: 'decisions',
+                tags: [],
+                path: 'decisions/use-clawvault.md',
+                missing: false,
+                degree: 0
+              }
+            ],
+            edges: [],
+            stats: { generatedAt: '2026-02-13T00:00:00.000Z' }
+          }
+        }),
+        'utf8'
+      );
+
+      const graph = await buildVaultGraph(vaultPath);
+      const node = graph.nodes.find((candidate) => candidate.id === 'decisions/use-clawvault');
+      expect(node?.title).not.toBe('Old node');
+      expect(graph.edges).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+          source: 'decisions/use-clawvault',
+          target: 'projects/clawvault',
+          type: 'wiki_link'
+        })
+      ]));
+    } finally {
+      fs.rmSync(vaultPath, { recursive: true, force: true });
+    }
+  });
+});

package/dist/{chunk-DCF4KMFD.js → chunk-DPK6P6BO.js}

@@ -6,13 +6,13 @@ import {
 } from "./chunk-DOIUYIXV.js";
 import {
   registerInjectCommand
-} from "./chunk-OFOCU2V4.js";
+} from "./chunk-QL34TMGN.js";
 import {
   registerMaintainCommand
-} from "./chunk-D5U3Q4N5.js";
+} from "./chunk-IOKLQR4W.js";
 import {
   registerObserveCommand
-} from "./chunk-BLQXXX7Q.js";
+} from "./chunk-FNFP7N6A.js";
 import {
   registerContextCommand
 } from "./chunk-GFCHWMGD.js";

package/dist/{chunk-BLQXXX7Q.js → chunk-FNFP7N6A.js}

@@ -1,9 +1,9 @@
 import {
   observeActiveSessions
-} from "./chunk-VXAGOLDP.js";
+} from "./chunk-LCBHM3D6.js";
 import {
   Observer
-} from "./chunk-7SWP5FKU.js";
+} from "./chunk-FSYISBTU.js";
 import {
   resolveVaultPath
 } from "./chunk-GJO3CFUN.js";