claude-memory-layer 1.0.30 → 1.0.32

package/tests/extensions/mcp-extension-boundary.test.ts

@@ -1,21 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-
-import { tools as toolsFromExtension } from '../../src/extensions/mcp/tools.js';
-import { tools as toolsFromCompat } from '../../src/mcp/tools.js';
-import { handleToolCall as handleFromExtension } from '../../src/extensions/mcp/handlers.js';
-import { handleToolCall as handleFromCompat } from '../../src/mcp/handlers.js';
-
-describe('mcp extension boundary', () => {
-  it('keeps MCP implementation under extensions with compatibility re-exports', () => {
-    const indexCompatSource = readFileSync('src/mcp/index.ts', 'utf8');
-    const toolsCompatSource = readFileSync('src/mcp/tools.ts', 'utf8');
-    const handlersCompatSource = readFileSync('src/mcp/handlers.ts', 'utf8');
-
-    expect(toolsFromCompat).toBe(toolsFromExtension);
-    expect(handleFromCompat).toBe(handleFromExtension);
-    expect(indexCompatSource).toContain("../extensions/mcp/index.js");
-    expect(toolsCompatSource).toContain("../extensions/mcp/tools.js");
-    expect(handlersCompatSource).toContain("../extensions/mcp/handlers.js");
-  });
-});

package/tests/extensions/mcp-package-build.test.ts

@@ -1,22 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-
-describe('MCP package/build wiring', () => {
-  it('exposes a package bin and build output for the MCP stdio server', () => {
-    const packageJson = JSON.parse(readFileSync('package.json', 'utf8')) as {
-      bin?: Record<string, string>;
-    };
-    const packageLock = JSON.parse(readFileSync('package-lock.json', 'utf8')) as {
-      packages?: Record<string, { bin?: Record<string, string> }>;
-    };
-    const buildScript = readFileSync('scripts/build.ts', 'utf8');
-
-    expect(packageJson.bin).toMatchObject({
-      'claude-memory-layer': 'dist/cli/index.js',
-      'claude-memory-layer-mcp': 'dist/mcp/index.js'
-    });
-    expect(packageLock.packages?.['']?.bin).toMatchObject(packageJson.bin ?? {});
-    expect(buildScript).toContain("entryPoints: ['src/mcp/index.ts']");
-    expect(buildScript).toContain("outfile: 'dist/mcp/index.js'");
-  });
-});

package/tests/extensions/mcp-project-aware-tools.test.ts

