claude-memory-layer 1.0.31 → 1.0.33

package/tests/core/consolidation-worker.test.ts

@@ -1,75 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import { ConsolidationWorker } from '../../src/core/consolidation-worker.js';
-import type { EndlessModeConfig, MemoryEvent } from '../../src/core/types.js';
-
-function makeEvent(id: string, content: string, hoursAgo = 20): MemoryEvent {
-  return {
-    id,
-    eventType: 'user_prompt',
-    sessionId: 's1',
-    timestamp: new Date(Date.now() - hoursAgo * 60 * 60 * 1000),
-    content,
-    canonicalKey: id,
-    dedupeKey: id,
-    metadata: {},
-  };
-}
-
-describe('ConsolidationWorker hierarchy automation', () => {
-  it('creates consolidated memories, promotes rules, and returns cost-quality report', async () => {
-    const events = [
-      makeEvent('e1', 'implement auth bug fix and add tests for token refresh'),
-      makeEvent('e2', 'fix auth error in middleware and update tests'),
-      makeEvent('e3', 'auth feature update with regression test and bug notes'),
-      makeEvent('e4', 'implement retry logic for auth and fix issue with token cache'),
-      makeEvent('e5', 'add integration test for auth flow and bug reproduction'),
-    ];
-
-    const created: Array<{ memoryId: string; summary: string; topics: string[]; sourceEvents: string[]; confidence: number }> = [];
-    const rules: Array<{ rule: string; sourceMemoryIds: string[] }> = [];
-
-    const workingSetStore = {
-      async get() {
-        return { recentEvents: events, lastActivity: new Date(), continuityScore: 0.8 };
-      },
-      async prune(_ids: string[]) {
-        return;
-      }
-    };
-
-    const consolidatedStore = {
-      async isAlreadyConsolidated() { return false; },
-      async create(input: any) {
-        const memoryId = `m-${created.length + 1}`;
-        created.push({ memoryId, ...input });
-        return memoryId;
-      },
-      async get(memoryId: string) {
-        return created.find((m) => m.memoryId === memoryId) || null;
-      },
-      async hasRuleForSourceMemory() { return false; },
-      async createRule(input: any) {
-        rules.push({ rule: input.rule, sourceMemoryIds: input.sourceMemoryIds });
-        return `r-${rules.length}`;
-      }
-    };
-
-    const config: EndlessModeConfig = {
-      enabled: true,
-      workingSet: { maxEvents: 100, timeWindowHours: 24, minRelevanceScore: 0.5 },
-      consolidation: { triggerIntervalMs: 3600000, triggerEventCount: 3, triggerIdleMs: 1000, useLLMSummarization: false },
-      continuity: { minScoreForSeamless: 0.7, topicDecayHours: 48 }
-    };
-
-    const worker = new ConsolidationWorker(workingSetStore as any, consolidatedStore as any, config);
-    const out = await worker.forceRunWithReport();
-
-    expect(out.consolidatedCount).toBeGreaterThan(0);
-    expect(out.promotedRuleCount).toBeGreaterThan(0);
-    expect(out.report.beforeTokenEstimate).toBeGreaterThan(0);
-    expect(out.report.reductionRatio).toBeGreaterThanOrEqual(0);
-    expect(out.report.qualityGuardPassed).toBe(true);
-    expect(rules[0]?.sourceMemoryIds?.length).toBeGreaterThan(0);
-  });
-});

package/tests/core/embedding-maintenance-service.test.ts

