cognitive-core 0.0.2 → 0.1.0

package/tests/embeddings/manager.test.ts

@@ -0,0 +1,205 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { EmbeddingManager, createEmbeddingManager } from '../../src/embeddings/manager.js';
+import type { EmbeddingProvider } from '../../src/embeddings/provider.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Mock embedding provider for testing
+class MockEmbeddingProvider implements EmbeddingProvider {
+  readonly name = 'mock';
+  readonly dimension = 3;
+  private callCount = 0;
+
+  async embed(text: string): Promise<number[]> {
+    this.callCount++;
+    // Simple hash-based embedding for deterministic testing
+    const hash = text.split('').reduce((acc, char) => acc + char.charCodeAt(0), 0);
+    return [
+      Math.sin(hash * 0.1),
+      Math.cos(hash * 0.2),
+      Math.sin(hash * 0.3),
+    ];
+  }
+
+  async embedBatch(texts: string[]): Promise<number[][]> {
+    return Promise.all(texts.map(t => this.embed(t)));
+  }
+
+  getCallCount(): number {
+    return this.callCount;
+  }
+}
+
+describe('EmbeddingManager', () => {
+  const testDbPath = '/tmp/test-embeddings.db';
+
+  afterEach(() => {
+    // Clean up test database
+    try {
+      fs.unlinkSync(testDbPath);
+    } catch {
+      // Ignore if file doesn't exist
+    }
+  });
+
+  describe('BM25-only mode (no provider)', () => {
+    let manager: EmbeddingManager;
+
+    beforeEach(() => {
+      manager = createEmbeddingManager({});
+    });
+
+    afterEach(() => {
+      manager.close();
+    });
+
+    it('should work without embedding provider', async () => {
+      await manager.store('id1', 'machine learning algorithms', 'experience');
+      await manager.store('id2', 'database optimization', 'strategy');
+
+      const results = await manager.search('machine learning');
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].id).toBe('id1');
+    });
+
+    it('should report no vector search available', () => {
+      expect(manager.hasVectorSearch).toBe(false);
+      expect(manager.dimension).toBeNull();
+    });
+
+    it('should return undefined embeddings when storing', async () => {
+      const embedding = await manager.store('id1', 'test content', 'experience');
+      expect(embedding).toBeUndefined();
+    });
+
+    it('should return null when trying to embed directly', async () => {
+      const embedding = await manager.embed('test');
+      expect(embedding).toBeNull();
+    });
+  });
+
+  describe('with mock embedding provider (no vector store)', () => {
+    let manager: EmbeddingManager;
+    let provider: MockEmbeddingProvider;
+
+    beforeEach(() => {
+      provider = new MockEmbeddingProvider();
+      // No vectorStorePath, so vector store won't be created
+      manager = createEmbeddingManager({
+        provider,
+      });
+    });
+
+    afterEach(() => {
+      manager.close();
+    });
+
+    it('should fall back to BM25 without vector store path', async () => {
+      await manager.store('id1', 'test content', 'experience');
+
+      // Should use BM25 for search since no vector store
+      const results = await manager.search('test');
+      expect(results.length).toBe(1);
+    });
+  });
+
+  describe('statistics', () => {
+    let manager: EmbeddingManager;
+
+    beforeEach(() => {
+      manager = createEmbeddingManager({});
+    });
+
+    afterEach(() => {
+      manager.close();
+    });
+
+    it('should report correct stats', async () => {
+      await manager.store('id1', 'content 1', 'experience');
+      await manager.store('id2', 'content 2', 'strategy');
+
+      const stats = manager.getStats();
+      expect(stats.bm25Count).toBe(2);
+      expect(stats.hasVectorSearch).toBe(false);
+      expect(stats.providerName).toBeNull();
+    });
+  });
+
+  describe('batch operations', () => {
+    let manager: EmbeddingManager;
+
+    beforeEach(() => {
+      manager = createEmbeddingManager({});
+    });
+
+    afterEach(() => {
+      manager.close();
+    });
+
+    it('should store batch items', async () => {
+      const items = [
+        { id: 'id1', content: 'content 1', type: 'experience' as const },
+        { id: 'id2', content: 'content 2', type: 'strategy' as const },
+        { id: 'id3', content: 'content 3', type: 'concept' as const },
+      ];
+
+      const results = await manager.storeBatch(items);
+
+      expect(results.size).toBe(3);
+      expect(manager.has('id1')).toBe(true);
+      expect(manager.has('id2')).toBe(true);
+      expect(manager.has('id3')).toBe(true);
+    });
+  });
+
+  describe('remove operation', () => {
+    let manager: EmbeddingManager;
+
+    beforeEach(() => {
+      manager = createEmbeddingManager({});
+    });
+
+    afterEach(() => {
+      manager.close();
+    });
+
+    it('should remove items from index', async () => {
+      await manager.store('id1', 'test content', 'experience');
+      expect(manager.has('id1')).toBe(true);
+
+      manager.remove('id1');
+      expect(manager.has('id1')).toBe(false);
+    });
+  });
+
+  describe('search with options', () => {
+    let manager: EmbeddingManager;
+
+    beforeEach(async () => {
+      manager = createEmbeddingManager({});
+      await manager.store('exp1', 'machine learning experience', 'experience');
+      await manager.store('str1', 'machine learning strategy', 'strategy');
+      await manager.store('con1', 'deep learning concept', 'concept');
+      await manager.store('skl1', 'learning skill', 'skill');
+    });
+
+    afterEach(() => {
+      manager.close();
+    });
+
+    it('should filter by type', async () => {
+      const results = await manager.search('learning', { type: 'experience' });
+      expect(results.every(r => r.id.startsWith('exp'))).toBe(true);
+    });
+
+    it('should limit results with k', async () => {
+      const results = await manager.search('learning', { k: 2 });
+      expect(results.length).toBeLessThanOrEqual(2);
+    });
+
+    it('should apply threshold', async () => {
+      const results = await manager.search('learning', { threshold: 0.5 });
+      expect(results.every(r => r.score >= 0.5)).toBe(true);
+    });
+  });
+});

