codex_memory/memory/

reflection_engine.rs

//! Reflection & Insight Generation Engine
//!
//! This module implements a cognitive architecture for generating higher-level insights
//! from accumulated memories through reflection processes. The design is based on:
//!
//! ## Cognitive Science Foundation
//!
//! ### Core Research
//! 1. **Metacognition Theory (Flavell, 1979)**: Thinking about thinking processes
//! 2. **Elaborative Processing (Craik & Lockhart, 1972)**: Deeper processing creates stronger memories
//! 3. **Schema Theory (Bartlett, 1932)**: Knowledge organized in interconnected structures
//! 4. **Constructive Memory (Schacter, 1999)**: Memory reconstruction creates new insights
//! 5. **Knowledge Graph Theory (Semantic Networks)**: Conceptual relationships enable inference
//!
//! ### Reflection Triggers
//! - **Importance Accumulation**: Sum > 150 points triggers reflection
//! - **Semantic Clustering**: Dense clusters of related memories
//! - **Temporal Patterns**: Recurring themes over time
//! - **Contradiction Detection**: Conflicting information requiring resolution
//! - **Gap Identification**: Missing knowledge in established schemas
//!
//! ## Architecture Components
//!
//! ### 1. Reflection Trigger System
//! Monitors memory accumulation and identifies when reflection should occur
//!
//! ### 2. Memory Clustering Engine
//! Groups semantically related memories for insight generation
//!
//! ### 3. Insight Generation Pipeline
//! - Pattern Detection: Identifies recurring themes and relationships
//! - Gap Analysis: Finds missing connections in knowledge structures
//! - Synthesis: Combines related concepts into higher-level insights
//! - Validation: Ensures insights are novel and meaningful
//!
//! ### 4. Knowledge Graph Builder
//! Creates and maintains bidirectional relationships between memories and insights
//!
//! ### 5. Meta-Memory Manager
//! Handles insight storage, retrieval, and relationship tracking

use super::error::{MemoryError, Result};
use super::models::*;
use super::repository::MemoryRepository;
use chrono::{DateTime, Duration, Utc};
use pgvector::Vector;
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet, VecDeque};
use std::sync::Arc;
use tracing::{debug, info, warn};
use uuid::Uuid;

/// Configuration for reflection and insight generation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReflectionConfig {
    /// Importance threshold that triggers reflection
    pub importance_trigger_threshold: f64,

    /// Maximum memories to analyze in one reflection session
    pub max_memories_per_reflection: usize,

    /// Target number of insights per reflection
    pub target_insights_per_reflection: usize,

    /// Minimum similarity for memory clustering
    pub clustering_similarity_threshold: f64,

    /// Importance multiplier for generated insights
    pub insight_importance_multiplier: f64,

    /// Maximum depth for knowledge graph traversal
    pub max_graph_depth: usize,

    /// Minimum cluster size for insight generation
    pub min_cluster_size: usize,

    /// Time window for temporal pattern analysis (days)
    pub temporal_analysis_window_days: i64,

    /// Cooldown period between reflections (hours)
    pub reflection_cooldown_hours: i64,
}

impl Default for ReflectionConfig {
    fn default() -> Self {
        Self {
            importance_trigger_threshold: 150.0,
            max_memories_per_reflection: 100,
            target_insights_per_reflection: 3,
            clustering_similarity_threshold: 0.75,
            insight_importance_multiplier: 1.5,
            max_graph_depth: 3,
            min_cluster_size: 3,
            temporal_analysis_window_days: 30,
            reflection_cooldown_hours: 6,
        }
    }
}

/// Types of insights that can be generated
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum InsightType {
    /// Pattern detected across multiple memories
    Pattern,
    /// Synthesis of related concepts
    Synthesis,
    /// Gap identified in knowledge structure
    Gap,
    /// Contradiction requiring resolution
    Contradiction,
    /// Temporal trend or evolution
    Trend,
    /// Causal relationship discovered
    Causality,
    /// Analogy between disparate concepts
    Analogy,
}

