/**
 * Character Memory System for BaoLife
 * Provides long-term memory for NPCs by extracting and storing important facts
 * from conversations. Enables characters to remember player preferences, past events,
 * and relationship history across sessions.
 * Ported from Python character_memory.py
 *
 * Features:
 * - AI-powered fact extraction from conversations
 * - Importance scoring for memory prioritization
 * - Memory decay over time (older memories fade)
 * - Context-aware memory retrieval
 */
import { Person } from '../../models/Person.js';
import { ConversationObj, ConversationMessage } from './types.js';
export interface MemoryFact {
    id?: number;
    fact: string;
    importance: number;
    learned_date: Date;
    last_accessed?: Date;
    access_count?: number;
}
export interface MemoryDecayConfig {
    /** Days until a memory starts decaying (default: 7) */
    decayStartDays: number;
    /** Minimum importance after full decay (default: 1) */
    minImportance: number;
    /** Decay rate per day after start (default: 0.5) */
    decayRatePerDay: number;
}
export declare const DEFAULT_DECAY_CONFIG: MemoryDecayConfig;
/**
 * Persistent memory system for NPC characters.
 * Extracts and stores important facts from conversations.
 */
export declare class CharacterMemory {
    private characterId;
    private playerId;
    private facts;
    private loaded;
    private decayConfig;
    constructor(characterId: string, playerId: string, decayConfig?: MemoryDecayConfig);
    /**
     * Extract important facts from recent conversation messages.
     * Called periodically (e.g., every 5 messages) to update memory.
     * Uses AI to extract facts and score their importance.
     */
    extractFacts(conversation: ConversationObj, character: Person): Promise<string[]>;
    /**
     * Parse facts with importance scores from AI response.
     * Expected format: "- [importance:X] Fact text"
     */
    private parseFactsWithImportance;
    /**
     * Calculate importance score heuristically when AI doesn't provide one.
     * Uses keywords and content analysis.
     */
    private calculateImportanceHeuristic;
    /**
     * Extract facts from a specific set of messages.
     * Unlike extractFacts(), this accepts an explicit message list,
     * allowing the caller to pass the full batch since last extraction.
     */
    extractFactsFromMessages(messages: ConversationMessage[], character: Person): Promise<string[]>;
    /**
     * Format messages for fact extraction
     */
    private formatMessagesForExtraction;
    /**
     * Load character's memory facts from database.
     * Applies memory decay to older facts.
     */
    loadFacts(limit?: number): Promise<string[]>;
    /**
     * Apply memory decay based on how old a memory is.
     * Uses the more recent of learned_date or last_accessed as the decay anchor,
     * so memories that keep coming up in conversation resist decay.
     */
    private applyMemoryDecay;
    /**
     * Reinforce a memory by accessing it.
     * Increases access count and updates last_accessed timestamp.
     * This helps important memories resist decay.
     */
    reinforceMemory(factId: number): Promise<void>;
    /**
     * Get relevant facts for context injection.
     * Returns facts sorted by effective importance (with decay applied).
     */
    getRelevantFacts(maxFacts?: number): Promise<string[]>;
    /**
     * Get relevant facts with metadata for advanced use cases.
     */
    getRelevantFactsWithMetadata(maxFacts?: number): Promise<MemoryFact[]>;
    /**
     * Get formatted memory context for prompt injection.
     * Reinforces accessed memories so they resist decay.
     */
    getMemoryContext(): Promise<string>;
    /**
     * Get context-aware memories based on current conversation topic.
     * Uses AI to find the most relevant memories for the current context.
     */
    getContextualMemories(currentTopic: string, maxFacts?: number): Promise<string[]>;
    /**
     * Save extracted facts to database with AI-provided importance scores.
     */
    private saveFactsWithImportance;
    /**
     * Clear all facts for this character-player relationship
     */
    clearFacts(): Promise<void>;
    /**
     * Clean up decayed memories that are no longer useful.
     * Removes memories that have decayed below a threshold.
     */
    pruneDecayedMemories(threshold?: number): Promise<number>;
    /**
     * Get memory statistics for debugging/analytics.
     */
    getMemoryStats(): Promise<{
        totalMemories: number;
        averageImportance: number;
        oldestMemory: Date | null;
        newestMemory: Date | null;
    }>;
}
/**
 * Create character_memory table if it doesn't exist.
 * Call this during server startup or migration.
 */
export declare function createCharacterMemoryTable(): Promise<void>;
/**
 * Store a single memory for a character.
 * Convenience function for direct memory storage without extraction.
 */
export declare function storeMemory(characterId: string, playerId: string, fact: string, importance?: number, conversationId?: string): Promise<void>;
/**
 * Retrieve memories for a character.
 * Convenience function for quick memory retrieval.
 */
export declare function retrieveMemories(characterId: string, playerId: string, limit?: number): Promise<string[]>;
/**
 * Apply memory decay globally for all characters.
 * Run this periodically (e.g., daily) to maintain memory hygiene.
 */
export declare function applyGlobalMemoryDecay(decayConfig?: MemoryDecayConfig): Promise<{
    processed: number;
    pruned: number;
}>;
export declare const characterMemoryManager: {
    CharacterMemory: typeof CharacterMemory;
    createCharacterMemoryTable: typeof createCharacterMemoryTable;
    storeMemory: typeof storeMemory;
    retrieveMemories: typeof retrieveMemories;
    applyGlobalMemoryDecay: typeof applyGlobalMemoryDecay;
    DEFAULT_DECAY_CONFIG: MemoryDecayConfig;
};
//# sourceMappingURL=character_memory.d.ts.map