claude-memory-layer 1.0.31 → 1.0.33

package/tests/core/markdown-mirror.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as os from 'os';
-import * as path from 'path';
-import * as fs from 'fs/promises';
-import { randomUUID } from 'crypto';
-import { buildMirrorPath, MarkdownMirror } from '../../src/core/markdown-mirror.js';
-import { SQLiteEventStore } from '../../src/core/sqlite-event-store.js';
-
-describe('markdown mirror', () => {
-  it('builds sanitized path with defaults', () => {
-    const event = {
-      id: randomUUID(),
-      eventType: 'user_prompt' as const,
-      sessionId: 's1',
-      timestamp: new Date('2026-02-24T00:49:00.000Z'),
-      content: 'hello',
-      canonicalKey: 'k',
-      dedupeKey: 'd',
-      metadata: {
-        namespace: 'Team ../Prod',
-        categoryPath: ['Ops & Alerts', 'Night Shift']
-      }
-    };
-
-    const out = buildMirrorPath('/tmp/root', event);
-    expect(out).toContain(path.join('memory', 'team-prod', 'ops-alerts', 'night-shift', '2026-02-24.md'));
-  });
-
-  it('appends without overwriting existing content', async () => {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'cml-md-mirror-'));
-    try {
-      const file = path.join(root, 'memory', 'default', 'session_summary', '2026-02-24.md');
-      await fs.mkdir(path.dirname(file), { recursive: true });
-      await fs.writeFile(file, 'PREEXISTING\n', 'utf8');
-
-      const mirror = new MarkdownMirror(root);
-      await mirror.append({
-        id: randomUUID(),
-        eventType: 'session_summary',
-        sessionId: 's2',
-        timestamp: new Date('2026-02-24T11:00:00.000Z'),
-        content: 'summary line',
-        canonicalKey: 'k2',
-        dedupeKey: 'd2',
-        metadata: {}
-      });
-
-      const content = await fs.readFile(file, 'utf8');
-      expect(content.startsWith('PREEXISTING\n')).toBe(true);
-      expect(content).toContain('summary line');
-    } finally {
-      await fs.rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it('is wired to sqlite append flow', async () => {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'cml-md-flow-'));
-    try {
-      const store = new SQLiteEventStore(path.join(root, 'events.sqlite'), {
-        markdownMirrorRoot: root
-      });
-      const ts = new Date('2026-02-24T12:00:00.000Z');
-      const result = await store.append({
-        eventType: 'agent_response',
-        sessionId: 'sess-flow',
-        timestamp: ts,
-        content: 'flow content',
-        metadata: { namespace: 'app', category: 'responses' }
-      });
-
-      expect(result.success).toBe(true);
-
-      // mirror append is async fire-and-forget; allow small delay
-      await new Promise((r) => setTimeout(r, 50));
-
-      const file = path.join(root, 'memory', 'app', 'responses', '2026-02-24.md');
-      const content = await fs.readFile(file, 'utf8');
-      expect(content).toContain('flow content');
-
-      await store.close();
-    } finally {
-      await fs.rm(root, { recursive: true, force: true });
-    }
-  });
-});

package/tests/core/matcher.test.ts

