claude-memory-layer 1.0.27 → 1.0.29

package/tests/apps/postinstall-embedding-backend.test.ts

@@ -0,0 +1,167 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createRequire } from 'node:module';
+
+import { describe, expect, it } from 'vitest';
+
+const require = createRequire(import.meta.url);
+
+type SpawnCall = {
+  cmd: string;
+  args: string[];
+  env: NodeJS.ProcessEnv;
+};
+
+type PostinstallEmbeddingBackend = {
+  EMBEDDING_BACKEND_PACKAGE: string;
+  parseCudaMajor(output: string): number | null;
+  shouldAttemptAutoInstall(input: {
+    platform: NodeJS.Platform;
+    arch: string;
+    cudaMajor: number | null;
+    transformersAvailable: boolean;
+    skipRequested: boolean;
+  }): boolean;
+  createRepairEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+  createNpmInstallArgs(): string[];
+  runPostinstall(input?: {
+    rootDir?: string;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    arch?: string;
+    execFileSyncImpl?: () => string;
+    spawnSyncImpl?: (cmd: string, args: string[], options: { env: NodeJS.ProcessEnv }) => { status: number };
+    log?: () => void;
+    warn?: () => void;
+  }): { attempted: boolean; success?: boolean; cudaMajor: number | null; transformersAvailable: boolean; skipRequested: boolean };
+};
+
+function loadPostinstallModule(): PostinstallEmbeddingBackend {
+  return require('../../scripts/postinstall-embedding-backend.cjs') as PostinstallEmbeddingBackend;
+}
+
+describe('embedding backend postinstall repair', () => {
+  it('keeps the install-time embedding backend optional and registers postinstall repair', () => {
+    const pkg = JSON.parse(readFileSync('package.json', 'utf-8')) as {
+      scripts: Record<string, string>;
+      dependencies?: Record<string, string>;
+      optionalDependencies?: Record<string, string>;
+    };
+
+    expect(pkg.dependencies).not.toHaveProperty('@huggingface/transformers');
+    expect(pkg.optionalDependencies).toMatchObject({
+      '@huggingface/transformers': '^3.8.1'
+    });
+    expect(pkg.scripts.postinstall).toBe('node scripts/postinstall-embedding-backend.cjs');
+  });
+
+  it('detects CUDA major version from nvcc output', () => {
+    const postinstall = loadPostinstallModule();
+
+    expect(postinstall.parseCudaMajor('Cuda compilation tools, release 11.8, V11.8.89')).toBe(11);
+    expect(postinstall.parseCudaMajor('Cuda compilation tools, release 12.4, V12.4.131')).toBe(12);
+    expect(postinstall.parseCudaMajor('nvcc: NVIDIA (R) Cuda compiler driver')).toBeNull();
+  });
+
+  it('only auto-installs the embedding backend for Linux x64 CUDA 11 when it is missing', () => {
+    const postinstall = loadPostinstallModule();
+
+    expect(postinstall.shouldAttemptAutoInstall({
+      platform: 'linux',
+      arch: 'x64',
+      cudaMajor: 11,
+      transformersAvailable: false,
+      skipRequested: false
+    })).toBe(true);
+
+    expect(postinstall.shouldAttemptAutoInstall({
+      platform: 'linux',
+      arch: 'x64',
+      cudaMajor: 11,
+      transformersAvailable: true,
+      skipRequested: false
+    })).toBe(false);
+
+    expect(postinstall.shouldAttemptAutoInstall({
+      platform: 'linux',
+      arch: 'arm64',
+      cudaMajor: 11,
+      transformersAvailable: false,
+      skipRequested: false
+    })).toBe(false);
+
+    expect(postinstall.shouldAttemptAutoInstall({
+      platform: 'darwin',
+      arch: 'x64',
+      cudaMajor: 11,
+      transformersAvailable: false,
+      skipRequested: false
+    })).toBe(false);
+
+    expect(postinstall.shouldAttemptAutoInstall({
+      platform: 'linux',
+      arch: 'x64',
+      cudaMajor: 12,
+      transformersAvailable: false,
+      skipRequested: false
+    })).toBe(false);
+
+    expect(postinstall.shouldAttemptAutoInstall({
+      platform: 'linux',
+      arch: 'x64',
+      cudaMajor: 11,
+      transformersAvailable: false,
+      skipRequested: true
+    })).toBe(false);
+  });
+
+  it('repairs missing transformers with CPU-only onnxruntime install settings', () => {
+    const postinstall = loadPostinstallModule();
+
+    expect(postinstall.createRepairEnv({})).toMatchObject({
+      ONNXRUNTIME_NODE_INSTALL_CUDA: 'skip',
+      CLAUDE_MEMORY_LAYER_EMBEDDING_POSTINSTALL_REPAIR: '1'
+    });
+    expect(postinstall.createNpmInstallArgs()).toEqual([
+      'install',
+      '--no-save',
+      '--no-package-lock',
+      '--omit=dev',
+      postinstall.EMBEDDING_BACKEND_PACKAGE
+    ]);
+  });
+
+  it('runs the automatic repair command when Linux x64 CUDA 11 skipped the optional backend', () => {
+    const postinstall = loadPostinstallModule();
+    const rootDir = mkdtempSync(join(tmpdir(), 'cml-postinstall-test-'));
+    const calls: SpawnCall[] = [];
+
+    try {
+      writeFileSync(join(rootDir, 'package.json'), JSON.stringify({ name: 'claude-memory-layer-install-root' }));
+
+      const result = postinstall.runPostinstall({
+        rootDir,
+        env: {},
+        platform: 'linux',
+        arch: 'x64',
+        execFileSyncImpl: () => 'Cuda compilation tools, release 11.8, V11.8.89',
+        spawnSyncImpl: (cmd, args, options) => {
+          calls.push({ cmd, args, env: options.env });
+          return { status: 0 };
+        },
+        log: () => undefined,
+        warn: () => undefined
+      });
+
+      expect(result).toMatchObject({ attempted: true, success: true, cudaMajor: 11, transformersAvailable: false });
+      expect(calls).toHaveLength(1);
+      expect(calls[0]?.cmd).toBe('npm');
+      expect(calls[0]?.args).toEqual(postinstall.createNpmInstallArgs());
+      expect(calls[0]?.env.ONNXRUNTIME_NODE_INSTALL_CUDA).toBe('skip');
+      expect(calls[0]?.env.CLAUDE_MEMORY_LAYER_EMBEDDING_POSTINSTALL_REPAIR).toBe('1');
+    } finally {
+      rmSync(rootDir, { recursive: true, force: true });
+    }
+  });
+});