@@ -1,102 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const mocks = vi.hoisted(() => {
-  function createService() {
-    return {
-      initialize: vi.fn(async () => undefined),
-      retrieveMemories: vi.fn(),
-      getRecentEvents: vi.fn(),
-      getStats: vi.fn()
-    };
-  }
-
-  const defaultService = createService();
-  const projectService = createService();
-
-  return {
-    defaultService,
-    projectService,
-    getDefaultMemoryService: vi.fn(() => defaultService),
-    getMemoryServiceForProject: vi.fn(() => projectService)
-  };
-});
-
-vi.mock('../../src/services/memory-service.js', () => ({
-  getDefaultMemoryService: mocks.getDefaultMemoryService,
-  getMemoryServiceForProject: mocks.getMemoryServiceForProject
-}));
-
-const { handleToolCall } = await import('../../src/extensions/mcp/handlers.js');
-const { tools } = await import('../../src/extensions/mcp/tools.js');
-
-function resetService(service: typeof mocks.defaultService) {
-  service.initialize.mockReset().mockResolvedValue(undefined);
-  service.retrieveMemories.mockReset().mockResolvedValue({ memories: [] });
-  service.getRecentEvents.mockReset().mockResolvedValue([]);
-  service.getStats.mockReset().mockResolvedValue({ totalEvents: 0, vectorCount: 0 });
-}
-
-describe('MCP project-aware memory tools', () => {
-  beforeEach(() => {
-    resetService(mocks.defaultService);
-    resetService(mocks.projectService);
-    mocks.getDefaultMemoryService.mockClear();
-    mocks.getMemoryServiceForProject.mockClear();
-  });
-
-  it('advertises optional projectPath on all memory tools', () => {
-    for (const tool of tools) {
-      expect(tool.inputSchema).toMatchObject({ type: 'object' });
-      const properties = tool.inputSchema.properties as Record<string, unknown>;
-      expect(properties.projectPath).toMatchObject({
-        type: 'string',
-        description: expect.stringContaining('project')
-      });
-    }
-  });
-
-  it('uses the project-scoped memory service when mem-search receives projectPath', async () => {
-    mocks.projectService.retrieveMemories.mockResolvedValue({
-      memories: [
-        {
-          score: 0.91,
-          event: {
-            id: 'event-project-1',
-            sessionId: 'session-a',
-            eventType: 'user_prompt',
-            timestamp: new Date('2026-05-05T00:00:00.000Z'),
-            content: 'project scoped memory result',
-            metadata: {}
-          }
-        }
-      ]
-    });
-
-    const result = await handleToolCall('mem-search', {
-      query: 'project scoped memory',
-      projectPath: '/repo/app',
-      topK: 7,
-      sessionId: 'session-a'
-    });
-
-    expect(result.isError).not.toBe(true);
-    expect(mocks.getMemoryServiceForProject).toHaveBeenCalledWith('/repo/app');
-    expect(mocks.getDefaultMemoryService).not.toHaveBeenCalled();
-    expect(mocks.projectService.initialize).toHaveBeenCalledTimes(1);
-    expect(mocks.projectService.retrieveMemories).toHaveBeenCalledWith('project scoped memory', {
-      topK: 7,
-      sessionId: 'session-a',
-      recordTrace: false
-    });
-    expect(result.content[0]?.text).toContain('project scoped memory result');
-  });
-
-  it('falls back to the global memory service when projectPath is absent', async () => {
-    await handleToolCall('mem-stats', {});
-
-    expect(mocks.getDefaultMemoryService).toHaveBeenCalledTimes(1);
-    expect(mocks.getMemoryServiceForProject).not.toHaveBeenCalled();
-    expect(mocks.defaultService.initialize).toHaveBeenCalledTimes(1);
-    expect(mocks.defaultService.getStats).toHaveBeenCalledTimes(1);
-  });
-});

package/tests/extensions/shared-memory-extension-boundary.test.ts

@@ -1,24 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-
-import {
-  createSharedMemoryServices as createFromExtension,
-  SharedMemoryServices as SharedMemoryServicesFromExtension
-} from '../../src/extensions/shared-memory/index.js';
-import {
-  createSharedMemoryServices as createFromCompat,
-  SharedMemoryServices as SharedMemoryServicesFromCompat
-} from '../../src/core/engine/shared-memory-services.js';
-
-describe('shared-memory extension boundary', () => {
-  it('keeps shared memory implementation under extensions with an engine compatibility re-export', () => {
-    const compatSource = readFileSync('src/core/engine/shared-memory-services.ts', 'utf8');
-    const implementationSource = readFileSync('src/extensions/shared-memory/shared-memory-services.ts', 'utf8');
-
-    expect(createFromCompat).toBe(createFromExtension);
-    expect(SharedMemoryServicesFromCompat).toBe(SharedMemoryServicesFromExtension);
-    expect(compatSource).toContain("../../extensions/shared-memory/index.js");
-    expect(implementationSource).not.toContain("../../core/embedder.js");
-    expect(implementationSource).toContain("../vector/index.js");
-  });
-});

package/tests/extensions/shared-memory-services.test.ts

