claude-memory-layer 1.0.31 → 1.0.33

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

@@ -1,36 +0,0 @@
-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

@@ -1,150 +0,0 @@
-/**
- * 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)
-  };
-}