aimemory-core 1.0.1

package/src/metadataStore.ts

@@ -0,0 +1,298 @@
+import { Memory, MemoryFilter, MemoryType, MemoryStats } from './types.js';
+
+export class MetadataStore {
+  private memories: Map<string, Memory> = new Map();
+  private indexByType: Map<MemoryType, Set<string>> = new Map();
+  private indexByTag: Map<string, Set<string>> = new Map();
+  private indexByUser: Map<string, Set<string>> = new Map();
+  private indexBySession: Map<string, Set<string>> = new Map();
+  private indexByTime: string[] = [];
+
+  constructor() {
+    this.initializeIndexes();
+  }
+
+  private initializeIndexes(): void {
+    const types: MemoryType[] = ['conversation', 'fact', 'preference', 'instruction', 'context', 'custom'];
+    for (const type of types) {
+      this.indexByType.set(type, new Set());
+    }
+  }
+
+  async add(memory: Memory): Promise<void> {
+    if (this.memories.has(memory.id)) {
+      await this.update(memory);
+      return;
+    }
+
+    this.memories.set(memory.id, { ...memory });
+
+    this.indexByType.get(memory.metadata.type)?.add(memory.id);
+    
+    const tags = memory.metadata.tags || [];
+    for (const tag of tags) {
+      if (!this.indexByTag.has(tag)) {
+        this.indexByTag.set(tag, new Set());
+      }
+      this.indexByTag.get(tag)!.add(memory.id);
+    }
+
+    if (memory.metadata.userId) {
+      if (!this.indexByUser.has(memory.metadata.userId)) {
+        this.indexByUser.set(memory.metadata.userId, new Set());
+      }
+      this.indexByUser.get(memory.metadata.userId)!.add(memory.id);
+    }
+
+    if (memory.metadata.sessionId) {
+      if (!this.indexBySession.has(memory.metadata.sessionId)) {
+        this.indexBySession.set(memory.metadata.sessionId, new Set());
+      }
+      this.indexBySession.get(memory.metadata.sessionId)!.add(memory.id);
+    }
+
+    this.insertByTime(memory.id, memory.timestamp);
+  }
+
+  private insertByTime(id: string, timestamp: number): void {
+    let left = 0;
+    let right = this.indexByTime.length - 1;
+    
+    while (left <= right) {
+      const mid = Math.floor((left + right) / 2);
+      const midTime = this.memories.get(this.indexByTime[mid])?.timestamp || 0;
+      
+      if (midTime < timestamp) {
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+    
+    this.indexByTime.splice(left, 0, id);
+  }
+
+  async update(memory: Memory): Promise<void> {
+    const existing = this.memories.get(memory.id);
+    if (!existing) {
+      throw new Error(`Memory ${memory.id} not found`);
+    }
+
+    if (existing.metadata.type !== memory.metadata.type) {
+      this.indexByType.get(existing.metadata.type)?.delete(memory.id);
+      this.indexByType.get(memory.metadata.type)?.add(memory.id);
+    }
+
+    const oldTags = new Set(existing.metadata.tags || []);
+    const newTags = new Set(memory.metadata.tags || []);
+    
+    for (const tag of oldTags) {
+      if (!newTags.has(tag)) {
+        this.indexByTag.get(tag)?.delete(memory.id);
+      }
+    }
+    for (const tag of newTags) {
+      if (!oldTags.has(tag)) {
+        if (!this.indexByTag.has(tag)) {
+          this.indexByTag.set(tag, new Set());
+        }
+        this.indexByTag.get(tag)!.add(memory.id);
+      }
+    }
+
+    this.memories.set(memory.id, { ...memory });
+  }
+
+  async delete(id: string): Promise<void> {
+    const memory = this.memories.get(id);
+    if (!memory) return;
+
+    this.indexByType.get(memory.metadata.type)?.delete(id);
+    
+    for (const tag of memory.metadata.tags) {
+      this.indexByTag.get(tag)?.delete(id);
+    }
+
+    if (memory.metadata.userId) {
+      this.indexByUser.get(memory.metadata.userId)?.delete(id);
+    }
+
+    if (memory.metadata.sessionId) {
+      this.indexBySession.get(memory.metadata.sessionId)?.delete(id);
+    }
+
+    const timeIndex = this.indexByTime.indexOf(id);
+    if (timeIndex !== -1) {
+      this.indexByTime.splice(timeIndex, 1);
+    }
+
+    this.memories.delete(id);
+  }
+
+  async getById(id: string): Promise<Memory | null> {
+    const memory = this.memories.get(id);
+    if (!memory) return null;
+    return { ...memory };
+  }
+
+  async getAll(): Promise<Memory[]> {
+    return Array.from(this.memories.values()).map(m => ({ ...m }));
+  }
+
+  async find(filter: MemoryFilter, limit: number = 100): Promise<Memory[]> {
+    let candidateIds: Set<string> | null = null;
+
+    if (filter.types && filter.types.length > 0) {
+      const typeIds = new Set<string>();
+      for (const type of filter.types) {
+        const ids = this.indexByType.get(type);
+        if (ids) {
+          for (const id of ids) {
+            typeIds.add(id);
+          }
+        }
+      }
+      candidateIds = typeIds;
+    }
+
+    if (filter.tags && filter.tags.length > 0) {
+      const tagIds = new Set<string>();
+      for (const tag of filter.tags) {
+        const ids = this.indexByTag.get(tag);
+        if (ids) {
+          for (const id of ids) {
+            tagIds.add(id);
+          }
+        }
+      }
+      candidateIds = candidateIds 
+        ? new Set([...candidateIds].filter(id => tagIds.has(id)))
+        : tagIds;
+    }
+
+    if (filter.userId) {
+      const userIds = this.indexByUser.get(filter.userId);
+      if (userIds) {
+        candidateIds = candidateIds
+          ? new Set([...candidateIds].filter(id => userIds.has(id)))
+          : new Set(userIds);
+      }
+    }
+
+    if (filter.sessionId) {
+      const sessionIds = this.indexBySession.get(filter.sessionId);
+      if (sessionIds) {
+        candidateIds = candidateIds
+          ? new Set([...candidateIds].filter(id => sessionIds.has(id)))
+          : new Set(sessionIds);
+      }
+    }
+
+    const idsToSearch = candidateIds || new Set(this.memories.keys());
+    const results: Memory[] = [];
+
+    for (const id of idsToSearch) {
+      const memory = this.memories.get(id);
+      if (!memory) continue;
+
+      if (filter.minImportance !== undefined && memory.metadata.importance < filter.minImportance) {
+        continue;
+      }
+
+      if (filter.maxImportance !== undefined && memory.metadata.importance > filter.maxImportance) {
+        continue;
+      }
+
+      if (filter.startDate !== undefined && memory.timestamp < filter.startDate) {
+        continue;
+      }
+
+      if (filter.endDate !== undefined && memory.timestamp > filter.endDate) {
+        continue;
+      }
+
+      if (filter.metadata) {
+        const matches = Object.entries(filter.metadata).every(
+          ([key, value]) => memory.metadata[key] === value
+        );
+        if (!matches) continue;
+      }
+
+      results.push({ ...memory });
+    }
+
+    results.sort((a, b) => b.timestamp - a.timestamp);
+    return results.slice(0, limit);
+  }
+
+  async getByTimeRange(startDate: number, endDate: number): Promise<Memory[]> {
+    const results: Memory[] = [];
+    
+    for (const id of this.indexByTime) {
+      const memory = this.memories.get(id);
+      if (!memory) continue;
+      
+      if (memory.timestamp >= startDate && memory.timestamp <= endDate) {
+        results.push({ ...memory });
+      }
+    }
+    
+    return results;
+  }
+
+  async getRecent(limit: number = 10): Promise<Memory[]> {
+    const recentIds = this.indexByTime.slice(-limit).reverse();
+    return recentIds.map(id => ({ ...this.memories.get(id)! })).filter(Boolean);
+  }
+
+  async getStats(): Promise<MemoryStats> {
+    const memories = Array.from(this.memories.values());
+    
+    const memoriesByType: Record<MemoryType, number> = {
+      conversation: 0,
+      fact: 0,
+      preference: 0,
+      instruction: 0,
+      context: 0,
+      custom: 0,
+    };
+
+    const memoriesByTag: Record<string, number> = {};
+
+    let oldestMemory = Date.now();
+    let newestMemory = 0;
+
+    for (const memory of memories) {
+      memoriesByType[memory.metadata.type]++;
+      
+      const tags = memory.metadata.tags || [];
+      for (const tag of tags) {
+        memoriesByTag[tag] = (memoriesByTag[tag] || 0) + 1;
+      }
+
+      if (memory.timestamp < oldestMemory) oldestMemory = memory.timestamp;
+      if (memory.timestamp > newestMemory) newestMemory = memory.timestamp;
+    }
+
+    return {
+      totalMemories: memories.length,
+      memoriesByType,
+      memoriesByTag,
+      oldestMemory: memories.length > 0 ? oldestMemory : Date.now(),
+      newestMemory: memories.length > 0 ? newestMemory : Date.now(),
+    };
+  }
+
+  async clear(): Promise<void> {
+    this.memories.clear();
+    this.indexByTag.clear();
+    this.indexByUser.clear();
+    this.indexBySession.clear();
+    this.indexByTime.length = 0;
+    this.initializeIndexes();
+  }
+
+  async size(): Promise<number> {
+    return this.memories.size;
+  }
+}

package/src/planManager.ts

@@ -0,0 +1,417 @@
+import { RateLimiter, RateLimitResult, DEFAULT_RATE_LIMITS } from './rateLimiter.js';
+import { UsageTracker, UsageLimits, UsageCheckResult, DEFAULT_USAGE_LIMITS } from './usageTracker.js';
+import { EmbeddingFunction, Memory, MemoryMetadata, SearchResult, ContextResult, MemoryStats } from './types.js';
+import { InMemoryVectorStore } from './vectorStore.js';
+import { MetadataStore } from './metadataStore.js';
+import { AIMemoryConfig, validateConfig } from './config.js';
+
+export type Plan = 'free' | 'starter' | 'pro' | 'enterprise';
+export type ExtensionPlan = 'free' | 'starter' | 'plus' | 'premium';
+export type TeamPlan = 'free' | 'team' | 'business' | 'enterprise';
+export type ProductPlan = Plan | ExtensionPlan | TeamPlan;
+
+export type ProductType = 'npm' | 'extension' | 'team';
+
+export interface PlanConfig {
+  name: ProductPlan;
+  price: number;
+  billingPeriod: 'monthly' | 'yearly';
+  productType: ProductType;
+  features: PlanFeatures;
+}
+
+export interface PlanFeatures {
+  maxMemories: number;
+  maxSearchPerDay: number;
+  maxContextPerDay: number;
+  maxApiCallsPerDay: number;
+  maxStorageMB: number;
+  embeddingDimension: number;
+  persistence: 'memory' | 'redis' | 'postgres';
+  support: 'community' | 'email' | 'priority';
+  customIntegrations: boolean;
+  apiKeys: number;
+  teamMembers: number;
+  cloudSync: boolean;
+  advancedSearch: boolean;
+  teamSharing: boolean;
+}
+
+export interface PlanLimits {
+  rateLimit: {
+    windowMs: number;
+    maxRequests: number;
+  };
+  usage: UsageLimits;
+}
+
+export const PLANS: Record<ProductPlan, PlanConfig> = {
+  // NPM Plans
+  free: {
+    name: 'free',
+    price: 0,
+    billingPeriod: 'monthly',
+    productType: 'npm',
+    features: {
+      maxMemories: 5000,
+      maxSearchPerDay: 500,
+      maxContextPerDay: 200,
+      maxApiCallsPerDay: 5000,
+      maxStorageMB: 50,
+      embeddingDimension: 1536,
+      persistence: 'memory',
+      support: 'community',
+      customIntegrations: false,
+      apiKeys: 0,
+      teamMembers: 1,
+      cloudSync: false,
+      advancedSearch: false,
+      teamSharing: false,
+    },
+  },
+  starter: {
+    name: 'starter',
+    price: 3,
+    billingPeriod: 'monthly',
+    productType: 'extension',
+    features: {
+      maxMemories: 30000,
+      maxSearchPerDay: 1000,
+      maxContextPerDay: 500,
+      maxApiCallsPerDay: 10000,
+      maxStorageMB: 100,
+      embeddingDimension: 1536,
+      persistence: 'memory',
+      support: 'community',
+      customIntegrations: false,
+      apiKeys: 1,
+      teamMembers: 1,
+      cloudSync: true,
+      advancedSearch: false,
+      teamSharing: false,
+    },
+  },
+  pro: {
+    name: 'pro',
+    price: 29,
+    billingPeriod: 'monthly',
+    productType: 'npm',
+    features: {
+      maxMemories: 50000,
+      maxSearchPerDay: 10000,
+      maxContextPerDay: 5000,
+      maxApiCallsPerDay: 100000,
+      maxStorageMB: 500,
+      embeddingDimension: 1536,
+      persistence: 'redis',
+      support: 'email',
+      customIntegrations: false,
+      apiKeys: 5,
+      teamMembers: 5,
+      cloudSync: true,
+      advancedSearch: true,
+      teamSharing: false,
+    },
+  },
+  plus: {
+    name: 'plus',
+    price: 9,
+    billingPeriod: 'monthly',
+    productType: 'extension',
+    features: {
+      maxMemories: 150000,
+      maxSearchPerDay: 5000,
+      maxContextPerDay: 2000,
+      maxApiCallsPerDay: 50000,
+      maxStorageMB: 250,
+      embeddingDimension: 1536,
+      persistence: 'memory',
+      support: 'email',
+      customIntegrations: false,
+      apiKeys: 2,
+      teamMembers: 2,
+      cloudSync: true,
+      advancedSearch: true,
+      teamSharing: false,
+    },
+  },
+  premium: {
+    name: 'premium',
+    price: 29,
+    billingPeriod: 'monthly',
+    productType: 'extension',
+    features: {
+      maxMemories: -1,
+      maxSearchPerDay: -1,
+      maxContextPerDay: -1,
+      maxApiCallsPerDay: -1,
+      maxStorageMB: -1,
+      embeddingDimension: 3072,
+      persistence: 'redis',
+      support: 'priority',
+      customIntegrations: true,
+      apiKeys: 10,
+      teamMembers: 10,
+      cloudSync: true,
+      advancedSearch: true,
+      teamSharing: true,
+    },
+  },
+  // Team Plans
+  team: {
+    name: 'team',
+    price: 149,
+    billingPeriod: 'monthly',
+    productType: 'team',
+    features: {
+      maxMemories: 500000,
+      maxSearchPerDay: 100000,
+      maxContextPerDay: 50000,
+      maxApiCallsPerDay: 1000000,
+      maxStorageMB: 5000,
+      embeddingDimension: 1536,
+      persistence: 'redis',
+      support: 'email',
+      customIntegrations: true,
+      apiKeys: 50,
+      teamMembers: 10,
+      cloudSync: true,
+      advancedSearch: true,
+      teamSharing: true,
+    },
+  },
+  business: {
+    name: 'business',
+    price: 399,
+    billingPeriod: 'monthly',
+    productType: 'team',
+    features: {
+      maxMemories: 2000000,
+      maxSearchPerDay: 500000,
+      maxContextPerDay: 200000,
+      maxApiCallsPerDay: 5000000,
+      maxStorageMB: 20000,
+      embeddingDimension: 3072,
+      persistence: 'postgres',
+      support: 'priority',
+      customIntegrations: true,
+      apiKeys: 200,
+      teamMembers: 50,
+      cloudSync: true,
+      advancedSearch: true,
+      teamSharing: true,
+    },
+  },
+  enterprise: {
+    name: 'enterprise',
+    price: 999,
+    billingPeriod: 'monthly',
+    productType: 'team',
+    features: {
+      maxMemories: -1,
+      maxSearchPerDay: -1,
+      maxContextPerDay: -1,
+      maxApiCallsPerDay: -1,
+      maxStorageMB: -1,
+      embeddingDimension: 3072,
+      persistence: 'postgres',
+      support: 'priority',
+      customIntegrations: true,
+      apiKeys: -1,
+      teamMembers: -1,
+      cloudSync: true,
+      advancedSearch: true,
+      teamSharing: true,
+    },
+  },
+};
+
+export function getPlanLimits(plan: ProductPlan): PlanLimits {
+  const limits = DEFAULT_RATE_LIMITS[plan] || DEFAULT_RATE_LIMITS.free;
+  const usage = DEFAULT_USAGE_LIMITS[plan] || DEFAULT_USAGE_LIMITS.free;
+  return {
+    rateLimit: limits,
+    usage: usage,
+  };
+}
+
+export function getPlan(plan: ProductPlan): PlanConfig {
+  return PLANS[plan];
+}
+
+export class PlanManager {
+  private userPlans: Map<string, ProductPlan> = new Map();
+  private rateLimiters: Map<string, RateLimiter> = new Map();
+  private usageTrackers: Map<string, UsageTracker> = new Map();
+  private defaultPlan: ProductPlan = 'free';
+
+  setUserPlan(userId: string, plan: ProductPlan): void {
+    this.userPlans.set(userId, plan);
+    
+    const limits = getPlanLimits(plan);
+    this.rateLimiters.set(userId, new RateLimiter(limits.rateLimit));
+    this.usageTrackers.set(userId, new UsageTracker(limits.usage));
+  }
+
+  getUserPlan(userId: string): ProductPlan {
+    return this.userPlans.get(userId) || this.defaultPlan;
+  }
+
+  getUserPlanConfig(userId: string): PlanConfig {
+    const plan = this.getUserPlan(userId);
+    return PLANS[plan];
+  }
+
+  checkRateLimit(userId: string): Promise<RateLimitResult> {
+    let limiter = this.rateLimiters.get(userId);
+    
+    if (!limiter) {
+      const plan = this.getUserPlan(userId);
+      const limits = getPlanLimits(plan);
+      limiter = new RateLimiter(limits.rateLimit);
+      this.rateLimiters.set(userId, limiter);
+    }
+    
+    return limiter.check(userId);
+  }
+
+  async checkUsageLimit(userId: string, metric: 'memories_added' | 'memories_searched' | 'context_built' | 'api_calls'): Promise<UsageCheckResult> {
+    let tracker = this.usageTrackers.get(userId);
+    
+    if (!tracker) {
+      const plan = this.getUserPlan(userId);
+      const limits = getPlanLimits(plan);
+      tracker = new UsageTracker(limits.usage);
+      this.usageTrackers.set(userId, tracker);
+    }
+    
+    return tracker.checkLimit(userId, metric);
+  }
+
+  async recordUsage(userId: string, metric: 'memories_added' | 'memories_searched' | 'context_built' | 'api_calls'): Promise<UsageCheckResult> {
+    let tracker = this.usageTrackers.get(userId);
+    
+    if (!tracker) {
+      const plan = this.getUserPlan(userId);
+      const limits = getPlanLimits(plan);
+      tracker = new UsageTracker(limits.usage);
+      this.usageTrackers.set(userId, tracker);
+    }
+    
+    return tracker.recordUsage(userId, metric);
+  }
+
+  async getUsageSummary(userId: string, period: 'daily' | 'monthly' | 'yearly') {
+    let tracker = this.usageTrackers.get(userId);
+    
+    if (!tracker) {
+      const plan = this.getUserPlan(userId);
+      const limits = getPlanLimits(plan);
+      tracker = new UsageTracker(limits.usage);
+      this.usageTrackers.set(userId, tracker);
+    }
+    
+    return tracker.getUsageSummary(userId, period);
+  }
+
+  removeUser(userId: string): void {
+    this.userPlans.delete(userId);
+    this.rateLimiters.delete(userId);
+    this.usageTrackers.delete(userId);
+  }
+
+  setDefaultPlan(plan: ProductPlan): void {
+    this.defaultPlan = plan;
+  }
+
+  getAllPlans(): PlanConfig[] {
+    return Object.values(PLANS);
+  }
+
+  getPlansByType(type: ProductType): PlanConfig[] {
+    return Object.values(PLANS).filter(p => p.productType === type);
+  }
+
+  getPlanByName(name: string): PlanConfig | null {
+    return PLANS[name as ProductPlan] || null;
+  }
+}
+
+export class AIMemoryPro {
+  private planManager: PlanManager;
+  private config: AIMemoryConfig;
+  private embeddingFunction: EmbeddingFunction | null = null;
+
+  constructor(config?: Partial<AIMemoryConfig>, planManager?: PlanManager) {
+    this.config = validateConfig(config || {});
+    this.planManager = planManager || new PlanManager();
+  }
+
+  setEmbeddingFunction(fn: EmbeddingFunction): void {
+    this.embeddingFunction = fn;
+  }
+
+  setUserPlan(userId: string, plan: ProductPlan): void {
+    this.planManager.setUserPlan(userId, plan);
+  }
+
+  async checkAccess(userId: string): Promise<{ allowed: boolean; reason?: string }> {
+    const rateResult = await this.planManager.checkRateLimit(userId);
+    
+    if (!rateResult.allowed) {
+      return {
+        allowed: false,
+        reason: `Rate limit exceeded. Retry after ${rateResult.retryAfter} seconds.`,
+      };
+    }
+
+    const usageResult = await this.planManager.checkUsageLimit(userId, 'api_calls');
+    
+    if (!usageResult.allowed) {
+      return {
+        allowed: false,
+        reason: `API limit exceeded. Upgrade to Pro for more calls.`,
+      };
+    }
+
+    return { allowed: true };
+  }
+
+  async addMemory(
+    userId: string,
+    content: string,
+    metadata?: Partial<MemoryMetadata>
+  ): Promise<Memory | { error: string }> {
+    const access = await this.checkAccess(userId);
+    
+    if (!access.allowed) {
+      return { error: access.reason! };
+    }
+
+    const usageCheck = await this.planManager.checkUsageLimit(userId, 'memories_added');
+    
+    if (!usageCheck.allowed) {
+      return { error: 'Memory limit reached. Upgrade your plan.' };
+    }
+
+    await this.planManager.recordUsage(userId, 'api_calls');
+    
+    return { error: 'Not implemented - requires memory manager' };
+  }
+
+  getPlanManager(): PlanManager {
+    return this.planManager;
+  }
+
+  getPlanConfig(userId: string) {
+    return this.planManager.getUserPlanConfig(userId);
+  }
+}
+
+export function createPlanManager(): PlanManager {
+  return new PlanManager();
+}
+
+export function getAvailablePlans(): PlanConfig[] {
+  return Object.values(PLANS);
+}