@auxiora/memory 1.0.0

package/tests/personality-adapter.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { MemoryStore } from '../src/store.js';
+import { PersonalityAdapter } from '../src/personality-adapter.js';
+
+let tmpDir: string;
+
+describe('PersonalityAdapter', () => {
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `auxiora-personality-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await fs.mkdir(tmpDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should record a personality signal', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const adapter = new PersonalityAdapter(store);
+
+    await adapter.recordSignal({
+      trait: 'humor',
+      adjustment: 0.3,
+      reason: 'User responds positively to jokes',
+      signalCount: 1,
+    });
+
+    const adjustments = await adapter.getAdjustments();
+    expect(adjustments).toHaveLength(1);
+    expect(adjustments[0].trait).toBe('humor');
+  });
+
+  it('should accumulate signals for the same trait', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const adapter = new PersonalityAdapter(store);
+
+    await adapter.recordSignal({
+      trait: 'humor',
+      adjustment: 0.3,
+      reason: 'User laughed at a joke',
+      signalCount: 1,
+    });
+
+    await adapter.recordSignal({
+      trait: 'humor',
+      adjustment: 0.3,
+      reason: 'User made a joke back',
+      signalCount: 1,
+    });
+
+    const adjustments = await adapter.getAdjustments();
+    expect(adjustments).toHaveLength(1);
+    expect(adjustments[0].signalCount).toBe(2);
+    // Adjustment should grow but not exceed 1
+    expect(adjustments[0].adjustment).toBeGreaterThan(0);
+    expect(adjustments[0].adjustment).toBeLessThanOrEqual(1);
+  });
+
+  it('should track different traits independently', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const adapter = new PersonalityAdapter(store);
+
+    await adapter.recordSignal({
+      trait: 'humor',
+      adjustment: 0.3,
+      reason: 'User likes humor',
+      signalCount: 1,
+    });
+
+    await adapter.recordSignal({
+      trait: 'formality',
+      adjustment: -0.2,
+      reason: 'User uses casual language',
+      signalCount: 1,
+    });
+
+    const adjustments = await adapter.getAdjustments();
+    expect(adjustments).toHaveLength(2);
+    const humor = adjustments.find(a => a.trait === 'humor');
+    const formality = adjustments.find(a => a.trait === 'formality');
+    expect(humor).toBeDefined();
+    expect(formality).toBeDefined();
+  });
+
+  it('should generate prompt modifier', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const adapter = new PersonalityAdapter(store);
+
+    await adapter.recordSignal({
+      trait: 'humor',
+      adjustment: 0.5,
+      reason: 'User responds positively to jokes',
+      signalCount: 3,
+    });
+
+    await adapter.recordSignal({
+      trait: 'formality',
+      adjustment: -0.5,
+      reason: 'User uses casual language',
+      signalCount: 3,
+    });
+
+    const modifier = await adapter.getPromptModifier();
+    expect(modifier).toContain('Personality Adaptations');
+    expect(modifier).toContain('humor');
+    expect(modifier).toContain('formality');
+  });
+
+  it('should return empty string when no adjustments', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const adapter = new PersonalityAdapter(store);
+
+    const modifier = await adapter.getPromptModifier();
+    expect(modifier).toBe('');
+  });
+
+  it('should skip very small adjustments in prompt modifier', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const adapter = new PersonalityAdapter(store);
+
+    await adapter.recordSignal({
+      trait: 'verbosity',
+      adjustment: 0.05,
+      reason: 'Weak signal',
+      signalCount: 1,
+    });
+
+    const modifier = await adapter.getPromptModifier();
+    // Adjustment of 0.05 < 0.1 threshold, so should not appear
+    // However the accumulation with 0.2 factor makes it 0.01, definitely below threshold
+    expect(modifier).toBe('');
+  });
+
+  it('should clamp adjustments to [-1, 1]', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const adapter = new PersonalityAdapter(store);
+
+    // Send many strong positive signals
+    for (let i = 0; i < 50; i++) {
+      await adapter.recordSignal({
+        trait: 'humor',
+        adjustment: 1.0,
+        reason: 'Very funny',
+        signalCount: 1,
+      });
+    }
+
+    const adjustments = await adapter.getAdjustments();
+    expect(adjustments[0].adjustment).toBeLessThanOrEqual(1);
+    expect(adjustments[0].adjustment).toBeGreaterThanOrEqual(-1);
+  });
+});

package/tests/retriever.test.ts

@@ -0,0 +1,240 @@
+import { describe, it, expect } from 'vitest';
+import { MemoryRetriever } from '../src/retriever.js';
+import type { MemoryEntry } from '../src/types.js';
+
+function makeMemory(overrides: Partial<MemoryEntry> = {}): MemoryEntry {
+  return {
+    id: 'mem-test',
+    content: 'Test memory',
+    category: 'fact',
+    source: 'explicit',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    accessCount: 0,
+    tags: ['test', 'memory'],
+    importance: 0.5,
+    confidence: 0.8,
+    sentiment: 'neutral',
+    encrypted: false,
+    ...overrides,
+  };
+}
+
+describe('MemoryRetriever', () => {
+  const retriever = new MemoryRetriever();
+
+  it('should return matching memories formatted for prompt', () => {
+    const memories = [
+      makeMemory({ content: 'Likes TypeScript', tags: ['typescript', 'programming'], category: 'preference' }),
+      makeMemory({ id: 'mem-2', content: 'Works at Acme', tags: ['acme', 'work', 'company'], category: 'fact' }),
+    ];
+
+    const result = retriever.retrieve(memories, 'Tell me about TypeScript');
+    expect(result).toContain('Likes TypeScript');
+    expect(result).toContain('What you know about the user');
+  });
+
+  it('should rank by tag overlap', () => {
+    const memories = [
+      makeMemory({ id: 'a', content: 'Likes Python', tags: ['python', 'programming'], category: 'preference' }),
+      makeMemory({ id: 'b', content: 'Loves TypeScript deeply', tags: ['typescript', 'programming', 'loves'], category: 'preference' }),
+    ];
+
+    const result = retriever.retrieve(memories, 'typescript programming');
+    // TypeScript memory should appear first (more tag overlap)
+    const tsIndex = result.indexOf('TypeScript');
+    const pyIndex = result.indexOf('Python');
+    expect(tsIndex).toBeLessThan(pyIndex);
+  });
+
+  it('should respect token budget', () => {
+    const memories = Array.from({ length: 100 }, (_, i) =>
+      makeMemory({
+        id: `mem-${i}`,
+        content: `Memory item number ${i} with some extra text to fill space`,
+        tags: ['matching', 'keyword'],
+      }),
+    );
+
+    const result = retriever.retrieve(memories, 'matching keyword');
+    // Should not include all 100
+    expect(result.length).toBeLessThan(100 * 60);
+    expect(result).toContain('What you know about the user');
+  });
+
+  it('should return empty string when no memories match', () => {
+    const thirtyOneDaysAgo = Date.now() - 31 * 24 * 60 * 60 * 1000;
+    const memories = [
+      makeMemory({
+        content: 'Likes cats',
+        tags: ['cats', 'animals'],
+        updatedAt: thirtyOneDaysAgo,
+        accessCount: 0,
+        importance: 0,
+        confidence: 0,
+      }),
+    ];
+
+    const result = retriever.retrieve(memories, 'quantum physics');
+    expect(result).toBe('');
+  });
+
+  it('should return empty string for empty memory list', () => {
+    const result = retriever.retrieve([], 'anything');
+    expect(result).toBe('');
+  });
+
+  // === New tests for importance weighting ===
+
+  it('should favor high-importance memories', () => {
+    const memories = [
+      makeMemory({ id: 'low', content: 'Low importance fact', tags: ['fact'], category: 'fact', importance: 0.1 }),
+      makeMemory({ id: 'high', content: 'High importance fact', tags: ['fact'], category: 'fact', importance: 0.9 }),
+    ];
+
+    const result = retriever.retrieve(memories, 'fact');
+    const highIndex = result.indexOf('High importance');
+    const lowIndex = result.indexOf('Low importance');
+    // High importance should appear before low importance
+    if (lowIndex >= 0) {
+      expect(highIndex).toBeLessThan(lowIndex);
+    } else {
+      // At minimum, high importance should appear
+      expect(highIndex).toBeGreaterThan(-1);
+    }
+  });
+
+  // === Category budget allocation ===
+
+  it('should include section headers by category', () => {
+    const memories = [
+      makeMemory({ id: 'f1', content: 'Works at Acme Corp', tags: ['acme', 'work'], category: 'fact' }),
+      makeMemory({ id: 'p1', content: 'Prefers dark mode', tags: ['dark', 'mode'], category: 'preference' }),
+      makeMemory({ id: 'r1', content: 'Shared debugging session', tags: ['debug', 'session'], category: 'relationship' }),
+      makeMemory({ id: 'pt1', content: 'Prefers brief responses', tags: ['brief', 'responses'], category: 'pattern' }),
+    ];
+
+    const result = retriever.retrieve(memories, 'dark mode debug session work acme brief responses');
+    expect(result).toContain('### Key Facts');
+    expect(result).toContain('### Preferences');
+  });
+
+  // === Expired memory filtering ===
+
+  it('should skip expired memories', () => {
+    const past = Date.now() - 1000;
+    const memories = [
+      makeMemory({
+        id: 'expired',
+        content: 'Expired memory',
+        tags: ['test', 'expired'],
+        expiresAt: past,
+      }),
+      makeMemory({
+        id: 'valid',
+        content: 'Valid memory still here',
+        tags: ['test', 'valid'],
+      }),
+    ];
+
+    const result = retriever.retrieve(memories, 'test');
+    expect(result).not.toContain('Expired memory');
+    expect(result).toContain('Valid memory');
+  });
+
+  it('should return empty when all memories are expired', () => {
+    const past = Date.now() - 1000;
+    const memories = [
+      makeMemory({ id: 'e1', content: 'Expired one', tags: ['test'], expiresAt: past }),
+      makeMemory({ id: 'e2', content: 'Expired two', tags: ['test'], expiresAt: past }),
+    ];
+
+    const result = retriever.retrieve(memories, 'test');
+    expect(result).toBe('');
+  });
+
+  // === Related memory boosting ===
+
+  it('should boost related memories', () => {
+    const memories = [
+      makeMemory({
+        id: 'primary',
+        content: 'Loves TypeScript',
+        tags: ['typescript'],
+        category: 'preference',
+        importance: 0.9,
+        relatedMemories: ['related'],
+      }),
+      makeMemory({
+        id: 'related',
+        content: 'Uses TypeScript at work',
+        tags: ['work', 'coding'],
+        category: 'fact',
+        importance: 0.3,
+        relatedMemories: ['primary'],
+      }),
+      makeMemory({
+        id: 'unrelated',
+        content: 'Likes hiking on weekends',
+        tags: ['hiking', 'weekends'],
+        category: 'preference',
+        importance: 0.3,
+      }),
+    ];
+
+    const result = retriever.retrieve(memories, 'typescript');
+    // The related memory should appear because it gets boosted by the primary match
+    expect(result).toContain('TypeScript at work');
+  });
+
+  // === Confidence scoring ===
+
+  it('should show high confidence annotation for facts', () => {
+    const memories = [
+      makeMemory({
+        id: 'hc',
+        content: 'Works at Acme Corp',
+        tags: ['acme', 'work'],
+        category: 'fact',
+        confidence: 0.95,
+      }),
+    ];
+
+    const result = retriever.retrieve(memories, 'acme work');
+    expect(result).toContain('high confidence');
+  });
+
+  // === Relationship bonus ===
+
+  it('should give bonus score to relationship memories', () => {
+    const thirtyDaysAgo = Date.now() - 29 * 24 * 60 * 60 * 1000;
+    const memories = [
+      makeMemory({
+        id: 'rel',
+        content: 'Shared a joke about recursion',
+        tags: ['joke'],
+        category: 'relationship',
+        importance: 0.5,
+        confidence: 0.5,
+        updatedAt: thirtyDaysAgo,
+      }),
+      makeMemory({
+        id: 'ctx',
+        content: 'Was in a meeting',
+        tags: ['meeting'],
+        category: 'context',
+        importance: 0.5,
+        confidence: 0.5,
+        updatedAt: thirtyDaysAgo,
+      }),
+    ];
+
+    // Both have same importance, confidence, recency but relationship gets a 0.05 bonus
+    const result = retriever.retrieve(memories, 'something unrelated');
+    // Relationship memory should still appear due to the bonus
+    if (result.length > 0) {
+      // If anything shows, relationship should be present
+      expect(result).toContain('recursion');
+    }
+  });
+});

package/tests/sentiment.test.ts

@@ -0,0 +1,207 @@
+import { describe, it, expect } from 'vitest';
+import { SentimentAnalyzer } from '../src/sentiment.js';
+import { PatternDetector } from '../src/pattern-detector.js';
+import type { SentimentSnapshot } from '../src/types.js';
+
+describe('SentimentAnalyzer', () => {
+  const analyzer = new SentimentAnalyzer();
+
+  describe('positive sentiment', () => {
+    it('should detect positive sentiment from positive words', () => {
+      const result = analyzer.analyzeSentiment('This is great and amazing!');
+      expect(result.sentiment).toBe('positive');
+      expect(result.confidence).toBeGreaterThan(0.4);
+      expect(result.keywords).toContain('great');
+      expect(result.keywords).toContain('amazing');
+    });
+
+    it('should detect positive sentiment from gratitude', () => {
+      const result = analyzer.analyzeSentiment('Thanks so much, this is really helpful!');
+      expect(result.sentiment).toBe('positive');
+      expect(result.keywords).toContain('thanks');
+      expect(result.keywords).toContain('helpful');
+    });
+
+    it('should detect positive sentiment from excitement', () => {
+      const result = analyzer.analyzeSentiment('I love it, this is perfect and beautiful!');
+      expect(result.sentiment).toBe('positive');
+      expect(result.confidence).toBeGreaterThan(0.5);
+    });
+
+    it('should boost positive sentiment with emojis', () => {
+      const withoutEmoji = analyzer.analyzeSentiment('This is good');
+      const withEmoji = analyzer.analyzeSentiment('This is good 😊👍');
+      expect(withEmoji.confidence).toBeGreaterThanOrEqual(withoutEmoji.confidence);
+    });
+  });
+
+  describe('negative sentiment', () => {
+    it('should detect negative sentiment from negative words', () => {
+      const result = analyzer.analyzeSentiment('This is terrible and broken');
+      expect(result.sentiment).toBe('negative');
+      expect(result.confidence).toBeGreaterThan(0.4);
+      expect(result.keywords).toContain('terrible');
+      expect(result.keywords).toContain('broken');
+    });
+
+    it('should detect negative sentiment from frustration', () => {
+      const result = analyzer.analyzeSentiment('Ugh, this is so annoying and frustrating');
+      expect(result.sentiment).toBe('negative');
+    });
+
+    it('should detect negative sentiment from error-related words', () => {
+      const result = analyzer.analyzeSentiment('The error keeps happening, the bug is still there, it failed again');
+      expect(result.sentiment).toBe('negative');
+      expect(result.keywords.length).toBeGreaterThan(0);
+    });
+
+    it('should boost negative sentiment with negative emojis', () => {
+      const result = analyzer.analyzeSentiment('This is bad 😢😡');
+      expect(result.sentiment).toBe('negative');
+    });
+  });
+
+  describe('neutral sentiment', () => {
+    it('should return neutral for factual statements', () => {
+      const result = analyzer.analyzeSentiment('The function takes two parameters and returns a string');
+      expect(result.sentiment).toBe('neutral');
+    });
+
+    it('should return neutral for questions without sentiment', () => {
+      const result = analyzer.analyzeSentiment('How do I configure the database connection?');
+      expect(result.sentiment).toBe('neutral');
+    });
+
+    it('should return neutral for balanced sentiment', () => {
+      const result = analyzer.analyzeSentiment('It has a good side but also a bad side');
+      expect(result.sentiment).toBe('neutral');
+    });
+  });
+
+  describe('negation handling', () => {
+    it('should handle "not good" as less positive', () => {
+      const good = analyzer.analyzeSentiment('This is good');
+      const notGood = analyzer.analyzeSentiment('This is not good');
+      // "not good" should be less positive or neutral/negative
+      expect(notGood.sentiment !== 'positive' || notGood.confidence < good.confidence).toBe(true);
+    });
+  });
+
+  describe('confidence levels', () => {
+    it('should have higher confidence with more signal words', () => {
+      const weak = analyzer.analyzeSentiment('This is good');
+      const strong = analyzer.analyzeSentiment('This is good, great, amazing, excellent, and perfect!');
+      expect(strong.confidence).toBeGreaterThanOrEqual(weak.confidence);
+    });
+
+    it('should return reasonable confidence for neutral text', () => {
+      const result = analyzer.analyzeSentiment('Set the variable to 42');
+      expect(result.confidence).toBeGreaterThan(0);
+      expect(result.confidence).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('keyword extraction', () => {
+    it('should return unique keywords', () => {
+      const result = analyzer.analyzeSentiment('good good good');
+      const uniqueCount = new Set(result.keywords).size;
+      expect(result.keywords.length).toBe(uniqueCount);
+    });
+
+    it('should return empty keywords for neutral text', () => {
+      const result = analyzer.analyzeSentiment('Define a variable');
+      expect(result.keywords).toEqual([]);
+    });
+  });
+});
+
+describe('PatternDetector mood tracking', () => {
+  it('should record and retrieve sentiment history', () => {
+    const detector = new PatternDetector();
+
+    const snapshot: SentimentSnapshot = {
+      sentiment: 'positive',
+      confidence: 0.8,
+      timestamp: Date.now(),
+      hour: 10,
+      dayOfWeek: 1,
+    };
+
+    detector.recordSentiment(snapshot);
+    const history = detector.getSentimentHistory();
+    expect(history).toHaveLength(1);
+    expect(history[0].sentiment).toBe('positive');
+  });
+
+  it('should detect mood patterns by time of day', () => {
+    const detector = new PatternDetector();
+
+    // Add 5 positive morning snapshots
+    for (let i = 0; i < 5; i++) {
+      detector.recordSentiment({
+        sentiment: 'positive',
+        confidence: 0.7,
+        timestamp: Date.now() - i * 86400000,
+        hour: 9,
+        dayOfWeek: (i + 1) % 7,
+      });
+    }
+
+    const signals = detector.detectMoodByTime();
+    const morningSignal = signals.find(s => s.pattern.includes('morning'));
+    expect(morningSignal).toBeDefined();
+    expect(morningSignal!.pattern).toContain('positive');
+  });
+
+  it('should detect mood patterns by day of week', () => {
+    const detector = new PatternDetector();
+
+    // Add 4 negative Monday snapshots
+    for (let i = 0; i < 4; i++) {
+      detector.recordSentiment({
+        sentiment: 'negative',
+        confidence: 0.8,
+        timestamp: Date.now() - i * 604800000,
+        hour: 14,
+        dayOfWeek: 1, // Monday
+      });
+    }
+
+    const signals = detector.detectMoodByTime();
+    const mondaySignal = signals.find(s => s.pattern.includes('Monday'));
+    expect(mondaySignal).toBeDefined();
+    expect(mondaySignal!.pattern).toContain('negative');
+  });
+
+  it('should not detect patterns with insufficient data', () => {
+    const detector = new PatternDetector();
+
+    detector.recordSentiment({
+      sentiment: 'positive',
+      confidence: 0.8,
+      timestamp: Date.now(),
+      hour: 10,
+      dayOfWeek: 1,
+    });
+
+    const signals = detector.detectMoodByTime();
+    expect(signals).toHaveLength(0);
+  });
+
+  it('should limit history to 200 snapshots', () => {
+    const detector = new PatternDetector();
+
+    for (let i = 0; i < 250; i++) {
+      detector.recordSentiment({
+        sentiment: 'neutral',
+        confidence: 0.5,
+        timestamp: Date.now() - i * 1000,
+        hour: i % 24,
+        dayOfWeek: i % 7,
+      });
+    }
+
+    const history = detector.getSentimentHistory();
+    expect(history.length).toBeLessThanOrEqual(200);
+  });
+});