claude-memory-layer 1.0.27 → 1.0.28

package/src/services/memory-service-config.ts

@@ -0,0 +1,36 @@
+import * as os from 'os';
+import * as path from 'path';
+
+import type { SharedStoreConfig } from '../core/types.js';
+
+export interface MemoryServiceConfig {
+  storagePath: string;
+  embeddingModel?: string;
+  readOnly?: boolean;
+  /** Enable DuckDB analytics store (default: true for server, false for hooks) */
+  analyticsEnabled?: boolean;
+  /** Lightweight mode for hooks - skip heavy initialization (default: false) */
+  lightweightMode?: boolean;
+  /** Start only VectorWorker, skip GraduationWorker and SyncWorker (default: false) */
+  embeddingOnly?: boolean;
+}
+
+const SHARED_STORAGE_PATH = path.join(os.homedir(), '.claude-code', 'memory', 'shared');
+
+export const DISABLED_SHARED_STORE_CONFIG: SharedStoreConfig = {
+  enabled: false,
+  autoPromote: false,
+  searchShared: false,
+  minConfidenceForPromotion: 0.8,
+  sharedStoragePath: SHARED_STORAGE_PATH
+};
+
+export const DEFAULT_ENABLED_SHARED_STORE_CONFIG: SharedStoreConfig = {
+  enabled: true,
+  autoPromote: true,
+  searchShared: true,
+  minConfidenceForPromotion: 0.8,
+  sharedStoragePath: SHARED_STORAGE_PATH
+};
+
+export const DEFAULT_SHARED_STORAGE_PATH = SHARED_STORAGE_PATH;

package/src/services/memory-service-registry.ts

@@ -0,0 +1,150 @@
+/**
+ * Memory Service Registry
+ *
+ * Owns process-local MemoryService instance caching and project/session service
+ * resolution. Keeping this out of MemoryService prevents the compatibility
+ * facade from also being the application-level service locator.
+ */
+
+import * as path from 'path';
+
+import type { SharedStoreConfig } from '../core/types.js';
+import type { MemoryServiceConfig } from './memory-service-config.js';
+
+export type MemoryServiceRegistryConfig = MemoryServiceConfig & {
+  projectHash?: string;
+  projectPath?: string;
+  sharedStoreConfig?: SharedStoreConfig;
+};
+
+export interface MemoryServiceRegistryDeps<TService> {
+  createService: (config: MemoryServiceRegistryConfig) => TService;
+  hashProjectPath: (projectPath: string) => string;
+  getProjectStoragePath: (projectPath: string) => string;
+  getSessionProject: (sessionId: string) => { projectHash: string; projectPath: string } | null;
+  homedir: () => string;
+  disabledSharedStoreConfig: SharedStoreConfig;
+  serviceCache?: Map<string, TService>;
+}
+
+export interface MemoryServiceRegistry<TService> {
+  getDefaultMemoryService(): TService;
+  getReadOnlyMemoryService(): TService;
+  getMemoryServiceForProject(projectPath: string, sharedStoreConfig?: SharedStoreConfig): TService;
+  getMemoryServiceForSession(sessionId: string): TService;
+  getLightweightMemoryService(sessionId: string): TService;
+  getLightweightMemoryServiceForProject(projectPath: string): TService;
+  createMemoryService(config: MemoryServiceConfig): TService;
+}
+
+const GLOBAL_KEY = '__global__';
+
+export function createMemoryServiceRegistry<TService>(
+  deps: MemoryServiceRegistryDeps<TService>
+): MemoryServiceRegistry<TService> {
+  const serviceCache = deps.serviceCache ?? new Map<string, TService>();
+
+  const getDefaultMemoryService = (): TService => {
+    if (!serviceCache.has(GLOBAL_KEY)) {
+      serviceCache.set(GLOBAL_KEY, deps.createService({
+        storagePath: '~/.claude-code/memory',
+        analyticsEnabled: false,
+        sharedStoreConfig: deps.disabledSharedStoreConfig
+      }));
+    }
+    return serviceCache.get(GLOBAL_KEY)!;
+  };
+
+  const getReadOnlyMemoryService = (): TService => deps.createService({
+    storagePath: '~/.claude-code/memory',
+    readOnly: true,
+    analyticsEnabled: false,
+    sharedStoreConfig: deps.disabledSharedStoreConfig
+  });
+
+  const getMemoryServiceForProject = (
+    projectPath: string,
+    sharedStoreConfig?: SharedStoreConfig
+  ): TService => {
+    const hash = deps.hashProjectPath(projectPath);
+
+    if (!serviceCache.has(hash)) {
+      serviceCache.set(hash, deps.createService({
+        storagePath: deps.getProjectStoragePath(projectPath),
+        projectHash: hash,
+        projectPath,
+        sharedStoreConfig: sharedStoreConfig ?? deps.disabledSharedStoreConfig,
+        analyticsEnabled: false
+      }));
+    }
+
+    // Project services are keyed only by project hash. This intentionally means
+    // the first sharedStoreConfig used for a project wins; later calls for the
+    // same project reuse the cached instance to preserve historical lock/cache
+    // semantics instead of replacing the service graph under existing callers.
+    return serviceCache.get(hash)!;
+  };
+
+  const getMemoryServiceForSession = (sessionId: string): TService => {
+    const projectInfo = deps.getSessionProject(sessionId);
+
+    if (projectInfo) {
+      return getMemoryServiceForProject(projectInfo.projectPath);
+    }
+
+    return getDefaultMemoryService();
+  };
+
+  const getOrCreateLightweightProjectService = (
+    projectHash: string,
+    projectPath: string
+  ): TService => {
+    const key = `lightweight_${projectHash}`;
+    if (!serviceCache.has(key)) {
+      serviceCache.set(key, deps.createService({
+        storagePath: deps.getProjectStoragePath(projectPath),
+        projectHash,
+        projectPath,
+        lightweightMode: true,
+        analyticsEnabled: false,
+        sharedStoreConfig: deps.disabledSharedStoreConfig
+      }));
+    }
+
+    return serviceCache.get(key)!;
+  };
+
+  const getLightweightMemoryService = (sessionId: string): TService => {
+    const projectInfo = deps.getSessionProject(sessionId);
+    if (projectInfo) {
+      return getOrCreateLightweightProjectService(projectInfo.projectHash, projectInfo.projectPath);
+    }
+
+    const key = 'lightweight_global';
+    if (!serviceCache.has(key)) {
+      serviceCache.set(key, deps.createService({
+        storagePath: path.join(deps.homedir(), '.claude-code', 'memory'),
+        lightweightMode: true,
+        analyticsEnabled: false,
+        sharedStoreConfig: deps.disabledSharedStoreConfig
+      }));
+    }
+
+    return serviceCache.get(key)!;
+  };
+
+  const getLightweightMemoryServiceForProject = (projectPath: string): TService => {
+    const projectHash = deps.hashProjectPath(projectPath);
+    return getOrCreateLightweightProjectService(projectHash, projectPath);
+  };
+
+  return {
+    getDefaultMemoryService,
+    getReadOnlyMemoryService,
+    getMemoryServiceForProject,
+    getMemoryServiceForSession,
+    getLightweightMemoryService,
+    getLightweightMemoryServiceForProject,
+    createMemoryService: (config: MemoryServiceConfig): TService => deps.createService(config)
+  };
+}