/// Insight generation result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Insight {
    pub id: Uuid,
    pub insight_type: InsightType,
    pub content: String,
    pub confidence_score: f64,
    pub source_memory_ids: Vec<Uuid>,
    pub related_concepts: Vec<String>,
    pub knowledge_graph_nodes: Vec<KnowledgeNode>,
    pub importance_score: f64,
    pub generated_at: DateTime<Utc>,
    pub validation_metrics: ValidationMetrics,
}

/// Metrics for validating insight quality
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationMetrics {
    pub novelty_score: f64,
    pub coherence_score: f64,
    pub evidence_strength: f64,
    pub semantic_richness: f64,
    pub predictive_power: f64,
}

/// Knowledge graph node representing concepts and relationships
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KnowledgeNode {
    pub id: Uuid,
    pub concept: String,
    pub node_type: NodeType,
    #[serde(skip)]
    pub embedding: Option<Vector>,
    pub confidence: f64,
    pub connections: Vec<KnowledgeEdge>,
    pub created_at: DateTime<Utc>,
}

/// Types of knowledge nodes
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum NodeType {
    Concept,
    Entity,
    Relationship,
    Insight,
    Memory,
}

/// Edges in the knowledge graph
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KnowledgeEdge {
    pub target_node_id: Uuid,
    pub relationship_type: RelationshipType,
    pub strength: f64,
    pub evidence_memories: Vec<Uuid>,
}

/// Types of relationships in the knowledge graph
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum RelationshipType {
    IsA,
    PartOf,
    CausedBy,
    SimilarTo,
    ConflictsWith,
    Enables,
    Requires,
    Exemplifies,
    GeneralizedBy,
    TemporallyPrecedes,
}

/// Memory cluster for insight generation
#[derive(Debug, Clone)]
pub struct MemoryCluster {
    pub id: Uuid,
    pub memories: Vec<Memory>,
    pub centroid_embedding: Option<Vector>,
    pub coherence_score: f64,
    pub dominant_concepts: Vec<String>,
    pub temporal_span: Option<(DateTime<Utc>, DateTime<Utc>)>,
}

/// Reflection session state
#[derive(Debug, Clone)]
pub struct ReflectionSession {
    pub id: Uuid,
    pub started_at: DateTime<Utc>,
    pub trigger_reason: String,
    pub analyzed_memories: Vec<Memory>,
    pub generated_clusters: Vec<MemoryCluster>,
    pub generated_insights: Vec<Insight>,
    pub knowledge_graph_updates: Vec<KnowledgeNode>,
    pub completion_status: ReflectionStatus,
}

/// Status of reflection session
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum ReflectionStatus {
    InProgress,
    Completed,
    Failed,
    Cancelled,
}

/// Main reflection and insight generation engine
pub struct ReflectionEngine {
    config: ReflectionConfig,
    repository: Arc<MemoryRepository>,
    #[allow(dead_code)]
    knowledge_graph: KnowledgeGraph,
    last_reflection_time: Option<DateTime<Utc>>,
}

impl ReflectionEngine {
    pub fn new(config: ReflectionConfig, repository: Arc<MemoryRepository>) -> Self {
        Self {
            config,
            repository,
            knowledge_graph: KnowledgeGraph::new(),
            last_reflection_time: None,
        }
    }

    /// Check if reflection should be triggered based on accumulated importance
    pub async fn should_trigger_reflection(&self) -> Result<Option<String>> {
        // Check cooldown period
        if let Some(last_time) = self.last_reflection_time {
            let hours_since_last = Utc::now().signed_duration_since(last_time).num_hours();
            if hours_since_last < self.config.reflection_cooldown_hours {
                return Ok(None);
            }
        }

        // Calculate total importance since last reflection
        let cutoff_time = self
            .last_reflection_time
            .unwrap_or(Utc::now() - Duration::days(1));

        let recent_memories = self.get_recent_memories_since(cutoff_time).await?;
        let total_importance: f64 = recent_memories.iter().map(|m| m.importance_score).sum();

        if total_importance >= self.config.importance_trigger_threshold {
            return Ok(Some(format!(
                "Importance threshold reached: {:.1} >= {:.1}",
                total_importance, self.config.importance_trigger_threshold
            )));
        }

        // Check for dense semantic clusters
        if let Some(cluster_reason) = self.check_cluster_density(&recent_memories).await? {
            return Ok(Some(cluster_reason));
        }

        // Check for temporal patterns
        if let Some(pattern_reason) = self.check_temporal_patterns(&recent_memories).await? {
            return Ok(Some(pattern_reason));
        }

        Ok(None)
    }

