cognitive-core 0.1.0 → 0.2.0

package/tests/memory/coherence.test.ts

@@ -0,0 +1,232 @@
+import { describe, it, expect } from 'vitest';
+import { CoherenceChecker } from '../../src/memory/coherence.js';
+import { createObservation } from '../../src/types/knowledge.js';
+import type { KnowledgeNote } from '../../src/types/knowledge.js';
+
+function makeNote(opts: {
+  id?: string;
+  body: string;
+  domain?: string[];
+  entities?: string[];
+}): KnowledgeNote {
+  return createObservation({
+    id: opts.id ?? `k-${crypto.randomUUID().slice(0, 8)}`,
+    title: 'Test note',
+    body: opts.body,
+    domain: opts.domain ?? ['testing'],
+    entities: opts.entities ?? ['vitest'],
+    confidence: 0.7,
+    source: { origin: 'extracted' },
+  });
+}
+
+describe('CoherenceChecker', () => {
+  const checker = new CoherenceChecker();
+
+  describe('coherent notes', () => {
+    it('should pass check for non-contradictory notes', async () => {
+      const newNote = makeNote({
+        body: 'Always use TypeScript for type safety in production code',
+        entities: ['typescript'],
+        domain: ['typescript'],
+      });
+      const existingNotes = [
+        makeNote({
+          body: 'TypeScript provides excellent type checking capabilities',
+          entities: ['typescript'],
+          domain: ['typescript'],
+        }),
+        makeNote({
+          body: 'Enable strict mode in tsconfig for better type safety',
+          entities: ['typescript'],
+          domain: ['typescript'],
+        }),
+      ];
+
+      const result = await checker.check(newNote, existingNotes);
+
+      expect(result.isCoherent).toBe(true);
+      expect(result.contradictions).toHaveLength(0);
+    });
+
+    it('should skip notes in different domains', async () => {
+      const newNote = makeNote({
+        body: 'Always use strict mode in Python for better error handling',
+        entities: ['python'],
+        domain: ['python'],
+      });
+      const existingNotes = [
+        makeNote({
+          body: 'Never use strict mode — it slows down development',
+          entities: ['javascript'],
+          domain: ['javascript'],
+        }),
+      ];
+
+      const result = await checker.check(newNote, existingNotes);
+
+      expect(result.isCoherent).toBe(true);
+      expect(result.contradictions).toHaveLength(0);
+    });
+  });
+
+  describe('contradictory notes', () => {
+    it('should detect "always use X" vs "never use X" contradiction', async () => {
+      const newNote = makeNote({
+        body: 'Always use semicolons in TypeScript code for consistency',
+        entities: ['typescript'],
+        domain: ['typescript'],
+      });
+      const existingNotes = [
+        makeNote({
+          body: 'Never use semicolons in TypeScript code — the parser handles it automatically',
+          entities: ['typescript'],
+          domain: ['typescript'],
+        }),
+      ];
+
+      const result = await checker.check(newNote, existingNotes);
+
+      expect(result.isCoherent).toBe(false);
+      expect(result.contradictions.length).toBeGreaterThan(0);
+      expect(result.contradictions[0].residualEnergy).toBeGreaterThan(0.2);
+    });
+
+    it('should detect "use X" vs "avoid X" contradiction', async () => {
+      const newNote = makeNote({
+        body: 'For TypeScript projects, use the any type when working with dynamic data structures',
+        entities: ['typescript'],
+        domain: ['typescript'],
+      });
+      const existingNotes = [
+        makeNote({
+          body: 'For TypeScript projects, avoid the any type when working with dynamic data structures',
+          entities: ['typescript'],
+          domain: ['typescript'],
+        }),
+      ];
+
+      const result = await checker.check(newNote, existingNotes);
+
+      expect(result.isCoherent).toBe(false);
+      expect(result.contradictions.length).toBeGreaterThan(0);
+    });
+
+    it('should detect "do X" vs "don\'t X" contradiction', async () => {
+      const newNote = makeNote({
+        body: 'When configuring eslint rules for the project, do enable strict type checking',
+        entities: ['eslint'],
+        domain: ['tooling'],
+      });
+      const existingNotes = [
+        makeNote({
+          body: "When configuring eslint rules for the project, don't enable strict type checking",
+          entities: ['eslint'],
+          domain: ['tooling'],
+        }),
+      ];
+
+      const result = await checker.check(newNote, existingNotes);
+
+      expect(result.isCoherent).toBe(false);
+      expect(result.contradictions.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('same-entity filtering', () => {
+    it('should compare notes with the same entities', async () => {
+      const newNote = makeNote({
+        body: 'Always use vitest for testing TypeScript projects',
+        entities: ['vitest'],
+        domain: ['testing'],
+      });
+      const existingNotes = [
+        makeNote({
+          body: 'Never use vitest for testing TypeScript projects — use jest instead',
+          entities: ['vitest'],
+          domain: ['testing'],
+        }),
+        makeNote({
+          body: 'Deploy applications to production every Friday',
+          entities: ['deployment'],
+          domain: ['devops'],
+        }),
+      ];
+
+      const result = await checker.check(newNote, existingNotes);
+
+      // Should only find contradiction with vitest note, not deployment note
+      expect(result.isCoherent).toBe(false);
+      expect(result.contradictions.length).toBe(1);
+    });
+  });
+
+  describe('global energy', () => {
+    it('should return 0 for a single note', () => {
+      const notes = [
+        makeNote({ body: 'TypeScript is great', domain: ['typescript'] }),
+      ];
+
+      const energy = checker.computeGlobalEnergy(notes);
+      expect(energy).toBe(0);
+    });
+
+    it('should increase energy with more contradictions', () => {
+      const coherentNotes = [
+        makeNote({
+          body: 'Use TypeScript for type safety',
+          domain: ['typescript'],
+          entities: ['typescript'],
+        }),
+        makeNote({
+          body: 'TypeScript provides compile-time checking',
+          domain: ['typescript'],
+          entities: ['typescript'],
+        }),
+      ];
+
+      const contradictoryNotes = [
+        makeNote({
+          body: 'Always use strict TypeScript types for safety',
+          domain: ['typescript'],
+          entities: ['typescript'],
+        }),
+        makeNote({
+          body: 'Never use strict TypeScript types — they slow development',
+          domain: ['typescript'],
+          entities: ['typescript'],
+        }),
+      ];
+
+      const coherentEnergy = checker.computeGlobalEnergy(coherentNotes);
+      const contradictoryEnergy = checker.computeGlobalEnergy(contradictoryNotes);
+
+      expect(contradictoryEnergy).toBeGreaterThan(coherentEnergy);
+    });
+  });
+
+  describe('configuration', () => {
+    it('should respect maxComparisons', async () => {
+      const checker2 = new CoherenceChecker({ maxComparisons: 1 });
+      const newNote = makeNote({
+        body: 'Always use semicolons for consistency',
+        entities: ['typescript'],
+        domain: ['typescript'],
+      });
+      // Create many existing notes — only 1 should be compared
+      const existingNotes = Array.from({ length: 10 }, (_, i) =>
+        makeNote({
+          id: `note-${i}`,
+          body: `Never use semicolons — note ${i} for consistency`,
+          entities: ['typescript'],
+          domain: ['typescript'],
+        })
+      );
+
+      const result = await checker2.check(newNote, existingNotes);
+
+      // Should find at most 1 contradiction since maxComparisons=1
+      expect(result.contradictions.length).toBeLessThanOrEqual(1);
+    });
+  });
+});

package/tests/memory/experience.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { ExperienceMemory } from '../../src/memory/experience.js';
 import { createExperience, type Experience } from '../../src/types/memory.js';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -8,15 +9,19 @@ import { tmpdir } from 'node:os';
 describe('ExperienceMemory', () => {
   let tempDir: string;
   let memory: ExperienceMemory;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'atlas-test-'));
-    memory = new ExperienceMemory(tempDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    memory = new ExperienceMemory(persistence);
     await memory.init();
   });
 
   afterEach(async () => {
     await memory.close();
+    persistence.close();
     await rm(tempDir, { recursive: true, force: true });
   });
 
@@ -184,8 +189,8 @@ describe('ExperienceMemory', () => {
       await memory.add(exp);
       await memory.close();
 
-      // Create new memory instance
-      const memory2 = new ExperienceMemory(tempDir);
+      // Create new memory instance from the same persistence (shared SQLite DB)
+      const memory2 = new ExperienceMemory(persistence);
       await memory2.init();
 
       const retrieved = await memory2.get(exp.id);

package/tests/memory/graph-layers/semantic.test.ts

@@ -0,0 +1,219 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { SemanticGraphLayer } from '../../../src/memory/graph-layers/semantic.js';
+import type { GraphEdge } from '../../../src/types/knowledge-graph.js';
+import type { KnowledgeNote } from '../../../src/types/knowledge.js';
+
+function makeEdge(
+  from: string,
+  to: string,
+  relation: string = 'related-to'
+): GraphEdge {
+  return {
+    from,
+    to,
+    relation,
+    weight: 1.0,
+    created: new Date().toISOString(),
+  };
+}
+
+function makeNote(
+  id: string,
+  links: Array<{ target: string; relation: string }> = []
+): 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,
+      })),
+      created: new Date().toISOString(),
+      updated: new Date().toISOString(),
+    },
+    body: `# ${id}`,
+    filePath: `knowledge/observations/${id}.md`,
+  };
+}
+
+describe('SemanticGraphLayer', () => {
+  let layer: SemanticGraphLayer;
+
+  beforeEach(() => {
+    layer = new SemanticGraphLayer(true);
+  });
+
+  describe('addEdge / getEdges', () => {
+    it('adds and retrieves outgoing edges', () => {
+      layer.addEdge(makeEdge('a', 'b'));
+
+      const outgoing = layer.getEdges('a', 'outgoing');
+      expect(outgoing).toHaveLength(1);
+      expect(outgoing[0].to).toBe('b');
+    });
+
+    it('adds and retrieves incoming edges', () => {
+      layer.addEdge(makeEdge('a', 'b'));
+
+      const incoming = layer.getEdges('b', 'incoming');
+      expect(incoming).toHaveLength(1);
+      expect(incoming[0].from).toBe('a');
+    });
+
+    it('retrieves both directions by default', () => {
+      layer.addEdge(makeEdge('a', 'b'));
+      layer.addEdge(makeEdge('c', 'a'));
+
+      const both = layer.getEdges('a');
+      expect(both).toHaveLength(2);
+    });
+
+    it('returns empty array for unknown node', () => {
+      expect(layer.getEdges('unknown')).toEqual([]);
+    });
+  });
+
+  describe('removeEdge', () => {
+    it('removes a specific edge', () => {
+      layer.addEdge(makeEdge('a', 'b', 'related-to'));
+      layer.addEdge(makeEdge('a', 'c', 'depends-on'));
+
+      layer.removeEdge('a', 'b', 'related-to');
+
+      expect(layer.getEdges('a', 'outgoing')).toHaveLength(1);
+      expect(layer.getEdges('a', 'outgoing')[0].to).toBe('c');
+      expect(layer.getEdges('b', 'incoming')).toHaveLength(0);
+    });
+  });
+
+  describe('neighbors', () => {
+    it('finds depth-1 neighbors', () => {
+      layer.addEdge(makeEdge('a', 'b'));
+      layer.addEdge(makeEdge('a', 'c'));
+      layer.addEdge(makeEdge('b', 'd'));
+
+      const neighbors = layer.neighbors('a', 1);
+
+      expect(neighbors).toContain('b');
+      expect(neighbors).toContain('c');
+      expect(neighbors).not.toContain('d');
+    });
+
+    it('finds depth-2 neighbors', () => {
+      layer.addEdge(makeEdge('a', 'b'));
+      layer.addEdge(makeEdge('b', 'c'));
+      layer.addEdge(makeEdge('c', 'd'));
+
+      const neighbors = layer.neighbors('a', 2);
+
+      expect(neighbors).toContain('b');
+      expect(neighbors).toContain('c');
+      expect(neighbors).not.toContain('d');
+    });
+
+    it('traverses bidirectionally', () => {
+      layer.addEdge(makeEdge('b', 'a'));
+
+      const neighbors = layer.neighbors('a', 1);
+      expect(neighbors).toContain('b');
+    });
+  });
+
+  describe('pathBetween', () => {
+    it('finds a direct path', () => {
+      layer.addEdge(makeEdge('a', 'b'));
+
+      const path = layer.pathBetween('a', 'b');
+      expect(path).toEqual(['a', 'b']);
+    });
+
+    it('finds a multi-hop path', () => {
+      layer.addEdge(makeEdge('a', 'b'));
+      layer.addEdge(makeEdge('b', 'c'));
+      layer.addEdge(makeEdge('c', 'd'));
+
+      const path = layer.pathBetween('a', 'd');
+      expect(path).toEqual(['a', 'b', 'c', 'd']);
+    });
+
+    it('returns null when no path exists', () => {
+      layer.addEdge(makeEdge('a', 'b'));
+      // c is disconnected
+
+      const path = layer.pathBetween('a', 'c');
+      expect(path).toBeNull();
+    });
+
+    it('returns [id] for same-node path', () => {
+      const path = layer.pathBetween('a', 'a');
+      expect(path).toEqual(['a']);
+    });
+  });
+
+  describe('rebuild', () => {
+    it('rebuilds edges from knowledge note links', () => {
+      const notes: KnowledgeNote[] = [
+        makeNote('a', [
+          { target: 'b', relation: 'related-to' },
+          { target: 'c', relation: 'depends-on' },
+        ]),
+        makeNote('b', [{ target: 'c', relation: 'supports' }]),
+      ];
+
+      layer.rebuild(notes);
+
+      expect(layer.edgeCount()).toBe(3);
+      expect(layer.getEdges('a', 'outgoing')).toHaveLength(2);
+      expect(layer.getEdges('b', 'outgoing')).toHaveLength(1);
+    });
+
+    it('ignores non-semantic relations', () => {
+      const notes: KnowledgeNote[] = [
+        makeNote('a', [
+          { target: 'b', relation: 'related-to' }, // semantic
+          { target: 'c', relation: 'caused-by' }, // causal — skip
+          { target: 'd', relation: 'uses' }, // entity — skip
+        ]),
+      ];
+
+      layer.rebuild(notes);
+
+      expect(layer.edgeCount()).toBe(1);
+    });
+
+    it('clears previous edges before rebuild', () => {
+      layer.addEdge(makeEdge('x', 'y'));
+      expect(layer.edgeCount()).toBe(1);
+
+      layer.rebuild([]);
+      expect(layer.edgeCount()).toBe(0);
+    });
+  });
+
+  describe('edgeCount / getAllEdges / clear', () => {
+    it('tracks edge count correctly', () => {
+      expect(layer.edgeCount()).toBe(0);
+
+      layer.addEdge(makeEdge('a', 'b'));
+      layer.addEdge(makeEdge('b', 'c'));
+      expect(layer.edgeCount()).toBe(2);
+
+      layer.clear();
+      expect(layer.edgeCount()).toBe(0);
+    });
+
+    it('getAllEdges returns all edges', () => {
+      layer.addEdge(makeEdge('a', 'b'));
+      layer.addEdge(makeEdge('c', 'd'));
+
+      const all = layer.getAllEdges();
+      expect(all).toHaveLength(2);
+    });
+  });
+});