claude-memory-layer 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-memory-layer",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Claude Code plugin that learns from conversations to provide personalized assistance",
   "main": "dist/index.js",
   "bin": {

package/src/cli/index.ts

@@ -5,7 +5,10 @@
  */
 
 import { Command } from 'commander';
-import { getDefaultMemoryService } from '../services/memory-service.js';
+import {
+  getDefaultMemoryService,
+  getMemoryServiceForProject
+} from '../services/memory-service.js';
 import { createSessionHistoryImporter } from '../services/session-history-importer.js';
 
 const program = new Command();
@@ -24,8 +27,10 @@ program
   .option('-k, --top-k <number>', 'Number of results', '5')
   .option('-s, --min-score <number>', 'Minimum similarity score', '0.7')
   .option('--session <id>', 'Filter by session ID')
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
   .action(async (query: string, options) => {
-    const service = getDefaultMemoryService();
+    const projectPath = options.project || process.cwd();
+    const service = getMemoryServiceForProject(projectPath);
 
     try {
       const result = await service.retrieveMemories(query, {
@@ -64,8 +69,10 @@ program
   .option('-l, --limit <number>', 'Number of events', '20')
   .option('--session <id>', 'Filter by session ID')
   .option('--type <type>', 'Filter by event type')
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
   .action(async (options) => {
-    const service = getDefaultMemoryService();
+    const projectPath = options.project || process.cwd();
+    const service = getMemoryServiceForProject(projectPath);
 
     try {
       let events;
@@ -107,8 +114,10 @@ program
 program
   .command('stats')
   .description('View memory statistics')
-  .action(async () => {
-    const service = getDefaultMemoryService();
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
+  .action(async (options) => {
+    const projectPath = options.project || process.cwd();
+    const service = getMemoryServiceForProject(projectPath);
 
     try {
       const stats = await service.getStats();
@@ -139,8 +148,10 @@ program
   .option('--session <id>', 'Forget all events from a session')
   .option('--before <date>', 'Forget events before date (YYYY-MM-DD)')
   .option('--confirm', 'Skip confirmation')
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
   .action(async (eventId: string | undefined, options) => {
-    const service = getDefaultMemoryService();
+    const projectPath = options.project || process.cwd();
+    const service = getMemoryServiceForProject(projectPath);
 
     try {
       if (!eventId && !options.session && !options.before) {
@@ -171,8 +182,10 @@ program
 program
   .command('process')
   .description('Process pending embeddings')
-  .action(async () => {
-    const service = getDefaultMemoryService();
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
+  .action(async (options) => {
+    const projectPath = options.project || process.cwd();
+    const service = getMemoryServiceForProject(projectPath);
 
     try {
       console.log('⏳ Processing pending embeddings...');
@@ -198,7 +211,11 @@ program
   .option('-l, --limit <number>', 'Limit messages per session')
   .option('-v, --verbose', 'Show detailed progress')
   .action(async (options) => {
-    const service = getDefaultMemoryService();
+    // Determine target project path for storage
+    const targetProjectPath = options.project || process.cwd();
+
+    // Use project-specific memory service
+    const service = getMemoryServiceForProject(targetProjectPath);
     const importer = createSessionHistoryImporter(service);
 
     try {
@@ -208,9 +225,10 @@ program
 
       if (options.session) {
         // Import specific session file
-        console.log(`\n📥 Importing session: ${options.session}\n`);
+        console.log(`\n📥 Importing session: ${options.session}`);
+        console.log(`   Target project: ${targetProjectPath}\n`);
         result = await importer.importSessionFile(options.session, {
-          projectPath: options.project,
+          projectPath: targetProjectPath,
           limit: options.limit ? parseInt(options.limit) : undefined,
           verbose: options.verbose
         });
@@ -223,11 +241,42 @@ program
         });
       } else if (options.all) {
         // Import all sessions from all projects
-        console.log('\n📥 Importing all sessions from all projects\n');
-        result = await importer.importAll({
+        // Note: --all imports to global storage for backward compatibility
+        console.log('\n📥 Importing all sessions from all projects');
+        console.log('   ⚠️  Using global storage (use -p for project-specific)\n');
+        const globalService = getDefaultMemoryService();
+        const globalImporter = createSessionHistoryImporter(globalService);
+        await globalService.initialize();
+        result = await globalImporter.importAll({
           limit: options.limit ? parseInt(options.limit) : undefined,
           verbose: options.verbose
         });
+
+        // Process embeddings
+        console.log('\n⏳ Processing embeddings...');
+        const embedCount = await globalService.processPendingEmbeddings();
+
+        // Show results
+        console.log('\n✅ Import Complete\n');
+        console.log(`Sessions processed: ${result.totalSessions}`);
+        console.log(`Total messages: ${result.totalMessages}`);
+        console.log(`Imported prompts: ${result.importedPrompts}`);
+        console.log(`Imported responses: ${result.importedResponses}`);
+        console.log(`Skipped duplicates: ${result.skippedDuplicates}`);
+        console.log(`Embeddings processed: ${embedCount}`);
+
+        if (result.errors.length > 0) {
+          console.log(`\n⚠️  Errors (${result.errors.length}):`);
+          for (const error of result.errors.slice(0, 5)) {
+            console.log(`  - ${error}`);
+          }
+          if (result.errors.length > 5) {
+            console.log(`  ... and ${result.errors.length - 5} more`);
+          }
+        }
+
+        await globalService.shutdown();
+        return;
       } else {
         // Default: import current project
         const cwd = process.cwd();
@@ -324,8 +373,10 @@ const endlessCmd = program
 endlessCmd
   .command('enable')
   .description('Enable Endless Mode')
-  .action(async () => {
-    const service = getDefaultMemoryService();
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
+  .action(async (options) => {
+    const projectPath = options.project || process.cwd();
+    const service = getMemoryServiceForProject(projectPath);
 
     try {
       await service.initialize();
@@ -353,8 +404,10 @@ endlessCmd
 endlessCmd
   .command('disable')
   .description('Disable Endless Mode (return to Session Mode)')
-  .action(async () => {
-    const service = getDefaultMemoryService();
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
+  .action(async (options) => {
+    const projectPath = options.project || process.cwd();
+    const service = getMemoryServiceForProject(projectPath);
 
     try {
       await service.initialize();
@@ -377,8 +430,10 @@ endlessCmd
 endlessCmd
   .command('status')
   .description('Show Endless Mode status')
-  .action(async () => {
-    const service = getDefaultMemoryService();
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
+  .action(async (options) => {
+    const projectPath = options.project || process.cwd();
+    const service = getMemoryServiceForProject(projectPath);
 
     try {
       await service.initialize();
@@ -423,8 +478,10 @@ endlessCmd
 endlessCmd
   .command('consolidate')
   .description('Manually trigger memory consolidation')
-  .action(async () => {
-    const service = getDefaultMemoryService();
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
+  .action(async (options) => {
+    const projectPath = options.project || process.cwd();
+    const service = getMemoryServiceForProject(projectPath);
 
     try {
       await service.initialize();
@@ -460,8 +517,10 @@ endlessCmd
   .alias('ws')
   .description('View current working set')
   .option('-l, --limit <number>', 'Number of events to show', '10')
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
   .action(async (options) => {
-    const service = getDefaultMemoryService();
+    const projectPath = options.project || process.cwd();
+    const service = getMemoryServiceForProject(projectPath);
 
     try {
       await service.initialize();
@@ -519,8 +578,10 @@ endlessCmd
   .description('View consolidated memories')
   .option('-l, --limit <number>', 'Number of memories to show', '10')
   .option('-q, --query <text>', 'Search consolidated memories')
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
   .action(async (options) => {
-    const service = getDefaultMemoryService();
+    const projectPath = options.project || process.cwd();
+    const service = getMemoryServiceForProject(projectPath);
 
     try {
       await service.initialize();

package/src/core/consolidated-store.ts

@@ -5,7 +5,7 @@
  */
 
 import { randomUUID } from 'crypto';
-import { Database } from 'duckdb';
+import { dbRun, dbAll, toDate, type Database } from './db-wrapper.js';
 import type {
   ConsolidatedMemory,
   ConsolidatedMemoryInput
@@ -25,7 +25,8 @@ export class ConsolidatedStore {
   async create(input: ConsolidatedMemoryInput): Promise<string> {
     const memoryId = randomUUID();
 
-    await this.db.run(
+    await dbRun(
+      this.db,
       `INSERT INTO consolidated_memories
         (memory_id, summary, topics, source_events, confidence, created_at)
        VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
@@ -45,7 +46,8 @@ export class ConsolidatedStore {
    * Get a consolidated memory by ID
    */
   async get(memoryId: string): Promise<ConsolidatedMemory | null> {
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT * FROM consolidated_memories WHERE memory_id = ?`,
       [memoryId]
     );
@@ -60,7 +62,8 @@ export class ConsolidatedStore {
   async search(query: string, options?: { topK?: number }): Promise<ConsolidatedMemory[]> {
     const topK = options?.topK || 5;
 
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT * FROM consolidated_memories
        WHERE summary LIKE ?
        ORDER BY confidence DESC
@@ -81,7 +84,8 @@ export class ConsolidatedStore {
     const topicConditions = topics.map(() => `topics LIKE ?`).join(' OR ');
     const topicParams = topics.map(t => `%"${t}"%`);
 
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT * FROM consolidated_memories
        WHERE ${topicConditions}
        ORDER BY confidence DESC
@@ -98,7 +102,8 @@ export class ConsolidatedStore {
   async getAll(options?: { limit?: number }): Promise<ConsolidatedMemory[]> {
     const limit = options?.limit || 100;
 
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT * FROM consolidated_memories
        ORDER BY confidence DESC, created_at DESC
        LIMIT ?`,
@@ -115,7 +120,8 @@ export class ConsolidatedStore {
     const limit = options?.limit || 10;
     const hours = options?.hours || 24;
 
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT * FROM consolidated_memories
        WHERE created_at > datetime('now', '-${hours} hours')
        ORDER BY created_at DESC
@@ -130,7 +136,8 @@ export class ConsolidatedStore {
    * Mark a memory as accessed (tracks usage for importance scoring)
    */
   async markAccessed(memoryId: string): Promise<void> {
-    await this.db.run(
+    await dbRun(
+      this.db,
       `UPDATE consolidated_memories
        SET accessed_at = CURRENT_TIMESTAMP,
            access_count = access_count + 1
@@ -143,7 +150,8 @@ export class ConsolidatedStore {
    * Update confidence score for a memory
    */
   async updateConfidence(memoryId: string, confidence: number): Promise<void> {
-    await this.db.run(
+    await dbRun(
+      this.db,
       `UPDATE consolidated_memories
        SET confidence = ?
        WHERE memory_id = ?`,
@@ -155,7 +163,8 @@ export class ConsolidatedStore {
    * Delete a consolidated memory
    */
   async delete(memoryId: string): Promise<void> {
-    await this.db.run(
+    await dbRun(
+      this.db,
       `DELETE FROM consolidated_memories WHERE memory_id = ?`,
       [memoryId]
     );
@@ -165,7 +174,8 @@ export class ConsolidatedStore {
    * Get count of consolidated memories
    */
   async count(): Promise<number> {
-    const result = await this.db.all<Array<{ count: number }>>(
+    const result = await dbAll<{ count: number }>(
+      this.db,
       `SELECT COUNT(*) as count FROM consolidated_memories`
     );
     return result[0]?.count || 0;
@@ -175,7 +185,8 @@ export class ConsolidatedStore {
    * Get most accessed memories (for importance scoring)
    */
   async getMostAccessed(limit: number = 10): Promise<ConsolidatedMemory[]> {
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT * FROM consolidated_memories
        WHERE access_count > 0
        ORDER BY access_count DESC
@@ -197,12 +208,14 @@ export class ConsolidatedStore {
   }> {
     const total = await this.count();
 
-    const avgResult = await this.db.all<Array<{ avg: number | null }>>(
+    const avgResult = await dbAll<{ avg: number | null }>(
+      this.db,
       `SELECT AVG(confidence) as avg FROM consolidated_memories`
     );
     const averageConfidence = avgResult[0]?.avg || 0;
 
-    const recentResult = await this.db.all<Array<{ count: number }>>(
+    const recentResult = await dbAll<{ count: number }>(
+      this.db,
       `SELECT COUNT(*) as count FROM consolidated_memories
        WHERE created_at > datetime('now', '-24 hours')`
     );
@@ -230,7 +243,8 @@ export class ConsolidatedStore {
    */
   async isAlreadyConsolidated(eventIds: string[]): Promise<boolean> {
     for (const eventId of eventIds) {
-      const result = await this.db.all<Array<{ count: number }>>(
+      const result = await dbAll<{ count: number }>(
+        this.db,
         `SELECT COUNT(*) as count FROM consolidated_memories
          WHERE source_events LIKE ?`,
         [`%"${eventId}"%`]
@@ -244,7 +258,8 @@ export class ConsolidatedStore {
    * Get the last consolidation time
    */
   async getLastConsolidationTime(): Promise<Date | null> {
-    const result = await this.db.all<Array<{ created_at: string }>>(
+    const result = await dbAll<{ created_at: string }>(
+      this.db,
       `SELECT created_at FROM consolidated_memories
        ORDER BY created_at DESC
        LIMIT 1`
@@ -264,8 +279,8 @@ export class ConsolidatedStore {
       topics: JSON.parse(row.topics as string || '[]'),
       sourceEvents: JSON.parse(row.source_events as string || '[]'),
       confidence: row.confidence as number,
-      createdAt: new Date(row.created_at as string),
-      accessedAt: row.accessed_at ? new Date(row.accessed_at as string) : undefined,
+      createdAt: toDate(row.created_at),
+      accessedAt: row.accessed_at ? toDate(row.accessed_at) : undefined,
       accessCount: row.access_count as number || 0
     };
   }

package/src/core/continuity-manager.ts

@@ -5,7 +5,7 @@
  */
 
 import { randomUUID } from 'crypto';
-import { Database } from 'duckdb';
+import { dbRun, dbAll, toDate, type Database } from './db-wrapper.js';
 import type {
   EndlessModeConfig,
   ContextSnapshot,
@@ -107,7 +107,8 @@ export class ContinuityManager {
    * Get recent continuity logs
    */
   async getRecentLogs(limit: number = 10): Promise<ContinuityLog[]> {
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT * FROM continuity_log
        ORDER BY created_at DESC
        LIMIT ?`,
@@ -120,7 +121,7 @@ export class ContinuityManager {
       toContextId: row.to_context_id as string | undefined,
       continuityScore: row.continuity_score as number,
       transitionType: row.transition_type as TransitionType,
-      createdAt: new Date(row.created_at as string)
+      createdAt: toDate(row.created_at)
     }));
   }
 
@@ -128,7 +129,8 @@ export class ContinuityManager {
    * Get average continuity score over time period
    */
   async getAverageScore(hours: number = 1): Promise<number> {
-    const result = await this.db.all<Array<{ avg_score: number | null }>>(
+    const result = await dbAll<{ avg_score: number | null }>(
+      this.db,
       `SELECT AVG(continuity_score) as avg_score
        FROM continuity_log
        WHERE created_at > datetime('now', '-${hours} hours')`
@@ -141,7 +143,8 @@ export class ContinuityManager {
    * Get transition type distribution
    */
   async getTransitionStats(hours: number = 24): Promise<Record<TransitionType, number>> {
-    const rows = await this.db.all<Array<{ transition_type: string; count: number }>>(
+    const rows = await dbAll<{ transition_type: string; count: number }>(
+      this.db,
       `SELECT transition_type, COUNT(*) as count
        FROM continuity_log
        WHERE created_at > datetime('now', '-${hours} hours')
@@ -165,7 +168,8 @@ export class ContinuityManager {
    * Clear old continuity logs
    */
   async cleanup(olderThanDays: number = 7): Promise<number> {
-    const result = await this.db.all<Array<{ changes: number }>>(
+    const result = await dbAll<{ changes: number }>(
+      this.db,
       `DELETE FROM continuity_log
        WHERE created_at < datetime('now', '-${olderThanDays} days')
        RETURNING COUNT(*) as changes`
@@ -211,7 +215,8 @@ export class ContinuityManager {
     score: number,
     type: TransitionType
   ): Promise<void> {
-    await this.db.run(
+    await dbRun(
+      this.db,
       `INSERT INTO continuity_log
         (log_id, from_context_id, to_context_id, continuity_score, transition_type, created_at)
        VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,

package/src/core/db-wrapper.ts

@@ -0,0 +1,112 @@
+/**
+ * DuckDB Promise Wrapper
+ * Wraps the callback-based DuckDB API with Promise-based async/await interface
+ */
+
+import duckdb from 'duckdb';
+
+export type Database = duckdb.Database;
+
+/**
+ * Converts BigInt values to Number in an object
+ * DuckDB returns BigInt for COUNT(*) and other aggregate functions
+ */
+function convertBigInts<T>(obj: T): T {
+  if (obj === null || obj === undefined) return obj;
+  if (typeof obj === 'bigint') return Number(obj) as unknown as T;
+  if (obj instanceof Date) return obj; // Preserve Date objects
+  if (Array.isArray(obj)) return obj.map(convertBigInts) as unknown as T;
+  if (typeof obj === 'object') {
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+      result[key] = convertBigInts(value);
+    }
+    return result as T;
+  }
+  return obj;
+}
+
+/**
+ * Safely converts a value to a Date object
+ * Handles both Date objects and string timestamps from DuckDB
+ */
+export function toDate(value: unknown): Date {
+  if (value instanceof Date) return value;
+  if (typeof value === 'string') return new Date(value);
+  if (typeof value === 'number') return new Date(value);
+  return new Date(String(value));
+}
+
+/**
+ * Creates a new DuckDB database with Promise-based API
+ */
+export function createDatabase(path: string): Database {
+  return new duckdb.Database(path);
+}
+
+/**
+ * Promisified db.run() - executes a statement that doesn't return rows
+ */
+export function dbRun(db: Database, sql: string, params: unknown[] = []): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (params.length === 0) {
+      db.run(sql, (err: Error | null) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    } else {
+      db.run(sql, ...params, (err: Error | null) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    }
+  });
+}
+
+/**
+ * Promisified db.all() - executes a query and returns all rows
+ * Automatically converts BigInt values to Number
+ */
+export function dbAll<T = Record<string, unknown>>(
+  db: Database,
+  sql: string,
+  params: unknown[] = []
+): Promise<T[]> {
+  return new Promise((resolve, reject) => {
+    if (params.length === 0) {
+      db.all(sql, (err: Error | null, rows: T[]) => {
+        if (err) reject(err);
+        else resolve(convertBigInts(rows || []));
+      });
+    } else {
+      db.all(sql, ...params, (err: Error | null, rows: T[]) => {
+        if (err) reject(err);
+        else resolve(convertBigInts(rows || []));
+      });
+    }
+  });
+}
+
+/**
+ * Promisified db.close() - closes the database connection
+ */
+export function dbClose(db: Database): Promise<void> {
+  return new Promise((resolve, reject) => {
+    db.close((err: Error | null) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}
+
+/**
+ * Promisified db.exec() - executes multiple statements
+ */
+export function dbExec(db: Database, sql: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    db.exec(sql, (err: Error | null) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}