@@ -1,112 +0,0 @@
-/**
- * Tests for AXIOMMIND Matcher
- */
-
-import { describe, it, expect } from 'vitest';
-import { Matcher } from '../../src/core/matcher.js';
-
-describe('Matcher', () => {
-  const matcher = new Matcher();
-
-  describe('calculateCombinedScore', () => {
-    it('should calculate weighted score', () => {
-      const score = matcher.calculateCombinedScore(0.9, 0.8, 0, true);
-      // 0.4*0.9 + 0.25*0.8 + 0.2*1.0 + 0.15*1.0 = 0.36 + 0.2 + 0.2 + 0.15 = 0.91
-      expect(score).toBeCloseTo(0.91, 2);
-    });
-
-    it('should apply recency decay', () => {
-      const recentScore = matcher.calculateCombinedScore(0.9, 0.8, 0, true);
-      const oldScore = matcher.calculateCombinedScore(0.9, 0.8, 30, true);
-
-      expect(recentScore).toBeGreaterThan(oldScore);
-    });
-
-    it('should penalize inactive events', () => {
-      const activeScore = matcher.calculateCombinedScore(0.9, 0.8, 0, true);
-      const inactiveScore = matcher.calculateCombinedScore(0.9, 0.8, 0, false);
-
-      expect(activeScore).toBeGreaterThan(inactiveScore);
-    });
-
-    it('should cap score at 1.0', () => {
-      const score = matcher.calculateCombinedScore(1.0, 1.0, 0, true);
-      expect(score).toBeLessThanOrEqual(1.0);
-    });
-  });
-
-  describe('classifyConfidence', () => {
-    it('should return "high" for score >= 0.92 and gap >= 0.03', () => {
-      expect(matcher.classifyConfidence(0.95, 0.90)).toBe('high');
-      expect(matcher.classifyConfidence(0.92, 0.85)).toBe('high');
-    });
-
-    it('should return "suggested" for score >= 0.75 but not high', () => {
-      expect(matcher.classifyConfidence(0.85, 0.83)).toBe('suggested'); // gap too small
-      expect(matcher.classifyConfidence(0.75, null)).toBe('suggested');
-    });
-
-    it('should return "none" for score < 0.75', () => {
-      expect(matcher.classifyConfidence(0.70, null)).toBe('none');
-      expect(matcher.classifyConfidence(0.50, 0.30)).toBe('none');
-    });
-
-    it('should handle null second score', () => {
-      expect(matcher.classifyConfidence(0.95, null)).toBe('high');
-    });
-  });
-
-  describe('matchSearchResults', () => {
-    it('should return "none" confidence for empty results', () => {
-      const result = matcher.matchSearchResults([], () => 0);
-      expect(result.confidence).toBe('none');
-      expect(result.match).toBeNull();
-    });
-
-    it('should return match with calculated score', () => {
-      const results = [
-        {
-          id: 'vec1',
-          eventId: 'event1',
-          content: 'test content',
-          score: 0.95,
-          sessionId: 'session1',
-          eventType: 'user_prompt',
-          timestamp: new Date().toISOString()
-        }
-      ];
-
-      const result = matcher.matchSearchResults(results, () => 0);
-      expect(result.match).not.toBeNull();
-      expect(result.match?.event.id).toBe('event1');
-    });
-  });
-
-  describe('custom config', () => {
-    it('should use custom thresholds', () => {
-      const customMatcher = new Matcher({
-        minCombinedScore: 0.8,
-        minGap: 0.05,
-        suggestionThreshold: 0.6
-      });
-
-      // With custom thresholds, 0.85 should be high confidence
-      expect(customMatcher.classifyConfidence(0.85, 0.75)).toBe('high');
-    });
-
-    it('should use custom weights', () => {
-      const customMatcher = new Matcher({
-        weights: {
-          semanticSimilarity: 0.6,
-          ftsScore: 0.2,
-          recencyBonus: 0.1,
-          statusWeight: 0.1
-        }
-      });
-
-      const score = customMatcher.calculateCombinedScore(0.9, 0.5, 0, true);
-      // 0.6*0.9 + 0.2*0.5 + 0.1*1.0 + 0.1*1.0 = 0.54 + 0.1 + 0.1 + 0.1 = 0.84
-      expect(score).toBeCloseTo(0.84, 2);
-    });
-  });
-});

