@lov3kaizen/agentsea-memory 0.5.1

package/dist/index-BGxYqpFb.d.cts

@@ -0,0 +1,601 @@
+import { L as LLMProviderInterface, c as MemoryEntry, i as MemoryStoreInterface } from './core.types-lkxKv-bW.cjs';
+
+/**
+ * Processing Types
+ *
+ * Types for memory processing utilities.
+ */
+
+/**
+ * Summarization strategy
+ */
+type SummarizationStrategy = 'hierarchical' | 'incremental' | 'abstractive' | 'extractive';
+/**
+ * Summarizer configuration
+ */
+interface SummarizerConfig {
+    provider?: LLMProviderInterface;
+    model?: string;
+    strategy?: SummarizationStrategy;
+    maxLength?: number;
+    preserveEntities?: boolean;
+    focusPrompt?: string;
+    maxSummaryLength?: number;
+    minEntriesForSummary?: number;
+    preserveKeyEntities?: boolean;
+    summaryStyle?: string;
+}
+/**
+ * Compression strategy
+ */
+type CompressionStrategy = 'importance-weighted' | 'recency' | 'semantic-clustering' | 'hybrid';
+/**
+ * Compressor configuration
+ */
+interface CompressorConfig {
+    targetRatio?: number;
+    preserveImportant?: boolean;
+    strategy?: CompressionStrategy;
+    minImportance?: number;
+    minContentLength?: number;
+    removeEmbeddings?: boolean;
+    truncateMetadata?: boolean;
+}
+/**
+ * Merge strategy for consolidation
+ */
+type MergeStrategy = 'newest-wins' | 'confidence-weighted' | 'union' | 'intersection';
+/**
+ * Consolidator configuration
+ */
+interface ConsolidatorConfig {
+    similarityThreshold?: number;
+    mergeStrategy?: MergeStrategy;
+    extractRelations?: boolean;
+    maxBatchSize?: number;
+    minGroupSize?: number;
+    maxGroupSize?: number;
+    groupingStrategy?: 'semantic' | 'temporal' | 'type';
+    preserveOriginals?: boolean;
+}
+/**
+ * Retention policy
+ */
+interface RetentionPolicy {
+    critical?: number;
+    high?: number;
+    medium?: number;
+    low?: number;
+    trivial?: number;
+}
+/**
+ * Forgetter configuration
+ */
+interface ForgetterConfig {
+    retentionPolicy?: RetentionPolicy;
+    importanceThreshold?: number;
+    maxAge?: number;
+    preserveTypes?: string[];
+    curve?: 'exponential' | 'power' | 'ebbinghaus';
+    halfLife?: number;
+    minRetention?: number;
+    accessBoost?: number;
+    importanceWeight?: number;
+    forgetThreshold?: number;
+}
+/**
+ * Extraction type
+ */
+type ExtractionType = 'person' | 'organization' | 'location' | 'date' | 'preference' | 'fact' | 'intent' | 'sentiment' | 'topic' | 'custom';
+/**
+ * Extractor configuration
+ */
+interface ExtractorConfig {
+    provider?: LLMProviderInterface;
+    model?: string;
+    extractTypes?: ExtractionType[];
+    customPrompt?: string;
+    confidence?: number;
+    extractEntities?: boolean;
+    extractRelations?: boolean;
+    extractKeywords?: boolean;
+    extractSentiment?: boolean;
+    minConfidence?: number;
+    maxEntitiesPerEntry?: number;
+}
+
+/**
+ * Summarizer
+ *
+ * Summarizes memory entries using LLM or heuristic methods.
+ */
+
+/**
+ * Summary result
+ */
+interface SummaryResult {
+    summary: string;
+    keyPoints: string[];
+    sourceCount: number;
+    compressionRatio: number;
+    metadata: Record<string, unknown>;
+}
+/**
+ * Summary function type (for LLM integration)
+ */
+type SummaryFunction = (entries: MemoryEntry[], options?: {
+    maxLength?: number;
+    style?: string;
+}) => Promise<string>;
+/**
+ * Memory summarizer
+ */
+declare class Summarizer {
+    private config;
+    private summaryFn?;
+    constructor(config?: SummarizerConfig);
+    /**
+     * Set custom summary function (for LLM integration)
+     */
+    setSummaryFunction(fn: SummaryFunction): void;
+    /**
+     * Summarize a collection of memories
+     */
+    summarize(entries: MemoryEntry[]): Promise<SummaryResult>;
+    /**
+     * Summarize memories by time period
+     */
+    summarizeByPeriod(entries: MemoryEntry[], period: 'hour' | 'day' | 'week'): Promise<Map<string, SummaryResult>>;
+    /**
+     * Summarize memories by topic/type
+     */
+    summarizeByTopic(entries: MemoryEntry[]): Promise<Map<string, SummaryResult>>;
+    /**
+     * Create incremental summary (add to existing summary)
+     */
+    incrementalSummarize(existingSummary: string, newEntries: MemoryEntry[]): Promise<SummaryResult>;
+    /**
+     * Heuristic-based summarization
+     */
+    private heuristicSummarize;
+    /**
+     * Create simple summary for few entries
+     */
+    private createSimpleSummary;
+    /**
+     * Extract key points from entries
+     */
+    private extractKeyPoints;
+    /**
+     * Group entries by time period
+     */
+    private groupByPeriod;
+    /**
+     * Group entries by topic/type
+     */
+    private groupByTopic;
+    /**
+     * Get time range description
+     */
+    private getTimeRange;
+    /**
+     * Calculate compression ratio
+     */
+    private calculateCompressionRatio;
+    /**
+     * Deduplicate similar strings
+     */
+    private deduplicateStrings;
+    /**
+     * Simple string similarity (Jaccard)
+     */
+    private stringSimilarity;
+    /**
+     * Update configuration
+     */
+    configure(config: Partial<SummarizerConfig>): void;
+}
+/**
+ * Create summarizer instance
+ */
+declare function createSummarizer(config?: SummarizerConfig): Summarizer;
+
+/**
+ * Compressor
+ *
+ * Compresses memory entries to save space while preserving key information.
+ */
+
+/**
+ * Compression result
+ */
+interface CompressionResult {
+    compressed: MemoryEntry;
+    originalSize: number;
+    compressedSize: number;
+    ratio: number;
+    preservedFields: string[];
+}
+/**
+ * Batch compression result
+ */
+interface BatchCompressionResult {
+    entries: MemoryEntry[];
+    totalOriginalSize: number;
+    totalCompressedSize: number;
+    avgRatio: number;
+    removedCount: number;
+}
+/**
+ * Memory compressor
+ */
+declare class Compressor {
+    private config;
+    constructor(config?: CompressorConfig);
+    /**
+     * Compress a single memory entry
+     */
+    compress(entry: MemoryEntry): CompressionResult;
+    /**
+     * Compress multiple entries
+     */
+    compressBatch(entries: MemoryEntry[]): BatchCompressionResult;
+    /**
+     * Compress entries to target size
+     */
+    compressToSize(entries: MemoryEntry[], targetSize: number): BatchCompressionResult;
+    /**
+     * Deduplicate and compress similar entries
+     */
+    deduplicateAndCompress(entries: MemoryEntry[]): BatchCompressionResult;
+    /**
+     * Truncate content based on importance
+     */
+    private truncateContent;
+    /**
+     * Truncate metadata
+     */
+    private truncateMetadata;
+    /**
+     * Aggressive compression for tight space constraints
+     */
+    private aggressiveCompress;
+    /**
+     * Get deduplication key for entry
+     */
+    private getDedupeKey;
+    /**
+     * Calculate approximate size of entry in bytes
+     */
+    private calculateSize;
+    /**
+     * Update configuration
+     */
+    configure(config: Partial<CompressorConfig>): void;
+}
+/**
+ * Create compressor instance
+ */
+declare function createCompressor(config?: CompressorConfig): Compressor;
+
+/**
+ * Consolidator
+ *
+ * Merges similar or related memories into consolidated entries.
+ */
+
+/**
+ * Consolidation group
+ */
+interface ConsolidationGroup {
+    id: string;
+    entries: MemoryEntry[];
+    similarity: number;
+    groupKey: string;
+}
+/**
+ * Consolidation result
+ */
+interface ConsolidationResult {
+    consolidated: MemoryEntry;
+    sourceIds: string[];
+    groupKey: string;
+    avgImportance: number;
+    timeSpan: {
+        start: number;
+        end: number;
+    };
+}
+/**
+ * Memory consolidator
+ */
+declare class Consolidator {
+    private config;
+    private summarizer;
+    private embedFn?;
+    constructor(config?: ConsolidatorConfig);
+    /**
+     * Set embedding function for semantic grouping
+     */
+    setEmbeddingFunction(fn: (text: string) => Promise<number[]>): void;
+    /**
+     * Set summarizer function
+     */
+    setSummarizerFunction(fn: (entries: MemoryEntry[], options?: {
+        maxLength?: number;
+    }) => Promise<string>): void;
+    /**
+     * Find and consolidate similar memories
+     */
+    consolidate(entries: MemoryEntry[], store?: MemoryStoreInterface): Promise<ConsolidationResult[]>;
+    /**
+     * Group similar entries
+     */
+    groupSimilar(entries: MemoryEntry[]): Promise<ConsolidationGroup[]>;
+    /**
+     * Group by semantic similarity
+     */
+    private groupBySemantic;
+    /**
+     * Group by text similarity (fallback)
+     */
+    private groupByTextSimilarity;
+    /**
+     * Group by temporal proximity
+     */
+    private groupByTemporal;
+    /**
+     * Group by memory type
+     */
+    private groupByType;
+    /**
+     * Consolidate a group into a single entry
+     */
+    private consolidateGroup;
+    /**
+     * Calculate cosine similarity
+     */
+    private cosineSimilarity;
+    /**
+     * Calculate text similarity (Jaccard)
+     */
+    private textSimilarity;
+    /**
+     * Calculate average similarity within a group
+     */
+    private calculateGroupSimilarity;
+    /**
+     * Generate unique ID
+     */
+    private generateId;
+    /**
+     * Update configuration
+     */
+    configure(config: Partial<ConsolidatorConfig>): void;
+}
+/**
+ * Create consolidator instance
+ */
+declare function createConsolidator(config?: ConsolidatorConfig): Consolidator;
+
+/**
+ * Forgetter
+ *
+ * Implements forgetting curves and memory decay for realistic memory behavior.
+ */
+
+/**
+ * Forgetting curve type
+ */
+type ForgettingCurve = 'exponential' | 'power' | 'ebbinghaus';
+/**
+ * Retention score for a memory
+ */
+interface RetentionScore {
+    entryId: string;
+    retention: number;
+    ageMs: number;
+    accessCount: number;
+    importance: number;
+    shouldForget: boolean;
+}
+/**
+ * Forgetting result
+ */
+interface ForgettingResult {
+    forgotten: string[];
+    decayed: Array<{
+        id: string;
+        oldImportance: number;
+        newImportance: number;
+    }>;
+    retained: string[];
+    avgRetention: number;
+}
+/**
+ * Memory forgetter with configurable decay
+ */
+declare class Forgetter {
+    private config;
+    constructor(config?: ForgetterConfig);
+    /**
+     * Calculate retention score for a memory
+     */
+    calculateRetention(entry: MemoryEntry, now?: number): RetentionScore;
+    /**
+     * Calculate base retention using the configured curve
+     */
+    private calculateBaseRetention;
+    /**
+     * Apply forgetting to memories in a store
+     */
+    applyForgetting(store: MemoryStoreInterface): Promise<ForgettingResult>;
+    /**
+     * Simulate forgetting over time (for testing/visualization)
+     */
+    simulateForgetting(entries: MemoryEntry[], timePeriodMs: number, steps?: number): Array<{
+        time: number;
+        avgRetention: number;
+        forgottenCount: number;
+    }>;
+    /**
+     * Get memories at risk of being forgotten
+     */
+    getAtRiskMemories(store: MemoryStoreInterface, threshold?: number): Promise<Array<{
+        entry: MemoryEntry;
+        retention: number;
+    }>>;
+    /**
+     * Reinforce a memory (simulate rehearsal)
+     */
+    reinforce(store: MemoryStoreInterface, id: string, boost?: number): Promise<boolean>;
+    /**
+     * Batch reinforce multiple memories
+     */
+    reinforceBatch(store: MemoryStoreInterface, ids: string[], boost?: number): Promise<number>;
+    /**
+     * Calculate optimal review schedule for a memory
+     */
+    calculateReviewSchedule(entry: MemoryEntry, targetRetention?: number): number[];
+    /**
+     * Get statistics about memory retention
+     */
+    getRetentionStats(store: MemoryStoreInterface): Promise<{
+        avgRetention: number;
+        atRiskCount: number;
+        forgettableCount: number;
+        healthyCount: number;
+        distribution: Record<string, number>;
+    }>;
+    /**
+     * Update configuration
+     */
+    configure(config: Partial<ForgetterConfig>): void;
+}
+/**
+ * Create forgetter instance
+ */
+declare function createForgetter(config?: ForgetterConfig): Forgetter;
+
+/**
+ * Extractor
+ *
+ * Extracts entities, relations, and structured information from memories.
+ */
+
+/**
+ * Extracted entity
+ */
+interface ExtractedEntity {
+    text: string;
+    type: 'person' | 'organization' | 'location' | 'date' | 'concept' | 'number' | 'other';
+    confidence: number;
+    position: {
+        start: number;
+        end: number;
+    };
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Extracted relation
+ */
+interface ExtractedRelation {
+    subject: string;
+    predicate: string;
+    object: string;
+    confidence: number;
+    sourceText: string;
+}
+/**
+ * Extraction result
+ */
+interface ExtractionResult {
+    entities: ExtractedEntity[];
+    relations: ExtractedRelation[];
+    keywords: string[];
+    sentiment?: {
+        score: number;
+        label: 'positive' | 'negative' | 'neutral';
+    };
+    topics?: string[];
+}
+/**
+ * LLM extraction function type
+ */
+type ExtractionFunction = (content: string, options?: {
+    extractRelations?: boolean;
+    extractSentiment?: boolean;
+}) => Promise<ExtractionResult>;
+/**
+ * Memory content extractor
+ */
+declare class Extractor {
+    private config;
+    private extractFn?;
+    constructor(config?: ExtractorConfig);
+    /**
+     * Set custom extraction function (for LLM integration)
+     */
+    setExtractionFunction(fn: ExtractionFunction): void;
+    /**
+     * Extract information from a memory entry
+     */
+    extract(entry: MemoryEntry): Promise<ExtractionResult>;
+    /**
+     * Extract from multiple entries
+     */
+    extractBatch(entries: MemoryEntry[]): Promise<Map<string, ExtractionResult>>;
+    /**
+     * Extract and aggregate across multiple entries
+     */
+    extractAggregate(entries: MemoryEntry[]): Promise<{
+        allEntities: Map<string, {
+            entity: ExtractedEntity;
+            count: number;
+        }>;
+        allRelations: ExtractedRelation[];
+        topKeywords: Array<{
+            keyword: string;
+            count: number;
+        }>;
+        avgSentiment: number | null;
+    }>;
+    /**
+     * Heuristic-based extraction (fallback)
+     */
+    private heuristicExtract;
+    /**
+     * Extract entities using patterns
+     */
+    private extractEntities;
+    /**
+     * Extract relations using patterns
+     */
+    private extractRelations;
+    /**
+     * Extract keywords
+     */
+    private extractKeywords;
+    /**
+     * Extract sentiment
+     */
+    private extractSentiment;
+    /**
+     * Check if text is a sentence starter
+     */
+    private isSentenceStarter;
+    /**
+     * Guess entity type from text
+     */
+    private guessEntityType;
+    /**
+     * Update configuration
+     */
+    configure(config: Partial<ExtractorConfig>): void;
+}
+/**
+ * Create extractor instance
+ */
+declare function createExtractor(config?: ExtractorConfig): Extractor;
+
+export { type BatchCompressionResult as B, type CompressorConfig as C, type ExtractorConfig as E, type ForgetterConfig as F, type RetentionScore as R, type SummarizerConfig as S, type ConsolidatorConfig as a, Summarizer as b, createSummarizer as c, Compressor as d, createCompressor as e, Consolidator as f, createConsolidator as g, Forgetter as h, createForgetter as i, Extractor as j, createExtractor as k, type SummaryResult as l, type SummaryFunction as m, type CompressionResult as n, type ConsolidationGroup as o, type ConsolidationResult as p, type ForgettingCurve as q, type ForgettingResult as r, type ExtractedEntity as s, type ExtractedRelation as t, type ExtractionResult as u, type ExtractionFunction as v };