@@ -1,282 +0,0 @@
-import * as path from 'path';
-import { describe, expect, it, vi } from 'vitest';
-
-import {
-  createEmbeddingMaintenanceService,
-  type EmbeddingMaintenanceFileSystem
-} from '../../src/core/engine/embedding-maintenance-service.js';
-
-function event(id: string, content = `content for ${id}`) {
-  return { id, content };
-}
-
-function createHarness(options?: {
-  currentModel?: string;
-  vectorCount?: number;
-  files?: Record<string, string>;
-  workerRunning?: boolean;
-  nullWorker?: boolean;
-  events?: Array<{ id: string; content: string }>;
-}) {
-  const storagePath = '/memory-root/project-a';
-  const metaPath = path.join(storagePath, 'embedding-meta.json');
-  const files = new Map<string, string>(Object.entries(options?.files ?? {}));
-  const calls: string[] = [];
-
-  const fileSystem: EmbeddingMaintenanceFileSystem = {
-    existsSync: vi.fn((targetPath: string) => files.has(targetPath)),
-    readFileSync: vi.fn((targetPath: string) => files.get(targetPath) ?? ''),
-    writeFileSync: vi.fn((targetPath: string, content: string) => {
-      files.set(targetPath, content);
-    })
-  };
-
-  const initialize = vi.fn(async () => {
-    calls.push('initialize');
-  });
-  const vectorStore = {
-    count: vi.fn(async () => options?.vectorCount ?? 0),
-    clearAll: vi.fn(async () => {
-      calls.push('clear-vectors');
-    })
-  };
-  const events = options?.events ?? [];
-  const eventStore = {
-    clearEmbeddingOutbox: vi.fn(async () => {
-      calls.push('clear-outbox');
-    }),
-    getEventsPage: vi.fn(async (limit: number, offset: number) => events.slice(offset, offset + limit)),
-    enqueueForEmbedding: vi.fn(async (eventId: string, _content: string) => {
-      calls.push(`enqueue:${eventId}`);
-    })
-  };
-  const worker = {
-    isRunning: vi.fn(() => options?.workerRunning ?? false),
-    stop: vi.fn(() => {
-      calls.push('stop-worker');
-    }),
-    start: vi.fn(() => {
-      calls.push('start-worker');
-    })
-  };
-
-  const service = createEmbeddingMaintenanceService({
-    storagePath,
-    initialize,
-    getEmbeddingModelName: vi.fn(() => options?.currentModel ?? 'embedding-model-a'),
-    vectorStore,
-    eventStore,
-    getVectorWorker: () => (options?.nullWorker ? null : worker),
-    fileSystem
-  });
-
-  return {
-    service,
-    storagePath,
-    metaPath,
-    files,
-    calls,
-    fileSystem,
-    initialize,
-    vectorStore,
-    eventStore,
-    worker
-  };
-}
-
-describe('EmbeddingMaintenanceService', () => {
-  it('initializes embedding metadata when no prior vectors exist', async () => {
-    const h = createHarness({ vectorCount: 0 });
-
-    const result = await h.service.ensureEmbeddingModelForImport();
-
-    expect(result).toEqual({
-      changed: false,
-      previousModel: null,
-      currentModel: 'embedding-model-a',
-      enqueued: 0,
-      reason: 'initialized-meta'
-    });
-    expect(h.initialize).toHaveBeenCalledTimes(1);
-    expect(h.vectorStore.count).toHaveBeenCalledTimes(1);
-    expect(h.vectorStore.clearAll).not.toHaveBeenCalled();
-    expect(h.eventStore.clearEmbeddingOutbox).not.toHaveBeenCalled();
-    expect(JSON.parse(h.files.get(h.metaPath)!)).toMatchObject({
-      model: 'embedding-model-a',
-      updatedAt: expect.any(String)
-    });
-  });
-
-  it('returns unchanged when stored metadata already matches the current model', async () => {
-    const metaPath = path.join('/memory-root/project-a', 'embedding-meta.json');
-    const h = createHarness({
-      vectorCount: 5,
-      files: {
-        [metaPath]: JSON.stringify({ model: 'embedding-model-a', updatedAt: '2026-05-02T00:00:00.000Z' })
-      }
-    });
-
-    const result = await h.service.ensureEmbeddingModelForImport();
-
-    expect(result).toEqual({
-      changed: false,
-      previousModel: 'embedding-model-a',
-      currentModel: 'embedding-model-a',
-      enqueued: 0
-    });
-    expect(h.fileSystem.writeFileSync).not.toHaveBeenCalled();
-    expect(h.vectorStore.clearAll).not.toHaveBeenCalled();
-    expect(h.eventStore.clearEmbeddingOutbox).not.toHaveBeenCalled();
-  });
-
-  it('reports a dry-run model mismatch without clearing vectors or outbox state', async () => {
-    const metaPath = path.join('/memory-root/project-a', 'embedding-meta.json');
-    const h = createHarness({
-      currentModel: 'embedding-model-b',
-      vectorCount: 2,
-      files: {
-        [metaPath]: JSON.stringify({ model: 'embedding-model-a' })
-      }
-    });
-
-    const result = await h.service.ensureEmbeddingModelForImport({ autoMigrate: false });
-
-    expect(result).toEqual({
-      changed: true,
-      previousModel: 'embedding-model-a',
-      currentModel: 'embedding-model-b',
-      enqueued: 0,
-      reason: 'model-mismatch'
-    });
-    expect(h.vectorStore.clearAll).not.toHaveBeenCalled();
-    expect(h.eventStore.clearEmbeddingOutbox).not.toHaveBeenCalled();
-    expect(h.eventStore.enqueueForEmbedding).not.toHaveBeenCalled();
-  });
-
-  it('reports legacy vectors without metadata as a dry-run migration requirement', async () => {
-    const h = createHarness({ vectorCount: 3 });
-
-    const result = await h.service.ensureEmbeddingModelForImport({ autoMigrate: false });
-
-    expect(result).toEqual({
-      changed: true,
-      previousModel: null,
-      currentModel: 'embedding-model-a',
-      enqueued: 0,
-      reason: 'legacy-vectors-without-meta'
-    });
-    expect(h.fileSystem.writeFileSync).not.toHaveBeenCalled();
-    expect(h.vectorStore.clearAll).not.toHaveBeenCalled();
-  });
-
-  it('migrates vectors by clearing indexes, re-enqueueing events, and restarting a running worker', async () => {
-    const metaPath = path.join('/memory-root/project-a', 'embedding-meta.json');
-    const h = createHarness({
-      currentModel: 'embedding-model-b',
-      vectorCount: 10,
-      workerRunning: true,
-      files: {
-        [metaPath]: JSON.stringify({ model: 'embedding-model-a' })
-      },
-      events: [event('e1', 'first memory'), event('e2', 'second memory')]
-    });
-
-    const result = await h.service.ensureEmbeddingModelForImport();
-
-    expect(result).toEqual({
-      changed: true,
-      previousModel: 'embedding-model-a',
-      currentModel: 'embedding-model-b',
-      enqueued: 2,
-      reason: 'model-mismatch'
-    });
-    expect(h.calls).toEqual([
-      'initialize',
-      'stop-worker',
-      'clear-vectors',
-      'clear-outbox',
-      'enqueue:e1',
-      'enqueue:e2',
-      'start-worker'
-    ]);
-    expect(h.eventStore.getEventsPage).toHaveBeenCalledWith(1000, 0);
-    expect(h.eventStore.enqueueForEmbedding).toHaveBeenNthCalledWith(1, 'e1', 'first memory');
-    expect(h.eventStore.enqueueForEmbedding).toHaveBeenNthCalledWith(2, 'e2', 'second memory');
-    expect(JSON.parse(h.files.get(h.metaPath)!)).toMatchObject({
-      model: 'embedding-model-b',
-      previousModel: 'embedding-model-a',
-      migratedAt: expect.any(String),
-      enqueued: 2
-    });
-  });
-
-  it('auto-migrates legacy vectors without metadata and does not restart an idle worker', async () => {
-    const h = createHarness({
-      vectorCount: 3,
-      workerRunning: false,
-      events: [event('legacy-1', 'legacy memory')]
-    });
-
-    const result = await h.service.ensureEmbeddingModelForImport();
-
-    expect(result).toEqual({
-      changed: true,
-      previousModel: null,
-      currentModel: 'embedding-model-a',
-      enqueued: 1,
-      reason: 'legacy-vectors-without-meta'
-    });
-    expect(h.worker.stop).not.toHaveBeenCalled();
-    expect(h.worker.start).not.toHaveBeenCalled();
-    expect(h.calls).toEqual(['initialize', 'clear-vectors', 'clear-outbox', 'enqueue:legacy-1']);
-    expect(JSON.parse(h.files.get(h.metaPath)!)).toMatchObject({
-      model: 'embedding-model-a',
-      previousModel: null,
-      migratedAt: expect.any(String),
-      enqueued: 1
-    });
-  });
-
-  it('re-enqueues events across page boundaries during migration', async () => {
-    const metaPath = path.join('/memory-root/project-a', 'embedding-meta.json');
-    const events = Array.from({ length: 1001 }, (_, index) => event(`event-${index + 1}`));
-    const h = createHarness({
-      currentModel: 'embedding-model-b',
-      vectorCount: 1001,
-      files: {
-        [metaPath]: JSON.stringify({ model: 'embedding-model-a' })
-      },
-      events
-    });
-
-    const result = await h.service.ensureEmbeddingModelForImport();
-
-    expect(result.enqueued).toBe(1001);
-    expect(h.eventStore.getEventsPage).toHaveBeenNthCalledWith(1, 1000, 0);
-    expect(h.eventStore.getEventsPage).toHaveBeenNthCalledWith(2, 1000, 1000);
-    expect(h.eventStore.getEventsPage).toHaveBeenCalledTimes(2);
-    expect(h.eventStore.enqueueForEmbedding).toHaveBeenCalledTimes(1001);
-    expect(h.eventStore.enqueueForEmbedding).toHaveBeenNthCalledWith(1001, 'event-1001', 'content for event-1001');
-  });
-
-  it('migrates without worker lifecycle calls when no vector worker is available', async () => {
-    const metaPath = path.join('/memory-root/project-a', 'embedding-meta.json');
-    const h = createHarness({
-      currentModel: 'embedding-model-b',
-      vectorCount: 1,
-      nullWorker: true,
-      files: {
-        [metaPath]: JSON.stringify({ model: 'embedding-model-a' })
-      },
-      events: [event('e1')]
-    });
-
-    const result = await h.service.ensureEmbeddingModelForImport();
-
-    expect(result.enqueued).toBe(1);
-    expect(h.calls).toEqual(['initialize', 'clear-vectors', 'clear-outbox', 'enqueue:e1']);
-    expect(h.worker.isRunning).not.toHaveBeenCalled();
-    expect(h.worker.stop).not.toHaveBeenCalled();
-    expect(h.worker.start).not.toHaveBeenCalled();
-  });
-});