package/tests/core/md-mirror.test.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import { buildMirrorPath, MarkdownMirror } from '../../src/core/md-mirror.js';
-import type { MemoryEventInput } from '../../src/core/types.js';
-
-function makeEvent(): MemoryEventInput {
-  return {
-    eventType: 'user_prompt',
-    sessionId: 'agent:main:test',
-    timestamp: new Date('2026-02-24T01:00:00.000Z'),
-    content: '아침 브리핑 포맷 기억해줘',
-    metadata: {
-      namespace: 'Briefing',
-      categoryPath: ['Preferences', 'Morning']
-    }
-  };
-}
-
-describe('MarkdownMirror', () => {
-  it('builds sanitized categorized path', () => {
-    const p = buildMirrorPath('/tmp/demo', makeEvent());
-    expect(p).toContain(path.join('memory', 'briefing', 'preferences', 'morning', '2026-02-24.md'));
-  });
-
-  it('uses uncategorized when category is missing', () => {
-    const ev = { ...makeEvent(), metadata: { namespace: 'Briefing' } };
-    const p = buildMirrorPath('/tmp/demo', ev);
-    expect(p).toContain(path.join('memory', 'briefing', 'uncategorized', '2026-02-24.md'));
-  });
-
-  it('appends without overwrite', async () => {
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'cl-md-mirror-'));
-    const mirror = new MarkdownMirror(tmp);
-    const ev = makeEvent();
-
-    await mirror.append(ev, 'e1');
-    await mirror.append({ ...ev, content: '두번째 기록' }, 'e2');
-
-    const out = buildMirrorPath(tmp, ev);
-    const text = fs.readFileSync(out, 'utf8');
-    expect(text).toContain('e1');
-    expect(text).toContain('e2');
-    expect(text).toContain('두번째 기록');
-
-    const index = fs.readFileSync(path.join(tmp, 'memory', '_index.md'), 'utf8');
-    expect(index).toContain('memory/briefing/preferences/morning/2026-02-24.md');
-  });
-});

package/tests/core/memory-engine-services.test.ts

