claude-memory-layer 1.0.1 → 1.0.3

package/src/services/memory-service.ts

@@ -13,8 +13,12 @@ import { VectorStore } from '../core/vector-store.js';
 import { Embedder, getDefaultEmbedder } from '../core/embedder.js';
 import { VectorWorker, createVectorWorker } from '../core/vector-worker.js';
 import { Matcher, getDefaultMatcher } from '../core/matcher.js';
-import { Retriever, createRetriever, RetrievalResult } from '../core/retriever.js';
+import { Retriever, createRetriever, RetrievalResult, UnifiedRetrievalResult } from '../core/retriever.js';
 import { GraduationPipeline, createGraduationPipeline } from '../core/graduation.js';
+import { SharedEventStore, createSharedEventStore } from '../core/shared-event-store.js';
+import { SharedStore, createSharedStore } from '../core/shared-store.js';
+import { SharedVectorStore, createSharedVectorStore } from '../core/shared-vector-store.js';
+import { SharedPromoter, createSharedPromoter, PromotionResult } from '../core/shared-promoter.js';
 import type {
   MemoryEventInput,
   AppendResult,
@@ -29,7 +33,9 @@ import type {
   ConsolidatedMemory,
   EndlessModeStatus,
   ContextSnapshot,
-  ContinuityScore
+  ContinuityScore,
+  SharedStoreConfig,
+  Entry
 } from '../core/types.js';
 import { createToolObservationEmbedding } from '../core/metadata-extractor.js';
 import { WorkingSetStore, createWorkingSetStore } from '../core/working-set-store.js';
@@ -87,6 +93,7 @@ export function getProjectStoragePath(projectPath: string): string {
 // ============================================================
 
 const REGISTRY_PATH = path.join(os.homedir(), '.claude-code', 'memory', 'session-registry.json');
+const SHARED_STORAGE_PATH = path.join(os.homedir(), '.claude-code', 'memory', 'shared');
 
 interface SessionRegistryEntry {
   projectPath: string;
@@ -172,7 +179,15 @@ export class MemoryService {
   private continuityManager: ContinuityManager | null = null;
   private endlessMode: MemoryMode = 'session';
 
-  constructor(config: MemoryServiceConfig) {
+  // Shared Store components (cross-project knowledge)
+  private sharedEventStore: SharedEventStore | null = null;
+  private sharedStore: SharedStore | null = null;
+  private sharedVectorStore: SharedVectorStore | null = null;
+  private sharedPromoter: SharedPromoter | null = null;
+  private sharedStoreConfig: SharedStoreConfig | null = null;
+  private projectHash: string | null = null;
+
+  constructor(config: MemoryServiceConfig & { projectHash?: string; sharedStoreConfig?: SharedStoreConfig }) {
     const storagePath = this.expandPath(config.storagePath);
 
     // Ensure storage directory exists
@@ -180,6 +195,11 @@ export class MemoryService {
       fs.mkdirSync(storagePath, { recursive: true });
     }
 
+    // Store project hash for shared store operations
+    this.projectHash = config.projectHash || null;
+    // Default: shared store enabled
+    this.sharedStoreConfig = config.sharedStoreConfig ?? { enabled: true };
+
     // Initialize components
     this.eventStore = new EventStore(path.join(storagePath, 'events.duckdb'));
     this.vectorStore = new VectorStore(path.join(storagePath, 'vectors'));
@@ -221,9 +241,49 @@ export class MemoryService {
       await this.initializeEndlessMode();
     }
 
+    // Initialize shared store (enabled by default)
+    if (this.sharedStoreConfig?.enabled !== false) {
+      await this.initializeSharedStore();
+    }
+
     this.initialized = true;
   }
 
+  /**
+   * Initialize Shared Store components
+   */
+  private async initializeSharedStore(): Promise<void> {
+    const sharedPath = this.sharedStoreConfig?.sharedStoragePath
+      ? this.expandPath(this.sharedStoreConfig.sharedStoragePath)
+      : SHARED_STORAGE_PATH;
+
+    // Ensure shared directory exists
+    if (!fs.existsSync(sharedPath)) {
+      fs.mkdirSync(sharedPath, { recursive: true });
+    }
+
+    this.sharedEventStore = createSharedEventStore(
+      path.join(sharedPath, 'shared.duckdb')
+    );
+    await this.sharedEventStore.initialize();
+
+    this.sharedStore = createSharedStore(this.sharedEventStore);
+    this.sharedVectorStore = createSharedVectorStore(
+      path.join(sharedPath, 'vectors')
+    );
+    await this.sharedVectorStore.initialize();
+
+    this.sharedPromoter = createSharedPromoter(
+      this.sharedStore,
+      this.sharedVectorStore,
+      this.embedder,
+      this.sharedStoreConfig || undefined
+    );
+
+    // Connect shared stores to retriever
+    this.retriever.setSharedStores(this.sharedStore, this.sharedVectorStore);
+  }
+
   /**
    * Start a new session
    */
@@ -370,8 +430,9 @@ export class MemoryService {
       topK?: number;
       minScore?: number;
       sessionId?: string;
+      includeShared?: boolean;
     }
-  ): Promise<RetrievalResult> {
+  ): Promise<UnifiedRetrievalResult> {
     await this.initialize();
 
     // Process any pending embeddings first
@@ -379,6 +440,15 @@ export class MemoryService {
       await this.vectorWorker.processAll();
     }
 
+    // Use unified retrieval if shared search is requested
+    if (options?.includeShared && this.sharedStore) {
+      return this.retriever.retrieveUnified(query, {
+        ...options,
+        includeShared: true,
+        projectHash: this.projectHash || undefined
+      });
+    }
+
     return this.retriever.retrieve(query, options);
   }
 
@@ -449,6 +519,62 @@ export class MemoryService {
     return header + result.context;
   }
 
+  // ============================================================
+  // Shared Store Methods (Cross-Project Knowledge)
+  // ============================================================
+
+  /**
+   * Check if shared store is enabled and initialized
+   */
+  isSharedStoreEnabled(): boolean {
+    return this.sharedStore !== null;
+  }
+
+  /**
+   * Promote an entry to shared storage
+   */
+  async promoteToShared(entry: Entry): Promise<PromotionResult> {
+    if (!this.sharedPromoter || !this.projectHash) {
+      return {
+        success: false,
+        error: 'Shared store not initialized or project hash not set'
+      };
+    }
+
+    return this.sharedPromoter.promoteEntry(entry, this.projectHash);
+  }
+
+  /**
+   * Get shared store statistics
+   */
+  async getSharedStoreStats(): Promise<{
+    total: number;
+    averageConfidence: number;
+    topTopics: Array<{ topic: string; count: number }>;
+    totalUsageCount: number;
+  } | null> {
+    if (!this.sharedStore) return null;
+    return this.sharedStore.getStats();
+  }
+
+  /**
+   * Search shared troubleshooting entries
+   */
+  async searchShared(
+    query: string,
+    options?: { topK?: number; minConfidence?: number }
+  ) {
+    if (!this.sharedStore) return [];
+    return this.sharedStore.search(query, options);
+  }
+
+  /**
+   * Get project hash for this service
+   */
+  getProjectHash(): string | null {
+    return this.projectHash;
+  }
+
   // ============================================================
   // Endless Mode Methods
   // ============================================================
@@ -708,6 +834,12 @@ export class MemoryService {
     if (this.vectorWorker) {
       this.vectorWorker.stop();
     }
+
+    // Close shared store
+    if (this.sharedEventStore) {
+      await this.sharedEventStore.close();
+    }
+
     await this.eventStore.close();
   }
 
@@ -747,12 +879,19 @@ export function getDefaultMemoryService(): MemoryService {
  * Get memory service for a specific project path
  * Creates isolated storage at ~/.claude-code/memory/projects/{hash}/
  */
-export function getMemoryServiceForProject(projectPath: string): MemoryService {
+export function getMemoryServiceForProject(
+  projectPath: string,
+  sharedStoreConfig?: SharedStoreConfig
+): MemoryService {
   const hash = hashProjectPath(projectPath);
 
   if (!serviceCache.has(hash)) {
     const storagePath = getProjectStoragePath(projectPath);
-    serviceCache.set(hash, new MemoryService({ storagePath }));
+    serviceCache.set(hash, new MemoryService({
+      storagePath,
+      projectHash: hash,
+      sharedStoreConfig
+    }));
   }
 
   return serviceCache.get(hash)!;