codex_memory/

models.rs

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

// Import memory tiering types
// Note: Memory tier system has been removed - this is now a simple storage system

/// Enhanced memory structure for text storage with context and summary
/// Implements encoding specificity principle (Tulving & Thomson, 1973)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Memory {
    pub id: Uuid,
    pub content: String,
    pub content_hash: String, // Simple content hash for basic deduplication
    pub context_fingerprint: String, // Context-aware fingerprint for encoding specificity
    pub tags: Vec<String>,
    pub context: String,           // Required: What is being stored and why
    pub summary: String,           // Required: Brief summary (120 words or less)
    pub chunk_index: Option<i32>,  // Index of this chunk (1-based, null for non-chunked content)
    pub total_chunks: Option<i32>, // Total number of chunks in the set
    pub parent_id: Option<Uuid>,   // ID of the parent document (for linking chunks together)
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

impl Memory {
    /// Create a new memory with the given content
    /// Implements encoding specificity principle - context matters for retrieval
    pub fn new(
        content: String,
        context: String,
        summary: String,
        tags: Option<Vec<String>>,
    ) -> Self {
        use sha2::{Digest, Sha256};

        // Simple content hash for basic deduplication
        let mut content_hasher = Sha256::new();
        content_hasher.update(content.as_bytes());
        let content_hash = hex::encode(content_hasher.finalize());

        // Context-aware fingerprint for encoding specificity
        // Combines content + context + summary for semantic distinctiveness
        let context_fingerprint =
            Self::compute_context_fingerprint(&content, &context, &summary, &tags);

        let now = Utc::now();
        Self {
            id: Uuid::new_v4(),
            content,
            content_hash,
            context_fingerprint,
            tags: tags.unwrap_or_default(),
            context,
            summary,
            chunk_index: None,
            total_chunks: None,
            parent_id: None,
            created_at: now,
            updated_at: now,
        }
    }

    /// Create a new chunked memory with parent reference
    /// Preserves context specificity for chunked content
    pub fn new_chunk(
        content: String,
        context: String,
        summary: String,
        tags: Option<Vec<String>>,
        chunk_index: i32,
        total_chunks: i32,
        parent_id: Uuid,
    ) -> Self {
        use sha2::{Digest, Sha256};

        // Simple content hash for basic deduplication
        let mut content_hasher = Sha256::new();
        content_hasher.update(content.as_bytes());
        let content_hash = hex::encode(content_hasher.finalize());

        // Context-aware fingerprint including chunk position
        let context_fingerprint = Self::compute_context_fingerprint_chunk(
            &content,
            &context,
            &summary,
            &tags,
            chunk_index,
            total_chunks,
            parent_id,
        );

        let now = Utc::now();
        Self {
            id: Uuid::new_v4(),
            content,
            content_hash,
            context_fingerprint,
            tags: tags.unwrap_or_default(),
            context,
            summary,
            chunk_index: Some(chunk_index),
            total_chunks: Some(total_chunks),
            parent_id: Some(parent_id),
            created_at: now,
            updated_at: now,
        }
    }

    /// Compute context-aware fingerprint implementing encoding specificity principle
    /// Based on Tulving & Thomson (1973) - context at encoding affects retrieval success
    fn compute_context_fingerprint(
        content: &str,
        context: &str,
        summary: &str,
        tags: &Option<Vec<String>>,
    ) -> String {
        use sha2::{Digest, Sha256};

        let mut hasher = Sha256::new();

        // Include content
        hasher.update(content.as_bytes());
        hasher.update(b"::CONTEXT::");

        // Include context - this is the key for encoding specificity
        hasher.update(context.as_bytes());
        hasher.update(b"::SUMMARY::");

        // Include summary for semantic distinctiveness
        hasher.update(summary.as_bytes());
        hasher.update(b"::TAGS::");

        // Include tags for additional contextual cues
        if let Some(tags) = tags {
            let mut sorted_tags = tags.clone();
            sorted_tags.sort(); // Ensure consistent ordering
            for tag in sorted_tags {
                hasher.update(tag.as_bytes());
                hasher.update(b",");
            }
        }

        hex::encode(hasher.finalize())
    }

    /// Compute context fingerprint for chunked content
    /// Includes chunk position in context for proper retrieval cues
    fn compute_context_fingerprint_chunk(
        content: &str,
        context: &str,
        summary: &str,
        tags: &Option<Vec<String>>,
        chunk_index: i32,
        total_chunks: i32,
        parent_id: Uuid,
    ) -> String {
        use sha2::{Digest, Sha256};

        let mut hasher = Sha256::new();

        // Include all basic context elements
        hasher.update(content.as_bytes());
        hasher.update(b"::CONTEXT::");
        hasher.update(context.as_bytes());
        hasher.update(b"::SUMMARY::");
        hasher.update(summary.as_bytes());
        hasher.update(b"::CHUNK_CONTEXT::");

        // Include chunk-specific context for retrieval cues
        hasher.update(chunk_index.to_string().as_bytes());
        hasher.update(b":");
        hasher.update(total_chunks.to_string().as_bytes());
        hasher.update(b"::");
        hasher.update(parent_id.to_string().as_bytes());
        hasher.update(b"::TAGS::");

        // Include tags
        if let Some(tags) = tags {
            let mut sorted_tags = tags.clone();
            sorted_tags.sort();
            for tag in sorted_tags {
                hasher.update(tag.as_bytes());
                hasher.update(b",");
            }
        }

        hex::encode(hasher.finalize())
    }

    /// Check semantic similarity between two memories
    /// Implements transfer appropriate processing - matching encoding and retrieval contexts
    pub fn is_semantically_similar(&self, other: &Memory, similarity_threshold: f64) -> bool {
        // For now, implement simple context similarity
        // In a full implementation, this would use embeddings
        let content_similarity = self.simple_text_similarity(&self.content, &other.content);
        let context_similarity = self.simple_text_similarity(&self.context, &other.context);

        // Combined similarity with context weighting (encoding specificity)
        let combined_similarity = (content_similarity * 0.6) + (context_similarity * 0.4);
        combined_similarity >= similarity_threshold
    }

    /// Simple text similarity for semantic comparison
    /// Production version would use proper embeddings
    fn simple_text_similarity(&self, text1: &str, text2: &str) -> f64 {
        use std::collections::HashSet;

        let words1: HashSet<&str> = text1.split_whitespace().collect();
        let words2: HashSet<&str> = text2.split_whitespace().collect();

        let intersection = words1.intersection(&words2).count();
        let union = words1.union(&words2).count();

        if union == 0 {
            0.0
        } else {
            intersection as f64 / union as f64
        }
    }
}

/// Simple storage statistics
#[derive(Debug, Serialize, Deserialize)]
pub struct StorageStats {
    pub total_memories: i64,
    pub table_size: String,
    pub last_memory_created: Option<DateTime<Utc>>,
}