@@ -1,240 +0,0 @@
-import * as path from 'path';
-import * as os from 'os';
-import { mkdtemp, rm, stat } from 'fs/promises';
-import { describe, expect, it, vi } from 'vitest';
-
-import {
-  createMemoryEngineServices,
-  type MemoryEngineServicesFactories
-} from '../../src/core/engine/memory-engine-services.js';
-import type { MemoryEvent, MemoryEventInput, ToolObservationPayload } from '../../src/core/types.js';
-import type { RetrievalServicesDeps } from '../../src/core/engine/retrieval-services.js';
-
-function event(id = 'e1'): MemoryEvent {
-  return {
-    id,
-    sessionId: 's1',
-    eventType: 'user_prompt',
-    content: 'thin core factory event',
-    canonicalKey: `test/${id}`,
-    dedupeKey: `s1:${id}`,
-    timestamp: new Date('2026-05-02T00:00:00.000Z'),
-    metadata: {}
-  };
-}
-
-describe('createMemoryEngineServices', () => {
-  it('creates the storage directory and wires storage-backed engine services', async () => {
-    const root = await mkdtemp(path.join(os.tmpdir(), 'memory-engine-services-'));
-    const storagePath = path.join(root, 'memory');
-    const initialize = vi.fn(async () => {});
-    const createToolEmbedding = vi.fn((payload: ToolObservationPayload) => `${payload.toolName}:${payload.success}`);
-    const enqueueForEmbedding = vi.fn(async (_eventId: string, _content: string) => {});
-    const append = vi.fn(async (_input: MemoryEventInput) => ({
-      success: true as const,
-      eventId: 'event:user_prompt',
-      isDuplicate: false as const
-    }));
-    const sqliteStore = {
-      initialize: vi.fn(async () => {}),
-      append,
-      enqueueForEmbedding,
-      upsertSession: vi.fn(async () => {}),
-      keywordSearch: vi.fn(async (_query: string, _topK: number) => [{ event: event('keyword'), rank: -0.1 }]),
-      getSessionEvents: vi.fn(async (_sessionId: string) => [event('session')]),
-      getSessionsWithoutSummary: vi.fn(async () => []),
-      getRecentEvents: vi.fn(async (_limit?: number) => [event('recent')]),
-      getEvent: vi.fn(async (id: string) => event(id)),
-      recordRetrievalTrace: vi.fn(async (_input: Record<string, unknown>) => {}),
-      incrementAccessCount: vi.fn(async (_eventIds: string[]) => {}),
-      recordRetrieval: vi.fn(async (_eventId: string, _sessionId: string, _score: number, _query: string) => {}),
-      getRetrievalTraceStats: vi.fn(async () => ({
-        totalQueries: 0,
-        avgCandidateCount: 0,
-        avgSelectedCount: 0,
-        selectionRate: 0
-      })),
-      getRecentRetrievalTraces: vi.fn(async () => []),
-      getMostAccessed: vi.fn(async () => []),
-      evaluateSessionHelpfulness: vi.fn(async (_sessionId: string) => {}),
-      getUnevaluatedSessions: vi.fn(async () => []),
-      getHelpfulMemories: vi.fn(async () => []),
-      getHelpfulnessStats: vi.fn(async () => ({
-        avgScore: 0,
-        totalEvaluated: 0,
-        totalRetrievals: 0,
-        helpful: 0,
-        neutral: 0,
-        unhelpful: 0
-      }))
-    };
-    const vectorStore = {
-      marker: 'vector',
-      count: vi.fn(async () => 5)
-    };
-    const embedder = { marker: 'embedder' };
-    const matcher = { marker: 'matcher' };
-    const graduation = {
-      marker: 'graduation',
-      getStats: vi.fn(async () => [{ level: 'working', count: 2 }])
-    };
-    const mdMirror = { marker: 'mirror', append: vi.fn(async (_input: MemoryEventInput, _eventId?: string) => {}) };
-    const retrievalBundle = {
-      retriever: { marker: 'retriever' },
-      retrievalOrchestrator: { marker: 'orchestrator' },
-      retrievalDisclosureService: { marker: 'disclosure' },
-      retrievalAnalyticsService: { marker: 'analytics' }
-    };
-    let retrievalDeps: RetrievalServicesDeps | null = null;
-
-    const factories: MemoryEngineServicesFactories = {
-      createSQLiteEventStore: vi.fn((dbPath, options) => {
-        expect(dbPath).toBe(path.join(storagePath, 'events.sqlite'));
-        expect(options).toEqual({ readonly: false, markdownMirrorRoot: storagePath });
-        return sqliteStore as any;
-      }),
-      createVectorStore: vi.fn((vectorsPath) => {
-        expect(vectorsPath).toBe(path.join(storagePath, 'vectors'));
-        return vectorStore as any;
-      }),
-      createEmbedder: vi.fn((model: string) => {
-        expect(model).toBe('custom-embedding-model');
-        return embedder as any;
-      }),
-      getDefaultEmbedder: vi.fn(() => {
-        throw new Error('custom model should use createEmbedder');
-      }),
-      getDefaultMatcher: vi.fn(() => matcher as any),
-      createMarkdownMirror: vi.fn((cwd: string) => {
-        expect(cwd).toBe('/workspace/project');
-        return mdMirror as any;
-      }),
-      createGraduationPipeline: vi.fn((store) => {
-        expect(store).toBe(sqliteStore);
-        return graduation as any;
-      }),
-      createRetrievalServices: vi.fn((deps) => {
-        retrievalDeps = deps;
-        return retrievalBundle as any;
-      })
-    };
-
-    try {
-      const services = createMemoryEngineServices({
-        storagePath,
-        readOnly: false,
-        embeddingModel: 'custom-embedding-model',
-        cwd: '/workspace/project',
-        initialize,
-        getProjectHash: () => 'project-1',
-        getProjectPath: () => '/workspace/project',
-        hasSharedStore: () => false,
-        sharedStore: { get: async () => null },
-        createToolObservationEmbedding: createToolEmbedding,
-        factories
-      });
-
-      await expect(stat(storagePath)).resolves.toMatchObject({});
-      expect(services).toMatchObject({
-        storagePath,
-        sqliteStore,
-        vectorStore,
-        embedder,
-        matcher,
-        graduation,
-        mdMirror,
-        retriever: retrievalBundle.retriever,
-        retrievalOrchestrator: retrievalBundle.retrievalOrchestrator,
-        retrievalDisclosureService: retrievalBundle.retrievalDisclosureService,
-        retrievalAnalyticsService: retrievalBundle.retrievalAnalyticsService
-      });
-      expect(retrievalDeps).toMatchObject({
-        initialize,
-        eventStore: sqliteStore,
-        vectorStore,
-        embedder,
-        matcher,
-        sharedStore: { get: expect.any(Function) }
-      });
-      expect(retrievalDeps?.getProjectHash()).toBe('project-1');
-      expect(retrievalDeps?.hasSharedStore()).toBe(false);
-
-      await services.ingestService.storeUserPrompt('s1', 'remember factory wiring', { source: 'test' });
-      expect(initialize).not.toHaveBeenCalled();
-      expect(sqliteStore.append).toHaveBeenCalledWith(expect.objectContaining({
-        eventType: 'user_prompt',
-        sessionId: 's1',
-        content: 'remember factory wiring',
-        metadata: expect.objectContaining({
-          source: 'test',
-          ingest: expect.objectContaining({ operation: 'user_prompt', pipeline: 'default' }),
-          scope: { project: { hash: 'project-1', path: '/workspace/project' } },
-          tags: ['proj:project-1']
-        })
-      }));
-      expect(sqliteStore.enqueueForEmbedding).toHaveBeenCalledWith('event:user_prompt', 'remember factory wiring');
-      expect(mdMirror.append).toHaveBeenCalledWith(expect.any(Object), 'event:user_prompt');
-
-      await services.queryService.getRecentEvents(3);
-      expect(sqliteStore.getRecentEvents).toHaveBeenCalledWith(3);
-      expect(sqliteStore.initialize).toHaveBeenCalledTimes(1);
-      expect(initialize).not.toHaveBeenCalled();
-
-      await expect(services.queryService.getStats()).resolves.toEqual({
-        totalEvents: 1,
-        vectorCount: 5,
-        levelStats: [{ level: 'working', count: 2 }]
-      });
-      expect(sqliteStore.getRecentEvents).toHaveBeenCalledWith(10000);
-      expect(sqliteStore.initialize).toHaveBeenCalledTimes(2);
-      expect(initialize).not.toHaveBeenCalled();
-      expect(vectorStore.count).toHaveBeenCalledOnce();
-      expect(graduation.getStats).toHaveBeenCalledOnce();
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it('does not create the storage directory before sqlite store construction in read-only mode', async () => {
-    const root = await mkdtemp(path.join(os.tmpdir(), 'memory-engine-services-readonly-'));
-    const storagePath = path.join(root, 'readonly-memory');
-    const factories: MemoryEngineServicesFactories = {
-      createSQLiteEventStore: vi.fn(() => ({}) as any),
-      createVectorStore: vi.fn(() => ({}) as any),
-      getDefaultEmbedder: vi.fn(() => ({}) as any),
-      getDefaultMatcher: vi.fn(() => ({}) as any),
-      createMarkdownMirror: vi.fn(() => ({}) as any),
-      createGraduationPipeline: vi.fn(() => ({}) as any),
-      createRetrievalServices: vi.fn(() => ({
-        retriever: {},
-        retrievalOrchestrator: {},
-        retrievalDisclosureService: {},
-        retrievalAnalyticsService: {}
-      }) as any)
-    };
-
-    try {
-      createMemoryEngineServices({
-        storagePath,
-        readOnly: true,
-        cwd: '/workspace/project',
-        initialize: async () => {},
-        getProjectHash: () => null,
-        hasSharedStore: () => false,
-        createToolObservationEmbedding: () => 'embedding',
-        factories
-      });
-
-      // This asserts the extracted factory does not eagerly mkdir in read-only mode
-      // before delegating to the sqlite-store constructor. The production sqlite
-      // layer may still require/open an existing read-only database.
-      await expect(stat(storagePath)).rejects.toMatchObject({ code: 'ENOENT' });
-      expect(factories.createSQLiteEventStore).toHaveBeenCalledWith(
-        path.join(storagePath, 'events.sqlite'),
-        { readonly: true, markdownMirrorRoot: storagePath }
-      );
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-});