    /// Execute a complete reflection session
    pub async fn execute_reflection(
        &mut self,
        trigger_reason: String,
    ) -> Result<ReflectionSession> {
        let session_id = Uuid::new_v4();
        let start_time = Utc::now();

        info!(
            "Starting reflection session {}: {}",
            session_id, trigger_reason
        );

        let mut session = ReflectionSession {
            id: session_id,
            started_at: start_time,
            trigger_reason: trigger_reason.clone(),
            analyzed_memories: Vec::new(),
            generated_clusters: Vec::new(),
            generated_insights: Vec::new(),
            knowledge_graph_updates: Vec::new(),
            completion_status: ReflectionStatus::InProgress,
        };

        match self.execute_reflection_pipeline(&mut session).await {
            Ok(_) => {
                session.completion_status = ReflectionStatus::Completed;
                self.last_reflection_time = Some(Utc::now());

                info!(
                    "Reflection session {} completed: {} insights generated from {} memories",
                    session_id,
                    session.generated_insights.len(),
                    session.analyzed_memories.len()
                );
            }
            Err(e) => {
                session.completion_status = ReflectionStatus::Failed;
                warn!("Reflection session {} failed: {}", session_id, e);
                return Err(e);
            }
        }

        Ok(session)
    }

    /// Main reflection pipeline execution
    async fn execute_reflection_pipeline(&self, session: &mut ReflectionSession) -> Result<()> {
        // Step 1: Gather memories for analysis
        session.analyzed_memories = self.gather_reflection_memories().await?;

        if session.analyzed_memories.is_empty() {
            return Err(MemoryError::InvalidRequest {
                message: "No memories available for reflection".to_string(),
            });
        }

        // Step 2: Cluster memories by semantic similarity
        session.generated_clusters = self.cluster_memories(&session.analyzed_memories).await?;

        // Step 3: Generate insights from clusters
        for cluster in &session.generated_clusters {
            let cluster_insights = self.generate_cluster_insights(cluster).await?;
            session.generated_insights.extend(cluster_insights);
        }

        // Step 4: Cross-cluster insight generation
        let cross_cluster_insights = self
            .generate_cross_cluster_insights(&session.generated_clusters)
            .await?;
        session.generated_insights.extend(cross_cluster_insights);

        // Step 5: Update knowledge graph
        session.knowledge_graph_updates = self
            .update_knowledge_graph(&session.generated_insights)
            .await?;

        // Step 6: Store insights as meta-memories
        self.store_insights_as_memories(&session.generated_insights)
            .await?;

        // Step 7: Validate and prune insights to prevent loops
        self.validate_and_prune_insights(&mut session.generated_insights)
            .await?;

        Ok(())
    }

    /// Gather memories for reflection analysis
    async fn gather_reflection_memories(&self) -> Result<Vec<Memory>> {
        let cutoff_time = self
            .last_reflection_time
            .unwrap_or(Utc::now() - Duration::days(self.config.temporal_analysis_window_days));

        // Get recent high-importance memories
        let search_request = SearchRequest {
            date_range: Some(DateRange {
                start: Some(cutoff_time),
                end: Some(Utc::now()),
            }),
            importance_range: Some(RangeFilter {
                min: Some(0.3),
                max: None,
            }),
            limit: Some(self.config.max_memories_per_reflection as i32),
            search_type: Some(SearchType::Temporal),
            ..Default::default()
        };

        let search_response = self.repository.search_memories(search_request).await?;

        Ok(search_response
            .results
            .into_iter()
            .map(|result| result.memory)
            .collect())
    }

