aimemory-core 1.0.1

package/src/index.ts

@@ -0,0 +1,209 @@
+import { Memory, MemoryMetadata, SearchResult, ContextResult, MemoryStats, EmbeddingFunction } from './types';
+import { AIMemoryConfig, validateConfig } from './config';
+import { MemoryManager } from './memoryManager';
+import { ContextBuilder } from './contextBuilder';
+
+export {
+  Memory,
+  MemoryMetadata,
+  MemoryType,
+  SearchResult,
+  MemoryQuery,
+  MemoryFilter,
+  MemoryStats,
+  ContextConfig,
+  ContextMessage,
+  ContextResult,
+  EmbeddingFunction,
+  StorageAdapter,
+  VectorStoreAdapter,
+  VectorEntry,
+  SearchOptions,
+} from './types';
+
+export {
+  AIMemoryConfig,
+  DEFAULT_CONFIG,
+  validateConfig,
+} from './config';
+
+export {
+  InMemoryVectorStore,
+  VectorStoreFactory,
+} from './vectorStore';
+
+export {
+  MetadataStore,
+} from './metadataStore';
+
+export {
+  MemoryManager,
+  createMemoryManager,
+} from './memoryManager';
+
+export {
+  ContextBuilder,
+  createContextBuilder,
+} from './contextBuilder';
+
+export {
+  RateLimiter,
+  RateLimitResult,
+  RateLimitConfig,
+  RateLimitStore,
+  InMemoryRateLimitStore,
+  createRateLimiter,
+  DEFAULT_RATE_LIMITS,
+} from './rateLimiter';
+
+export {
+  UsageTracker,
+  UsageLimits,
+  UsageCheckResult,
+  UsageMetric,
+  UsageSummary,
+  UsageStore,
+  InMemoryUsageStore,
+  createUsageTracker,
+  DEFAULT_USAGE_LIMITS,
+} from './usageTracker';
+
+export {
+  PlanManager,
+  PlanManager as AIMemoryPro,
+  Plan,
+  ExtensionPlan,
+  TeamPlan,
+  ProductPlan,
+  ProductType,
+  PlanConfig,
+  PlanFeatures,
+  PlanLimits,
+  PLANS,
+  getPlan,
+  getPlanLimits,
+  getAvailablePlans,
+  createPlanManager,
+} from './planManager';
+
+export {
+  RedisRateLimitStore,
+  PostgresUsageStore,
+  RedisConfig,
+  PostgresConfig,
+  createRedisRateLimiter,
+  createPostgresUsageStore,
+} from './storage';
+
+export {
+  LicenseManager,
+  AIMemoryLicense,
+  LicenseConfig,
+  LicenseValidation,
+  createLicenseManager,
+  getLicenseManager,
+} from './licensing';
+
+export class AIMemory {
+  private memoryManager: MemoryManager;
+  private contextBuilder: ContextBuilder;
+
+  constructor(config?: Partial<AIMemoryConfig>) {
+    const validatedConfig = validateConfig(config || {});
+    this.memoryManager = new MemoryManager(validatedConfig);
+    this.contextBuilder = new ContextBuilder(
+      this.memoryManager, 
+      validatedConfig.context
+    );
+  }
+
+  setEmbeddingFunction(fn: EmbeddingFunction): void {
+    this.memoryManager.setEmbeddingFunction(fn);
+  }
+
+  async remember(content: string, metadata?: Partial<MemoryMetadata>): Promise<Memory> {
+    return this.memoryManager.addMemory(content, metadata);
+  }
+
+  async rememberConversation(
+    content: string, 
+    role: 'user' | 'assistant',
+    metadata?: Partial<MemoryMetadata>
+  ): Promise<Memory> {
+    return this.memoryManager.addConversation(content, role, metadata);
+  }
+
+  async rememberFact(content: string, metadata?: Partial<MemoryMetadata>): Promise<Memory> {
+    return this.memoryManager.addFact(content, metadata);
+  }
+
+  async rememberPreference(content: string, metadata?: Partial<MemoryMetadata>): Promise<Memory> {
+    return this.memoryManager.addPreference(content, metadata);
+  }
+
+  async rememberInstruction(content: string, metadata?: Partial<MemoryMetadata>): Promise<Memory> {
+    return this.memoryManager.addInstruction(content, metadata);
+  }
+
+  async recall(query: string, options?: { limit?: number; threshold?: number }): Promise<SearchResult[]> {
+    return this.memoryManager.search({
+      text: query,
+      limit: options?.limit || 10,
+      threshold: options?.threshold,
+    });
+  }
+
+  async getContext(query: string): Promise<ContextResult> {
+    return this.contextBuilder.buildContext(query);
+  }
+
+  async getMemory(id: string): Promise<Memory | null> {
+    return this.memoryManager.getMemory(id);
+  }
+
+  async updateMemory(id: string, updates: Partial<Memory>): Promise<Memory | null> {
+    return this.memoryManager.updateMemory(id, updates);
+  }
+
+  async forget(id: string): Promise<void> {
+    return this.memoryManager.deleteMemory(id);
+  }
+
+  async getRecentMemories(limit?: number): Promise<Memory[]> {
+    return this.memoryManager.getRecentMemories(limit);
+  }
+
+  async getStats(): Promise<MemoryStats> {
+    return this.memoryManager.getStats();
+  }
+
+  async clear(): Promise<void> {
+    return this.memoryManager.clear();
+  }
+
+  async cleanup(): Promise<number> {
+    return this.memoryManager.cleanup();
+  }
+
+  async exportData(): Promise<Memory[]> {
+    return this.memoryManager.exportData();
+  }
+
+  async importData(memories: Memory[]): Promise<void> {
+    return this.memoryManager.importData(memories);
+  }
+
+  getMemoryManager(): MemoryManager {
+    return this.memoryManager;
+  }
+
+  getContextBuilder(): ContextBuilder {
+    return this.contextBuilder;
+  }
+}
+
+export function createAIMemory(config?: Partial<AIMemoryConfig>): AIMemory {
+  return new AIMemory(config);
+}
+
+export { createAIMemory as createAIBrain };

