aimemory-core 1.0.1

package/src/usageTracker.ts

@@ -0,0 +1,325 @@
+export type UsageMetric = 
+  | 'memories_added'
+  | 'memories_searched'
+  | 'context_built'
+  | 'api_calls'
+  | 'storage_used';
+
+export interface UsageRecord {
+  userId: string;
+  date: string;
+  metrics: Record<UsageMetric, number>;
+}
+
+export interface UsageSummary {
+  userId: string;
+  period: 'daily' | 'monthly' | 'yearly';
+  startDate: Date;
+  endDate: Date;
+  metrics: Record<UsageMetric, number>;
+  totalOperations: number;
+}
+
+export interface UsageLimits {
+  maxMemories: number;
+  maxSearchPerDay: number;
+  maxContextPerDay: number;
+  maxApiCallsPerDay: number;
+  maxStorageMB: number;
+}
+
+export interface UsageCheckResult {
+  allowed: boolean;
+  metric: UsageMetric;
+  current: number;
+  limit: number;
+  remaining: number;
+  resetDate: Date;
+}
+
+export interface UsageStore {
+  get(userId: string, date: string): Promise<UsageRecord | null>;
+  set(userId: string, date: string, record: UsageRecord): Promise<void>;
+  increment(userId: string, metric: UsageMetric, amount?: number): Promise<void>;
+  getRange(userId: string, startDate: string, endDate: string): Promise<UsageRecord[]>;
+  reset(userId: string, date: string): Promise<void>;
+  deleteUser(userId: string): Promise<void>;
+}
+
+export class InMemoryUsageStore implements UsageStore {
+  private store: Map<string, Map<string, UsageRecord>> = new Map();
+
+  private getKey(userId: string, date: string): string {
+    return `${userId}:${date}`;
+  }
+
+  async get(userId: string, date: string): Promise<UsageRecord | null> {
+    const userMap = this.store.get(userId);
+    if (!userMap) return null;
+    return userMap.get(date) || null;
+  }
+
+  async set(userId: string, date: string, record: UsageRecord): Promise<void> {
+    if (!this.store.has(userId)) {
+      this.store.set(userId, new Map());
+    }
+    this.store.get(userId)!.set(date, record);
+  }
+
+  async increment(userId: string, metric: UsageMetric, amount: number = 1): Promise<void> {
+    const today = new Date().toISOString().split('T')[0];
+    
+    if (!this.store.has(userId)) {
+      this.store.set(userId, new Map());
+    }
+    
+    const userMap = this.store.get(userId)!;
+    let record = userMap.get(today);
+    
+    if (!record) {
+      record = {
+        userId,
+        date: today,
+        metrics: {
+          memories_added: 0,
+          memories_searched: 0,
+          context_built: 0,
+          api_calls: 0,
+          storage_used: 0,
+        },
+      };
+    }
+    
+    record.metrics[metric] = (record.metrics[metric] || 0) + amount;
+    userMap.set(today, record);
+  }
+
+  async getRange(userId: string, startDate: string, endDate: string): Promise<UsageRecord[]> {
+    const userMap = this.store.get(userId);
+    if (!userMap) return [];
+    
+    const results: UsageRecord[] = [];
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+    
+    for (const record of userMap.values()) {
+      const recordDate = new Date(record.date);
+      if (recordDate >= start && recordDate <= end) {
+        results.push(record);
+      }
+    }
+    
+    return results;
+  }
+
+  async reset(userId: string, date: string): Promise<void> {
+    const userMap = this.store.get(userId);
+    if (userMap) {
+      userMap.delete(date);
+    }
+  }
+
+  async deleteUser(userId: string): Promise<void> {
+    this.store.delete(userId);
+  }
+}
+
+export class UsageTracker {
+  private store: UsageStore;
+  private limits: UsageLimits;
+
+  constructor(limits: UsageLimits, store?: UsageStore) {
+    this.limits = limits;
+    this.store = store || new InMemoryUsageStore();
+  }
+
+  async checkLimit(userId: string, metric: UsageMetric): Promise<UsageCheckResult> {
+    const today = new Date().toISOString().split('T')[0];
+    const record = await this.store.get(userId, today);
+    
+    const current = record?.metrics[metric] || 0;
+    const limit = this.getLimitForMetric(metric);
+    const remaining = Math.max(0, limit - current);
+    
+    const now = new Date();
+    const resetDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+    
+    return {
+      allowed: current < limit,
+      metric,
+      current,
+      limit,
+      remaining,
+      resetDate,
+    };
+  }
+
+  async recordUsage(userId: string, metric: UsageMetric, amount: number = 1): Promise<UsageCheckResult> {
+    const checkResult = await this.checkLimit(userId, metric);
+    
+    if (!checkResult.allowed) {
+      return checkResult;
+    }
+    
+    await this.store.increment(userId, metric, amount);
+    
+    return this.checkLimit(userId, metric);
+  }
+
+  async getUsageSummary(userId: string, period: 'daily' | 'monthly' | 'yearly'): Promise<UsageSummary> {
+    const now = new Date();
+    let startDate: Date;
+    let endDate: Date = now;
+    
+    switch (period) {
+      case 'daily':
+        startDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        break;
+      case 'monthly':
+        startDate = new Date(now.getFullYear(), now.getMonth(), 1);
+        break;
+      case 'yearly':
+        startDate = new Date(now.getFullYear(), 0, 1);
+        break;
+    }
+    
+    const records = await this.store.getRange(
+      userId,
+      startDate.toISOString().split('T')[0],
+      endDate.toISOString().split('T')[0]
+    );
+    
+    const metrics: Record<UsageMetric, number> = {
+      memories_added: 0,
+      memories_searched: 0,
+      context_built: 0,
+      api_calls: 0,
+      storage_used: 0,
+    };
+    
+    let totalOperations = 0;
+    
+    for (const record of records) {
+      for (const [key, value] of Object.entries(record.metrics)) {
+        metrics[key as UsageMetric] += value;
+        totalOperations += value;
+      }
+    }
+    
+    return {
+      userId,
+      period,
+      startDate,
+      endDate,
+      metrics,
+      totalOperations,
+    };
+  }
+
+  async getAllUsage(userId: string): Promise<Record<UsageMetric, number>> {
+    const summary = await this.getUsageSummary(userId, 'monthly');
+    return summary.metrics;
+  }
+
+  private getLimitForMetric(metric: UsageMetric): number {
+    switch (metric) {
+      case 'memories_added':
+        return this.limits.maxMemories;
+      case 'memories_searched':
+        return this.limits.maxSearchPerDay;
+      case 'context_built':
+        return this.limits.maxContextPerDay;
+      case 'api_calls':
+        return this.limits.maxApiCallsPerDay;
+      case 'storage_used':
+        return this.limits.maxStorageMB;
+      default:
+        return 0;
+    }
+  }
+
+  updateLimits(limits: Partial<UsageLimits>): void {
+    this.limits = { ...this.limits, ...limits };
+  }
+
+  async resetUser(userId: string): Promise<void> {
+    await this.store.deleteUser(userId);
+  }
+
+  async resetDay(userId: string): Promise<void> {
+    const today = new Date().toISOString().split('T')[0];
+    await this.store.reset(userId, today);
+  }
+}
+
+export const DEFAULT_USAGE_LIMITS: Record<string, UsageLimits> = {
+  // NPM & Extension Free
+  free: {
+    maxMemories: 5000,
+    maxSearchPerDay: 500,
+    maxContextPerDay: 200,
+    maxApiCallsPerDay: 5000,
+    maxStorageMB: 50,
+  },
+  // Extension Starter
+  starter: {
+    maxMemories: 30000,
+    maxSearchPerDay: 1000,
+    maxContextPerDay: 500,
+    maxApiCallsPerDay: 10000,
+    maxStorageMB: 100,
+  },
+  // NPM Pro
+  pro: {
+    maxMemories: 50000,
+    maxSearchPerDay: 10000,
+    maxContextPerDay: 5000,
+    maxApiCallsPerDay: 100000,
+    maxStorageMB: 500,
+  },
+  // Extension Plus
+  plus: {
+    maxMemories: 150000,
+    maxSearchPerDay: 5000,
+    maxContextPerDay: 2000,
+    maxApiCallsPerDay: 50000,
+    maxStorageMB: 250,
+  },
+  // Extension Premium
+  premium: {
+    maxMemories: -1,
+    maxSearchPerDay: -1,
+    maxContextPerDay: -1,
+    maxApiCallsPerDay: -1,
+    maxStorageMB: -1,
+  },
+  // Team
+  team: {
+    maxMemories: 500000,
+    maxSearchPerDay: 100000,
+    maxContextPerDay: 50000,
+    maxApiCallsPerDay: 1000000,
+    maxStorageMB: 5000,
+  },
+  // Business
+  business: {
+    maxMemories: 2000000,
+    maxSearchPerDay: 500000,
+    maxContextPerDay: 200000,
+    maxApiCallsPerDay: 5000000,
+    maxStorageMB: 20000,
+  },
+  // Enterprise
+  enterprise: {
+    maxMemories: -1,
+    maxSearchPerDay: -1,
+    maxContextPerDay: -1,
+    maxApiCallsPerDay: -1,
+    maxStorageMB: -1,
+  },
+};
+
+export function createUsageTracker(plan: string = 'free', store?: UsageStore): UsageTracker {
+  const limits = DEFAULT_USAGE_LIMITS[plan] || DEFAULT_USAGE_LIMITS.free;
+  return new UsageTracker(limits, store);
+}