    /// Cluster memories by semantic similarity using hierarchical clustering
    async fn cluster_memories(&self, memories: &[Memory]) -> Result<Vec<MemoryCluster>> {
        let mut clusters = Vec::new();
        let mut unassigned_memories: Vec<_> = memories.iter().collect();

        while !unassigned_memories.is_empty() {
            let seed_memory = unassigned_memories.remove(0);
            let mut cluster_memories = vec![seed_memory.clone()];

            // Find similar memories for this cluster
            let mut i = 0;
            while i < unassigned_memories.len() {
                let memory = unassigned_memories[i];

                if let (Some(seed_embedding), Some(memory_embedding)) =
                    (&seed_memory.embedding, &memory.embedding)
                {
                    let similarity =
                        self.calculate_cosine_similarity(seed_embedding, memory_embedding)?;

                    if similarity >= self.config.clustering_similarity_threshold {
                        cluster_memories.push(memory.clone());
                        unassigned_memories.remove(i);
                    } else {
                        i += 1;
                    }
                } else {
                    i += 1;
                }
            }

            // Only create cluster if it meets minimum size requirement
            if cluster_memories.len() >= self.config.min_cluster_size {
                let cluster = self.create_memory_cluster(cluster_memories).await?;
                clusters.push(cluster);
            }
        }

        Ok(clusters)
    }

    /// Create a memory cluster with computed properties
    async fn create_memory_cluster(&self, memories: Vec<Memory>) -> Result<MemoryCluster> {
        let cluster_id = Uuid::new_v4();

        // Calculate centroid embedding if available
        let centroid_embedding = self.calculate_centroid_embedding(&memories)?;

        // Calculate coherence score (average pairwise similarity)
        let coherence_score = self.calculate_cluster_coherence(&memories)?;

        // Extract dominant concepts (simplified - would use NER/topic modeling in production)
        let dominant_concepts = self.extract_dominant_concepts(&memories).await?;

        // Calculate temporal span
        let temporal_span = self.calculate_temporal_span(&memories);

        Ok(MemoryCluster {
            id: cluster_id,
            memories,
            centroid_embedding,
            coherence_score,
            dominant_concepts,
            temporal_span,
        })
    }

    /// Generate insights from a single memory cluster
    async fn generate_cluster_insights(&self, cluster: &MemoryCluster) -> Result<Vec<Insight>> {
        let mut insights = Vec::new();

        // Pattern detection insight
        if let Some(pattern_insight) = self.detect_cluster_patterns(cluster).await? {
            insights.push(pattern_insight);
        }

        // Synthesis insight
        if let Some(synthesis_insight) = self.generate_synthesis_insight(cluster).await? {
            insights.push(synthesis_insight);
        }

        // Temporal trend insight
        if let Some(trend_insight) = self.detect_temporal_trends(cluster).await? {
            insights.push(trend_insight);
        }

        // Gap analysis insight
        if let Some(gap_insight) = self.identify_knowledge_gaps(cluster).await? {
            insights.push(gap_insight);
        }

        Ok(insights)
    }

    /// Generate insights across multiple clusters
    async fn generate_cross_cluster_insights(
        &self,
        clusters: &[MemoryCluster],
    ) -> Result<Vec<Insight>> {
        let mut insights = Vec::new();

        // Analogy detection between clusters
        for i in 0..clusters.len() {
            for j in i + 1..clusters.len() {
                if let Some(analogy_insight) = self
                    .detect_cross_cluster_analogies(&clusters[i], &clusters[j])
                    .await?
                {
                    insights.push(analogy_insight);
                }
            }
        }

        // Causal relationship detection
        let causal_insights = self.detect_causal_relationships(clusters).await?;
        insights.extend(causal_insights);

        Ok(insights)
    }