@@ -1,309 +0,0 @@
-import * as path from 'path';
-import { describe, expect, it } from 'vitest';
-import {
-  createSharedMemoryServices,
-  type SharedMemoryServicesFactories
-} from '../../src/core/engine/shared-memory-services.js';
-import type { Embedder } from '../../src/core/embedder.js';
-import type { Retriever } from '../../src/core/retriever.js';
-import type { SharedEventStore } from '../../src/core/shared-event-store.js';
-import type { SharedPromoter } from '../../src/core/shared-promoter.js';
-import type { SharedStore } from '../../src/core/shared-store.js';
-import type { Entry, SharedStoreConfig, SharedTroubleshootingEntry } from '../../src/core/types.js';
-import type { SharedVectorStore } from '../../src/core/shared-vector-store.js';
-
-const enabledConfig: SharedStoreConfig = {
-  enabled: true,
-  autoPromote: true,
-  searchShared: true,
-  minConfidenceForPromotion: 0.8,
-  sharedStoragePath: '~/shared-memory'
-};
-
-function sharedEntry(entryId: string): SharedTroubleshootingEntry {
-  return {
-    entryId,
-    sourceProjectHash: 'project-a',
-    sourceEntryId: 'local-entry',
-    title: 'Shared troubleshooting entry',
-    symptoms: ['symptom'],
-    rootCause: 'root cause',
-    solution: 'solution',
-    topics: ['shared'],
-    technologies: ['typescript'],
-    confidence: 0.9,
-    usageCount: 0,
-    promotedAt: new Date('2026-03-01T00:00:00.000Z'),
-    createdAt: new Date('2026-03-01T00:00:00.000Z')
-  };
-}
-
-function makeHarness(options?: { existingPaths?: string[] }) {
-  const existing = new Set(options?.existingPaths ?? []);
-  const mkdirCalls: string[] = [];
-  const eventStoreInits: string[] = [];
-  const vectorStoreInits: string[] = [];
-  const closeCalls: string[] = [];
-  const sharedStoreGets: string[] = [];
-  const sharedStoreSearches: Array<{ query: string; options?: { topK?: number; minConfidence?: number } }> = [];
-  const promoteCalls: Array<{ entry: Entry; projectHash: string }> = [];
-  const setSharedStoresCalls: Array<{ store: SharedStore; vectorStore: SharedVectorStore }> = [];
-  const createdEventStorePaths: string[] = [];
-  const createdVectorStorePaths: string[] = [];
-  const createdPromoters: Array<{ store: SharedStore; vectorStore: SharedVectorStore; embedder: Embedder; config?: SharedStoreConfig }> = [];
-
-  const eventStore = {
-    initialize: async () => { eventStoreInits.push('event-store'); },
-    close: async () => { closeCalls.push('event-store'); }
-  } as unknown as SharedEventStore;
-  const sharedStore = {
-    get: async (entryId: string) => {
-      sharedStoreGets.push(entryId);
-      return sharedEntry(entryId);
-    },
-    getStats: async () => ({
-      total: 1,
-      averageConfidence: 0.9,
-      topTopics: [{ topic: 'shared', count: 1 }],
-      totalUsageCount: 2
-    }),
-    search: async (query: string, searchOptions?: { topK?: number; minConfidence?: number }) => {
-      sharedStoreSearches.push({ query, options: searchOptions });
-      return [sharedEntry('search-result')];
-    }
-  } as unknown as SharedStore;
-  const vectorStore = {
-    initialize: async () => { vectorStoreInits.push('vector-store'); }
-  } as unknown as SharedVectorStore;
-  const promoter = {
-    promoteEntry: async (entry: Entry, projectHash: string) => {
-      promoteCalls.push({ entry, projectHash });
-      return { success: true, entryId: 'shared-promoted' };
-    }
-  } as unknown as SharedPromoter;
-  const embedder = { marker: 'embedder' } as unknown as Embedder;
-  const retriever = {
-    setSharedStores(store: SharedStore, sharedVectorStore: SharedVectorStore) {
-      setSharedStoresCalls.push({ store, vectorStore: sharedVectorStore });
-    }
-  } as unknown as Retriever;
-
-  const factories: SharedMemoryServicesFactories = {
-    existsSync: (targetPath: string) => existing.has(targetPath),
-    mkdirSync: (targetPath: string) => {
-      mkdirCalls.push(targetPath);
-      existing.add(targetPath);
-    },
-    createSharedEventStore: (dbPath: string) => {
-      createdEventStorePaths.push(dbPath);
-      return eventStore;
-    },
-    createSharedStore: (createdEventStore: SharedEventStore) => {
-      expect(createdEventStore).toBe(eventStore);
-      return sharedStore;
-    },
-    createSharedVectorStore: (dbPath: string) => {
-      createdVectorStorePaths.push(dbPath);
-      return vectorStore;
-    },
-    createSharedPromoter: (createdStore, createdVectorStore, createdEmbedder, config) => {
-      createdPromoters.push({
-        store: createdStore,
-        vectorStore: createdVectorStore,
-        embedder: createdEmbedder,
-        config
-      });
-      return promoter;
-    }
-  };
-
-  return {
-    factories,
-    embedder,
-    retriever,
-    eventStore,
-    sharedStore,
-    vectorStore,
-    promoter,
-    mkdirCalls,
-    eventStoreInits,
-    vectorStoreInits,
-    closeCalls,
-    sharedStoreGets,
-    sharedStoreSearches,
-    promoteCalls,
-    setSharedStoresCalls,
-    createdEventStorePaths,
-    createdVectorStorePaths,
-    createdPromoters
-  };
-}
-
-describe('createSharedMemoryServices', () => {
-  it('owns writable shared-store initialization and connects the retriever', async () => {
-    const harness = makeHarness();
-    const services = createSharedMemoryServices({
-      config: enabledConfig,
-      defaultSharedStoragePath: '/default/shared',
-      readOnly: false,
-      expandPath: (input) => input.replace('~', '/home/tester'),
-      embedder: harness.embedder,
-      retriever: harness.retriever,
-      factories: harness.factories
-    });
-
-    await services.initialize();
-
-    expect(services.getSharedStoragePath()).toBe('/home/tester/shared-memory');
-    expect(harness.mkdirCalls).toEqual(['/home/tester/shared-memory']);
-    expect(harness.createdEventStorePaths).toEqual([path.join('/home/tester/shared-memory', 'shared.duckdb')]);
-    expect(harness.eventStoreInits).toEqual(['event-store']);
-    expect(services.eventStore).toBe(harness.eventStore);
-    expect(services.store).toBe(harness.sharedStore);
-    expect(harness.createdVectorStorePaths).toEqual([path.join('/home/tester/shared-memory', 'vectors')]);
-    expect(harness.vectorStoreInits).toEqual(['vector-store']);
-    expect(services.vectorStore).toBe(harness.vectorStore);
-    expect(services.promoter).toBe(harness.promoter);
-    expect(harness.createdPromoters).toEqual([{
-      store: harness.sharedStore,
-      vectorStore: harness.vectorStore,
-      embedder: harness.embedder,
-      config: enabledConfig
-    }]);
-    expect(harness.setSharedStoresCalls).toEqual([{
-      store: harness.sharedStore,
-      vectorStore: harness.vectorStore
-    }]);
-  });
-
-  it('opens only the shared event/store pair for disclosure reads', async () => {
-    const harness = makeHarness({ existingPaths: ['/existing/shared'] });
-    const services = createSharedMemoryServices({
-      config: { ...enabledConfig, sharedStoragePath: '/existing/shared' },
-      defaultSharedStoragePath: '/default/shared',
-      readOnly: true,
-      expandPath: (input) => input,
-      embedder: harness.embedder,
-      retriever: harness.retriever,
-      factories: harness.factories
-    });
-
-    const store = await services.ensureStoreForRead();
-    const entry = await services.getEntryForDisclosure('shared-entry-1');
-
-    expect(store).toBe(harness.sharedStore);
-    expect(entry).toMatchObject({ entryId: 'shared-entry-1', sourceProjectHash: 'project-a' });
-    expect(harness.sharedStoreGets).toEqual(['shared-entry-1']);
-    expect(harness.mkdirCalls).toEqual([]);
-    expect(harness.createdEventStorePaths).toEqual([path.join('/existing/shared', 'shared.duckdb')]);
-    expect(harness.eventStoreInits).toEqual(['event-store']);
-    expect(harness.createdVectorStorePaths).toEqual([]);
-    expect(harness.vectorStoreInits).toEqual([]);
-    expect(harness.createdPromoters).toEqual([]);
-    expect(harness.setSharedStoresCalls).toEqual([]);
-  });
-
-  it('does not create missing shared storage during read-only disclosure reads', async () => {
-    const harness = makeHarness();
-    const services = createSharedMemoryServices({
-      config: enabledConfig,
-      defaultSharedStoragePath: '/default/shared',
-      readOnly: true,
-      expandPath: (input) => input.replace('~', '/home/tester'),
-      embedder: harness.embedder,
-      retriever: harness.retriever,
-      factories: harness.factories
-    });
-
-    await expect(services.ensureStoreForRead()).resolves.toBeNull();
-    await expect(services.getEntryForDisclosure('missing')).resolves.toBeNull();
-
-    expect(harness.mkdirCalls).toEqual([]);
-    expect(harness.createdEventStorePaths).toEqual([]);
-    expect(harness.createdVectorStorePaths).toEqual([]);
-    expect(harness.createdPromoters).toEqual([]);
-    expect(harness.setSharedStoresCalls).toEqual([]);
-  });
-
-  it('delegates promotion, stats, and shared search through the initialized store', async () => {
-    const harness = makeHarness();
-    const services = createSharedMemoryServices({
-      config: enabledConfig,
-      defaultSharedStoragePath: '/default/shared',
-      readOnly: false,
-      expandPath: (input) => input,
-      embedder: harness.embedder,
-      retriever: harness.retriever,
-      factories: harness.factories
-    });
-    const entry = { id: 'entry-1', content: 'content' } as Entry;
-
-    await services.initialize();
-
-    await expect(services.promoteToShared(entry, 'project-a')).resolves.toEqual({
-      success: true,
-      entryId: 'shared-promoted'
-    });
-    await expect(services.getStats()).resolves.toEqual({
-      total: 1,
-      averageConfidence: 0.9,
-      topTopics: [{ topic: 'shared', count: 1 }],
-      totalUsageCount: 2
-    });
-    await expect(services.search('timeout', { topK: 3, minConfidence: 0.7 })).resolves.toMatchObject([
-      { entryId: 'search-result' }
-    ]);
-    expect(harness.promoteCalls).toEqual([{ entry, projectHash: 'project-a' }]);
-    expect(harness.sharedStoreSearches).toEqual([
-      { query: 'timeout', options: { topK: 3, minConfidence: 0.7 } }
-    ]);
-  });
-
-  it('keeps disabled shared-store configuration inert', async () => {
-    const harness = makeHarness();
-    const services = createSharedMemoryServices({
-      config: { ...enabledConfig, enabled: false },
-      defaultSharedStoragePath: '/default/shared',
-      readOnly: false,
-      expandPath: (input) => input,
-      embedder: harness.embedder,
-      retriever: harness.retriever,
-      factories: harness.factories
-    });
-
-    await services.initialize();
-
-    await expect(services.ensureStoreForRead()).resolves.toBeNull();
-    await expect(services.getEntryForDisclosure('shared-entry')).resolves.toBeNull();
-    await expect(services.getStats()).resolves.toBeNull();
-    await expect(services.search('timeout')).resolves.toEqual([]);
-    await expect(services.promoteToShared({ id: 'entry-1', content: 'content' } as Entry, 'project-a'))
-      .resolves.toMatchObject({ success: false });
-    expect(services.isEnabled()).toBe(false);
-    expect(harness.mkdirCalls).toEqual([]);
-    expect(harness.createdEventStorePaths).toEqual([]);
-    expect(harness.createdVectorStorePaths).toEqual([]);
-    expect(harness.createdPromoters).toEqual([]);
-    expect(harness.setSharedStoresCalls).toEqual([]);
-  });
-
-  it('closes the shared event store when one was opened', async () => {
-    const harness = makeHarness({ existingPaths: ['/existing/shared'] });
-    const services = createSharedMemoryServices({
-      config: { ...enabledConfig, sharedStoragePath: '/existing/shared' },
-      defaultSharedStoragePath: '/default/shared',
-      readOnly: true,
-      expandPath: (input) => input,
-      embedder: harness.embedder,
-      retriever: harness.retriever,
-      factories: harness.factories
-    });
-
-    await services.ensureStoreForRead();
-    await services.close();
-
-    expect(harness.closeCalls).toEqual(['event-store']);
-    expect(services.eventStore).toBeNull();
-    expect(services.store).toBeNull();
-  });
-});

package/tests/extensions/vector-extension-boundary.test.ts

@@ -1,21 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-
-import {
-  Embedder as EmbedderFromExtension,
-  getDefaultEmbedder as getDefaultEmbedderFromExtension
-} from '../../src/extensions/vector/index.js';
-import {
-  Embedder as EmbedderFromCompat,
-  getDefaultEmbedder as getDefaultEmbedderFromCompat
-} from '../../src/core/embedder.js';
-
-describe('vector extension boundary', () => {
-  it('keeps Embedder implementation under extensions with a core compatibility re-export', () => {
-    const compatSource = readFileSync('src/core/embedder.ts', 'utf8');
-
-    expect(EmbedderFromCompat).toBe(EmbedderFromExtension);
-    expect(getDefaultEmbedderFromCompat).toBe(getDefaultEmbedderFromExtension);
-    expect(compatSource).toContain("../extensions/vector/index.js");
-  });
-});

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests"]
-}

package/vitest.config.ts

@@ -1,15 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['tests/**/*.test.ts'],
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'json', 'html'],
-      include: ['src/**/*.ts'],
-      exclude: ['src/**/*.d.ts']
-    }
-  }
-});