cognitive-core 0.1.0 → 0.2.0

package/tests/memory/knowledge-graph.test.ts

@@ -0,0 +1,492 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { KnowledgeGraphManager } from '../../src/memory/knowledge-graph.js';
+import type { GraphNode, GraphEdge } from '../../src/types/knowledge-graph.js';
+import type { KnowledgeNote } from '../../src/types/knowledge.js';
+
+function makeNode(
+  id: string,
+  overrides: Partial<GraphNode> = {}
+): GraphNode {
+  return {
+    id,
+    file: `knowledge/observations/${id}.md`,
+    type: 'observation',
+    domains: ['test'],
+    entities: [],
+    tags: [],
+    confidence: 0.5,
+    updated: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+function makeEdge(
+  from: string,
+  to: string,
+  relation: string = 'related-to',
+  overrides: Partial<GraphEdge> = {}
+): GraphEdge {
+  return {
+    from,
+    to,
+    relation,
+    weight: 1.0,
+    created: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+function makeNote(
+  id: string,
+  links: Array<{ target: string; relation: string; layer?: string }> = [],
+  overrides: Partial<KnowledgeNote['frontmatter']> = {}
+): KnowledgeNote {
+  return {
+    frontmatter: {
+      id,
+      type: 'observation',
+      domain: ['test'],
+      entities: [],
+      tags: [],
+      confidence: 0.5,
+      source: { origin: 'extracted' },
+      links: links.map((l) => ({
+        target: l.target,
+        relation: l.relation as any,
+        ...(l.layer ? { layer: l.layer as any } : {}),
+      })),
+      created: new Date().toISOString(),
+      updated: new Date().toISOString(),
+      ...overrides,
+    },
+    body: `# ${id}`,
+    filePath: `knowledge/observations/${id}.md`,
+  };
+}
+
+describe('KnowledgeGraphManager', () => {
+  let graph: KnowledgeGraphManager;
+
+  beforeEach(() => {
+    graph = new KnowledgeGraphManager();
+  });
+
+  describe('node management', () => {
+    it('adds and retrieves a node', () => {
+      const node = makeNode('a');
+      graph.addNode(node);
+
+      expect(graph.getNode('a')).toEqual(node);
+    });
+
+    it('returns undefined for unknown node', () => {
+      expect(graph.getNode('missing')).toBeUndefined();
+    });
+
+    it('gets all nodes', () => {
+      graph.addNode(makeNode('a'));
+      graph.addNode(makeNode('b'));
+
+      expect(graph.getAllNodes()).toHaveLength(2);
+    });
+
+    it('removes a node and its edges', () => {
+      graph.addNode(makeNode('a'));
+      graph.addNode(makeNode('b'));
+
+      const layer = graph.getLayer('semantic')!;
+      layer.addEdge(makeEdge('a', 'b'));
+
+      graph.removeNode('a');
+
+      expect(graph.getNode('a')).toBeUndefined();
+      expect(layer.getEdges('a', 'outgoing')).toHaveLength(0);
+      expect(layer.getEdges('b', 'incoming')).toHaveLength(0);
+    });
+  });
+
+  describe('layer access', () => {
+    it('returns semantic layer (enabled by default)', () => {
+      const layer = graph.getLayer('semantic');
+      expect(layer).not.toBeNull();
+      expect(layer!.name).toBe('semantic');
+      expect(layer!.enabled).toBe(true);
+    });
+
+    it('returns null for disabled layers', () => {
+      // Only semantic is enabled by default
+      expect(graph.getLayer('temporal')).toBeNull();
+      expect(graph.getLayer('causal')).toBeNull();
+      expect(graph.getLayer('entity')).toBeNull();
+    });
+
+    it('enables additional layers via config', () => {
+      const g = new KnowledgeGraphManager({
+        enabledLayers: ['semantic', 'temporal', 'causal', 'entity'],
+      });
+
+      expect(g.getLayer('temporal')).not.toBeNull();
+      expect(g.getLayer('causal')).not.toBeNull();
+      expect(g.getLayer('entity')).not.toBeNull();
+    });
+  });
+
+  describe('neighbors (cross-layer BFS)', () => {
+    it('finds depth-1 neighbors via semantic layer', () => {
+      graph.addNode(makeNode('a'));
+      graph.addNode(makeNode('b'));
+      graph.addNode(makeNode('c'));
+
+      const layer = graph.getLayer('semantic')!;
+      layer.addEdge(makeEdge('a', 'b'));
+      layer.addEdge(makeEdge('a', 'c'));
+
+      const result = graph.neighbors('a', { depth: 1 });
+      const ids = result.map((n) => n.id);
+
+      expect(ids).toContain('b');
+      expect(ids).toContain('c');
+    });
+
+    it('does not include the query node itself', () => {
+      graph.addNode(makeNode('a'));
+      graph.addNode(makeNode('b'));
+
+      const layer = graph.getLayer('semantic')!;
+      layer.addEdge(makeEdge('a', 'b'));
+
+      const result = graph.neighbors('a');
+      const ids = result.map((n) => n.id);
+
+      expect(ids).not.toContain('a');
+    });
+
+    it('respects minWeight filter', () => {
+      graph.addNode(makeNode('a'));
+      graph.addNode(makeNode('b'));
+      graph.addNode(makeNode('c'));
+
+      const layer = graph.getLayer('semantic')!;
+      layer.addEdge(makeEdge('a', 'b', 'related-to', { weight: 0.9 }));
+      layer.addEdge(makeEdge('a', 'c', 'related-to', { weight: 0.1 }));
+
+      const result = graph.neighbors('a', { minWeight: 0.5 });
+      const ids = result.map((n) => n.id);
+
+      expect(ids).toContain('b');
+      expect(ids).not.toContain('c');
+    });
+
+    it('traverses multiple layers when enabled', () => {
+      const g = new KnowledgeGraphManager({
+        enabledLayers: ['semantic', 'temporal'],
+      });
+
+      g.addNode(makeNode('a'));
+      g.addNode(makeNode('b'));
+      g.addNode(makeNode('c'));
+
+      g.getLayer('semantic')!.addEdge(makeEdge('a', 'b', 'related-to'));
+      g.getLayer('temporal')!.addEdge(makeEdge('a', 'c', 'co-occurred'));
+
+      const result = g.neighbors('a', { depth: 1 });
+      const ids = result.map((n) => n.id);
+
+      expect(ids).toContain('b');
+      expect(ids).toContain('c');
+    });
+
+    it('limits traversal to specified layers', () => {
+      const g = new KnowledgeGraphManager({
+        enabledLayers: ['semantic', 'temporal'],
+      });
+
+      g.addNode(makeNode('a'));
+      g.addNode(makeNode('b'));
+      g.addNode(makeNode('c'));
+
+      g.getLayer('semantic')!.addEdge(makeEdge('a', 'b'));
+      g.getLayer('temporal')!.addEdge(makeEdge('a', 'c', 'co-occurred'));
+
+      const result = g.neighbors('a', {
+        depth: 1,
+        layers: ['semantic'],
+      });
+      const ids = result.map((n) => n.id);
+
+      expect(ids).toContain('b');
+      expect(ids).not.toContain('c');
+    });
+  });
+
+  describe('pathBetween', () => {
+    it('returns empty array for same-node path', () => {
+      graph.addNode(makeNode('a'));
+
+      const path = graph.pathBetween('a', 'a');
+      expect(path).toEqual([]);
+    });
+
+    it('finds a direct path', () => {
+      graph.addNode(makeNode('a'));
+      graph.addNode(makeNode('b'));
+
+      graph.getLayer('semantic')!.addEdge(makeEdge('a', 'b'));
+
+      const path = graph.pathBetween('a', 'b');
+      expect(path).not.toBeNull();
+      expect(path!).toHaveLength(1);
+      expect(path![0].node.id).toBe('b');
+      expect(path![0].layer).toBe('semantic');
+    });
+
+    it('finds multi-hop path', () => {
+      graph.addNode(makeNode('a'));
+      graph.addNode(makeNode('b'));
+      graph.addNode(makeNode('c'));
+
+      const layer = graph.getLayer('semantic')!;
+      layer.addEdge(makeEdge('a', 'b'));
+      layer.addEdge(makeEdge('b', 'c'));
+
+      const path = graph.pathBetween('a', 'c');
+      expect(path).not.toBeNull();
+      expect(path!).toHaveLength(2);
+      expect(path![0].node.id).toBe('b');
+      expect(path![1].node.id).toBe('c');
+    });
+
+    it('returns null when no path exists', () => {
+      graph.addNode(makeNode('a'));
+      graph.addNode(makeNode('b'));
+      // No edges
+
+      const path = graph.pathBetween('a', 'b');
+      expect(path).toBeNull();
+    });
+
+    it('returns null for unknown node', () => {
+      const path = graph.pathBetween('missing', 'also-missing');
+      expect(path).toBeNull();
+    });
+  });
+
+  describe('filterNodes', () => {
+    beforeEach(() => {
+      graph.addNode(
+        makeNode('a', {
+          type: 'observation',
+          domains: ['database'],
+          entities: ['prisma'],
+          tags: ['migration'],
+          confidence: 0.9,
+        })
+      );
+      graph.addNode(
+        makeNode('b', {
+          type: 'entity',
+          domains: ['frontend'],
+          entities: ['react'],
+          tags: ['component'],
+          confidence: 0.3,
+        })
+      );
+      graph.addNode(
+        makeNode('c', {
+          type: 'observation',
+          domains: ['database', 'backend'],
+          entities: ['postgresql'],
+          tags: ['migration', 'schema'],
+          confidence: 0.7,
+        })
+      );
+    });
+
+    it('filters by type', () => {
+      const result = graph.filterNodes({ type: 'observation' });
+      expect(result).toHaveLength(2);
+    });
+
+    it('filters by domain', () => {
+      const result = graph.filterNodes({ domains: ['database'] });
+      expect(result).toHaveLength(2);
+    });
+
+    it('filters by entity', () => {
+      const result = graph.filterNodes({ entities: ['prisma'] });
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('a');
+    });
+
+    it('filters by tag', () => {
+      const result = graph.filterNodes({ tags: ['migration'] });
+      expect(result).toHaveLength(2);
+    });
+
+    it('filters by minConfidence', () => {
+      const result = graph.filterNodes({ minConfidence: 0.5 });
+      expect(result).toHaveLength(2);
+      expect(result.map((n) => n.id)).not.toContain('b');
+    });
+
+    it('combines multiple filters', () => {
+      const result = graph.filterNodes({
+        type: 'observation',
+        domains: ['database'],
+        minConfidence: 0.8,
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('a');
+    });
+
+    it('returns all nodes with empty filter', () => {
+      const result = graph.filterNodes({});
+      expect(result).toHaveLength(3);
+    });
+  });
+
+  describe('crossSystemLinks', () => {
+    it('returns cross-system edges', () => {
+      const layer = graph.getLayer('semantic')!;
+      layer.addEdge(
+        makeEdge('a', 'b', 'supports', { crossSystem: 'playbook' })
+      );
+      layer.addEdge(makeEdge('a', 'c', 'related-to'));
+
+      const links = graph.crossSystemLinks('a');
+      expect(links).toHaveLength(1);
+      expect(links[0].crossSystem).toBe('playbook');
+    });
+
+    it('returns empty array when no cross-system links', () => {
+      const layer = graph.getLayer('semantic')!;
+      layer.addEdge(makeEdge('a', 'b'));
+
+      const links = graph.crossSystemLinks('a');
+      expect(links).toHaveLength(0);
+    });
+  });
+
+  describe('rebuildAll', () => {
+    it('rebuilds nodes and edges from notes', () => {
+      const notes: KnowledgeNote[] = [
+        makeNote('a', [
+          { target: 'b', relation: 'related-to' },
+          { target: 'c', relation: 'depends-on' },
+        ]),
+        makeNote('b', [{ target: 'c', relation: 'supports' }]),
+        makeNote('c'),
+      ];
+
+      graph.rebuildAll(notes);
+
+      expect(graph.getAllNodes()).toHaveLength(3);
+      expect(graph.getNode('a')).toBeDefined();
+
+      const layer = graph.getLayer('semantic')!;
+      expect(layer.edgeCount()).toBe(3);
+    });
+
+    it('clears previous state on rebuild', () => {
+      graph.addNode(makeNode('old'));
+      graph.getLayer('semantic')!.addEdge(makeEdge('old', 'gone'));
+
+      graph.rebuildAll([makeNote('new')]);
+
+      expect(graph.getNode('old')).toBeUndefined();
+      expect(graph.getAllNodes()).toHaveLength(1);
+      expect(graph.getNode('new')).toBeDefined();
+    });
+
+    it('routes links to correct layers when multiple enabled', () => {
+      const g = new KnowledgeGraphManager({
+        enabledLayers: ['semantic', 'temporal', 'causal', 'entity'],
+      });
+
+      const notes: KnowledgeNote[] = [
+        makeNote('a', [
+          { target: 'b', relation: 'related-to' }, // semantic
+          { target: 'c', relation: 'co-occurred' }, // temporal
+          { target: 'd', relation: 'caused-by' }, // causal
+          { target: 'e', relation: 'uses' }, // entity
+        ]),
+        makeNote('b'),
+        makeNote('c'),
+        makeNote('d'),
+        makeNote('e'),
+      ];
+
+      g.rebuildAll(notes);
+
+      expect(g.getLayer('semantic')!.edgeCount()).toBe(1);
+      expect(g.getLayer('temporal')!.edgeCount()).toBe(1);
+      expect(g.getLayer('causal')!.edgeCount()).toBe(1);
+      expect(g.getLayer('entity')!.edgeCount()).toBe(1);
+    });
+  });
+
+  describe('getStats', () => {
+    it('returns correct statistics', () => {
+      graph.addNode(makeNode('a'));
+      graph.addNode(makeNode('b'));
+
+      const layer = graph.getLayer('semantic')!;
+      layer.addEdge(makeEdge('a', 'b'));
+
+      const stats = graph.getStats();
+
+      expect(stats.nodeCount).toBe(2);
+      expect(stats.enabledLayers).toEqual(['semantic']);
+      expect(stats.edgeCountByLayer.semantic).toBe(1);
+    });
+
+    it('returns zero counts when empty', () => {
+      const stats = graph.getStats();
+
+      expect(stats.nodeCount).toBe(0);
+      expect(stats.enabledLayers).toEqual(['semantic']);
+      expect(stats.edgeCountByLayer.semantic).toBe(0);
+    });
+  });
+
+  describe('persistence (saveToDisk / loadFromDisk)', () => {
+    it('round-trips nodes and edges through disk', async () => {
+      const { mkdtemp, rm } = await import('node:fs/promises');
+      const { tmpdir } = await import('node:os');
+      const { join } = await import('node:path');
+
+      const dir = await mkdtemp(join(tmpdir(), 'kg-test-'));
+
+      try {
+        // Build a graph
+        graph.addNode(makeNode('a'));
+        graph.addNode(makeNode('b'));
+        graph.getLayer('semantic')!.addEdge(makeEdge('a', 'b'));
+
+        // Save to disk
+        await graph.saveToDisk(dir);
+
+        // Create new graph and load
+        const loaded = new KnowledgeGraphManager();
+        await loaded.loadFromDisk(dir);
+
+        expect(loaded.getNode('a')).toBeDefined();
+        expect(loaded.getNode('b')).toBeDefined();
+        expect(loaded.getAllNodes()).toHaveLength(2);
+
+        const layer = loaded.getLayer('semantic')!;
+        expect(layer.edgeCount()).toBe(1);
+        expect(layer.getEdges('a', 'outgoing')).toHaveLength(1);
+      } finally {
+        await rm(dir, { recursive: true, force: true });
+      }
+    });
+
+    it('handles missing directory gracefully on load', async () => {
+      // Should not throw — just starts with empty data
+      await graph.loadFromDisk('/nonexistent/path');
+
+      expect(graph.getAllNodes()).toHaveLength(0);
+    });
+  });
+});