@auxiora/memory 1.0.0

package/tests/extractor.test.ts

@@ -0,0 +1,247 @@
+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 { MemoryExtractor } from '../src/extractor.js';
+import type { AIProvider } from '../src/extractor.js';
+
+let tmpDir: string;
+
+function createMockProvider(response: string): AIProvider {
+  return {
+    complete: async () => ({ content: response }),
+  };
+}
+
+describe('MemoryExtractor', () => {
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `auxiora-extractor-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 extract facts from AI response', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const provider = createMockProvider(JSON.stringify({
+      facts: [
+        { content: 'User works at Acme Corp', category: 'fact', importance: 0.8 },
+        { content: 'User prefers dark mode', category: 'preference', importance: 0.6 },
+      ],
+      relationships: [],
+      patterns: [],
+      contradictions: [],
+      personalitySignals: [],
+    }));
+
+    const extractor = new MemoryExtractor(store, provider);
+    const result = await extractor.extract(
+      'I work at Acme Corp and I love dark mode',
+      'That sounds great!',
+    );
+
+    expect(result.factsExtracted).toHaveLength(2);
+    expect(result.factsExtracted[0].content).toBe('User works at Acme Corp');
+    expect(result.factsExtracted[0].importance).toBe(0.8);
+
+    const all = await store.getAll();
+    expect(all).toHaveLength(2);
+  });
+
+  it('should extract relationships', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const provider = createMockProvider(JSON.stringify({
+      facts: [],
+      relationships: [
+        { content: 'Shared a joke about recursion', type: 'inside_joke' },
+      ],
+      patterns: [],
+      contradictions: [],
+      personalitySignals: [],
+    }));
+
+    const extractor = new MemoryExtractor(store, provider);
+    const result = await extractor.extract(
+      'That recursion joke was hilarious',
+      'Ha, the classic "to understand recursion..."!',
+    );
+
+    expect(result.relationshipsFound).toHaveLength(1);
+    expect(result.relationshipsFound[0].category).toBe('relationship');
+  });
+
+  it('should extract patterns', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const provider = createMockProvider(JSON.stringify({
+      facts: [],
+      relationships: [],
+      patterns: [
+        { pattern: 'User prefers concise responses', type: 'communication' },
+      ],
+      contradictions: [],
+      personalitySignals: [],
+    }));
+
+    const extractor = new MemoryExtractor(store, provider);
+    const result = await extractor.extract('Just the answer please', 'Sure: 42.');
+
+    expect(result.patternsDetected).toHaveLength(1);
+    expect(result.patternsDetected[0].category).toBe('pattern');
+  });
+
+  it('should extract personality signals', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const provider = createMockProvider(JSON.stringify({
+      facts: [],
+      relationships: [],
+      patterns: [],
+      contradictions: [],
+      personalitySignals: [
+        { trait: 'humor', direction: 'increase', reason: 'User made a joke' },
+        { trait: 'formality', direction: 'decrease', reason: 'Casual tone' },
+      ],
+    }));
+
+    const extractor = new MemoryExtractor(store, provider);
+    const result = await extractor.extract('lol that was funny', 'Glad you liked it!');
+
+    expect(result.personalitySignals).toHaveLength(2);
+    expect(result.personalitySignals[0].trait).toBe('humor');
+    expect(result.personalitySignals[0].adjustment).toBe(0.1);
+    expect(result.personalitySignals[1].trait).toBe('formality');
+    expect(result.personalitySignals[1].adjustment).toBe(-0.1);
+  });
+
+  it('should handle contradictions with update resolution', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    // Seed existing fact
+    await store.add('User works at Acme Corp', 'fact', 'extracted');
+
+    const provider = createMockProvider(JSON.stringify({
+      facts: [],
+      relationships: [],
+      patterns: [],
+      contradictions: [
+        { existingFact: 'works at Acme Corp', newFact: 'User works at Globex now', resolution: 'update' },
+      ],
+      personalitySignals: [],
+    }));
+
+    const extractor = new MemoryExtractor(store, provider);
+    const result = await extractor.extract(
+      'I switched jobs, now at Globex',
+      'Congrats on the new position!',
+    );
+
+    expect(result.contradictionsFound).toHaveLength(1);
+    expect(result.contradictionsFound[0].resolution).toBe('update');
+
+    // The existing fact should have been updated
+    const all = await store.getAll();
+    expect(all.some(m => m.content === 'User works at Globex now')).toBe(true);
+  });
+
+  it('should handle empty AI response gracefully', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const provider = createMockProvider(JSON.stringify({
+      facts: [],
+      relationships: [],
+      patterns: [],
+      contradictions: [],
+      personalitySignals: [],
+    }));
+
+    const extractor = new MemoryExtractor(store, provider);
+    const result = await extractor.extract('hello', 'Hi there!');
+
+    expect(result.factsExtracted).toHaveLength(0);
+    expect(result.patternsDetected).toHaveLength(0);
+    expect(result.relationshipsFound).toHaveLength(0);
+    expect(result.personalitySignals).toHaveLength(0);
+  });
+
+  it('should handle malformed AI response', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const provider = createMockProvider('not valid json at all');
+
+    const extractor = new MemoryExtractor(store, provider);
+    const result = await extractor.extract('hello', 'Hi!');
+
+    expect(result.factsExtracted).toHaveLength(0);
+    expect(result.patternsDetected).toHaveLength(0);
+  });
+
+  it('should handle AI provider error gracefully', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const provider: AIProvider = {
+      complete: async () => { throw new Error('API down'); },
+    };
+
+    const extractor = new MemoryExtractor(store, provider);
+    const result = await extractor.extract('hello', 'Hi!');
+
+    expect(result.factsExtracted).toHaveLength(0);
+  });
+
+  it('should strip markdown code fences from response', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const json = JSON.stringify({
+      facts: [{ content: 'User likes TypeScript', category: 'preference', importance: 0.7 }],
+      relationships: [],
+      patterns: [],
+      contradictions: [],
+      personalitySignals: [],
+    });
+    const provider = createMockProvider('```json\n' + json + '\n```');
+
+    const extractor = new MemoryExtractor(store, provider);
+    const result = await extractor.extract('I love TypeScript', 'Me too!');
+
+    expect(result.factsExtracted).toHaveLength(1);
+  });
+
+  it('should clamp importance to 0-1', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const provider = createMockProvider(JSON.stringify({
+      facts: [
+        { content: 'High importance fact', category: 'fact', importance: 5.0 },
+        { content: 'Negative importance fact', category: 'fact', importance: -2.0 },
+      ],
+      relationships: [],
+      patterns: [],
+      contradictions: [],
+      personalitySignals: [],
+    }));
+
+    const extractor = new MemoryExtractor(store, provider);
+    const result = await extractor.extract('test', 'test');
+
+    expect(result.factsExtracted[0].importance).toBe(1.0);
+    expect(result.factsExtracted[1].importance).toBe(0);
+  });
+
+  it('should skip entries with missing content', async () => {
+    const store = new MemoryStore({ dir: tmpDir });
+    const provider = createMockProvider(JSON.stringify({
+      facts: [
+        { content: '', category: 'fact', importance: 0.5 },
+        { content: 'Valid fact', category: 'fact', importance: 0.5 },
+      ],
+      relationships: [{ content: '', type: 'inside_joke' }],
+      patterns: [{ pattern: '', type: 'communication' }],
+      contradictions: [],
+      personalitySignals: [{ trait: '', direction: 'increase', reason: 'test' }],
+    }));
+
+    const extractor = new MemoryExtractor(store, provider);
+    const result = await extractor.extract('test', 'test');
+
+    expect(result.factsExtracted).toHaveLength(1);
+    expect(result.relationshipsFound).toHaveLength(0);
+    expect(result.patternsDetected).toHaveLength(0);
+    expect(result.personalitySignals).toHaveLength(0);
+  });
+});

package/tests/partition.test.ts

@@ -0,0 +1,168 @@
+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 { MemoryPartitionManager } from '../src/partition.js';
+import { MemoryStore } from '../src/store.js';
+import { MemoryRetriever } from '../src/retriever.js';
+
+describe('MemoryPartitionManager', () => {
+  let tmpDir: string;
+  let manager: MemoryPartitionManager;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'memory-partition-'));
+    manager = new MemoryPartitionManager({ dir: tmpDir });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should create a private partition', async () => {
+    const partition = await manager.createPartition('Alice Private', 'private', {
+      ownerId: 'user-alice',
+    });
+    expect(partition.id).toMatch(/^part-/);
+    expect(partition.type).toBe('private');
+    expect(partition.ownerId).toBe('user-alice');
+  });
+
+  it('should create a shared partition', async () => {
+    const partition = await manager.createPartition('Team Shared', 'shared', {
+      ownerId: 'user-alice',
+      memberIds: ['user-bob', 'user-charlie'],
+    });
+    expect(partition.type).toBe('shared');
+    expect(partition.memberIds).toContain('user-bob');
+  });
+
+  it('should always have implicit global partition', async () => {
+    const global = await manager.getPartition('global');
+    expect(global).toBeDefined();
+    expect(global!.type).toBe('global');
+  });
+
+  it('should list partitions for a user', async () => {
+    await manager.createPartition('Alice Private', 'private', { ownerId: 'user-alice' });
+    await manager.createPartition('Bob Private', 'private', { ownerId: 'user-bob' });
+    await manager.createPartition('Team', 'shared', {
+      ownerId: 'user-alice',
+      memberIds: ['user-bob'],
+    });
+
+    const alicePartitions = await manager.listPartitions('user-alice');
+    // global + alice private + team (as owner)
+    expect(alicePartitions.length).toBe(3);
+
+    const bobPartitions = await manager.listPartitions('user-bob');
+    // global + bob private + team (as member)
+    expect(bobPartitions.length).toBe(3);
+  });
+
+  it('should check access correctly', async () => {
+    const priv = await manager.createPartition('Alice Only', 'private', {
+      ownerId: 'user-alice',
+    });
+
+    expect(await manager.hasAccess(priv.id, 'user-alice')).toBe(true);
+    expect(await manager.hasAccess(priv.id, 'user-bob')).toBe(false);
+    expect(await manager.hasAccess('global', 'user-bob')).toBe(true);
+  });
+
+  it('should delete partition', async () => {
+    const partition = await manager.createPartition('Temp', 'private', {
+      ownerId: 'user-alice',
+    });
+    const deleted = await manager.deletePartition(partition.id);
+    expect(deleted).toBe(true);
+
+    const found = await manager.getPartition(partition.id);
+    expect(found).toBeUndefined();
+  });
+
+  it('should not delete global partition', async () => {
+    const deleted = await manager.deletePartition('global');
+    expect(deleted).toBe(false);
+  });
+});
+
+describe('Memory Partition Isolation', () => {
+  let tmpDir: string;
+  let store: MemoryStore;
+  let retriever: MemoryRetriever;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'memory-isolation-'));
+    store = new MemoryStore({ dir: tmpDir });
+    retriever = new MemoryRetriever();
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should tag memories with partitionId', async () => {
+    const entry = await store.add('Alice likes cats', 'preference', 'extracted', {
+      partitionId: 'alice-private',
+      sourceUserId: 'user-alice',
+    });
+
+    expect(entry.partitionId).toBe('alice-private');
+    expect(entry.sourceUserId).toBe('user-alice');
+  });
+
+  it('should default partition to global', async () => {
+    const entry = await store.add('Shared fact', 'fact', 'explicit');
+    expect(entry.partitionId).toBe('global');
+  });
+
+  it('should filter memories by partition', async () => {
+    await store.add('Alice secret', 'fact', 'explicit', { partitionId: 'alice-private' });
+    await store.add('Bob secret', 'fact', 'explicit', { partitionId: 'bob-private' });
+    await store.add('Shared info', 'fact', 'explicit', { partitionId: 'global' });
+
+    const aliceMemories = await store.getByPartition('alice-private');
+    expect(aliceMemories).toHaveLength(1);
+    expect(aliceMemories[0].content).toBe('Alice secret');
+
+    const globalMemories = await store.getByPartition('global');
+    expect(globalMemories).toHaveLength(1);
+    expect(globalMemories[0].content).toBe('Shared info');
+  });
+
+  it('should get memories by multiple partitions', async () => {
+    await store.add('Alice pref', 'preference', 'explicit', { partitionId: 'alice-private' });
+    await store.add('Bob pref', 'preference', 'explicit', { partitionId: 'bob-private' });
+    await store.add('Global pref', 'preference', 'explicit', { partitionId: 'global' });
+
+    const aliceAccessible = await store.getByPartitions(['alice-private', 'global']);
+    expect(aliceAccessible).toHaveLength(2);
+  });
+
+  it('should not leak private memories in retriever', async () => {
+    await store.add('Alice coffee preference', 'preference', 'explicit', {
+      partitionId: 'alice-private',
+      importance: 0.9,
+    });
+    await store.add('Bob tea preference', 'preference', 'explicit', {
+      partitionId: 'bob-private',
+      importance: 0.9,
+    });
+    await store.add('Global coffee facts', 'fact', 'explicit', {
+      partitionId: 'global',
+      importance: 0.9,
+    });
+
+    const allMemories = await store.getAll();
+
+    // Bob should not see Alice's private memories
+    const bobResult = retriever.retrieve(allMemories, 'coffee', ['bob-private', 'global']);
+    expect(bobResult).not.toContain('Alice coffee');
+
+    // Alice should see her own + global
+    const aliceResult = retriever.retrieve(allMemories, 'coffee', ['alice-private', 'global']);
+    expect(aliceResult).toContain('Alice coffee');
+    expect(aliceResult).toContain('Global coffee');
+  });
+});

package/tests/pattern-detector.test.ts

@@ -0,0 +1,150 @@
+import { describe, it, expect } from 'vitest';
+import { PatternDetector } from '../src/pattern-detector.js';
+
+describe('PatternDetector', () => {
+  const detector = new PatternDetector();
+
+  it('should return empty for too few messages', () => {
+    const signals = detector.detect([
+      { content: 'hi', role: 'user', timestamp: Date.now() },
+    ]);
+    expect(signals).toHaveLength(0);
+  });
+
+  it('should detect brief message pattern', () => {
+    const messages = Array.from({ length: 10 }, (_, i) => ({
+      content: 'short msg',
+      role: 'user',
+      timestamp: Date.now() + i * 1000,
+    }));
+
+    const signals = detector.detect(messages);
+    const commSignals = signals.filter(s => s.type === 'communication');
+    expect(commSignals.some(s => s.pattern.includes('brief'))).toBe(true);
+  });
+
+  it('should detect detailed message pattern', () => {
+    const longContent = 'This is a very detailed message about various topics that goes on for quite a while and contains much information and many words to push the character count above two hundred characters easily and without much difficulty at all.';
+    const messages = Array.from({ length: 10 }, (_, i) => ({
+      content: longContent,
+      role: 'user',
+      timestamp: Date.now() + i * 1000,
+    }));
+
+    const signals = detector.detect(messages);
+    const commSignals = signals.filter(s => s.type === 'communication');
+    expect(commSignals.some(s => s.pattern.includes('detailed'))).toBe(true);
+  });
+
+  it('should detect question-heavy pattern', () => {
+    const messages = Array.from({ length: 10 }, (_, i) => ({
+      content: `What is the answer to question ${i}?`,
+      role: 'user',
+      timestamp: Date.now() + i * 1000,
+    }));
+
+    const signals = detector.detect(messages);
+    const commSignals = signals.filter(s => s.type === 'communication');
+    expect(commSignals.some(s => s.pattern.includes('questions'))).toBe(true);
+  });
+
+  it('should detect code-heavy pattern', () => {
+    const messages = Array.from({ length: 10 }, (_, i) => ({
+      content: `const value${i} = ${i}; function doSomething() {}`,
+      role: 'user',
+      timestamp: Date.now() + i * 1000,
+    }));
+
+    const signals = detector.detect(messages);
+    const commSignals = signals.filter(s => s.type === 'communication');
+    expect(commSignals.some(s => s.pattern.includes('code'))).toBe(true);
+  });
+
+  it('should detect schedule patterns', () => {
+    // All messages at 10 PM
+    const messages = Array.from({ length: 10 }, (_, i) => {
+      const date = new Date();
+      date.setHours(22, 0, 0, 0);
+      date.setDate(date.getDate() - i);
+      return {
+        content: `Working late on day ${i}`,
+        role: 'user',
+        timestamp: date.getTime(),
+      };
+    });
+
+    const signals = detector.detect(messages);
+    const scheduleSignals = signals.filter(s => s.type === 'schedule');
+    expect(scheduleSignals.length).toBeGreaterThanOrEqual(1);
+    expect(scheduleSignals[0].pattern).toContain('active');
+  });
+
+  it('should detect topic patterns', () => {
+    const messages = [
+      { content: 'TypeScript generics are tricky', role: 'user', timestamp: Date.now() },
+      { content: 'TypeScript types need work', role: 'user', timestamp: Date.now() + 1000 },
+      { content: 'TypeScript compiler is slow', role: 'user', timestamp: Date.now() + 2000 },
+      { content: 'React components need TypeScript', role: 'user', timestamp: Date.now() + 3000 },
+      { content: 'TypeScript interfaces rock', role: 'user', timestamp: Date.now() + 4000 },
+      { content: 'Need help with TypeScript React', role: 'user', timestamp: Date.now() + 5000 },
+    ];
+
+    const signals = detector.detect(messages);
+    const topicSignals = signals.filter(s => s.type === 'topic');
+    expect(topicSignals.length).toBeGreaterThanOrEqual(1);
+    expect(topicSignals[0].pattern).toContain('typescript');
+  });
+
+  it('should detect enthusiastic mood', () => {
+    const messages = Array.from({ length: 10 }, (_, i) => ({
+      content: `This is amazing! Great work! I love it!`,
+      role: 'user',
+      timestamp: Date.now() + i * 1000,
+    }));
+
+    const signals = detector.detect(messages);
+    const moodSignals = signals.filter(s => s.type === 'mood');
+    expect(moodSignals.some(s => s.pattern.includes('enthusiastic'))).toBe(true);
+  });
+
+  it('should detect casual mood', () => {
+    const messages = Array.from({ length: 10 }, (_, i) => ({
+      content: `lol tbh gonna try this haha`,
+      role: 'user',
+      timestamp: Date.now() + i * 1000,
+    }));
+
+    const signals = detector.detect(messages);
+    const moodSignals = signals.filter(s => s.type === 'mood');
+    expect(moodSignals.some(s => s.pattern.includes('casual'))).toBe(true);
+  });
+
+  it('should only analyze user messages', () => {
+    const messages = [
+      { content: 'hi', role: 'user', timestamp: Date.now() },
+      { content: 'Hello! How can I help?', role: 'assistant', timestamp: Date.now() + 1000 },
+      { content: 'thanks', role: 'user', timestamp: Date.now() + 2000 },
+      { content: 'You are welcome!', role: 'assistant', timestamp: Date.now() + 3000 },
+    ];
+
+    // Should return empty because only 2 user messages (need >= 5 for most patterns)
+    const signals = detector.detect(messages);
+    // Communication patterns require >= 5 user messages
+    const commSignals = signals.filter(s => s.type === 'communication');
+    expect(commSignals).toHaveLength(0);
+  });
+
+  it('should have confidence between 0 and 1', () => {
+    const messages = Array.from({ length: 20 }, (_, i) => ({
+      content: 'short',
+      role: 'user',
+      timestamp: Date.now() + i * 1000,
+    }));
+
+    const signals = detector.detect(messages);
+    for (const s of signals) {
+      expect(s.confidence).toBeGreaterThanOrEqual(0);
+      expect(s.confidence).toBeLessThanOrEqual(1);
+    }
+  });
+});