    /// Update the knowledge graph with new insights
    async fn update_knowledge_graph(&self, insights: &[Insight]) -> Result<Vec<KnowledgeNode>> {
        let mut new_nodes = Vec::new();

        for insight in insights {
            // Create node for the insight itself
            let insight_node = KnowledgeNode {
                id: insight.id,
                concept: insight.content.clone(),
                node_type: NodeType::Insight,
                embedding: None, // Would generate embedding in production
                confidence: insight.confidence_score,
                connections: Vec::new(),
                created_at: insight.generated_at,
            };

            new_nodes.push(insight_node);

            // Create nodes for related concepts
            for concept in &insight.related_concepts {
                let concept_node = KnowledgeNode {
                    id: Uuid::new_v4(),
                    concept: concept.clone(),
                    node_type: NodeType::Concept,
                    embedding: None,
                    confidence: 0.8,
                    connections: vec![KnowledgeEdge {
                        target_node_id: insight.id,
                        relationship_type: RelationshipType::Exemplifies,
                        strength: 0.9,
                        evidence_memories: insight.source_memory_ids.clone(),
                    }],
                    created_at: Utc::now(),
                };

                new_nodes.push(concept_node);
            }
        }

        Ok(new_nodes)
    }

    /// Store insights as high-importance meta-memories
    async fn store_insights_as_memories(&self, insights: &[Insight]) -> Result<()> {
        for insight in insights {
            let importance_score =
                insight.importance_score * self.config.insight_importance_multiplier;
            let importance_score = importance_score.min(1.0); // Cap at 1.0

            let metadata = serde_json::json!({
                "insight_type": insight.insight_type,
                "confidence_score": insight.confidence_score,
                "source_memory_ids": insight.source_memory_ids,
                "related_concepts": insight.related_concepts,
                "validation_metrics": insight.validation_metrics,
                "is_meta_memory": true,
                "generated_by": "reflection_engine"
            });

            let create_request = CreateMemoryRequest {
                content: insight.content.clone(),
                embedding: None,                 // Would generate in production
                tier: Some(MemoryTier::Working), // Start insights in working tier
                importance_score: Some(importance_score),
                metadata: Some(metadata),
                parent_id: None,
                expires_at: None,
            };

            match self.repository.create_memory(create_request).await {
                Ok(memory) => {
                    debug!("Stored insight {} as memory {}", insight.id, memory.id);
                }
                Err(e) => {
                    warn!("Failed to store insight {} as memory: {}", insight.id, e);
                }
            }
        }

        Ok(())
    }

    /// Validate insights and prune duplicates/loops to prevent insight inflation
    async fn validate_and_prune_insights(&self, insights: &mut Vec<Insight>) -> Result<()> {
        let mut validated_insights = Vec::new();
        let mut seen_concepts = HashSet::new();

        for insight in insights.iter() {
            // Check for conceptual novelty
            let concept_hash = self.hash_insight_concepts(insight);
            if seen_concepts.contains(&concept_hash) {
                debug!("Pruning duplicate insight: {}", insight.content);
                continue;
            }

            // Validate insight quality
            if self.validate_insight_quality(insight).await? {
                seen_concepts.insert(concept_hash);
                validated_insights.push(insight.clone());
            } else {
                debug!("Pruning low-quality insight: {}", insight.content);
            }
        }

        *insights = validated_insights;
        Ok(())
    }

    // Helper methods for insight generation
    async fn detect_cluster_patterns(&self, _cluster: &MemoryCluster) -> Result<Option<Insight>> {
        // Implementation would analyze recurring patterns within cluster
        // This is a simplified placeholder
        Ok(None)
    }

    async fn generate_synthesis_insight(
        &self,
        _cluster: &MemoryCluster,
    ) -> Result<Option<Insight>> {
        // Implementation would synthesize cluster concepts into higher-level understanding
        Ok(None)
    }

    async fn detect_temporal_trends(&self, _cluster: &MemoryCluster) -> Result<Option<Insight>> {
        // Implementation would analyze temporal patterns within cluster
        Ok(None)
    }