package/tests/apps/search-api-disclosure.test.ts

@@ -0,0 +1,162 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Hono } from 'hono';
+
+const mocks = vi.hoisted(() => {
+  const service = {
+    initialize: vi.fn(),
+    shutdown: vi.fn(),
+    retrieveMemories: vi.fn(),
+    searchDisclosure: vi.fn(),
+    expandDisclosure: vi.fn(),
+    sourceDisclosure: vi.fn()
+  };
+
+  const lightweightService = {
+    initialize: vi.fn(),
+    shutdown: vi.fn(),
+    searchDisclosure: vi.fn()
+  };
+
+  return {
+    service,
+    lightweightService,
+    getServiceFromQuery: vi.fn(() => service),
+    getLightweightServiceFromQuery: vi.fn(() => lightweightService)
+  };
+});
+
+vi.mock('../../src/apps/server/api/utils.js', () => ({
+  getServiceFromQuery: mocks.getServiceFromQuery,
+  getLightweightServiceFromQuery: mocks.getLightweightServiceFromQuery
+}));
+
+const { searchRouter } = await import('../../src/server/api/search.js');
+
+function createApp() {
+  const app = new Hono();
+  app.route('/api/search', searchRouter);
+  return app;
+}
+
+describe('search disclosure API', () => {
+  beforeEach(() => {
+    mocks.service.initialize.mockReset().mockResolvedValue(undefined);
+    mocks.service.shutdown.mockReset().mockResolvedValue(undefined);
+    mocks.service.retrieveMemories.mockReset();
+    mocks.service.searchDisclosure.mockReset();
+    mocks.service.expandDisclosure.mockReset();
+    mocks.service.sourceDisclosure.mockReset();
+    mocks.lightweightService.initialize.mockReset().mockResolvedValue(undefined);
+    mocks.lightweightService.shutdown.mockReset().mockResolvedValue(undefined);
+    mocks.lightweightService.searchDisclosure.mockReset();
+    mocks.getServiceFromQuery.mockClear();
+    mocks.getLightweightServiceFromQuery.mockClear();
+  });
+
+  it('POST /api/search/disclosure delegates to MemoryService.searchDisclosure', async () => {
+    const responseBody = {
+      results: [{ id: 'event:e1', resultType: 'source', snippet: 'checkout fix', score: 0.91, reasons: ['semantic_match'], sourceRef: 'event:e1' }],
+      meta: { total: 1, usedVector: true, usedKeyword: true, fallbackApplied: false }
+    };
+    mocks.service.searchDisclosure.mockResolvedValue(responseBody);
+
+    const res = await createApp().request('/api/search/disclosure?project=abc12345', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query: 'checkout fix', options: { topK: 3, includeShared: true } })
+    });
+
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual(responseBody);
+    expect(mocks.getServiceFromQuery).toHaveBeenCalledTimes(1);
+    expect(mocks.service.initialize).toHaveBeenCalledTimes(1);
+    expect(mocks.service.searchDisclosure).toHaveBeenCalledWith('checkout fix', { topK: 3, includeShared: true });
+    expect(mocks.service.shutdown).toHaveBeenCalledTimes(1);
+  });
+
+
+  it('POST /api/search/disclosure uses lightweight service for explicit fast search', async () => {
+    const responseBody = {
+      results: [{ id: 'event:e1', resultType: 'source', snippet: 'checkout fix', score: 0.91, reasons: ['keyword_match'], sourceRef: 'event:e1' }],
+      meta: { total: 1, usedVector: false, usedKeyword: true, fallbackApplied: false }
+    };
+    mocks.lightweightService.searchDisclosure.mockResolvedValue(responseBody);
+
+    const res = await createApp().request('/api/search/disclosure?project=abc12345', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query: 'checkout fix', options: { topK: 3, strategy: 'fast', includeShared: true } })
+    });
+
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual(responseBody);
+    expect(mocks.getLightweightServiceFromQuery).toHaveBeenCalledTimes(1);
+    expect(mocks.getServiceFromQuery).not.toHaveBeenCalled();
+    expect(mocks.lightweightService.initialize).toHaveBeenCalledTimes(1);
+    expect(mocks.lightweightService.searchDisclosure).toHaveBeenCalledWith('checkout fix', { topK: 3, strategy: 'fast', includeShared: true });
+    expect(mocks.lightweightService.shutdown).toHaveBeenCalledTimes(1);
+    expect(mocks.service.initialize).not.toHaveBeenCalled();
+    expect(mocks.service.searchDisclosure).not.toHaveBeenCalled();
+  });
+
+  it('POST /api/search/disclosure rejects missing query', async () => {
+    const res = await createApp().request('/api/search/disclosure', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ options: { topK: 3 } })
+    });
+
+    expect(res.status).toBe(400);
+    expect(await res.json()).toEqual({ error: 'Query is required' });
+    expect(mocks.getServiceFromQuery).not.toHaveBeenCalled();
+    expect(mocks.getLightweightServiceFromQuery).not.toHaveBeenCalled();
+    expect(mocks.service.searchDisclosure).not.toHaveBeenCalled();
+    expect(mocks.service.shutdown).not.toHaveBeenCalled();
+  });
+
+  it('GET /api/search/disclosure/:resultId/expand expands a disclosure result', async () => {
+    const responseBody = {
+      target: { id: 'event:e1', resultType: 'source', snippet: 'checkout fix', score: 1, reasons: ['continuity_link'] },
+      surroundingFacts: [],
+      relatedSources: [{ sourceRef: 'event:e1', sourceType: 'raw_event', eventIds: ['e1'] }]
+    };
+    mocks.service.expandDisclosure.mockResolvedValue(responseBody);
+
+    const res = await createApp().request('/api/search/disclosure/event:e1/expand?windowSize=2');
+
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual(responseBody);
+    expect(mocks.service.initialize).not.toHaveBeenCalled();
+    expect(mocks.service.expandDisclosure).toHaveBeenCalledWith('event:e1', { windowSize: 2 });
+    expect(mocks.service.shutdown).toHaveBeenCalledTimes(1);
+  });
+
+  it('GET /api/search/disclosure/:resultId/source resolves a disclosure result source', async () => {
+    const responseBody = {
+      sourceRef: 'event:e1',
+      sourceType: 'raw_event',
+      eventIds: ['e1'],
+      rawEvents: [{ id: 'e1', content: 'checkout fix' }]
+    };
+    mocks.service.sourceDisclosure.mockResolvedValue(responseBody);
+
+    const res = await createApp().request('/api/search/disclosure/event:e1/source');
+
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual(responseBody);
+    expect(mocks.service.initialize).not.toHaveBeenCalled();
+    expect(mocks.service.sourceDisclosure).toHaveBeenCalledWith('event:e1');
+    expect(mocks.service.shutdown).toHaveBeenCalledTimes(1);
+  });
+
+  it('GET /api/search/disclosure/:resultId/source returns 404 when source is missing', async () => {
+    mocks.service.sourceDisclosure.mockResolvedValue(null);
+
+    const res = await createApp().request('/api/search/disclosure/event:missing/source');
+
+    expect(res.status).toBe(404);
+    expect(await res.json()).toEqual({ error: 'Source not found' });
+    expect(mocks.service.initialize).not.toHaveBeenCalled();
+    expect(mocks.service.shutdown).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/apps/stats-api-lightweight.test.ts

@@ -0,0 +1,67 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Hono } from 'hono';
+
+const mocks = vi.hoisted(() => {
+  const service = {
+    initialize: vi.fn(),
+    shutdown: vi.fn(),
+    getStats: vi.fn(),
+    getRecentEvents: vi.fn(),
+    getRetrievalTraceStats: vi.fn()
+  };
+
+  return {
+    service,
+    getServiceFromQuery: vi.fn(),
+    getLightweightServiceFromQuery: vi.fn(() => service)
+  };
+});
+
+vi.mock('../../src/apps/server/api/utils.js', () => ({
+  getServiceFromQuery: mocks.getServiceFromQuery,
+  getLightweightServiceFromQuery: mocks.getLightweightServiceFromQuery
+}));
+
+vi.mock('../../src/services/memory-service.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../src/services/memory-service.js')>();
+  return {
+    ...actual,
+    getMemoryServiceForProject: vi.fn(() => mocks.service)
+  };
+});
+
+const { statsRouter } = await import('../../src/server/api/stats.js');
+
+function createApp() {
+  const app = new Hono();
+  app.route('/api/stats', statsRouter);
+  return app;
+}
+
+describe('stats API lightweight read paths', () => {
+  beforeEach(() => {
+    mocks.service.initialize.mockReset().mockResolvedValue(undefined);
+    mocks.service.shutdown.mockReset().mockResolvedValue(undefined);
+    mocks.service.getStats.mockReset().mockResolvedValue({ totalEvents: 2, vectorCount: 0, levelStats: [] });
+    mocks.service.getRecentEvents.mockReset().mockResolvedValue([
+      { id: 'e1', eventType: 'user_prompt', sessionId: 's1', timestamp: new Date('2026-05-01T00:00:00.000Z'), content: 'prompt', metadata: {} },
+      { id: 'e2', eventType: 'agent_response', sessionId: 's1', timestamp: new Date('2026-05-01T00:01:00.000Z'), content: 'response', metadata: {} }
+    ]);
+    mocks.service.getRetrievalTraceStats.mockReset().mockResolvedValue({ totalQueries: 0, avgCandidateCount: 0, avgSelectedCount: 0, selectionRate: 0 });
+    mocks.getServiceFromQuery.mockClear();
+    mocks.getLightweightServiceFromQuery.mockClear();
+  });
+
+  it('GET /api/stats uses the lightweight read-only service instead of full initialization service', async () => {
+    const res = await createApp().request('/api/stats?project=abc12345');
+
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.storage).toEqual({ eventCount: 2, vectorCount: 0 });
+    expect(body.sessions).toEqual({ total: 1 });
+    expect(mocks.getLightweightServiceFromQuery).toHaveBeenCalledTimes(1);
+    expect(mocks.getServiceFromQuery).not.toHaveBeenCalled();
+    expect(mocks.service.initialize).toHaveBeenCalledTimes(1);
+    expect(mocks.service.shutdown).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/apps/ui-disclosure-output.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import * as vm from 'node:vm';
+
+class TestElement {
+  innerHTML = '';
+  textContent = '';
+  style: Record<string, string> = {};
+  disabled = false;
+  classList = { add() {}, remove() {}, toggle() {} };
+  dataset: Record<string, string> = {};
+  options: unknown[] = [];
+  addEventListener() {}
+  querySelectorAll() { return []; }
+  appendChild() {}
+}
+
+function loadDashboardWithElements(elements: Record<string, TestElement>) {
+  const dashboardDir = join(process.cwd(), 'src/apps/dashboard/assets/js');
+  const source = ['state.js', 'views.js', 'disclosure.js']
+    .map(file => readFileSync(join(dashboardDir, file), 'utf-8'))
+    .join('\n');
+  const context = {
+    console,
+    URL,
+    fetch: async () => ({ ok: true, json: async () => ({}) }),
+    window: { location: { origin: 'http://localhost:37777' } },
+    document: {
+      addEventListener() {},
+      getElementById(id: string) { return elements[id] ?? null; },
+      querySelectorAll() { return []; },
+      querySelector() { return null; },
+      createElement() { return new TestElement(); }
+    },
+    setTimeout,
+    clearTimeout
+  };
+
+  vm.runInNewContext(
+    `${source}\n;globalThis.__dashboardTestHooks = { state, renderDisclosureResults, renderDisclosureDrilldown };`,
+    context
+  );
+  return (context as unknown as { __dashboardTestHooks: {
+    state: Record<string, any>;
+    renderDisclosureResults: () => void;
+    renderDisclosureDrilldown: () => void;
+  }}).__dashboardTestHooks;
+}
+
+describe('dashboard retrieval disclosure provenance output', () => {
+  it('renders shared search results with source/project/topics provenance', () => {
+    const elements = { 'disclosure-results': new TestElement() };
+    const hooks = loadDashboardWithElements(elements);
+
+    hooks.state.isDisclosureLoading = false;
+    hooks.state.disclosureSelectedId = 'shared:shared-1';
+    hooks.state.disclosureMeta = { total: 1, usedVector: true, usedKeyword: true, fallbackApplied: false };
+    hooks.state.disclosureResults = [
+      {
+        id: 'shared:shared-1',
+        resultType: 'rule',
+        title: 'Shared checkout troubleshooting',
+        snippet: 'clear cache and retry',
+        score: 0.88,
+        reasons: ['semantic_match'],
+        sourceRef: 'shared:shared-1',
+        metadata: {
+          sourceProjectHash: 'project-a',
+          sourceEntryId: 'e-shared',
+          topics: ['checkout']
+        }
+      }
+    ];
+
+    hooks.renderDisclosureResults();
+
+    const html = elements['disclosure-results'].innerHTML;
+    expect(html).toContain('shared:shared-1');
+    expect(html).toContain('Shared checkout troubleshooting');
+    expect(html).toContain('sourceProjectHash');
+    expect(html).toContain('project-a');
+    expect(html).toContain('topics');
+    expect(html).toContain('checkout');
+  });
+
+  it('renders shared drilldown with explicit source metadata and no fake raw event', () => {
+    const elements = { 'disclosure-drilldown': new TestElement() };
+    const hooks = loadDashboardWithElements(elements);
+
+    hooks.state.disclosureSelectedId = 'shared:shared-1';
+    hooks.state.disclosureExpansion = {
+      target: {
+        id: 'shared:shared-1',
+        resultType: 'rule',
+        title: 'Shared checkout troubleshooting',
+        snippet: 'clear cache and retry',
+        score: 0.88,
+        reasons: ['semantic_match'],
+        sourceRef: 'shared:shared-1',
+        metadata: { sourceProjectHash: 'project-a', sourceEntryId: 'e-shared', topics: ['checkout'] }
+      },
+      relatedSources: [
+        {
+          sourceRef: 'shared:shared-1',
+          sourceType: 'shared_troubleshooting',
+          eventIds: [],
+          metadata: { sourceProjectHash: 'project-a', sourceEntryId: 'e-shared', topics: ['checkout'] }
+        }
+      ],
+      expandedContext: '[shared_troubleshooting] Shared checkout troubleshooting\nRoot cause: stale cache\nSolution: clear cache and retry'
+    };
+    hooks.state.disclosureSource = {
+      sourceRef: 'shared:shared-1',
+      sourceType: 'shared_troubleshooting',
+      eventIds: [],
+      rawEvents: [],
+      metadata: {
+        sourceProjectHash: 'project-a',
+        sourceEntryId: 'e-shared',
+        topics: ['checkout'],
+        rootCause: 'stale cache',
+        solution: 'clear cache and retry'
+      }
+    };
+
+    hooks.renderDisclosureDrilldown();
+
+    const html = elements['disclosure-drilldown'].innerHTML;
+    expect(html).toContain('shared_troubleshooting');
+    expect(html).toContain('Shared source provenance');
+    expect(html).toContain('sourceProjectHash');
+    expect(html).toContain('project-a');
+    expect(html).toContain('rootCause');
+    expect(html).toContain('stale cache');
+    expect(html).toContain('solution');
+    expect(html).toContain('clear cache and retry');
+    expect(html).toContain('No local raw events for this shared source.');
+  });
+});

package/tests/{bootstrap-organizer.test.ts → core/bootstrap-organizer.test.ts}

@@ -3,7 +3,7 @@ import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { execSync } from 'node:child_process';
-import { bootstrapKnowledgeBase } from '../src/services/bootstrap-organizer.js';
+import { bootstrapKnowledgeBase } from '../../src/services/bootstrap-organizer.js';
 
 async function makeTempRepo(): Promise<string> {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'cml-bootstrap-'));

package/tests/{canonical-key.test.ts → core/canonical-key.test.ts}

@@ -8,7 +8,7 @@ import {
   isSameCanonicalKey,
   makeDedupeKey,
   hashContent
-} from '../src/core/canonical-key.js';
+} from '../../src/core/canonical-key.js';
 
 describe('makeCanonicalKey', () => {
   it('should normalize to lowercase', () => {