package/src/licensing.ts

@@ -0,0 +1,138 @@
+import { PLANS, ProductPlan, PlanConfig } from './planManager.js';
+
+export interface LicenseConfig {
+  apiKey?: string;
+  userId?: string;
+  environment: 'development' | 'production';
+}
+
+export interface LicenseValidation {
+  valid: boolean;
+  plan: ProductPlan;
+  features: PlanConfig['features'];
+  error?: string;
+}
+
+export interface AIMemoryLicense {
+  validate(config: LicenseConfig): Promise<LicenseValidation>;
+  getPlan(userId: string): ProductPlan;
+  setPlan(userId: string, plan: ProductPlan): void;
+  requiresApiKey(): boolean;
+  isDevelopmentMode(): boolean;
+}
+
+export class LicenseManager implements AIMemoryLicense {
+  private userPlans: Map<string, ProductPlan> = new Map();
+  private developmentMode: boolean;
+  private apiKeys: Map<string, { userId: string; plan: ProductPlan }> = new Map();
+
+  constructor(options?: { developmentMode?: boolean; apiKeys?: Map<string, { userId: string; plan: ProductPlan }> }) {
+    this.developmentMode = options?.developmentMode ?? true;
+    if (options?.apiKeys) {
+      this.apiKeys = options.apiKeys;
+    }
+  }
+
+  async validate(config: LicenseConfig): Promise<LicenseValidation> {
+    if (config.environment === 'development' && this.developmentMode) {
+      return {
+        valid: true,
+        plan: 'free',
+        features: PLANS.free.features,
+      };
+    }
+
+    if (config.environment === 'production') {
+      if (!config.apiKey && !this.developmentMode) {
+        return {
+          valid: false,
+          plan: 'free',
+          features: PLANS.free.features,
+          error: 'API key required for production use. Get one at https://aimemory.dev/dashboard',
+        };
+      }
+
+      if (config.apiKey) {
+        const keyData = this.apiKeys.get(config.apiKey);
+        if (!keyData) {
+          return {
+            valid: false,
+            plan: 'free',
+            features: PLANS.free.features,
+            error: 'Invalid API key',
+          };
+        }
+        return {
+          valid: true,
+          plan: keyData.plan,
+          features: PLANS[keyData.plan].features,
+        };
+      }
+
+      if (!config.userId) {
+        return {
+          valid: false,
+          plan: 'free',
+          features: PLANS.free.features,
+          error: 'User ID required',
+        };
+      }
+
+      const userPlan = this.getPlan(config.userId);
+      return {
+        valid: true,
+        plan: userPlan,
+        features: PLANS[userPlan].features,
+      };
+    }
+
+    return {
+      valid: true,
+      plan: 'free',
+      features: PLANS.free.features,
+    };
+  }
+
+  getPlan(userId: string): ProductPlan {
+    return this.userPlans.get(userId) || 'free';
+  }
+
+  setPlan(userId: string, plan: ProductPlan): void {
+    this.userPlans.set(userId, plan);
+  }
+
+  registerApiKey(apiKey: string, userId: string, plan: ProductPlan): void {
+    this.apiKeys.set(apiKey, { userId, plan });
+  }
+
+  revokeApiKey(apiKey: string): boolean {
+    return this.apiKeys.delete(apiKey);
+  }
+
+  requiresApiKey(): boolean {
+    return !this.developmentMode;
+  }
+
+  isDevelopmentMode(): boolean {
+    return this.developmentMode;
+  }
+
+  enableProductionMode(): void {
+    this.developmentMode = false;
+  }
+
+  disableProductionMode(): void {
+    this.developmentMode = true;
+  }
+}
+
+let globalLicenseManager: LicenseManager | null = null;
+
+export function createLicenseManager(options?: { developmentMode?: boolean }): LicenseManager {
+  globalLicenseManager = new LicenseManager(options);
+  return globalLicenseManager;
+}
+
+export function getLicenseManager(): LicenseManager | null {
+  return globalLicenseManager;
+}