    async fn identify_knowledge_gaps(&self, _cluster: &MemoryCluster) -> Result<Option<Insight>> {
        // Implementation would identify missing knowledge in cluster domain
        Ok(None)
    }

    async fn detect_cross_cluster_analogies(
        &self,
        _cluster1: &MemoryCluster,
        _cluster2: &MemoryCluster,
    ) -> Result<Option<Insight>> {
        // Implementation would find analogies between different concept clusters
        Ok(None)
    }

    async fn detect_causal_relationships(
        &self,
        _clusters: &[MemoryCluster],
    ) -> Result<Vec<Insight>> {
        // Implementation would identify causal relationships across clusters
        Ok(Vec::new())
    }

    // Utility methods
    async fn get_recent_memories_since(&self, cutoff_time: DateTime<Utc>) -> Result<Vec<Memory>> {
        let search_request = SearchRequest {
            date_range: Some(DateRange {
                start: Some(cutoff_time),
                end: Some(Utc::now()),
            }),
            search_type: Some(SearchType::Temporal),
            limit: Some(1000),
            ..Default::default()
        };

        let response = self.repository.search_memories(search_request).await?;
        Ok(response.results.into_iter().map(|r| r.memory).collect())
    }

    async fn check_cluster_density(&self, _memories: &[Memory]) -> Result<Option<String>> {
        // Implementation would check for dense semantic clusters
        Ok(None)
    }

    async fn check_temporal_patterns(&self, _memories: &[Memory]) -> Result<Option<String>> {
        // Implementation would check for temporal patterns warranting reflection
        Ok(None)
    }

    fn calculate_cosine_similarity(&self, vec1: &Vector, vec2: &Vector) -> Result<f64> {
        let slice1 = vec1.as_slice();
        let slice2 = vec2.as_slice();

        if slice1.len() != slice2.len() {
            return Ok(0.0);
        }

        let dot_product: f64 = slice1
            .iter()
            .zip(slice2.iter())
            .map(|(a, b)| (*a as f64) * (*b as f64))
            .sum();

        let norm1: f64 = slice1
            .iter()
            .map(|x| (*x as f64).powi(2))
            .sum::<f64>()
            .sqrt();
        let norm2: f64 = slice2
            .iter()
            .map(|x| (*x as f64).powi(2))
            .sum::<f64>()
            .sqrt();

        if norm1 == 0.0 || norm2 == 0.0 {
            return Ok(0.0);
        }

        Ok(dot_product / (norm1 * norm2))
    }

    fn calculate_centroid_embedding(&self, memories: &[Memory]) -> Result<Option<Vector>> {
        let embeddings: Vec<_> = memories
            .iter()
            .filter_map(|m| m.embedding.as_ref())
            .collect();

        if embeddings.is_empty() {
            return Ok(None);
        }

        let dim = embeddings[0].as_slice().len();
        let mut centroid = vec![0.0f32; dim];

        for embedding in &embeddings {
            for (i, &val) in embedding.as_slice().iter().enumerate() {
                centroid[i] += val;
            }
        }

        for val in &mut centroid {
            *val /= embeddings.len() as f32;
        }

        Ok(Some(Vector::from(centroid)))
    }

    fn calculate_cluster_coherence(&self, memories: &[Memory]) -> Result<f64> {
        let embeddings: Vec<_> = memories
            .iter()
            .filter_map(|m| m.embedding.as_ref())
            .collect();

        if embeddings.len() < 2 {
            return Ok(1.0);
        }

        let mut total_similarity = 0.0;
        let mut pair_count = 0;

        for i in 0..embeddings.len() {
            for j in i + 1..embeddings.len() {
                let similarity = self.calculate_cosine_similarity(embeddings[i], embeddings[j])?;
                total_similarity += similarity;
                pair_count += 1;
            }
        }

        Ok(if pair_count > 0 {
            total_similarity / pair_count as f64
        } else {
            0.0
        })
    }

    async fn extract_dominant_concepts(&self, _memories: &[Memory]) -> Result<Vec<String>> {
        // Simplified implementation - would use NLP/topic modeling in production
        Ok(vec!["concept1".to_string(), "concept2".to_string()])
    }

