@aitytech/agentkits-memory 1.0.0

package/src/__tests__/index.test.ts

@@ -0,0 +1,407 @@
+/**
+ * ProjectMemoryService Tests
+ *
+ * Tests for the high-level memory service.
+ *
+ * @module @agentkits/memory/__tests__/index.test
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  ProjectMemoryService,
+  createProjectMemory,
+  DEFAULT_NAMESPACES,
+  MemoryEntry,
+  createDefaultEntry,
+} from '../index.js';
+
+describe('ProjectMemoryService', () => {
+  let service: ProjectMemoryService;
+  let testDir: string;
+
+  beforeEach(async () => {
+    // Create temp directory for tests
+    testDir = path.join(tmpdir(), `memory-test-${Date.now()}`);
+    fs.mkdirSync(testDir, { recursive: true });
+
+    service = new ProjectMemoryService({
+      baseDir: testDir,
+      dbFilename: 'test.db',
+      cacheEnabled: false,
+      enableVectorIndex: false,
+      autoPersistInterval: 0,
+    });
+    await service.initialize();
+  });
+
+  afterEach(async () => {
+    await service.shutdown();
+    // Cleanup temp directory
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('Initialization', () => {
+    it('should initialize successfully', async () => {
+      const newService = new ProjectMemoryService({
+        baseDir: path.join(testDir, 'init-test'),
+        dbFilename: 'init.db',
+      });
+
+      await newService.initialize();
+      const health = await newService.healthCheck();
+
+      expect(health.status).toBe('healthy');
+      await newService.shutdown();
+    });
+
+    it('should create directory if not exists', async () => {
+      const newDir = path.join(testDir, 'new-dir');
+
+      const newService = new ProjectMemoryService({
+        baseDir: newDir,
+        dbFilename: 'new.db',
+      });
+
+      await newService.initialize();
+      expect(fs.existsSync(newDir)).toBe(true);
+
+      await newService.shutdown();
+    });
+
+    it('should accept string as baseDir', async () => {
+      const dir = path.join(testDir, 'string-dir');
+      const newService = new ProjectMemoryService(dir);
+
+      await newService.initialize();
+      expect(fs.existsSync(dir)).toBe(true);
+
+      await newService.shutdown();
+    });
+  });
+
+  describe('Store and Retrieve', () => {
+    it('should store entry via storeEntry convenience method', async () => {
+      const entry = await service.storeEntry({
+        key: 'test-key',
+        content: 'Test content',
+        namespace: 'test',
+        tags: ['tag1'],
+      });
+
+      expect(entry.id).toBeDefined();
+      expect(entry.key).toBe('test-key');
+      expect(entry.content).toBe('Test content');
+    });
+
+    it('should get entry by id', async () => {
+      const stored = await service.storeEntry({
+        key: 'get-test',
+        content: 'Content',
+        namespace: 'test',
+      });
+
+      const retrieved = await service.get(stored.id);
+
+      expect(retrieved).not.toBeNull();
+      expect(retrieved!.id).toBe(stored.id);
+    });
+
+    it('should get entry by namespace and key', async () => {
+      await service.storeEntry({
+        key: 'ns-key-test',
+        content: 'Content',
+        namespace: 'my-namespace',
+      });
+
+      const retrieved = await service.getByKey('my-namespace', 'ns-key-test');
+
+      expect(retrieved).not.toBeNull();
+      expect(retrieved!.key).toBe('ns-key-test');
+      expect(retrieved!.namespace).toBe('my-namespace');
+    });
+
+    it('should update entry', async () => {
+      const stored = await service.storeEntry({
+        key: 'update-test',
+        content: 'Original',
+        namespace: 'test',
+      });
+
+      const updated = await service.update(stored.id, { content: 'Updated' });
+
+      expect(updated!.content).toBe('Updated');
+    });
+
+    it('should delete entry', async () => {
+      const stored = await service.storeEntry({
+        key: 'delete-test',
+        content: 'To delete',
+        namespace: 'test',
+      });
+
+      expect(await service.count()).toBe(1);
+
+      const deleted = await service.delete(stored.id);
+      expect(deleted).toBe(true);
+      expect(await service.count()).toBe(0);
+    });
+  });
+
+  describe('Query Operations', () => {
+    beforeEach(async () => {
+      await service.storeEntry({ key: 'p1', content: 'Pattern 1', namespace: 'patterns', tags: ['auth'] });
+      await service.storeEntry({ key: 'p2', content: 'Pattern 2', namespace: 'patterns', tags: ['api'] });
+      await service.storeEntry({ key: 'd1', content: 'Decision 1', namespace: 'decisions', tags: ['db'] });
+    });
+
+    it('should query all entries', async () => {
+      const results = await service.query({ type: 'hybrid', limit: 10 });
+      expect(results.length).toBe(3);
+    });
+
+    it('should query by namespace', async () => {
+      const results = await service.query({ type: 'hybrid', namespace: 'patterns', limit: 10 });
+      expect(results.length).toBe(2);
+    });
+
+    it('should use getByNamespace convenience method', async () => {
+      const results = await service.getByNamespace('patterns');
+      expect(results.length).toBe(2);
+    });
+  });
+
+  describe('Get or Create', () => {
+    it('should create entry if not exists', async () => {
+      const entry = await service.getOrCreate('test-ns', 'new-key', () => ({
+        key: 'new-key',
+        content: 'New content',
+        namespace: 'test-ns',
+      }));
+
+      expect(entry.content).toBe('New content');
+    });
+
+    it('should return existing entry if exists', async () => {
+      await service.storeEntry({
+        key: 'existing-key',
+        content: 'Existing content',
+        namespace: 'test-ns',
+      });
+
+      const entry = await service.getOrCreate('test-ns', 'existing-key', () => ({
+        key: 'existing-key',
+        content: 'New content',
+        namespace: 'test-ns',
+      }));
+
+      expect(entry.content).toBe('Existing content');
+    });
+  });
+
+  describe('Session Management', () => {
+    it('should start session', async () => {
+      const session = await service.startSession();
+
+      expect(session.id).toBeDefined();
+      expect(session.status).toBe('active');
+      expect(session.startedAt).toBeDefined();
+    });
+
+    it('should get current session', async () => {
+      expect(service.getCurrentSession()).toBeNull();
+
+      await service.startSession();
+      const current = service.getCurrentSession();
+
+      expect(current).not.toBeNull();
+      expect(current!.status).toBe('active');
+    });
+
+    it('should create checkpoint', async () => {
+      await service.startSession();
+      await service.checkpoint('Test checkpoint');
+
+      const session = service.getCurrentSession();
+      expect(session!.lastCheckpoint).toBe('Test checkpoint');
+    });
+
+    it('should throw error when checkpoint without session', async () => {
+      await expect(service.checkpoint('Test')).rejects.toThrow('No active session');
+    });
+
+    it('should end session', async () => {
+      await service.startSession();
+      const ended = await service.endSession('Session summary');
+
+      expect(ended).not.toBeNull();
+      expect(ended!.status).toBe('completed');
+      expect(ended!.summary).toBe('Session summary');
+      expect(ended!.endedAt).toBeDefined();
+    });
+
+    it('should add session id to entries', async () => {
+      const session = await service.startSession();
+
+      const entry = await service.storeEntry({
+        key: 'session-entry',
+        content: 'Content',
+        namespace: 'test',
+      });
+
+      expect(entry.sessionId).toBe(session.id);
+    });
+
+    it('should get recent sessions', async () => {
+      await service.startSession();
+      await service.endSession('Session 1');
+
+      await service.startSession();
+      await service.endSession('Session 2');
+
+      const sessions = await service.getRecentSessions();
+      expect(sessions.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe('Namespace Operations', () => {
+    beforeEach(async () => {
+      await service.storeEntry({ key: 'ns1-1', content: 'C1', namespace: 'ns1' });
+      await service.storeEntry({ key: 'ns1-2', content: 'C2', namespace: 'ns1' });
+      await service.storeEntry({ key: 'ns2-1', content: 'C3', namespace: 'ns2' });
+    });
+
+    it('should list namespaces', async () => {
+      const namespaces = await service.listNamespaces();
+      expect(namespaces).toContain('ns1');
+      expect(namespaces).toContain('ns2');
+    });
+
+    it('should count by namespace', async () => {
+      const count = await service.count('ns1');
+      expect(count).toBe(2);
+    });
+
+    it('should clear namespace', async () => {
+      const cleared = await service.clearNamespace('ns1');
+      expect(cleared).toBe(2);
+      expect(await service.count('ns1')).toBe(0);
+      expect(await service.count('ns2')).toBe(1);
+    });
+  });
+
+  describe('Bulk Operations', () => {
+    it('should bulk insert entries', async () => {
+      const entries = [
+        createDefaultEntry({ key: 'b1', content: 'C1', namespace: 'bulk' }),
+        createDefaultEntry({ key: 'b2', content: 'C2', namespace: 'bulk' }),
+      ];
+
+      await service.bulkInsert(entries);
+      expect(await service.count('bulk')).toBe(2);
+    });
+
+    it('should bulk delete entries', async () => {
+      const e1 = await service.storeEntry({ key: 'bd1', content: 'C1', namespace: 'bd' });
+      const e2 = await service.storeEntry({ key: 'bd2', content: 'C2', namespace: 'bd' });
+
+      const deleted = await service.bulkDelete([e1.id, e2.id]);
+      expect(deleted).toBe(2);
+      expect(await service.count('bd')).toBe(0);
+    });
+  });
+
+  describe('Statistics and Health', () => {
+    it('should get stats', async () => {
+      await service.storeEntry({ key: 's1', content: 'C1', namespace: 'ns1' });
+      await service.storeEntry({ key: 's2', content: 'C2', namespace: 'ns2' });
+
+      const stats = await service.getStats();
+
+      expect(stats.totalEntries).toBe(2);
+      expect(stats.entriesByNamespace).toBeDefined();
+    });
+
+    it('should health check', async () => {
+      const health = await service.healthCheck();
+
+      expect(health.status).toBe('healthy');
+      expect(health.components).toBeDefined();
+    });
+  });
+
+  describe('Events', () => {
+    it('should emit entry:stored event', async () => {
+      const listener = vi.fn();
+      service.on('entry:stored', listener);
+
+      await service.storeEntry({ key: 'event-test', content: 'Content', namespace: 'test' });
+
+      expect(listener).toHaveBeenCalled();
+    });
+
+    it('should emit session:started event', async () => {
+      const listener = vi.fn();
+      service.on('session:started', listener);
+
+      await service.startSession();
+
+      expect(listener).toHaveBeenCalled();
+    });
+
+    it('should emit session:ended event', async () => {
+      const listener = vi.fn();
+      service.on('session:ended', listener);
+
+      await service.startSession();
+      await service.endSession();
+
+      expect(listener).toHaveBeenCalled();
+    });
+  });
+});
+
+describe('createProjectMemory factory', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = path.join(tmpdir(), `factory-test-${Date.now()}`);
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('should create memory service with defaults', async () => {
+    const service = createProjectMemory(testDir);
+    await service.initialize();
+
+    expect(fs.existsSync(testDir)).toBe(true);
+
+    await service.shutdown();
+  });
+
+  it('should accept options', async () => {
+    const service = createProjectMemory(testDir, {
+      cacheEnabled: false,
+      verbose: true,
+    });
+
+    await service.initialize();
+    await service.shutdown();
+  });
+});
+
+describe('DEFAULT_NAMESPACES', () => {
+  it('should have all required namespaces', () => {
+    expect(DEFAULT_NAMESPACES.CONTEXT).toBe('context');
+    expect(DEFAULT_NAMESPACES.ACTIVE).toBe('active-context');
+    expect(DEFAULT_NAMESPACES.SESSION).toBe('session-state');
+    expect(DEFAULT_NAMESPACES.PROGRESS).toBe('progress');
+    expect(DEFAULT_NAMESPACES.PATTERNS).toBe('patterns');
+    expect(DEFAULT_NAMESPACES.DECISIONS).toBe('decisions');
+    expect(DEFAULT_NAMESPACES.ERRORS).toBe('errors');
+  });
+});