@aitytech/agentkits-memory 1.0.1 → 2.0.0

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

@@ -18,6 +18,15 @@ 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',
@@ -30,17 +39,39 @@ function createTestInput(overrides: Partial<NormalizedHookInput> = {}): Normaliz
 
 describe('Hook System Integration', () => {
   beforeEach(() => {
+    activeHooks = [];
     // Clean up test directory
     if (existsSync(TEST_DIR)) {
-      rmSync(TEST_DIR, { recursive: true });
+      try {
+        rmSync(TEST_DIR, { recursive: true });
+      } catch {
+        // Ignore errors on Windows
+      }
     }
     mkdirSync(TEST_DIR, { recursive: true });
   });
 
-  afterEach(() => {
+  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)) {
-      rmSync(TEST_DIR, { recursive: true });
+      try {
+        rmSync(TEST_DIR, { recursive: true });
+      } catch {
+        // Ignore errors on Windows - files may still be locked
+      }
     }
   });
 
@@ -50,24 +81,26 @@ describe('Hook System Integration', () => {
       const project = 'test-project';
 
       // 1. Session Start - Context Hook (no previous context)
-      const contextHook = createContextHook(TEST_DIR);
+      const contextHook = trackHook(createContextHook(TEST_DIR));
       const contextResult = await contextHook.execute(
         createTestInput({ sessionId, project })
       );
 
       expect(contextResult.continue).toBe(true);
       expect(contextResult.additionalContext).toBeUndefined(); // No previous sessions
+      await contextHook.shutdown();
 
       // 2. User Prompt Submit - Session Init Hook
-      const sessionInitHook = createSessionInitHook(TEST_DIR);
+      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 = createObservationHook(TEST_DIR);
+      const observationHook = trackHook(createObservationHook(TEST_DIR));
 
       // Simulate reading files
       await observationHook.execute(
@@ -112,9 +145,10 @@ describe('Hook System Integration', () => {
           toolResponse: { stdout: 'All tests passed' },
         })
       );
+      await observationHook.shutdown();
 
       // 4. Session End - Summarize Hook
-      const summarizeHook = createSummarizeHook(TEST_DIR);
+      const summarizeHook = trackHook(createSummarizeHook(TEST_DIR));
       const summarizeResult = await summarizeHook.execute(
         createTestInput({ sessionId, project, stopReason: 'user_exit' })
       );
@@ -146,11 +180,12 @@ describe('Hook System Integration', () => {
       const project = 'test-project';
 
       // Init session 1
-      const initHook1 = createSessionInitHook(TEST_DIR);
+      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 = createObservationHook(TEST_DIR);
+      const obsHook1 = trackHook(createObservationHook(TEST_DIR));
       await obsHook1.execute(createTestInput({
         sessionId: session1Id,
         project,
@@ -158,15 +193,16 @@ describe('Hook System Integration', () => {
         toolInput: { file_path: 'src/auth.ts' },
         toolResponse: {},
       }));
+      await obsHook1.shutdown();
 
       // Complete session 1
-      const sumHook1 = createSummarizeHook(TEST_DIR);
+      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 = createContextHook(TEST_DIR);
+      const contextHook2 = trackHook(createContextHook(TEST_DIR));
       const contextResult = await contextHook2.execute(
         createTestInput({ sessionId: session2Id, project })
       );
@@ -181,14 +217,15 @@ describe('Hook System Integration', () => {
 
     it('should handle multiple projects independently', async () => {
       // Session for project A
-      const initHookA = createSessionInitHook(TEST_DIR);
+      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 = createObservationHook(TEST_DIR);
+      const obsHookA = trackHook(createObservationHook(TEST_DIR));
       await obsHookA.execute(createTestInput({
         sessionId: 'session-a',
         project: 'project-a',
@@ -196,16 +233,18 @@ describe('Hook System Integration', () => {
         toolInput: { file_path: 'a.ts' },
         toolResponse: {},
       }));
+      await obsHookA.shutdown();
 
       // Session for project B
-      const initHookB = createSessionInitHook(TEST_DIR);
+      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 = createObservationHook(TEST_DIR);
+      const obsHookB = trackHook(createObservationHook(TEST_DIR));
       await obsHookB.execute(createTestInput({
         sessionId: 'session-b',
         project: 'project-b',
@@ -213,6 +252,7 @@ describe('Hook System Integration', () => {
         toolInput: { file_path: 'b.ts' },
         toolResponse: {},
       }));
+      await obsHookB.shutdown();
 
       // Verify isolation
       const service = new MemoryHookService(TEST_DIR);
@@ -260,10 +300,11 @@ describe('Hook System Integration', () => {
       expect(parsed.toolResponse).toEqual({ content: 'file contents here' });
 
       // Process through observation hook
-      const observationHook = createObservationHook(TEST_DIR);
+      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);
@@ -282,11 +323,12 @@ describe('Hook System Integration', () => {
       const project = 'test-project';
 
       // Init session
-      const initHook = createSessionInitHook(TEST_DIR);
+      const initHook = trackHook(createSessionInitHook(TEST_DIR));
       await initHook.execute(createTestInput({ sessionId, project }));
+      await initHook.shutdown();
 
       // Successful observation
-      const obsHook = createObservationHook(TEST_DIR);
+      const obsHook = trackHook(createObservationHook(TEST_DIR));
       await obsHook.execute(createTestInput({
         sessionId,
         project,
@@ -303,6 +345,7 @@ describe('Hook System Integration', () => {
         toolInput: {},
         toolResponse: {},
       }));
+      await obsHook.shutdown();
 
       // Verify both observations stored
       const service = new MemoryHookService(TEST_DIR);
@@ -319,14 +362,16 @@ describe('Hook System Integration', () => {
       const project = 'test-project';
 
       // Start two sessions sequentially (SQLite doesn't handle concurrent writes well)
-      const initHook1 = createSessionInitHook(TEST_DIR);
+      const initHook1 = trackHook(createSessionInitHook(TEST_DIR));
       await initHook1.execute(createTestInput({ sessionId: 'multi-1', project }));
+      await initHook1.shutdown();
 
-      const initHook2 = createSessionInitHook(TEST_DIR);
+      const initHook2 = trackHook(createSessionInitHook(TEST_DIR));
       await initHook2.execute(createTestInput({ sessionId: 'multi-2', project }));
+      await initHook2.shutdown();
 
       // Add observations sequentially
-      const obsHook1 = createObservationHook(TEST_DIR);
+      const obsHook1 = trackHook(createObservationHook(TEST_DIR));
       await obsHook1.execute(createTestInput({
         sessionId: 'multi-1',
         project,
@@ -334,8 +379,9 @@ describe('Hook System Integration', () => {
         toolInput: {},
         toolResponse: {},
       }));
+      await obsHook1.shutdown();
 
-      const obsHook2 = createObservationHook(TEST_DIR);
+      const obsHook2 = trackHook(createObservationHook(TEST_DIR));
       await obsHook2.execute(createTestInput({
         sessionId: 'multi-2',
         project,
@@ -343,6 +389,7 @@ describe('Hook System Integration', () => {
         toolInput: {},
         toolResponse: {},
       }));
+      await obsHook2.shutdown();
 
       // Verify both sessions have their observations
       const service = new MemoryHookService(TEST_DIR);
@@ -366,11 +413,12 @@ describe('Hook System Integration', () => {
       const project = 'test-project';
 
       // Init session
-      const initHook = createSessionInitHook(TEST_DIR);
+      const initHook = trackHook(createSessionInitHook(TEST_DIR));
       await initHook.execute(createTestInput({ sessionId, project }));
+      await initHook.shutdown();
 
       // Add many observations
-      const obsHook = createObservationHook(TEST_DIR);
+      const obsHook = trackHook(createObservationHook(TEST_DIR));
       const observationCount = 50;
 
       for (let i = 0; i < observationCount; i++) {
@@ -382,6 +430,7 @@ describe('Hook System Integration', () => {
           toolResponse: { content: `content ${i}` },
         }));
       }
+      await obsHook.shutdown();
 
       // Verify all observations stored
       const service = new MemoryHookService(TEST_DIR);
@@ -401,11 +450,12 @@ describe('Hook System Integration', () => {
       const project = 'test-project';
 
       // Init session
-      const initHook = createSessionInitHook(TEST_DIR);
+      const initHook = trackHook(createSessionInitHook(TEST_DIR));
       await initHook.execute(createTestInput({ sessionId, project }));
+      await initHook.shutdown();
 
       // Add observation with large response
-      const obsHook = createObservationHook(TEST_DIR);
+      const obsHook = trackHook(createObservationHook(TEST_DIR));
       const largeContent = 'A'.repeat(100000); // 100KB
 
       await obsHook.execute(createTestInput({
@@ -415,6 +465,7 @@ describe('Hook System Integration', () => {
         toolInput: { file_path: 'large.ts' },
         toolResponse: { content: largeContent },
       }));
+      await obsHook.shutdown();
 
       // Verify response was truncated
       const service = new MemoryHookService(TEST_DIR);

package/src/hooks/context.ts

@@ -23,9 +23,20 @@ import { MemoryHookService } from './service.js';
  */
 export class ContextHook implements EventHandler {
   private service: MemoryHookService;
+  private ownsService: boolean;
 
-  constructor(service: MemoryHookService) {
+  constructor(service: MemoryHookService, ownsService = false) {
     this.service = service;
+    this.ownsService = ownsService;
+  }
+
+  /**
+   * Shutdown the hook (closes database if owned)
+   */
+  async shutdown(): Promise<void> {
+    if (this.ownsService) {
+      await this.service.shutdown();
+    }
   }
 
   /**
@@ -71,7 +82,7 @@ export class ContextHook implements EventHandler {
  */
 export function createContextHook(cwd: string): ContextHook {
   const service = new MemoryHookService(cwd);
-  return new ContextHook(service);
+  return new ContextHook(service, true); // owns service
 }
 
 export default ContextHook;

package/src/hooks/observation.ts

@@ -32,9 +32,20 @@ const SKIP_TOOLS = new Set([
  */
 export class ObservationHook implements EventHandler {
   private service: MemoryHookService;
+  private ownsService: boolean;
 
-  constructor(service: MemoryHookService) {
+  constructor(service: MemoryHookService, ownsService = false) {
     this.service = service;
+    this.ownsService = ownsService;
+  }
+
+  /**
+   * Shutdown the hook (closes database if owned)
+   */
+  async shutdown(): Promise<void> {
+    if (this.ownsService) {
+      await this.service.shutdown();
+    }
   }
 
   /**
@@ -96,7 +107,7 @@ export class ObservationHook implements EventHandler {
  */
 export function createObservationHook(cwd: string): ObservationHook {
   const service = new MemoryHookService(cwd);
-  return new ObservationHook(service);
+  return new ObservationHook(service, true);
 }
 
 export default ObservationHook;

package/src/hooks/service.ts

@@ -2,18 +2,15 @@
  * Memory Hook Service
  *
  * Lightweight service for hooks to store/retrieve memory.
- * Direct SQLite access without HTTP worker (simpler than claude-mem).
+ * Direct SQLite access without HTTP worker.
  *
  * @module @agentkits/memory/hooks/service
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import * as path from 'node:path';
-import { createRequire } from 'node:module';
-import initSqlJs, { Database as SqlJsDatabase } from 'sql.js';
-
-// ESM-compatible require for resolving sql.js WASM path
-const require = createRequire(import.meta.url);
+import Database from 'better-sqlite3';
+import type { Database as BetterDatabase } from 'better-sqlite3';
 import {
   Observation,
   SessionRecord,
@@ -60,8 +57,7 @@ const DEFAULT_CONFIG: MemoryHookServiceConfig = {
  */
 export class MemoryHookService {
   private config: MemoryHookServiceConfig;
-  private db: SqlJsDatabase | null = null;
-  private SQL: any = null;
+  private db: BetterDatabase | null = null;
   private initialized: boolean = false;
   private dbPath: string;
 
@@ -82,25 +78,11 @@ export class MemoryHookService {
       mkdirSync(dir, { recursive: true });
     }
 
-    // Load sql.js - use local wasm file from node_modules
-    this.SQL = await initSqlJs({
-      locateFile: (file: string) => {
-        // Try to find the wasm file in node_modules
-        const localPath = path.join(
-          path.dirname(require.resolve('sql.js')),
-          file
-        );
-        return localPath;
-      },
-    });
-
-    // Load or create database
-    if (existsSync(this.dbPath)) {
-      const buffer = readFileSync(this.dbPath);
-      this.db = new this.SQL.Database(new Uint8Array(buffer));
-    } else {
-      this.db = new this.SQL.Database();
-    }
+    // Open database with better-sqlite3
+    this.db = new Database(this.dbPath);
+
+    // Enable WAL mode for better performance
+    this.db.pragma('journal_mode = WAL');
 
     // Create schema
     this.createSchema();
@@ -108,24 +90,12 @@ export class MemoryHookService {
     this.initialized = true;
   }
 
-  /**
-   * Persist database to disk
-   */
-  async persist(): Promise<void> {
-    if (!this.db) return;
-
-    const data = this.db.export();
-    const buffer = Buffer.from(data);
-    writeFileSync(this.dbPath, buffer);
-  }
-
   /**
    * Shutdown the service
    */
   async shutdown(): Promise<void> {
     if (!this.initialized || !this.db) return;
 
-    await this.persist();
     this.db.close();
     this.db = null;
     this.initialized = false;
@@ -147,15 +117,13 @@ export class MemoryHookService {
 
     // Create new session
     const now = Date.now();
-    this.db!.run(`
+    const result = this.db!.prepare(`
       INSERT INTO sessions (session_id, project, prompt, started_at, observation_count, status)
       VALUES (?, ?, ?, ?, 0, 'active')
-    `, [sessionId, project, prompt || '', now]);
-
-    await this.persist();
+    `).run(sessionId, project, prompt || '', now);
 
     return {
-      id: this.db!.exec('SELECT last_insert_rowid()')[0]?.values[0]?.[0] as number || 0,
+      id: Number(result.lastInsertRowid),
       sessionId,
       project,
       prompt: prompt || '',
@@ -171,16 +139,12 @@ export class MemoryHookService {
   getSession(sessionId: string): SessionRecord | null {
     if (!this.db) return null;
 
-    const stmt = this.db.prepare('SELECT * FROM sessions WHERE session_id = ?');
-    stmt.bind([sessionId]);
+    const row = this.db.prepare('SELECT * FROM sessions WHERE session_id = ?').get(sessionId) as Record<string, unknown> | undefined;
 
-    if (stmt.step()) {
-      const row = stmt.getAsObject();
-      stmt.free();
+    if (row) {
       return this.rowToSession(row);
     }
 
-    stmt.free();
     return null;
   }
 
@@ -191,13 +155,11 @@ export class MemoryHookService {
     await this.ensureInitialized();
 
     const now = Date.now();
-    this.db!.run(`
+    this.db!.prepare(`
       UPDATE sessions
       SET ended_at = ?, summary = ?, status = 'completed'
       WHERE session_id = ?
-    `, [now, summary || '', sessionId]);
-
-    await this.persist();
+    `).run(now, summary || '', sessionId);
   }
 
   /**
@@ -206,21 +168,14 @@ export class MemoryHookService {
   async getRecentSessions(project: string, limit: number = 5): Promise<SessionRecord[]> {
     await this.ensureInitialized();
 
-    const stmt = this.db!.prepare(`
+    const rows = this.db!.prepare(`
       SELECT * FROM sessions
       WHERE project = ?
       ORDER BY started_at DESC
       LIMIT ?
-    `);
-    stmt.bind([project, limit]);
-
-    const sessions: SessionRecord[] = [];
-    while (stmt.step()) {
-      sessions.push(this.rowToSession(stmt.getAsObject()));
-    }
-    stmt.free();
+    `).all(project, limit) as Record<string, unknown>[];
 
-    return sessions;
+    return rows.map(row => this.rowToSession(row));
   }
 
   // ===== Observation Management =====
@@ -250,19 +205,17 @@ export class MemoryHookService {
       this.config.maxResponseSize
     );
 
-    this.db!.run(`
+    this.db!.prepare(`
       INSERT INTO observations (id, session_id, project, tool_name, tool_input, tool_response, cwd, timestamp, type, title)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `, [id, sessionId, project, toolName, inputStr, responseStr, cwd, now, type, title]);
+    `).run(id, sessionId, project, toolName, inputStr, responseStr, cwd, now, type, title);
 
     // Update session observation count
-    this.db!.run(`
+    this.db!.prepare(`
       UPDATE sessions
       SET observation_count = observation_count + 1
       WHERE session_id = ?
-    `, [sessionId]);
-
-    await this.persist();
+    `).run(sessionId);
 
     return {
       id,
@@ -284,21 +237,14 @@ export class MemoryHookService {
   async getSessionObservations(sessionId: string, limit: number = 50): Promise<Observation[]> {
     await this.ensureInitialized();
 
-    const stmt = this.db!.prepare(`
+    const rows = this.db!.prepare(`
       SELECT * FROM observations
       WHERE session_id = ?
       ORDER BY timestamp DESC
       LIMIT ?
-    `);
-    stmt.bind([sessionId, limit]);
+    `).all(sessionId, limit) as Record<string, unknown>[];
 
-    const observations: Observation[] = [];
-    while (stmt.step()) {
-      observations.push(this.rowToObservation(stmt.getAsObject()));
-    }
-    stmt.free();
-
-    return observations;
+    return rows.map(row => this.rowToObservation(row));
   }
 
   /**
@@ -307,21 +253,14 @@ export class MemoryHookService {
   async getRecentObservations(project: string, limit: number = 20): Promise<Observation[]> {
     await this.ensureInitialized();
 
-    const stmt = this.db!.prepare(`
+    const rows = this.db!.prepare(`
       SELECT * FROM observations
       WHERE project = ?
       ORDER BY timestamp DESC
       LIMIT ?
-    `);
-    stmt.bind([project, limit]);
-
-    const observations: Observation[] = [];
-    while (stmt.step()) {
-      observations.push(this.rowToObservation(stmt.getAsObject()));
-    }
-    stmt.free();
+    `).all(project, limit) as Record<string, unknown>[];
 
-    return observations;
+    return rows.map(row => this.rowToObservation(row));
   }
 
   // ===== Context Generation =====
@@ -480,7 +419,7 @@ export class MemoryHookService {
   private createSchema(): void {
     if (!this.db) return;
 
-    this.db.run(`
+    this.db.exec(`
       CREATE TABLE IF NOT EXISTS sessions (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         session_id TEXT UNIQUE NOT NULL,
@@ -494,7 +433,7 @@ export class MemoryHookService {
       )
     `);
 
-    this.db.run(`
+    this.db.exec(`
       CREATE TABLE IF NOT EXISTS observations (
         id TEXT PRIMARY KEY,
         session_id TEXT NOT NULL,
@@ -510,13 +449,13 @@ export class MemoryHookService {
       )
     `);
 
-    this.db.run('CREATE INDEX IF NOT EXISTS idx_obs_session ON observations(session_id)');
-    this.db.run('CREATE INDEX IF NOT EXISTS idx_obs_project ON observations(project)');
-    this.db.run('CREATE INDEX IF NOT EXISTS idx_obs_timestamp ON observations(timestamp)');
-    this.db.run('CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project)');
+    this.db.exec('CREATE INDEX IF NOT EXISTS idx_obs_session ON observations(session_id)');
+    this.db.exec('CREATE INDEX IF NOT EXISTS idx_obs_project ON observations(project)');
+    this.db.exec('CREATE INDEX IF NOT EXISTS idx_obs_timestamp ON observations(timestamp)');
+    this.db.exec('CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project)');
   }
 
-  private rowToSession(row: any): SessionRecord {
+  private rowToSession(row: Record<string, unknown>): SessionRecord {
     return {
       id: row.id as number,
       sessionId: row.session_id as string,
@@ -530,7 +469,7 @@ export class MemoryHookService {
     };
   }
 
-  private rowToObservation(row: any): Observation {
+  private rowToObservation(row: Record<string, unknown>): Observation {
     return {
       id: row.id as string,
       sessionId: row.session_id as string,
@@ -540,7 +479,7 @@ export class MemoryHookService {
       toolResponse: row.tool_response as string,
       cwd: row.cwd as string,
       timestamp: row.timestamp as number,
-      type: row.type as any,
+      type: row.type as Observation['type'],
       title: row.title as string | undefined,
     };
   }

package/src/hooks/session-init.ts

@@ -22,9 +22,20 @@ import { MemoryHookService } from './service.js';
  */
 export class SessionInitHook implements EventHandler {
   private service: MemoryHookService;
+  private ownsService: boolean;
 
-  constructor(service: MemoryHookService) {
+  constructor(service: MemoryHookService, ownsService = false) {
     this.service = service;
+    this.ownsService = ownsService;
+  }
+
+  /**
+   * Shutdown the hook (closes database if owned)
+   */
+  async shutdown(): Promise<void> {
+    if (this.ownsService) {
+      await this.service.shutdown();
+    }
   }
 
   /**
@@ -64,7 +75,7 @@ export class SessionInitHook implements EventHandler {
  */
 export function createSessionInitHook(cwd: string): SessionInitHook {
   const service = new MemoryHookService(cwd);
-  return new SessionInitHook(service);
+  return new SessionInitHook(service, true);
 }
 
 export default SessionInitHook;