    fn calculate_temporal_span(
        &self,
        memories: &[Memory],
    ) -> Option<(DateTime<Utc>, DateTime<Utc>)> {
        if memories.is_empty() {
            return None;
        }

        let mut min_time = memories[0].created_at;
        let mut max_time = memories[0].created_at;

        for memory in memories {
            if memory.created_at < min_time {
                min_time = memory.created_at;
            }
            if memory.created_at > max_time {
                max_time = memory.created_at;
            }
        }

        Some((min_time, max_time))
    }

    fn hash_insight_concepts(&self, insight: &Insight) -> u64 {
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};

        let mut hasher = DefaultHasher::new();
        insight.related_concepts.hash(&mut hasher);
        insight.insight_type.hash(&mut hasher);
        hasher.finish()
    }

    async fn validate_insight_quality(&self, insight: &Insight) -> Result<bool> {
        // Validate based on metrics
        let metrics = &insight.validation_metrics;

        // Minimum thresholds for quality
        Ok(metrics.novelty_score > 0.3
            && metrics.coherence_score > 0.5
            && metrics.evidence_strength > 0.4
            && insight.confidence_score > 0.6)
    }
}

/// Knowledge graph management
pub struct KnowledgeGraph {
    nodes: HashMap<Uuid, KnowledgeNode>,
    concept_index: HashMap<String, Vec<Uuid>>,
}

impl KnowledgeGraph {
    pub fn new() -> Self {
        Self {
            nodes: HashMap::new(),
            concept_index: HashMap::new(),
        }
    }

    pub fn add_node(&mut self, node: KnowledgeNode) {
        // Index by concept for fast lookup
        self.concept_index
            .entry(node.concept.clone())
            .or_insert_with(Vec::new)
            .push(node.id);

        self.nodes.insert(node.id, node);
    }

    pub fn find_related_concepts(&self, concept: &str, max_depth: usize) -> Vec<Uuid> {
        let mut related = Vec::new();
        let mut visited = HashSet::new();
        let mut queue = VecDeque::new();

        // Start with direct matches
        if let Some(direct_matches) = self.concept_index.get(concept) {
            for &node_id in direct_matches {
                queue.push_back((node_id, 0));
            }
        }

        // Breadth-first traversal
        while let Some((node_id, depth)) = queue.pop_front() {
            if depth >= max_depth || visited.contains(&node_id) {
                continue;
            }

            visited.insert(node_id);
            related.push(node_id);

            if let Some(node) = self.nodes.get(&node_id) {
                for edge in &node.connections {
                    if !visited.contains(&edge.target_node_id) {
                        queue.push_back((edge.target_node_id, depth + 1));
                    }
                }
            }
        }

        related
    }
}

impl Default for KnowledgeGraph {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_reflection_config_defaults() {
        let config = ReflectionConfig::default();
        assert_eq!(config.importance_trigger_threshold, 150.0);
        assert_eq!(config.target_insights_per_reflection, 3);
        assert_eq!(config.insight_importance_multiplier, 1.5);
    }

    #[test]
    fn test_knowledge_graph_creation() {
        let mut graph = KnowledgeGraph::new();

        let node = KnowledgeNode {
            id: Uuid::new_v4(),
            concept: "test_concept".to_string(),
            node_type: NodeType::Concept,
            embedding: None,
            confidence: 0.8,
            connections: Vec::new(),
            created_at: Utc::now(),
        };

        let node_id = node.id;
        graph.add_node(node);

        assert!(graph.nodes.contains_key(&node_id));
        assert!(graph.concept_index.contains_key("test_concept"));
    }

    #[test]
    fn test_insight_type_serialization() {
        let insight_type = InsightType::Pattern;
        let serialized = serde_json::to_string(&insight_type).unwrap();
        let deserialized: InsightType = serde_json::from_str(&serialized).unwrap();
        assert_eq!(insight_type, deserialized);
    }
}