package/src/memoryManager.ts

@@ -0,0 +1,340 @@
+import { v4 as uuidv4 } from 'uuid';
+import { 
+  Memory, 
+  MemoryMetadata, 
+  MemoryType, 
+  MemoryQuery, 
+  SearchResult,
+  MemoryStats,
+  EmbeddingFunction
+} from './types.js';
+import { InMemoryVectorStore } from './vectorStore.js';
+import { MetadataStore } from './metadataStore.js';
+import { AIMemoryConfig, validateConfig } from './config.js';
+
+export class MemoryManager {
+  private vectorStore: InMemoryVectorStore;
+  private metadataStore: MetadataStore;
+  private config: AIMemoryConfig;
+  private embeddingFunction: EmbeddingFunction | null = null;
+
+  constructor(config: Partial<AIMemoryConfig> = {}) {
+    this.config = validateConfig(config);
+    this.vectorStore = new InMemoryVectorStore(this.config.embeddingDimension);
+    this.metadataStore = new MetadataStore();
+  }
+
+  setEmbeddingFunction(fn: EmbeddingFunction): void {
+    this.embeddingFunction = fn;
+  }
+
+  async addMemory(
+    content: string,
+    metadata: Partial<MemoryMetadata> = {}
+  ): Promise<Memory> {
+    const id = uuidv4();
+    const timestamp = Date.now();
+
+    const fullMetadata: MemoryMetadata = {
+      type: metadata.type || 'context',
+      importance: metadata.importance ?? this.config.defaultImportance,
+      tags: metadata.tags || [],
+      userId: metadata.userId,
+      sessionId: metadata.sessionId,
+      source: metadata.source,
+      ...metadata,
+    };
+
+    let embedding: number[] | undefined;
+    if (this.embeddingFunction) {
+      try {
+        embedding = await this.embeddingFunction(content);
+      } catch (error) {
+        console.warn('Failed to generate embedding:', error);
+      }
+    }
+
+    const memory: Memory = {
+      id,
+      content,
+      embedding,
+      timestamp,
+      metadata: fullMetadata,
+    };
+
+    await this.metadataStore.add(memory);
+
+    if (embedding) {
+      await this.vectorStore.add([{
+        id,
+        vector: embedding,
+        metadata: { ...memory },
+      }]);
+    }
+
+    await this.enforceMaxMemories();
+
+    return memory;
+  }
+
+  async addConversation(
+    content: string,
+    role: 'user' | 'assistant',
+    metadata: Partial<MemoryMetadata> = {}
+  ): Promise<Memory> {
+    const prefix = role === 'user' ? 'User: ' : 'Assistant: ';
+    return this.addMemory(prefix + content, {
+      type: 'conversation',
+      ...metadata,
+    });
+  }
+
+  async addFact(
+    content: string,
+    metadata: Partial<MemoryMetadata> = {}
+  ): Promise<Memory> {
+    return this.addMemory(content, {
+      type: 'fact',
+      importance: Math.max(metadata.importance ?? 0.7, 0.7),
+      ...metadata,
+    });
+  }
+
+  async addPreference(
+    content: string,
+    metadata: Partial<MemoryMetadata> = {}
+  ): Promise<Memory> {
+    return this.addMemory(content, {
+      type: 'preference',
+      importance: Math.max(metadata.importance ?? 0.6, 0.6),
+      ...metadata,
+    });
+  }
+
+  async addInstruction(
+    content: string,
+    metadata: Partial<MemoryMetadata> = {}
+  ): Promise<Memory> {
+    return this.addMemory(content, {
+      type: 'instruction',
+      importance: Math.max(metadata.importance ?? 0.9, 0.9),
+      ...metadata,
+    });
+  }
+
+  async search(query: MemoryQuery): Promise<SearchResult[]> {
+    const { text, embedding, filter, limit = 10, threshold } = query;
+
+    if (!embedding && !text) {
+      throw new Error('Either text or embedding must be provided');
+    }
+
+    let searchEmbedding = embedding;
+
+    if (text && !searchEmbedding && this.embeddingFunction) {
+      try {
+        searchEmbedding = await this.embeddingFunction(text);
+      } catch (error) {
+        console.warn('Failed to generate embedding for search:', error);
+        const memories = await this.metadataStore.find(filter || {}, limit);
+        return memories.map(m => ({ memory: m, score: 1 }));
+      }
+    }
+
+    if (searchEmbedding) {
+      const vectorResults = await this.vectorStore.search(searchEmbedding, {
+        limit: limit * 2,
+        threshold,
+        filter: filter ? this.buildVectorFilter(filter) : undefined,
+      });
+
+      let results = vectorResults;
+      
+      if (filter) {
+        results = vectorResults.filter(r => this.matchesFilter(r.memory, filter));
+      }
+
+      return results.slice(0, limit);
+    }
+
+    const memories = await this.metadataStore.find(filter || {}, limit);
+    return memories.map(m => ({ memory: m, score: 1 }));
+  }
+
+  private buildVectorFilter(filter: any): Record<string, unknown> {
+    const vectorFilter: Record<string, unknown> = {};
+    
+    if (filter.types) {
+      vectorFilter['metadata.type'] = { $in: filter.types };
+    }
+    if (filter.userId) {
+      vectorFilter['metadata.userId'] = filter.userId;
+    }
+    if (filter.sessionId) {
+      vectorFilter['metadata.sessionId'] = filter.sessionId;
+    }
+    
+    return vectorFilter;
+  }
+
+  private matchesFilter(memory: Memory, filter: any): boolean {
+    if (filter.types && !filter.types.includes(memory.metadata.type)) {
+      return false;
+    }
+    if (filter.tags) {
+      const hasTag = filter.tags.some((tag: string) => 
+        memory.metadata.tags.includes(tag)
+      );
+      if (!hasTag) return false;
+    }
+    if (filter.userId && memory.metadata.userId !== filter.userId) {
+      return false;
+    }
+    if (filter.sessionId && memory.metadata.sessionId !== filter.sessionId) {
+      return false;
+    }
+    if (filter.minImportance !== undefined && 
+        memory.metadata.importance < filter.minImportance) {
+      return false;
+    }
+    if (filter.maxImportance !== undefined && 
+        memory.metadata.importance > filter.maxImportance) {
+      return false;
+    }
+    if (filter.startDate !== undefined && memory.timestamp < filter.startDate) {
+      return false;
+    }
+    if (filter.endDate !== undefined && memory.timestamp > filter.endDate) {
+      return false;
+    }
+    return true;
+  }
+
+  async getMemory(id: string): Promise<Memory | null> {
+    return this.metadataStore.getById(id);
+  }
+
+  async updateMemory(id: string, updates: Partial<Memory>): Promise<Memory | null> {
+    const existing = await this.metadataStore.getById(id);
+    if (!existing) return null;
+
+    const updated: Memory = {
+      ...existing,
+      ...updates,
+      id,
+      metadata: {
+        ...existing.metadata,
+        ...updates.metadata,
+      },
+    };
+
+    await this.metadataStore.update(updated);
+
+    if (updates.embedding || updates.content) {
+      const embedding = updates.embedding || existing.embedding;
+      if (embedding) {
+        await this.vectorStore.delete([id]);
+        await this.vectorStore.add([{
+          id,
+          vector: embedding,
+          metadata: { ...updated },
+        }]);
+      }
+    }
+
+    return updated;
+  }
+
+  async deleteMemory(id: string): Promise<void> {
+    await this.metadataStore.delete(id);
+    await this.vectorStore.delete([id]);
+  }
+
+  async getRecentMemories(limit: number = 10): Promise<Memory[]> {
+    return this.metadataStore.getRecent(limit);
+  }
+
+  async getMemoriesByType(type: MemoryType, limit: number = 50): Promise<Memory[]> {
+    return this.metadataStore.find({ types: [type] }, limit);
+  }
+
+  async getMemoriesByTag(tag: string, limit: number = 50): Promise<Memory[]> {
+    return this.metadataStore.find({ tags: [tag] }, limit);
+  }
+
+  async getMemoriesByUser(userId: string, limit: number = 50): Promise<Memory[]> {
+    return this.metadataStore.find({ userId }, limit);
+  }
+
+  async getMemoriesBySession(sessionId: string, limit: number = 50): Promise<Memory[]> {
+    return this.metadataStore.find({ sessionId }, limit);
+  }
+
+  async getStats(): Promise<MemoryStats> {
+    return this.metadataStore.getStats();
+  }
+
+  async clear(): Promise<void> {
+    await this.metadataStore.clear();
+    await this.vectorStore.clear();
+  }
+
+  private async enforceMaxMemories(): Promise<void> {
+    const size = await this.metadataStore.size();
+    
+    if (size > this.config.maxMemories) {
+      const memories = await this.metadataStore.getRecent(size);
+      const toDelete = memories
+        .filter(m => m.metadata.importance < this.config.autoCleanup.minImportance)
+        .slice(this.config.maxMemories - size);
+
+      for (const memory of toDelete) {
+        await this.deleteMemory(memory.id);
+      }
+    }
+  }
+
+  async cleanup(): Promise<number> {
+    if (!this.config.autoCleanup.enabled) return 0;
+
+    const cutoff = Date.now() - this.config.autoCleanup.maxAge;
+    const allMemories = await this.metadataStore.getAll();
+    
+    let deletedCount = 0;
+    for (const memory of allMemories) {
+      if (memory.timestamp < cutoff && 
+          memory.metadata.importance < this.config.autoCleanup.minImportance) {
+        await this.deleteMemory(memory.id);
+        deletedCount++;
+      }
+    }
+
+    return deletedCount;
+  }
+
+  getConfig(): Readonly<AIMemoryConfig> {
+    return { ...this.config };
+  }
+
+  async exportData(): Promise<Memory[]> {
+    return this.metadataStore.getAll();
+  }
+
+  async importData(memories: Memory[]): Promise<void> {
+    for (const memory of memories) {
+      await this.metadataStore.add(memory);
+      
+      if (memory.embedding) {
+        await this.vectorStore.add([{
+          id: memory.id,
+          vector: memory.embedding,
+          metadata: { ...memory },
+        }]);
+      }
+    }
+  }
+}
+
+export function createMemoryManager(config?: Partial<AIMemoryConfig>): MemoryManager {
+  return new MemoryManager(config);
+}