package/tests/core/evidence-aligner.test.ts

@@ -1,152 +0,0 @@
-/**
- * Tests for Evidence Aligner
- */
-
-import { describe, it, expect } from 'vitest';
-import { EvidenceAligner } from '../../src/core/evidence-aligner.js';
-
-describe('EvidenceAligner', () => {
-  const aligner = new EvidenceAligner();
-
-  describe('align', () => {
-    it('should find exact matches', () => {
-      const claims = ['the quick brown fox'];
-      const source = 'The quick brown fox jumps over the lazy dog.';
-
-      const result = aligner.align(claims, source);
-
-      expect(result.isAligned).toBe(true);
-      expect(result.spans.length).toBe(1);
-      expect(result.spans[0].matchType).toBe('exact');
-      expect(result.spans[0].confidence).toBe(1.0);
-    });
-
-    it('should find fuzzy matches', () => {
-      const claims = ['quick brown fox jumping'];
-      const source = 'The quick brown fox jumps over the lazy dog.';
-
-      const result = aligner.align(claims, source);
-
-      // May or may not find fuzzy match depending on threshold
-      expect(result.confidence).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should report missing claims', () => {
-      const claims = ['completely unrelated content'];
-      const source = 'The quick brown fox jumps over the lazy dog.';
-
-      const result = aligner.align(claims, source);
-
-      expect(result.missingClaims.length).toBe(1);
-      expect(result.missingClaims[0]).toBe('completely unrelated content');
-    });
-
-    it('should skip short claims', () => {
-      const claims = ['short'];
-      const source = 'This is a short test.';
-
-      const result = aligner.align(claims, source);
-
-      // Short claims are skipped
-      expect(result.spans.length).toBe(0);
-      expect(result.missingClaims.length).toBe(0);
-    });
-
-    it('should calculate correct confidence', () => {
-      const claims = [
-        'the quick brown fox',
-        'jumps over the lazy dog'
-      ];
-      const source = 'The quick brown fox jumps over the lazy dog.';
-
-      const result = aligner.align(claims, source);
-
-      expect(result.confidence).toBeGreaterThan(0.5);
-    });
-  });
-
-  describe('extractClaims', () => {
-    it('should split text into sentences', () => {
-      const text = 'First sentence. Second sentence. Third sentence.';
-      const claims = aligner.extractClaims(text);
-
-      expect(claims.length).toBe(3);
-    });
-
-    it('should filter out questions', () => {
-      const text = 'This is a statement. Is this a question?';
-      const claims = aligner.extractClaims(text);
-
-      expect(claims.length).toBe(1);
-      expect(claims[0]).not.toContain('?');
-    });
-
-    it('should filter out short sentences', () => {
-      const text = 'Hi. This is a longer sentence that should be included.';
-      const claims = aligner.extractClaims(text);
-
-      // "Hi" is too short
-      expect(claims.some(c => c === 'Hi')).toBe(false);
-    });
-  });
-
-  describe('verifyGrounding', () => {
-    it('should verify response is grounded in context', () => {
-      const response = 'The fox is quick and brown.';
-      const context = [
-        'The quick brown fox jumps over the lazy dog.',
-        'Foxes are known for their speed.'
-      ];
-
-      const result = aligner.verifyGrounding(response, context);
-
-      expect(result.isAligned).toBe(true);
-    });
-
-    it('should detect ungrounded responses', () => {
-      const response = 'Elephants are the largest land animals.';
-      const context = [
-        'The quick brown fox jumps over the lazy dog.'
-      ];
-
-      const result = aligner.verifyGrounding(response, context);
-
-      expect(result.missingClaims.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('custom options', () => {
-    it('should use custom fuzzy threshold', () => {
-      const strictAligner = new EvidenceAligner({
-        fuzzyThreshold: 0.95
-      });
-
-      const claims = ['quick brown foxes'];
-      const source = 'The quick brown fox jumps.';
-
-      const result = strictAligner.align(claims, source);
-
-      // Strict threshold should result in no match
-      expect(result.spans.length).toBe(0);
-    });
-
-    it('should use custom max missing claims', () => {
-      const tolerantAligner = new EvidenceAligner({
-        maxMissingClaims: 5
-      });
-
-      const claims = [
-        'claim one that exists',
-        'claim two missing',
-        'claim three missing',
-        'claim four missing'
-      ];
-      const source = 'This source contains claim one that exists.';
-
-      const result = tolerantAligner.align(claims, source);
-
-      // Should still be aligned with 3 missing claims (< 5)
-      expect(result.isAligned).toBe(true);
-    });
-  });
-});