clawvault 2.6.0 → 3.0.0

package/templates/workspace.md

@@ -0,0 +1,50 @@
+---
+primitive: workspace
+description: Canonical schema for a shared ClawVault workspace.
+fields:
+  type:
+    type: string
+    required: true
+    default: workspace
+    description: Primitive discriminator for workspace documents.
+  status:
+    type: string
+    required: true
+    default: active
+    enum:
+      - active
+      - paused
+      - archived
+    description: Workspace lifecycle state.
+  created:
+    type: datetime
+    required: true
+    default: "{{datetime}}"
+    description: ISO timestamp when the workspace was created.
+  updated:
+    type: datetime
+    required: true
+    default: "{{datetime}}"
+    description: ISO timestamp when the workspace was last updated.
+  owner:
+    type: string
+    description: Primary workspace owner.
+  parties:
+    type: string[]
+    description: Related party slugs.
+  policy_profile:
+    type: string
+    description: Default policy profile for automation.
+  tags:
+    type: string[]
+    description: Labels used for filtering.
+  description:
+    type: string
+    description: One-line summary of workspace intent.
+---
+
+# {{title}}
+
+{{links_line}}
+
+{{content}}

package/dashboard/lib/graph-diff.js

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