package/tests/integration/atlas.test.ts

@@ -0,0 +1,266 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { Atlas, createAtlas } from '../../src/atlas.js';
+import { createTask } from '../../src/types/task.js';
+import { createTrajectory } from '../../src/types/trajectory.js';
+import { createStep } from '../../src/types/step.js';
+import { successOutcome, failureOutcome } from '../../src/types/outcome.js';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('Atlas', () => {
+  let tempDir: string;
+  let atlas: Atlas;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-test-'));
+    atlas = createAtlas({
+      storage: { baseDir: tempDir },
+      learning: { batchSize: 3 },
+    });
+    await atlas.init();
+  });
+
+  afterEach(async () => {
+    await atlas.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('initialization', () => {
+    it('should initialize with default config', async () => {
+      const stats = await atlas.getStats();
+      expect(stats.memory.experienceCount).toBe(0);
+      expect(stats.memory.playbookCount).toBe(0);
+      expect(stats.memory.metaObservationCount).toBe(0);
+      expect(stats.learning.trajectoriesProcessed).toBe(0);
+    });
+
+    it('should expose memory and learning systems', () => {
+      expect(atlas.getMemory()).toBeDefined();
+      expect(atlas.getLearning()).toBeDefined();
+    });
+  });
+
+  describe('processTrajectory', () => {
+    it('should process a trajectory and update stats', async () => {
+      const trajectory = createTrajectory({
+        task: createTask({ domain: 'code', description: 'Test task' }),
+        steps: [
+          createStep({ action: 'read', observation: 'content' }),
+          createStep({ action: 'write', observation: 'done' }),
+        ],
+        outcome: successOutcome('Completed'),
+        agentId: 'test-agent',
+      });
+
+      const result = await atlas.processTrajectory(trajectory);
+
+      expect(result).toBeDefined();
+      const stats = await atlas.getStats();
+      expect(stats.learning.trajectoriesProcessed).toBe(1);
+    });
+
+    it('should accumulate trajectories for batch learning', async () => {
+      const createTraj = (id: string) =>
+        createTrajectory({
+          id,
+          task: createTask({ domain: 'code', description: `Task ${id}` }),
+          steps: [createStep({ action: 'a', observation: 'o' })],
+          outcome: successOutcome('done'),
+          agentId: 'agent',
+        });
+
+      await atlas.processTrajectory(createTraj('1'));
+      await atlas.processTrajectory(createTraj('2'));
+
+      const stats = await atlas.getStats();
+      expect(stats.learning.trajectoriesProcessed).toBe(2);
+      expect(stats.learning.pendingTrajectories).toBeGreaterThan(0);
+    });
+  });
+
+  describe('queryMemory', () => {
+    it('should query memory with default options', async () => {
+      // First add some data
+      const memory = atlas.getMemory();
+      await memory.experiences.add({
+        id: 'exp-1',
+        taskInput: 'Write a function to add numbers',
+        solutionOutput: 'function add(a, b) { return a + b; }',
+        feedback: 'Correct',
+        success: true,
+        domain: 'code',
+        trajectoryId: 'traj-1',
+        usageCount: 0,
+        createdAt: new Date(),
+        metadata: {},
+      });
+
+      const results = await atlas.queryMemory('add numbers');
+      expect(results).toBeDefined();
+    });
+
+    it('should filter by domain', async () => {
+      const memory = atlas.getMemory();
+      await memory.experiences.add({
+        id: 'exp-code',
+        taskInput: 'Code task',
+        solutionOutput: 'solution',
+        feedback: 'ok',
+        success: true,
+        domain: 'code',
+        trajectoryId: 't1',
+        usageCount: 0,
+        createdAt: new Date(),
+        metadata: {},
+      });
+      await memory.experiences.add({
+        id: 'exp-math',
+        taskInput: 'Math task',
+        solutionOutput: 'solution',
+        feedback: 'ok',
+        success: true,
+        domain: 'math',
+        trajectoryId: 't2',
+        usageCount: 0,
+        createdAt: new Date(),
+        metadata: {},
+      });
+
+      const results = await atlas.queryMemory('task', { domains: ['code'] });
+      // Should only return code domain results
+      expect(results.experiences.every(e => e.experience.domain === 'code')).toBe(true);
+    });
+  });
+
+  describe('updateConfig', () => {
+    it('should update learning config', () => {
+      atlas.updateConfig({
+        learning: { batchSize: 10 },
+      });
+
+      // Config is updated internally - we can verify through behavior
+      // Batch learning won't trigger until 10 trajectories
+    });
+  });
+
+  describe('runBatchLearning', () => {
+    it('should run batch learning explicitly', async () => {
+      // Add some trajectories
+      const trajectory = createTrajectory({
+        task: createTask({ domain: 'code', description: 'Test' }),
+        steps: [createStep({ action: 'a', observation: 'o' })],
+        outcome: successOutcome('done'),
+        agentId: 'agent',
+      });
+
+      await atlas.processTrajectory(trajectory);
+
+      const result = await atlas.runBatchLearning();
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('solve', () => {
+    it('should throw if no provider is set', async () => {
+      const task = createTask({
+        domain: 'code',
+        description: 'Solve this',
+      });
+
+      await expect(atlas.solve(task)).rejects.toThrow('No execution method available');
+    });
+
+    // Note: Testing with actual provider requires mocking
+    // The solve functionality integrates with LLMProvider
+  });
+
+  // Note: extractPatterns was removed - LLM-based extraction is now handled
+  // through the LLMPlaybookExtractor directly
+
+  describe('persistence', () => {
+    it('should persist data across restarts', async () => {
+      // Add data
+      const memory = atlas.getMemory();
+      await memory.experiences.add({
+        id: 'persist-exp',
+        taskInput: 'Persistent task',
+        solutionOutput: 'solution',
+        feedback: 'ok',
+        success: true,
+        domain: 'code',
+        trajectoryId: 'traj-persist',
+        usageCount: 0,
+        createdAt: new Date(),
+        metadata: {},
+      });
+
+      // Close and reopen
+      await atlas.close();
+
+      const atlas2 = createAtlas({
+        storage: { baseDir: tempDir },
+      });
+      await atlas2.init();
+
+      const stats = await atlas2.getStats();
+      expect(stats.memory.experienceCount).toBe(1);
+
+      // Query should find the data
+      const experience = await atlas2.getMemory().experiences.get('persist-exp');
+      expect(experience?.taskInput).toBe('Persistent task');
+
+      await atlas2.close();
+    });
+  });
+
+  describe('batch learning trigger', () => {
+    it('should trigger batch learning when threshold is reached', async () => {
+      // Create atlas with batch size of 2
+      const testAtlas = createAtlas({
+        storage: { baseDir: tempDir },
+        learning: { batchSize: 2 },
+      });
+      await testAtlas.init();
+
+      const createTraj = (id: string) =>
+        createTrajectory({
+          id,
+          task: createTask({ domain: 'code', description: `Task ${id}` }),
+          steps: [
+            createStep({ thought: 'thinking', action: 'action', observation: 'result' }),
+            createStep({ action: 'action2', observation: 'result2' }),
+          ],
+          outcome: successOutcome({ result: 'done' }),
+          agentId: 'agent',
+        });
+
+      await testAtlas.processTrajectory(createTraj('1'));
+      let stats = await testAtlas.getStats();
+      expect(stats.learning.pendingTrajectories).toBe(1);
+
+      await testAtlas.processTrajectory(createTraj('2'));
+      // Batch learning should have been triggered
+      stats = await testAtlas.getStats();
+      // After batch learning, pending should be 0 or experiences should be added
+      expect(stats.learning.trajectoriesProcessed).toBe(2);
+
+      await testAtlas.close();
+    });
+  });
+});
+
+describe('createAtlas', () => {
+  it('should create an Atlas instance with defaults', () => {
+    const atlas = createAtlas();
+    expect(atlas).toBeInstanceOf(Atlas);
+  });
+
+  it('should accept custom config', () => {
+    const atlas = createAtlas({
+      storage: { baseDir: '/tmp/custom' },
+      learning: { batchSize: 20 },
+    });
+    expect(atlas).toBeInstanceOf(Atlas);
+  });
+});