package/src/vectorStore.ts

@@ -0,0 +1,116 @@
+import { VectorStoreAdapter, VectorEntry, SearchOptions, SearchResult, Memory } from './types.js';
+
+export class InMemoryVectorStore implements VectorStoreAdapter {
+  private vectors: Map<string, VectorEntry> = new Map();
+  private dimension: number;
+
+  constructor(dimension: number = 1536) {
+    this.dimension = dimension;
+  }
+
+  async add(entries: VectorEntry[]): Promise<void> {
+    for (const entry of entries) {
+      if (!entry.vector || entry.vector.length !== this.dimension) {
+        throw new Error(`Invalid vector dimension. Expected ${this.dimension}, got ${entry.vector?.length || 0}`);
+      }
+      this.vectors.set(entry.id, {
+        id: entry.id,
+        vector: [...entry.vector],
+        metadata: { ...entry.metadata },
+      });
+    }
+  }
+
+  async search(query: number[], options: SearchOptions): Promise<SearchResult[]> {
+    if (query.length !== this.dimension) {
+      throw new Error(`Invalid query dimension. Expected ${this.dimension}, got ${query.length}`);
+    }
+
+    const results: SearchResult[] = [];
+    const { limit, threshold, filter } = options;
+
+    for (const entry of this.vectors.values()) {
+      if (filter) {
+        const matchesFilter = Object.entries(filter).every(
+          ([key, value]) => entry.metadata[key] === value
+        );
+        if (!matchesFilter) continue;
+      }
+
+      const score = this.cosineSimilarity(query, entry.vector);
+      
+      if (threshold !== undefined && score < threshold) {
+        continue;
+      }
+
+      results.push({
+        memory: {
+          id: entry.id,
+          content: entry.metadata.content || '',
+          timestamp: entry.metadata.timestamp as number || Date.now(),
+          metadata: entry.metadata,
+        } as unknown as Memory,
+        score,
+      });
+    }
+
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+  }
+
+  async delete(ids: string[]): Promise<void> {
+    for (const id of ids) {
+      this.vectors.delete(id);
+    }
+  }
+
+  async getById(id: string): Promise<VectorEntry | null> {
+    const entry = this.vectors.get(id);
+    if (!entry) return null;
+    return {
+      id: entry.id,
+      vector: [...entry.vector],
+      metadata: { ...entry.metadata },
+    };
+  }
+
+  async getAll(): Promise<VectorEntry[]> {
+    return Array.from(this.vectors.values()).map(entry => ({
+      id: entry.id,
+      vector: [...entry.vector],
+      metadata: { ...entry.metadata },
+    }));
+  }
+
+  async clear(): Promise<void> {
+    this.vectors.clear();
+  }
+
+  async size(): Promise<number> {
+    return this.vectors.size;
+  }
+
+  private cosineSimilarity(a: number[], b: number[]): number {
+    if (a.length !== b.length) return 0;
+    
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+
+    if (normA === 0 || normB === 0) return 0;
+    
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+}
+
+export class VectorStoreFactory {
+  static create(dimension: number = 1536): VectorStoreAdapter {
+    return new InMemoryVectorStore(dimension);
+  }
+}

package/tests/aibrain.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createAIMemory, AIMemory } from '../src/index.js';
+import { EmbeddingFunction } from '../src/types.js';
+
+const mockEmbedding: EmbeddingFunction = async (text: string): Promise<number[]> => {
+  const hash = text.split('').reduce((acc, char) => {
+    return ((acc << 5) - acc) + char.charCodeAt(0);
+  }, 0);
+  
+  const embedding = new Array(1536).fill(0);
+  for (let i = 0; i < embedding.length; i++) {
+    embedding[i] = Math.sin(hash * i) * Math.cos(hash * i);
+  }
+  
+  const magnitude = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
+  return embedding.map(val => val / magnitude);
+};
+
+describe('AIMemory', () => {
+  let memory: AIMemory;
+
+  beforeEach(() => {
+    memory = createAIMemory();
+    memory.setEmbeddingFunction(mockEmbedding);
+  });
+
+  it('should create instance', () => {
+    expect(memory).toBeDefined();
+  });
+
+  it('should remember content', async () => {
+    const mem = await memory.remember('Test content', {
+      type: 'fact',
+    });
+
+    expect(mem.content).toBe('Test content');
+  });
+
+  it('should remember conversation', async () => {
+    const mem = await memory.rememberConversation('Hello', 'user');
+
+    expect(mem.content).toBe('User: Hello');
+    expect(mem.metadata.type).toBe('conversation');
+  });
+
+  it('should remember fact', async () => {
+    const mem = await memory.rememberFact('The earth is round');
+
+    expect(mem.metadata.type).toBe('fact');
+  });
+
+  it('should remember preference', async () => {
+    const mem = await memory.rememberPreference('I like coffee');
+
+    expect(mem.metadata.type).toBe('preference');
+  });
+
+  it('should remember instruction', async () => {
+    const mem = await memory.rememberInstruction('Be polite');
+
+    expect(mem.metadata.type).toBe('instruction');
+  });
+
+  it('should recall memories', async () => {
+    await memory.remember('Python programming', { type: 'fact' });
+    await memory.remember('JavaScript programming', { type: 'fact' });
+
+    const results = await memory.recall('programming');
+
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it('should get context', async () => {
+    await memory.rememberFact('User likes cats');
+
+    const context = await memory.getContext('pets');
+
+    expect(context.messages.length).toBeGreaterThan(0);
+    expect(context.stats).toBeDefined();
+  });
+
+  it('should get memory by id', async () => {
+    const added = await memory.remember('Test');
+
+    const retrieved = await memory.getMemory(added.id);
+
+    expect(retrieved).not.toBeNull();
+    expect(retrieved!.content).toBe('Test');
+  });
+
+  it('should update memory', async () => {
+    const added = await memory.remember('Original');
+
+    const updated = await memory.updateMemory(added.id, {
+      content: 'Updated',
+    });
+
+    expect(updated!.content).toBe('Updated');
+  });
+
+  it('should forget memory', async () => {
+    const added = await memory.remember('To forget');
+
+    await memory.forget(added.id);
+
+    const retrieved = await memory.getMemory(added.id);
+    expect(retrieved).toBeNull();
+  });
+
+  it('should get recent memories', async () => {
+    await memory.remember('First');
+    await memory.remember('Second');
+
+    const recent = await memory.getRecentMemories();
+
+    expect(recent.length).toBe(2);
+  });
+
+  it('should get stats', async () => {
+    await memory.remember('Test 1', { type: 'fact' });
+    await memory.remember('Test 2', { type: 'fact' });
+
+    const stats = await memory.getStats();
+
+    expect(stats.totalMemories).toBe(2);
+    expect(stats.memoriesByType.fact).toBe(2);
+  });
+
+  it('should clear all memories', async () => {
+    await memory.remember('Test');
+    await memory.clear();
+
+    const stats = await memory.getStats();
+    expect(stats.totalMemories).toBe(0);
+  });
+
+  it('should export and import data', async () => {
+    await memory.remember('Memory 1');
+    await memory.remember('Memory 2');
+
+    const exported = await memory.exportData();
+
+    await memory.clear();
+    await memory.importData(exported);
+
+    const stats = await memory.getStats();
+    expect(stats.totalMemories).toBe(2);
+  });
+
+  it('should work with config', () => {
+    const customMemory = createAIMemory({
+      maxMemories: 500,
+      context: {
+        maxTokens: 3000,
+        relevanceThreshold: 0.6,
+      },
+    });
+
+    expect(customMemory).toBeDefined();
+  });
+
+  it('should get underlying memory manager', () => {
+    const manager = memory.getMemoryManager();
+    expect(manager).toBeDefined();
+  });
+
+  it('should get underlying context builder', () => {
+    const contextBuilder = memory.getContextBuilder();
+    expect(contextBuilder).toBeDefined();
+  });
+});