@aitytech/agentkits-memory 1.0.0

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

@@ -0,0 +1,431 @@
+/**
+ * Integration Tests for Hook System
+ *
+ * Tests the full hook flow from session start to end.
+ *
+ * @module @agentkits/memory/hooks/__tests__/integration
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { existsSync, rmSync, mkdirSync } from 'node:fs';
+import * as path from 'node:path';
+import { NormalizedHookInput, parseHookInput } from '../types.js';
+import { MemoryHookService } from '../service.js';
+import { createContextHook } from '../context.js';
+import { createSessionInitHook } from '../session-init.js';
+import { createObservationHook } from '../observation.js';
+import { createSummarizeHook } from '../summarize.js';
+
+const TEST_DIR = path.join(process.cwd(), '.test-integration-hooks');
+
+function createTestInput(overrides: Partial<NormalizedHookInput> = {}): NormalizedHookInput {
+  return {
+    sessionId: 'integration-session',
+    cwd: TEST_DIR,
+    project: 'test-project',
+    timestamp: Date.now(),
+    ...overrides,
+  };
+}
+
+describe('Hook System Integration', () => {
+  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('Full Session Flow', () => {
+    it('should complete a full session lifecycle', async () => {
+      const sessionId = 'full-flow-session';
+      const project = 'test-project';
+
+      // 1. Session Start - Context Hook (no previous context)
+      const contextHook = createContextHook(TEST_DIR);
+      const contextResult = await contextHook.execute(
+        createTestInput({ sessionId, project })
+      );
+
+      expect(contextResult.continue).toBe(true);
+      expect(contextResult.additionalContext).toBeUndefined(); // No previous sessions
+
+      // 2. User Prompt Submit - Session Init Hook
+      const sessionInitHook = createSessionInitHook(TEST_DIR);
+      const sessionInitResult = await sessionInitHook.execute(
+        createTestInput({ sessionId, project, prompt: 'Help me implement a feature' })
+      );
+
+      expect(sessionInitResult.continue).toBe(true);
+
+      // 3. Tool Uses - Observation Hooks
+      const observationHook = createObservationHook(TEST_DIR);
+
+      // Simulate reading files
+      await observationHook.execute(
+        createTestInput({
+          sessionId,
+          project,
+          toolName: 'Read',
+          toolInput: { file_path: 'src/index.ts' },
+          toolResponse: { content: 'export function main() {}' },
+        })
+      );
+
+      // Simulate grep search
+      await observationHook.execute(
+        createTestInput({
+          sessionId,
+          project,
+          toolName: 'Grep',
+          toolInput: { pattern: 'function', path: 'src' },
+          toolResponse: { matches: ['src/index.ts:1'] },
+        })
+      );
+
+      // Simulate writing file
+      await observationHook.execute(
+        createTestInput({
+          sessionId,
+          project,
+          toolName: 'Write',
+          toolInput: { file_path: 'src/feature.ts' },
+          toolResponse: { success: true },
+        })
+      );
+
+      // Simulate running tests
+      await observationHook.execute(
+        createTestInput({
+          sessionId,
+          project,
+          toolName: 'Bash',
+          toolInput: { command: 'npm test' },
+          toolResponse: { stdout: 'All tests passed' },
+        })
+      );
+
+      // 4. Session End - Summarize Hook
+      const summarizeHook = createSummarizeHook(TEST_DIR);
+      const summarizeResult = await summarizeHook.execute(
+        createTestInput({ sessionId, project, stopReason: 'user_exit' })
+      );
+
+      expect(summarizeResult.continue).toBe(true);
+
+      // Verify final state
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initialize();
+
+      const session = service.getSession(sessionId);
+      expect(session).not.toBeNull();
+      expect(session?.status).toBe('completed');
+      expect(session?.observationCount).toBe(4);
+      expect(session?.summary).toBeDefined();
+      expect(session?.summary).toContain('file(s) modified');
+      expect(session?.summary).toContain('file(s) read');
+      expect(session?.summary).toContain('command(s) executed');
+
+      const observations = await service.getSessionObservations(sessionId);
+      expect(observations.length).toBe(4);
+
+      await service.shutdown();
+    });
+
+    it('should provide context from previous sessions', async () => {
+      // Session 1: Complete a full session
+      const session1Id = 'previous-session';
+      const project = 'test-project';
+
+      // Init session 1
+      const initHook1 = createSessionInitHook(TEST_DIR);
+      await initHook1.execute(createTestInput({ sessionId: session1Id, project, prompt: 'First task' }));
+
+      // Add observations to session 1
+      const obsHook1 = createObservationHook(TEST_DIR);
+      await obsHook1.execute(createTestInput({
+        sessionId: session1Id,
+        project,
+        toolName: 'Write',
+        toolInput: { file_path: 'src/auth.ts' },
+        toolResponse: {},
+      }));
+
+      // Complete session 1
+      const sumHook1 = createSummarizeHook(TEST_DIR);
+      await sumHook1.execute(createTestInput({ sessionId: session1Id, project }));
+
+      // Session 2: Should see context from session 1
+      const session2Id = 'current-session';
+
+      const contextHook2 = createContextHook(TEST_DIR);
+      const contextResult = await contextHook2.execute(
+        createTestInput({ sessionId: session2Id, project })
+      );
+
+      expect(contextResult.continue).toBe(true);
+      expect(contextResult.suppressOutput).toBe(false);
+      expect(contextResult.additionalContext).toBeDefined();
+      expect(contextResult.additionalContext).toContain('Previous Sessions');
+      expect(contextResult.additionalContext).toContain('Recent Activity');
+      expect(contextResult.additionalContext).toContain('Write');
+    });
+
+    it('should handle multiple projects independently', async () => {
+      // Session for project A
+      const initHookA = createSessionInitHook(TEST_DIR);
+      await initHookA.execute(createTestInput({
+        sessionId: 'session-a',
+        project: 'project-a',
+        prompt: 'Task for A',
+      }));
+
+      const obsHookA = createObservationHook(TEST_DIR);
+      await obsHookA.execute(createTestInput({
+        sessionId: 'session-a',
+        project: 'project-a',
+        toolName: 'Write',
+        toolInput: { file_path: 'a.ts' },
+        toolResponse: {},
+      }));
+
+      // Session for project B
+      const initHookB = createSessionInitHook(TEST_DIR);
+      await initHookB.execute(createTestInput({
+        sessionId: 'session-b',
+        project: 'project-b',
+        prompt: 'Task for B',
+      }));
+
+      const obsHookB = createObservationHook(TEST_DIR);
+      await obsHookB.execute(createTestInput({
+        sessionId: 'session-b',
+        project: 'project-b',
+        toolName: 'Read',
+        toolInput: { file_path: 'b.ts' },
+        toolResponse: {},
+      }));
+
+      // Verify isolation
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initialize();
+
+      const sessionsA = await service.getRecentSessions('project-a', 10);
+      const sessionsB = await service.getRecentSessions('project-b', 10);
+
+      expect(sessionsA.length).toBe(1);
+      expect(sessionsB.length).toBe(1);
+      expect(sessionsA[0].prompt).toBe('Task for A');
+      expect(sessionsB[0].prompt).toBe('Task for B');
+
+      const obsA = await service.getRecentObservations('project-a', 10);
+      const obsB = await service.getRecentObservations('project-b', 10);
+
+      expect(obsA.length).toBe(1);
+      expect(obsB.length).toBe(1);
+      expect(obsA[0].toolName).toBe('Write');
+      expect(obsB[0].toolName).toBe('Read');
+
+      await service.shutdown();
+    });
+  });
+
+  describe('CLI Input Parsing Integration', () => {
+    it('should parse and process real Claude Code input', async () => {
+      // Simulate real Claude Code hook input
+      const claudeInput = JSON.stringify({
+        session_id: 'abc123',
+        cwd: TEST_DIR,
+        prompt: 'Help me fix the bug',
+        tool_name: 'Read',
+        tool_input: { file_path: '/path/to/file.ts' },
+        tool_result: { content: 'file contents here' },
+      });
+
+      const parsed = parseHookInput(claudeInput);
+
+      expect(parsed.sessionId).toBe('abc123');
+      expect(parsed.cwd).toBe(TEST_DIR);
+      expect(parsed.prompt).toBe('Help me fix the bug');
+      expect(parsed.toolName).toBe('Read');
+      expect(parsed.toolInput).toEqual({ file_path: '/path/to/file.ts' });
+      expect(parsed.toolResponse).toEqual({ content: 'file contents here' });
+
+      // Process through observation hook
+      const observationHook = createObservationHook(TEST_DIR);
+      const result = await observationHook.execute(parsed);
+
+      expect(result.continue).toBe(true);
+
+      // Verify stored
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initialize();
+      const obs = await service.getSessionObservations('abc123');
+      await service.shutdown();
+
+      expect(obs.length).toBe(1);
+      expect(obs[0].title).toBe('Read /path/to/file.ts');
+    });
+  });
+
+  describe('Error Recovery', () => {
+    it('should continue working after errors', async () => {
+      const sessionId = 'error-recovery-session';
+      const project = 'test-project';
+
+      // Init session
+      const initHook = createSessionInitHook(TEST_DIR);
+      await initHook.execute(createTestInput({ sessionId, project }));
+
+      // Successful observation
+      const obsHook = createObservationHook(TEST_DIR);
+      await obsHook.execute(createTestInput({
+        sessionId,
+        project,
+        toolName: 'Read',
+        toolInput: {},
+        toolResponse: {},
+      }));
+
+      // Another successful observation
+      await obsHook.execute(createTestInput({
+        sessionId,
+        project,
+        toolName: 'Write',
+        toolInput: {},
+        toolResponse: {},
+      }));
+
+      // Verify both observations stored
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initialize();
+      const obs = await service.getSessionObservations(sessionId);
+      await service.shutdown();
+
+      expect(obs.length).toBe(2);
+    });
+  });
+
+  describe('Multiple Sessions', () => {
+    it('should handle multiple sessions sequentially', async () => {
+      const project = 'test-project';
+
+      // Start two sessions sequentially (SQLite doesn't handle concurrent writes well)
+      const initHook1 = createSessionInitHook(TEST_DIR);
+      await initHook1.execute(createTestInput({ sessionId: 'multi-1', project }));
+
+      const initHook2 = createSessionInitHook(TEST_DIR);
+      await initHook2.execute(createTestInput({ sessionId: 'multi-2', project }));
+
+      // Add observations sequentially
+      const obsHook1 = createObservationHook(TEST_DIR);
+      await obsHook1.execute(createTestInput({
+        sessionId: 'multi-1',
+        project,
+        toolName: 'Read',
+        toolInput: {},
+        toolResponse: {},
+      }));
+
+      const obsHook2 = createObservationHook(TEST_DIR);
+      await obsHook2.execute(createTestInput({
+        sessionId: 'multi-2',
+        project,
+        toolName: 'Write',
+        toolInput: {},
+        toolResponse: {},
+      }));
+
+      // Verify both sessions have their observations
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initialize();
+
+      const obs1 = await service.getSessionObservations('multi-1');
+      const obs2 = await service.getSessionObservations('multi-2');
+
+      expect(obs1.length).toBe(1);
+      expect(obs2.length).toBe(1);
+      expect(obs1[0].toolName).toBe('Read');
+      expect(obs2[0].toolName).toBe('Write');
+
+      await service.shutdown();
+    });
+  });
+
+  describe('Large Data Handling', () => {
+    it('should handle many observations efficiently', async () => {
+      const sessionId = 'large-data-session';
+      const project = 'test-project';
+
+      // Init session
+      const initHook = createSessionInitHook(TEST_DIR);
+      await initHook.execute(createTestInput({ sessionId, project }));
+
+      // Add many observations
+      const obsHook = createObservationHook(TEST_DIR);
+      const observationCount = 50;
+
+      for (let i = 0; i < observationCount; i++) {
+        await obsHook.execute(createTestInput({
+          sessionId,
+          project,
+          toolName: i % 2 === 0 ? 'Read' : 'Write',
+          toolInput: { file_path: `file${i}.ts` },
+          toolResponse: { content: `content ${i}` },
+        }));
+      }
+
+      // Verify all observations stored
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initialize();
+
+      const session = service.getSession(sessionId);
+      expect(session?.observationCount).toBe(observationCount);
+
+      const obs = await service.getSessionObservations(sessionId);
+      expect(obs.length).toBe(observationCount);
+
+      await service.shutdown();
+    });
+
+    it('should truncate large tool responses', async () => {
+      const sessionId = 'large-response-session';
+      const project = 'test-project';
+
+      // Init session
+      const initHook = createSessionInitHook(TEST_DIR);
+      await initHook.execute(createTestInput({ sessionId, project }));
+
+      // Add observation with large response
+      const obsHook = createObservationHook(TEST_DIR);
+      const largeContent = 'A'.repeat(100000); // 100KB
+
+      await obsHook.execute(createTestInput({
+        sessionId,
+        project,
+        toolName: 'Read',
+        toolInput: { file_path: 'large.ts' },
+        toolResponse: { content: largeContent },
+      }));
+
+      // Verify response was truncated
+      const service = new MemoryHookService(TEST_DIR);
+      await service.initialize();
+
+      const obs = await service.getSessionObservations(sessionId);
+      expect(obs.length).toBe(1);
+      expect(obs[0].toolResponse.length).toBeLessThan(100000);
+      expect(obs[0].toolResponse).toContain('[truncated]');
+
+      await service.shutdown();
+    });
+  });
+});