agent-relay 2.0.29 → 2.0.32

package/packages/memory/src/context-compaction.test.ts

@@ -0,0 +1,660 @@
+/**
+ * Tests for Context Compaction
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  estimateTokens,
+  estimateMessageTokens,
+  estimateContextTokens,
+  calculateImportance,
+  calculateSimilarity,
+  findDuplicates,
+  createSummary,
+  ContextCompactor,
+  createContextCompactor,
+  formatTokenCount,
+  benchmarkTokenEstimation,
+  type Message,
+} from './context-compaction.js';
+
+// =============================================================================
+// Test Helpers
+// =============================================================================
+
+const makeMessage = (overrides: Partial<Message> = {}): Message => ({
+  id: overrides.id ?? `msg-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`,
+  role: overrides.role ?? 'user',
+  content: overrides.content ?? 'Test message content',
+  timestamp: overrides.timestamp ?? Date.now(),
+  importance: overrides.importance,
+  isSummary: overrides.isSummary,
+  summarizes: overrides.summarizes,
+  thread: overrides.thread,
+  tokenCount: overrides.tokenCount,
+});
+
+// =============================================================================
+// Token Estimation Tests
+// =============================================================================
+
+describe('Token Estimation', () => {
+  describe('estimateTokens', () => {
+    it('returns 0 for empty string', () => {
+      expect(estimateTokens('')).toBe(0);
+    });
+
+    it('estimates short text', () => {
+      const text = 'Hello world';
+      const tokens = estimateTokens(text);
+      expect(tokens).toBeGreaterThan(0);
+      expect(tokens).toBeLessThan(10);
+    });
+
+    it('estimates longer text', () => {
+      const text = 'This is a longer piece of text that contains multiple sentences. It should have more tokens than a short phrase.';
+      const tokens = estimateTokens(text);
+      expect(tokens).toBeGreaterThan(20);
+      expect(tokens).toBeLessThan(50);
+    });
+
+    it('handles code with more tokens per character', () => {
+      const prose = 'This is a regular sentence with normal words.';
+      const code = 'function() { return arr.map(x => x * 2); }';
+
+      const proseTokens = estimateTokens(prose);
+      const codeTokens = estimateTokens(code);
+
+      // Code typically has more tokens per character due to symbols
+      // Both should be in reasonable range
+      expect(proseTokens).toBeGreaterThan(0);
+      expect(codeTokens).toBeGreaterThan(0);
+    });
+
+    it('scales linearly with length', () => {
+      const short = estimateTokens('a'.repeat(100));
+      const long = estimateTokens('a'.repeat(1000));
+
+      expect(long).toBeGreaterThan(short * 5);
+      expect(long).toBeLessThan(short * 15);
+    });
+
+    it('handles whitespace efficiently', () => {
+      const dense = estimateTokens('wordwordwordword');
+      const spaced = estimateTokens('word word word word');
+
+      // Whitespace affects token count but shouldn't double it
+      expect(spaced).toBeLessThan(dense * 2);
+    });
+  });
+
+  describe('estimateMessageTokens', () => {
+    it('includes role overhead', () => {
+      const message = makeMessage({ content: '' });
+      const tokens = estimateMessageTokens(message);
+      expect(tokens).toBeGreaterThan(0); // Role overhead
+    });
+
+    it('caches token count', () => {
+      const message = makeMessage({ content: 'Test content' });
+      expect(message.tokenCount).toBeUndefined();
+
+      const tokens1 = estimateMessageTokens(message);
+      expect(message.tokenCount).toBe(tokens1);
+
+      // Modify content (shouldn't affect cached value)
+      message.content = 'Different content';
+      const tokens2 = estimateMessageTokens(message);
+      expect(tokens2).toBe(tokens1); // Uses cached value
+    });
+
+    it('respects pre-set token count', () => {
+      const message = makeMessage({ content: 'Test', tokenCount: 100 });
+      expect(estimateMessageTokens(message)).toBe(100);
+    });
+  });
+
+  describe('estimateContextTokens', () => {
+    it('sums message tokens with separator overhead', () => {
+      const messages = [
+        makeMessage({ content: 'First message' }),
+        makeMessage({ content: 'Second message' }),
+        makeMessage({ content: 'Third message' }),
+      ];
+
+      const total = estimateContextTokens(messages);
+      const sumIndividual = messages.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
+
+      // Total should include separator overhead (~2 per message)
+      expect(total).toBeGreaterThan(sumIndividual);
+      expect(total).toBeLessThan(sumIndividual + messages.length * 5);
+    });
+
+    it('returns 0 for empty array', () => {
+      expect(estimateContextTokens([])).toBe(0);
+    });
+  });
+});
+
+// =============================================================================
+// Importance Scoring Tests
+// =============================================================================
+
+describe('Importance Scoring', () => {
+  describe('calculateImportance', () => {
+    it('gives higher score to recent messages', () => {
+      const messages = [
+        makeMessage({ id: 'old' }),
+        makeMessage({ id: 'new' }),
+      ];
+
+      const oldScore = calculateImportance(messages[0], 0, 2);
+      const newScore = calculateImportance(messages[1], 1, 2);
+
+      expect(newScore).toBeGreaterThan(oldScore);
+    });
+
+    it('gives higher score to system messages', () => {
+      const userMsg = makeMessage({ role: 'user', content: 'Hello' });
+      const sysMsg = makeMessage({ role: 'system', content: 'Hello' });
+
+      const userScore = calculateImportance(userMsg, 0, 2);
+      const sysScore = calculateImportance(sysMsg, 0, 2);
+
+      expect(sysScore).toBeGreaterThan(userScore);
+    });
+
+    it('boosts task-related keywords', () => {
+      const normal = makeMessage({ content: 'Hello world' });
+      const task = makeMessage({ content: 'TODO: implement feature' });
+
+      const normalScore = calculateImportance(normal, 0, 2);
+      const taskScore = calculateImportance(task, 0, 2);
+
+      expect(taskScore).toBeGreaterThan(normalScore);
+    });
+
+    it('boosts code blocks', () => {
+      const noCode = makeMessage({ content: 'Just text' });
+      const withCode = makeMessage({ content: 'Here is code:\n```javascript\nconsole.log("hi");\n```' });
+
+      const noCodeScore = calculateImportance(noCode, 0, 2);
+      const withCodeScore = calculateImportance(withCode, 0, 2);
+
+      expect(withCodeScore).toBeGreaterThan(noCodeScore);
+    });
+
+    it('penalizes short acknowledgments', () => {
+      const ack = makeMessage({ content: 'ok' });
+      const detail = makeMessage({ content: 'I understand the requirements and will proceed.' });
+
+      const ackScore = calculateImportance(ack, 0, 2);
+      const detailScore = calculateImportance(detail, 0, 2);
+
+      expect(detailScore).toBeGreaterThan(ackScore);
+    });
+
+    it('boosts summaries', () => {
+      const normal = makeMessage({ content: 'Normal message' });
+      const summary = makeMessage({ content: 'Summary message', isSummary: true });
+
+      const normalScore = calculateImportance(normal, 0, 2);
+      const summaryScore = calculateImportance(summary, 0, 2);
+
+      expect(summaryScore).toBeGreaterThan(normalScore);
+    });
+
+    it('respects user-specified importance', () => {
+      const msg = makeMessage({ content: 'Test', importance: 90 });
+      const score = calculateImportance(msg, 0, 2);
+
+      // Score should be influenced by user importance
+      expect(score).toBeGreaterThan(60);
+    });
+
+    it('clamps score to 0-100', () => {
+      const low = makeMessage({ content: 'ok', importance: 0 });
+      const high = makeMessage({ role: 'system', content: 'CRITICAL: important task TODO', importance: 100 });
+
+      const lowScore = calculateImportance(low, 0, 2);
+      const highScore = calculateImportance(high, 1, 2);
+
+      expect(lowScore).toBeGreaterThanOrEqual(0);
+      expect(lowScore).toBeLessThanOrEqual(100);
+      expect(highScore).toBeGreaterThanOrEqual(0);
+      expect(highScore).toBeLessThanOrEqual(100);
+    });
+  });
+});
+
+// =============================================================================
+// Similarity Detection Tests
+// =============================================================================
+
+describe('Similarity Detection', () => {
+  describe('calculateSimilarity', () => {
+    it('returns 1 for identical strings', () => {
+      const text = 'The quick brown fox jumps over the lazy dog';
+      expect(calculateSimilarity(text, text)).toBe(1);
+    });
+
+    it('returns 0 for completely different strings', () => {
+      const a = 'apple banana cherry';
+      const b = 'xyz qrs tuv';
+      expect(calculateSimilarity(a, b)).toBe(0);
+    });
+
+    it('returns partial similarity for overlapping content', () => {
+      const a = 'The quick brown fox';
+      const b = 'The slow brown dog';
+
+      const similarity = calculateSimilarity(a, b);
+      expect(similarity).toBeGreaterThan(0);
+      expect(similarity).toBeLessThan(1);
+    });
+
+    it('is case insensitive', () => {
+      const a = 'Hello World';
+      const b = 'HELLO WORLD';
+      expect(calculateSimilarity(a, b)).toBe(1);
+    });
+
+    it('ignores short words', () => {
+      const a = 'the a an is';
+      const b = 'of in to at';
+      // All words are <=2 chars, should return 0
+      expect(calculateSimilarity(a, b)).toBe(0);
+    });
+
+    it('handles empty strings', () => {
+      expect(calculateSimilarity('', '')).toBe(0);
+      expect(calculateSimilarity('hello', '')).toBe(0);
+      expect(calculateSimilarity('', 'hello')).toBe(0);
+    });
+  });
+
+  describe('findDuplicates', () => {
+    it('finds duplicate messages', () => {
+      const messages = [
+        makeMessage({ id: 'm1', content: 'Please review the authentication code' }),
+        makeMessage({ id: 'm2', content: 'Check the logging implementation' }),
+        makeMessage({ id: 'm3', content: 'Please review the authentication code changes' }), // Similar to m1
+      ];
+
+      const duplicates = findDuplicates(messages, 0.7);
+
+      expect(duplicates.size).toBeGreaterThan(0);
+    });
+
+    it('respects similarity threshold', () => {
+      const messages = [
+        makeMessage({ id: 'm1', content: 'Hello world' }),
+        makeMessage({ id: 'm2', content: 'Hello there' }),
+      ];
+
+      const strictDups = findDuplicates(messages, 0.95);
+      const looseDups = findDuplicates(messages, 0.3);
+
+      expect(strictDups.size).toBe(0);
+      expect(looseDups.size).toBeGreaterThan(0);
+    });
+
+    it('returns empty map for no duplicates', () => {
+      const messages = [
+        makeMessage({ id: 'm1', content: 'Completely unique message one' }),
+        makeMessage({ id: 'm2', content: 'Totally different content here' }),
+      ];
+
+      const duplicates = findDuplicates(messages, 0.8);
+      expect(duplicates.size).toBe(0);
+    });
+  });
+});
+
+// =============================================================================
+// Summarization Tests
+// =============================================================================
+
+describe('Summarization', () => {
+  describe('createSummary', () => {
+    it('creates summary message', () => {
+      const messages = [
+        makeMessage({ role: 'user', content: 'First point about authentication.' }),
+        makeMessage({ role: 'assistant', content: 'Second point about database.' }),
+        makeMessage({ role: 'user', content: 'Third point about API design.' }),
+      ];
+
+      const summary = createSummary(messages);
+
+      expect(summary.id).toMatch(/^summary_/);
+      expect(summary.role).toBe('system');
+      expect(summary.isSummary).toBe(true);
+      expect(summary.summarizes).toEqual(['msg-', 'msg-', 'msg-'].map((_, i) => messages[i].id));
+      expect(summary.content).toContain('Summary of 3 messages');
+    });
+
+    it('includes participant roles', () => {
+      const messages = [
+        makeMessage({ role: 'user', content: 'User message' }),
+        makeMessage({ role: 'assistant', content: 'Assistant message' }),
+      ];
+
+      const summary = createSummary(messages);
+      expect(summary.content).toContain('Participants:');
+    });
+
+    it('includes thread information if present', () => {
+      const messages = [
+        makeMessage({ thread: 'auth-thread', content: 'Message in thread' }),
+      ];
+
+      const summary = createSummary(messages);
+      expect(summary.content).toContain('auth-thread');
+    });
+
+    it('extracts key points', () => {
+      const messages = [
+        makeMessage({ content: 'Implement user authentication. This is critical.' }),
+        makeMessage({ content: 'Add logging for debugging. Very important.' }),
+      ];
+
+      const summary = createSummary(messages);
+      expect(summary.content).toContain('Key points');
+    });
+
+    it('has moderate importance', () => {
+      const messages = [makeMessage({ content: 'Test' })];
+      const summary = createSummary(messages);
+      expect(summary.importance).toBe(70);
+    });
+  });
+});
+
+// =============================================================================
+// Context Compactor Tests
+// =============================================================================
+
+describe('ContextCompactor', () => {
+  let compactor: ContextCompactor;
+
+  beforeEach(() => {
+    compactor = new ContextCompactor({
+      maxTokens: 1000,
+      targetUsage: 0.7,
+      compactionThreshold: 0.85,
+      keepRecentCount: 3,
+      enableSummarization: true,
+      enableDeduplication: true,
+    });
+  });
+
+  describe('getContextWindow', () => {
+    it('returns context window status', () => {
+      const messages = [
+        makeMessage({ content: 'First message' }),
+        makeMessage({ content: 'Second message' }),
+      ];
+
+      const window = compactor.getContextWindow(messages);
+
+      expect(window.messages).toBe(messages);
+      expect(window.totalTokens).toBeGreaterThan(0);
+      expect(window.maxTokens).toBe(1000);
+      expect(window.usagePercent).toBeGreaterThan(0);
+      expect(window.usagePercent).toBeLessThan(1);
+    });
+  });
+
+  describe('needsCompaction', () => {
+    it('returns false below threshold', () => {
+      const messages = [makeMessage({ content: 'Short' })];
+      expect(compactor.needsCompaction(messages)).toBe(false);
+    });
+
+    it('returns true above threshold', () => {
+      // Create many messages to exceed threshold
+      const messages = Array.from({ length: 100 }, (_, i) =>
+        makeMessage({ content: 'This is a reasonably long message number ' + i + ' with enough content to consume tokens.' })
+      );
+      expect(compactor.needsCompaction(messages)).toBe(true);
+    });
+  });
+
+  describe('compact', () => {
+    it('returns unchanged if below threshold', () => {
+      const messages = [makeMessage({ content: 'Short' })];
+      const result = compactor.compact(messages);
+
+      expect(result.strategy).toBe('none');
+      expect(result.messagesRemoved).toBe(0);
+      expect(result.messages.length).toBe(1);
+    });
+
+    it('removes duplicates', () => {
+      const compactorWithLowThreshold = new ContextCompactor({
+        maxTokens: 500,
+        compactionThreshold: 0.1, // Very low to trigger compaction
+        targetUsage: 0.05,
+        enableDeduplication: true,
+        keepRecentCount: 2,
+      });
+
+      const messages = [
+        makeMessage({ content: 'Please review the authentication module code' }),
+        makeMessage({ content: 'Check the database connection handling' }),
+        makeMessage({ content: 'Please review the authentication module code changes' }), // Similar
+      ];
+
+      const result = compactorWithLowThreshold.compact(messages);
+
+      // May remove duplicates or use other strategies
+      expect(result.messages.length).toBeLessThanOrEqual(messages.length);
+    });
+
+    it('keeps recent messages', () => {
+      const compactorSmall = new ContextCompactor({
+        maxTokens: 500,
+        compactionThreshold: 0.1,
+        targetUsage: 0.5, // 250 tokens target - enough for several messages
+        keepRecentCount: 3,
+        enableSummarization: false,
+        enableDeduplication: false, // Disable to test pure retention
+      });
+
+      // Use distinct content to avoid deduplication
+      const topics = ['auth', 'db', 'api', 'ui', 'tests', 'deploy', 'config', 'docs', 'perf', 'security'];
+      const messages = topics.map((topic, i) =>
+        makeMessage({ id: `msg-${i}`, content: `Working on ${topic} implementation with ${topic}-specific details` })
+      );
+
+      const result = compactorSmall.compact(messages);
+
+      // Recent messages should be kept (at least the last keepRecentCount)
+      const lastThree = messages.slice(-3).map(m => m.id);
+      const resultIds = result.messages.map(m => m.id);
+
+      // Result should include the most recent messages
+      expect(result.messages.length).toBeGreaterThanOrEqual(3);
+      for (const id of lastThree) {
+        expect(resultIds).toContain(id);
+      }
+    });
+
+    it('adds summary when summarization enabled', () => {
+      const compactorSmall = new ContextCompactor({
+        maxTokens: 300,
+        compactionThreshold: 0.1,
+        targetUsage: 0.05,
+        keepRecentCount: 2,
+        enableSummarization: true,
+        minImportanceRetain: 100, // High threshold to trigger summarization
+      });
+
+      const messages = Array.from({ length: 10 }, (_, i) =>
+        makeMessage({ id: `msg-${i}`, content: `Message number ${i} with some content that takes up space.` })
+      );
+
+      const result = compactorSmall.compact(messages);
+
+      if (result.summaryAdded) {
+        expect(result.summaryAdded.isSummary).toBe(true);
+        expect(result.strategy).toBe('summarize');
+      }
+    });
+  });
+
+  describe('addMessage', () => {
+    it('adds message without compaction when below threshold', () => {
+      const messages = [makeMessage({ content: 'First' })];
+      const newMsg = makeMessage({ content: 'Second' });
+
+      const result = compactor.addMessage(messages, newMsg);
+
+      expect(result.compacted).toBe(false);
+      expect(result.messages.length).toBe(2);
+    });
+
+    it('triggers compaction when threshold exceeded', () => {
+      const compactorSmall = new ContextCompactor({
+        maxTokens: 100,
+        compactionThreshold: 0.5,
+        targetUsage: 0.3,
+        keepRecentCount: 2,
+      });
+
+      const messages = Array.from({ length: 10 }, (_, i) =>
+        makeMessage({ content: `Message ${i} with enough content to fill tokens.` })
+      );
+
+      const newMsg = makeMessage({ content: 'New message that pushes over threshold.' });
+      const result = compactorSmall.addMessage(messages, newMsg);
+
+      expect(result.compacted).toBe(true);
+      expect(result.result).toBeDefined();
+    });
+  });
+
+  describe('getTokenBudget', () => {
+    it('returns budget information', () => {
+      const messages = [
+        makeMessage({ content: 'Test message one' }),
+        makeMessage({ content: 'Test message two' }),
+      ];
+
+      const budget = compactor.getTokenBudget(messages);
+
+      expect(budget.used).toBeGreaterThan(0);
+      expect(budget.remaining).toBeLessThan(1000);
+      expect(budget.remaining).toBe(1000 - budget.used);
+      expect(budget.percentUsed).toBeGreaterThan(0);
+      expect(budget.percentUsed).toBeLessThan(100);
+    });
+  });
+});
+
+// =============================================================================
+// Factory Function Tests
+// =============================================================================
+
+describe('createContextCompactor', () => {
+  it('creates compactor with default config', () => {
+    const compactor = createContextCompactor();
+    expect(compactor).toBeInstanceOf(ContextCompactor);
+  });
+
+  it('creates compactor with custom config', () => {
+    const compactor = createContextCompactor({
+      maxTokens: 50000,
+      compactionThreshold: 0.9,
+    });
+
+    const window = compactor.getContextWindow([]);
+    expect(window.maxTokens).toBe(50000);
+  });
+});
+
+// =============================================================================
+// Utility Function Tests
+// =============================================================================
+
+describe('Utility Functions', () => {
+  describe('formatTokenCount', () => {
+    it('formats small numbers', () => {
+      expect(formatTokenCount(100)).toBe('100');
+      expect(formatTokenCount(999)).toBe('999');
+    });
+
+    it('formats thousands', () => {
+      expect(formatTokenCount(1000)).toBe('1.0k');
+      expect(formatTokenCount(1500)).toBe('1.5k');
+      expect(formatTokenCount(10000)).toBe('10.0k');
+      expect(formatTokenCount(100000)).toBe('100.0k');
+    });
+
+    it('formats millions', () => {
+      expect(formatTokenCount(1000000)).toBe('1.0M');
+      expect(formatTokenCount(1500000)).toBe('1.5M');
+    });
+  });
+
+  describe('benchmarkTokenEstimation', () => {
+    it('runs benchmark and returns results', () => {
+      const results = benchmarkTokenEstimation(100);
+
+      expect(results.avgNs).toBeGreaterThan(0);
+      expect(results.maxNs).toBeGreaterThan(0);
+      expect(results.tokensPerMs).toBeGreaterThan(0);
+    });
+
+    it('meets performance target', () => {
+      const results = benchmarkTokenEstimation(1000);
+
+      // Target: catch major performance regressions, not microoptimizations
+      // For 1000 iterations, average per operation should be < 50 microseconds
+      // (Relaxed from 30μs to avoid flaky failures on loaded CI systems)
+      expect(results.avgNs).toBeLessThan(50000); // 50 microseconds in nanoseconds
+    });
+  });
+});
+
+// =============================================================================
+// Edge Cases
+// =============================================================================
+
+describe('Edge Cases', () => {
+  it('handles empty message array', () => {
+    const compactor = new ContextCompactor();
+
+    expect(compactor.needsCompaction([])).toBe(false);
+    expect(compactor.compact([]).messages).toEqual([]);
+    expect(compactor.getTokenBudget([]).used).toBe(0);
+  });
+
+  it('handles single message', () => {
+    const compactor = new ContextCompactor({ maxTokens: 100, keepRecentCount: 1 });
+    const messages = [makeMessage({ content: 'Only message' })];
+
+    const result = compactor.compact(messages);
+    expect(result.messages.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('handles very long message', () => {
+    const longContent = 'word '.repeat(10000);
+    const message = makeMessage({ content: longContent });
+
+    const tokens = estimateMessageTokens(message);
+    expect(tokens).toBeGreaterThan(1000);
+  });
+
+  it('handles unicode content', () => {
+    const message = makeMessage({ content: '你好世界 🌍 مرحبا العالم' });
+    const tokens = estimateMessageTokens(message);
+    expect(tokens).toBeGreaterThan(0);
+  });
+
+  it('handles empty content message', () => {
+    const message = makeMessage({ content: '' });
+    const tokens = estimateMessageTokens(message);
+    expect(tokens).toBeGreaterThan(0); // Role overhead
+  });
+});