claude-memory-layer 1.0.27 → 1.0.29

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

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

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

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

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

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

@@ -0,0 +1,21 @@
+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/.claude/settings.local.json

@@ -1,25 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(curl -s http://localhost:37777/api/stats | python3 -m json.tool 2>/dev/null || curl -s http://localhost:37777/api/stats)",
-      "Bash(curl -s http://localhost:37777/api/projects | python3 -m json.tool 2>/dev/null | head -60)",
-      "Bash(curl -s \"http://localhost:37777/api/retrievals?project=f4d5c120&limit=10\" | python3 -m json.tool 2>/dev/null | head -60)",
-      "Bash(curl -s \"http://localhost:37777/api/stats/retrieval-traces?project=f4d5c120&limit=5\" | python3 -m json.tool 2>/dev/null | head -30)",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/health?project=f4d5c120\" | python3 -m json.tool)",
-      "WebFetch(domain:be2f-222-112-203-51.ngrok-free.app)",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/stats?projectId=f4d5c120\" | jq .)",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/stats\" | jq .)",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/sessions?projectId=f4d5c120&limit=5\" | jq .)",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/retrieval-traces?projectId=f4d5c120&limit=20\" | jq .)",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/events?projectId=f4d5c120&eventType=session_summary&limit=20\")",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/events?projectId=f4d5c120&limit=20\")",
-      "Bash(curl -s -H \"Accept: application/json\" \"https://be2f-222-112-203-51.ngrok-free.app/api/retrieval-traces?projectId=f4d5c120&limit=20\" | head -100)",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/events?projectId=f4d5c120&limit=30\" 2>&1 | jq -r '.eventsByType' 2>/dev/null || echo \"Parse failed, checking raw output:\")",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/events?projectId=f4d5c120&limit=50\" | jq '.events[] | select\\(.eventType == \"retrieval_trace\"\\) | {id, eventType, timestamp, metadata}' | head -100)",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/events?projectId=f4d5c120&limit=100\" | jq '{total, eventCount: \\(.events | length\\), eventTypes: \\(.events | group_by\\(.eventType\\) | map\\({type: .[0].eventType, count: length}\\) | sort_by\\(-.count\\)\\)}')",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/stats?projectId=f4d5c120\" | jq '.')",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/sessions?projectId=f4d5c120&limit=10\" | jq '{total, sessionCount: \\(.sessions | length\\), recentSessions: .sessions[0:3]}')",
-      "Bash(curl -s \"https://be2f-222-112-203-51.ngrok-free.app/api/events?projectId=f4d5c120&limit=200\" | jq '{total, eventCount: \\(.events | length\\), allEventTypes: \\(.events | group_by\\(.eventType\\) | map\\({type: .[0].eventType, count: length}\\) | sort_by\\(-.count\\)\\), hasRetrievalTraces: \\(.events | map\\(select\\(.eventType == \"retrieval_trace\"\\)\\) | length > 0\\)}')"
-    ]
-  }
-}

package/.npm-cache/_cacache/index-v5/2b/9a/7f8f40206ed8a2e0a84efaa953ccaed1f5d001e14b931083f2e7a0738007

@@ -1,2 +0,0 @@
-
-ca0b85131c7d7e635e2aae558092cee8fd28ee30	{"key":"pacote:tarball:file:claude-memory-layer-1.0.14.tgz","integrity":"sha512-YCXS7NOc/HyrWDURYoFL53+TXG1kkcEMN0XUVtp92yEX/9kMEOU/48Dx7Ra0AzB4QVQ2NFBDmLFu5Oa23Y4MRQ==","time":1772107553766,"size":3945696}

package/.npm-cache/_cacache/index-v5/2e/d9/fcfa5c6a6abdc2a3644ab84a95936047298c465a2f47ee03db8f7fe1e946

@@ -1,3 +0,0 @@
-
-a778f258301662cd6e1f8150eef0e44f05546bc3	{"key":"pacote:tarball:file:/home/walter/workspace/opensource/claude-memory-layer","integrity":"sha512-BHbAmPiN/lhKK4CHC/90IbBdF9PZ7hAn93dyMyoi0/k6mlcQGihVEH9q2CB3qBi7qRKyvDF/I2G13bCa0oTZzg==","time":1772107493751,"size":1970687}
-76edaf7a5135175602d22662e8b30bf868b36394	{"key":"pacote:tarball:file:/home/walter/workspace/opensource/claude-memory-layer","integrity":"sha512-YCXS7NOc/HyrWDURYoFL53+TXG1kkcEMN0XUVtp92yEX/9kMEOU/48Dx7Ra0AzB4QVQ2NFBDmLFu5Oa23Y4MRQ==","time":1772107549550,"size":3945696}

package/.npm-cache/_cacache/index-v5/a9/42/e519633356d12d3d2f19da66a8301016d496c8f5c3e0554124aaa62dc043

@@ -1,2 +0,0 @@
-
-f70e2e3803de9e5b678f434a8b00019c0c5550f8	{"key":"pacote:tarball:file:../../../../home/walter/workspace/opensource/claude-memory-layer/claude-memory-layer-1.0.14.tgz","integrity":"sha512-YCXS7NOc/HyrWDURYoFL53+TXG1kkcEMN0XUVtp92yEX/9kMEOU/48Dx7Ra0AzB4QVQ2NFBDmLFu5Oa23Y4MRQ==","time":1772107553853,"size":3945696}