@aitytech/agentkits-memory 1.0.0

package/src/hooks/__tests__/handlers.test.ts

@@ -0,0 +1,298 @@
+/**
+ * Unit Tests for Hook Handlers
+ *
+ * @module @agentkits/memory/hooks/__tests__/handlers
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { existsSync, rmSync, mkdirSync } from 'node:fs';
+import * as path from 'node:path';
+import { NormalizedHookInput } from '../types.js';
+import { MemoryHookService } from '../service.js';
+import { ContextHook, createContextHook } from '../context.js';
+import { SessionInitHook, createSessionInitHook } from '../session-init.js';
+import { ObservationHook, createObservationHook } from '../observation.js';
+import { SummarizeHook, createSummarizeHook } from '../summarize.js';
+
+const TEST_DIR = path.join(process.cwd(), '.test-hook-handlers');
+
+function createTestInput(overrides: Partial<NormalizedHookInput> = {}): NormalizedHookInput {
+  return {
+    sessionId: 'test-session-123',
+    cwd: TEST_DIR,
+    project: 'test-project',
+    timestamp: Date.now(),
+    ...overrides,
+  };
+}
+
+describe('Hook Handlers', () => {
+  beforeEach(() => {
+    // Clean up test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+    mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    // Clean up test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  describe('ContextHook', () => {
+    it('should return no context for new project', async () => {
+      const hook = createContextHook(TEST_DIR);
+      const input = createTestInput();
+
+      const result = await hook.execute(input);
+
+      expect(result.continue).toBe(true);
+      expect(result.suppressOutput).toBe(true);
+      expect(result.additionalContext).toBeUndefined();
+    });
+
+    it('should return context for existing project', async () => {
+      // Set up existing data
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initSession('old-session', 'test-project', 'Previous task');
+      await service.storeObservation('old-session', 'test-project', 'Read', { file_path: 'file.ts' }, {}, TEST_DIR);
+      await service.completeSession('old-session', 'Done');
+      await service.shutdown();
+
+      // Run context hook
+      const hook = createContextHook(TEST_DIR);
+      const input = createTestInput({ sessionId: 'new-session' });
+
+      const result = await hook.execute(input);
+
+      expect(result.continue).toBe(true);
+      expect(result.suppressOutput).toBe(false);
+      expect(result.additionalContext).toBeDefined();
+      expect(result.additionalContext).toContain('# Memory Context');
+      expect(result.additionalContext).toContain('test-project');
+    });
+
+    it('should handle errors gracefully', async () => {
+      // Create hook with invalid directory
+      const hook = new ContextHook({
+        initialize: async () => { throw new Error('Test error'); },
+      } as unknown as MemoryHookService);
+
+      const input = createTestInput();
+      const result = await hook.execute(input);
+
+      expect(result.continue).toBe(true);
+      expect(result.suppressOutput).toBe(true);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  describe('SessionInitHook', () => {
+    it('should initialize a new session', async () => {
+      const hook = createSessionInitHook(TEST_DIR);
+      const input = createTestInput({ prompt: 'Hello Claude' });
+
+      const result = await hook.execute(input);
+
+      expect(result.continue).toBe(true);
+      expect(result.suppressOutput).toBe(true);
+
+      // Verify session was created
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initialize();
+      const session = service.getSession('test-session-123');
+      await service.shutdown();
+
+      expect(session).not.toBeNull();
+      expect(session?.prompt).toBe('Hello Claude');
+    });
+
+    it('should not overwrite existing session', async () => {
+      // Create initial session
+      const hook1 = createSessionInitHook(TEST_DIR);
+      await hook1.execute(createTestInput({ prompt: 'First prompt' }));
+
+      // Try to re-init with different prompt
+      const hook2 = createSessionInitHook(TEST_DIR);
+      await hook2.execute(createTestInput({ prompt: 'Second prompt' }));
+
+      // Verify original prompt preserved
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initialize();
+      const session = service.getSession('test-session-123');
+      await service.shutdown();
+
+      expect(session?.prompt).toBe('First prompt');
+    });
+
+    it('should handle errors gracefully', async () => {
+      const hook = new SessionInitHook({
+        initialize: async () => { throw new Error('Test error'); },
+      } as unknown as MemoryHookService);
+
+      const input = createTestInput();
+      const result = await hook.execute(input);
+
+      expect(result.continue).toBe(true);
+      expect(result.suppressOutput).toBe(true);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  describe('ObservationHook', () => {
+    it('should store observation', async () => {
+      // Initialize session first
+      const initHook = createSessionInitHook(TEST_DIR);
+      await initHook.execute(createTestInput());
+
+      // Store observation
+      const hook = createObservationHook(TEST_DIR);
+      const input = createTestInput({
+        toolName: 'Read',
+        toolInput: { file_path: '/path/to/file.ts' },
+        toolResponse: { content: 'file contents' },
+      });
+
+      const result = await hook.execute(input);
+
+      expect(result.continue).toBe(true);
+      expect(result.suppressOutput).toBe(true);
+
+      // Verify observation was stored
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initialize();
+      const observations = await service.getSessionObservations('test-session-123');
+      await service.shutdown();
+
+      expect(observations.length).toBe(1);
+      expect(observations[0].toolName).toBe('Read');
+    });
+
+    it('should skip if no tool name', async () => {
+      const hook = createObservationHook(TEST_DIR);
+      const input = createTestInput({ toolName: undefined });
+
+      const result = await hook.execute(input);
+
+      expect(result.continue).toBe(true);
+      expect(result.suppressOutput).toBe(true);
+    });
+
+    it('should skip internal tools', async () => {
+      // Initialize session first
+      const initHook = createSessionInitHook(TEST_DIR);
+      await initHook.execute(createTestInput());
+
+      const hook = createObservationHook(TEST_DIR);
+
+      // Test skipped tools
+      for (const tool of ['TodoWrite', 'TodoRead', 'AskFollowupQuestion', 'AttemptCompletion']) {
+        const input = createTestInput({ toolName: tool });
+        const result = await hook.execute(input);
+
+        expect(result.continue).toBe(true);
+        expect(result.suppressOutput).toBe(true);
+      }
+
+      // Verify no observations stored
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initialize();
+      const observations = await service.getSessionObservations('test-session-123');
+      await service.shutdown();
+
+      expect(observations.length).toBe(0);
+    });
+
+    it('should create session if not exists', async () => {
+      const hook = createObservationHook(TEST_DIR);
+      const input = createTestInput({
+        sessionId: 'new-session',
+        toolName: 'Read',
+        toolInput: {},
+        toolResponse: {},
+      });
+
+      const result = await hook.execute(input);
+
+      expect(result.continue).toBe(true);
+
+      // Verify session was created
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initialize();
+      const session = service.getSession('new-session');
+      await service.shutdown();
+
+      expect(session).not.toBeNull();
+    });
+
+    it('should handle errors gracefully', async () => {
+      const hook = new ObservationHook({
+        initialize: async () => { throw new Error('Test error'); },
+      } as unknown as MemoryHookService);
+
+      const input = createTestInput({ toolName: 'Read' });
+      const result = await hook.execute(input);
+
+      expect(result.continue).toBe(true);
+      expect(result.suppressOutput).toBe(true);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  describe('SummarizeHook', () => {
+    it('should complete session with summary', async () => {
+      // Set up session with observations
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initSession('test-session-123', 'test-project');
+      await service.storeObservation('test-session-123', 'test-project', 'Read', { file_path: 'a.ts' }, {}, TEST_DIR);
+      await service.storeObservation('test-session-123', 'test-project', 'Write', { file_path: 'b.ts' }, {}, TEST_DIR);
+      await service.shutdown();
+
+      // Run summarize hook
+      const hook = createSummarizeHook(TEST_DIR);
+      const input = createTestInput();
+
+      const result = await hook.execute(input);
+
+      expect(result.continue).toBe(true);
+      expect(result.suppressOutput).toBe(true);
+
+      // Verify session was completed
+      const service2 = new MemoryHookService(TEST_DIR);
+      await service2.initialize();
+      const session = service2.getSession('test-session-123');
+      await service2.shutdown();
+
+      expect(session?.status).toBe('completed');
+      expect(session?.summary).toBeDefined();
+      expect(session?.summary).toContain('file');
+    });
+
+    it('should handle non-existent session', async () => {
+      const hook = createSummarizeHook(TEST_DIR);
+      const input = createTestInput({ sessionId: 'non-existent' });
+
+      const result = await hook.execute(input);
+
+      expect(result.continue).toBe(true);
+      expect(result.suppressOutput).toBe(true);
+    });
+
+    it('should handle errors gracefully', async () => {
+      const hook = new SummarizeHook({
+        initialize: async () => { throw new Error('Test error'); },
+        shutdown: async () => {},
+      } as unknown as MemoryHookService);
+
+      const input = createTestInput();
+      const result = await hook.execute(input);
+
+      expect(result.continue).toBe(true);
+      expect(result.suppressOutput).toBe(true);
+      expect(result.error).toBeDefined();
+    });
+  });
+});