/**
* 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');
// Track hooks for cleanup (needed for Windows file locking)
let activeHooks: Array<{ shutdown: () => Promise<void> }> = [];
// Helper to track hooks for cleanup
function trackHook<T extends { shutdown: () => Promise<void> }>(hook: T): T {
activeHooks.push(hook);
return hook;
}
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(() => {
activeHooks = [];
// Clean up test directory
if (existsSync(TEST_DIR)) {
try {
rmSync(TEST_DIR, { recursive: true });
} catch {
// Ignore errors on Windows
}
}
mkdirSync(TEST_DIR, { recursive: true });
});
afterEach(async () => {
// Shutdown all hooks first (releases database locks)
for (const hook of activeHooks) {
try {
await hook.shutdown();
} catch {
// Ignore shutdown errors
}
}
activeHooks = [];
// Small delay for Windows file system
await new Promise((r) => setTimeout(r, 100));
// Clean up test directory
if (existsSync(TEST_DIR)) {
try {
rmSync(TEST_DIR, { recursive: true });
} catch {
// Ignore errors on Windows - files may still be locked
}
}
});
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 = trackHook(createContextHook(TEST_DIR));
const contextResult = await contextHook.execute(
createTestInput({ sessionId, project })
);
expect(contextResult.continue).toBe(true);
// Empty state now injects guidance (save-first workflow)
expect(contextResult.additionalContext).toBeDefined();
expect(contextResult.additionalContext).toContain('memory_save');
expect(contextResult.additionalContext).toContain('Do NOT call');
await contextHook.shutdown();
// 2. User Prompt Submit - Session Init Hook
const sessionInitHook = trackHook(createSessionInitHook(TEST_DIR));
const sessionInitResult = await sessionInitHook.execute(
createTestInput({ sessionId, project, prompt: 'Help me implement a feature' })
);
expect(sessionInitResult.continue).toBe(true);
await sessionInitHook.shutdown();
// 3. Tool Uses - Observation Hooks
const observationHook = trackHook(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' },
})
);
await observationHook.shutdown();
// 4. Session End - Summarize Hook
const summarizeHook = trackHook(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 = trackHook(createSessionInitHook(TEST_DIR));
await initHook1.execute(createTestInput({ sessionId: session1Id, project, prompt: 'First task' }));
await initHook1.shutdown();
// Add observations to session 1
const obsHook1 = trackHook(createObservationHook(TEST_DIR));
await obsHook1.execute(createTestInput({
sessionId: session1Id,
project,
toolName: 'Write',
toolInput: { file_path: 'src/auth.ts' },
toolResponse: {},
}));
await obsHook1.shutdown();
// Complete session 1
const sumHook1 = trackHook(createSummarizeHook(TEST_DIR));
await sumHook1.execute(createTestInput({ sessionId: session1Id, project }));
// Session 2: Should see context from session 1
const session2Id = 'current-session';
const contextHook2 = trackHook(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 Session Summaries');
expect(contextResult.additionalContext).toContain('Recent Activity');
expect(contextResult.additionalContext).toContain('auth.ts');
});
it('should handle multiple projects independently', async () => {
// Session for project A
const initHookA = trackHook(createSessionInitHook(TEST_DIR));
await initHookA.execute(createTestInput({
sessionId: 'session-a',
project: 'project-a',
prompt: 'Task for A',
}));
await initHookA.shutdown();
const obsHookA = trackHook(createObservationHook(TEST_DIR));
await obsHookA.execute(createTestInput({
sessionId: 'session-a',
project: 'project-a',
toolName: 'Write',
toolInput: { file_path: 'a.ts' },
toolResponse: {},
}));
await obsHookA.shutdown();
// Session for project B
const initHookB = trackHook(createSessionInitHook(TEST_DIR));
await initHookB.execute(createTestInput({
sessionId: 'session-b',
project: 'project-b',
prompt: 'Task for B',
}));
await initHookB.shutdown();
const obsHookB = trackHook(createObservationHook(TEST_DIR));
await obsHookB.execute(createTestInput({
sessionId: 'session-b',
project: 'project-b',
toolName: 'Read',
toolInput: { file_path: 'b.ts' },
toolResponse: {},
}));
await obsHookB.shutdown();
// 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 = trackHook(createObservationHook(TEST_DIR));
const result = await observationHook.execute(parsed);
expect(result.continue).toBe(true);
await observationHook.shutdown();
// 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 = trackHook(createSessionInitHook(TEST_DIR));
await initHook.execute(createTestInput({ sessionId, project }));
await initHook.shutdown();
// Successful observation
const obsHook = trackHook(createObservationHook(TEST_DIR));
await obsHook.execute(createTestInput({
sessionId,
project,
toolName: 'Read',
toolInput: { file_path: '/test/file.ts' },
toolResponse: { content: 'test content' },
}));
// Another successful observation
await obsHook.execute(createTestInput({
sessionId,
project,
toolName: 'Write',
toolInput: { file_path: '/test/output.ts' },
toolResponse: { success: true },
}));
await obsHook.shutdown();
// 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 = trackHook(createSessionInitHook(TEST_DIR));
await initHook1.execute(createTestInput({ sessionId: 'multi-1', project }));
await initHook1.shutdown();
const initHook2 = trackHook(createSessionInitHook(TEST_DIR));
await initHook2.execute(createTestInput({ sessionId: 'multi-2', project }));
await initHook2.shutdown();
// Add observations sequentially
const obsHook1 = trackHook(createObservationHook(TEST_DIR));
await obsHook1.execute(createTestInput({
sessionId: 'multi-1',
project,
toolName: 'Read',
toolInput: { file_path: '/test/file1.ts' },
toolResponse: { content: 'content1' },
}));
await obsHook1.shutdown();
const obsHook2 = trackHook(createObservationHook(TEST_DIR));
await obsHook2.execute(createTestInput({
sessionId: 'multi-2',
project,
toolName: 'Write',
toolInput: { file_path: '/test/file2.ts' },
toolResponse: { success: true },
}));
await obsHook2.shutdown();
// 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 = trackHook(createSessionInitHook(TEST_DIR));
await initHook.execute(createTestInput({ sessionId, project }));
await initHook.shutdown();
// Add many observations
const obsHook = trackHook(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}` },
}));
}
await obsHook.shutdown();
// 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 = trackHook(createSessionInitHook(TEST_DIR));
await initHook.execute(createTestInput({ sessionId, project }));
await initHook.shutdown();
// Add observation with large response
const obsHook = trackHook(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 },
}));
await obsHook.shutdown();
// 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();
});
});
});
