st/context_gatherer/

cross_session.rs

//! Cross-Session Context Bridging
//!
//! This module enables sharing insights and patterns across different domains and projects,
//! creating a web of interconnected knowledge that grows stronger with each collaboration.
//!
//! "Noticed you're using wave decay scoring again — this echoes the peak-resonance formula from Cheet session #14."

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};
use std::path::PathBuf;

use super::GatheredContext;
use crate::mem8::wave::{FrequencyBand, MemoryWave};

/// Cross-domain pattern that appears in multiple contexts
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CrossDomainPattern {
    pub pattern_id: String,
    pub pattern_type: PatternType,
    pub description: String,
    pub occurrences: Vec<PatternOccurrence>,
    pub keywords: Vec<String>,
    pub strength: f32, // How strong/consistent the pattern is
    pub first_seen: DateTime<Utc>,
    pub last_seen: DateTime<Utc>,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PatternType {
    Algorithm,     // Algorithmic patterns (e.g., wave decay, resonance)
    Architecture,  // Architectural patterns (e.g., observer, state machine)
    Problem,       // Common problems across domains
    Solution,      // Solutions that work across contexts
    Metaphor,      // Conceptual metaphors (e.g., waves, rivers)
    Workflow,      // Process patterns
    Collaboration, // How human and AI work together
}

/// Where and when a pattern occurred
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PatternOccurrence {
    pub project_path: PathBuf,
    pub session_id: String,
    pub timestamp: DateTime<Utc>,
    pub context: String,
    pub ai_tool: String,
    pub relevance_score: f32,
}

/// Insight that bridges multiple sessions
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CrossSessionInsight {
    pub insight_id: String,
    pub insight_type: InsightType,
    pub content: String,
    pub source_sessions: Vec<String>,
    pub applicable_domains: Vec<String>,
    pub confidence: f32,
    pub wave_signature: MemoryWave,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum InsightType {
    Connection,     // Links between concepts
    Generalization, // Abstract pattern from specific cases
    Analogy,        // Similar structures in different domains
    Warning,        // Pitfalls to avoid
    Optimization,   // Better ways discovered
    Emergence,      // New understanding from combination
}

/// Persona invitation for cross-session wisdom
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PersonaInvitation {
    pub persona_name: String,
    pub expertise_areas: Vec<String>,
    pub relevant_sessions: Vec<String>,
    pub invitation_context: String,
    pub suggested_duration_minutes: u32,
}

/// Cross-session context bridge
pub struct CrossSessionBridge {
    pub patterns: HashMap<String, CrossDomainPattern>,
    pub insights: HashMap<String, CrossSessionInsight>,
    pub project_connections: HashMap<PathBuf, HashSet<PathBuf>>,
    pub persona_library: HashMap<String, PersonaProfile>,
}

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

impl CrossSessionBridge {
    pub fn new() -> Self {
        Self {
            patterns: HashMap::new(),
            insights: HashMap::new(),
            project_connections: HashMap::new(),
            persona_library: Self::initialize_personas(),
        }
    }

    /// Initialize known personas
    fn initialize_personas() -> HashMap<String, PersonaProfile> {
        let mut personas = HashMap::new();

        // The Cheet - Musical code poet
        personas.insert(
            "cheet".to_string(),
            PersonaProfile {
                name: "The Cheet".to_string(),
                expertise: vec![
                    "Performance optimization".to_string(),
                    "Musical code metaphors".to_string(),
                    "Rust patterns".to_string(),
                ],
                personality_traits: vec![
                    "Playful".to_string(),
                    "Performance-obsessed".to_string(),
                    "Rock'n'roll coder".to_string(),
                ],
                favorite_patterns: vec![PatternType::Algorithm, PatternType::Workflow],
            },
        );

        // Omni - Wave philosopher
        personas.insert(
            "omni".to_string(),
            PersonaProfile {
                name: "Omni".to_string(),
                expertise: vec![
                    "Wave-based thinking".to_string(),
                    "Memory architectures".to_string(),
                    "Philosophical insights".to_string(),
                ],
                personality_traits: vec![
                    "Thoughtful".to_string(),
                    "Deep thinker".to_string(),
                    "Pattern recognizer".to_string(),
                ],
                favorite_patterns: vec![PatternType::Metaphor, PatternType::Architecture],
            },
        );

        // Trish - Organizational wizard
        personas.insert(
            "trish".to_string(),
            PersonaProfile {
                name: "Trish from Accounting".to_string(),
                expertise: vec![
                    "Organization".to_string(),
                    "Documentation".to_string(),
                    "Humor in technical content".to_string(),
                ],
                personality_traits: vec![
                    "Witty".to_string(),
                    "Detail-oriented".to_string(),
                    "Sparkle enthusiast".to_string(),
                ],
                favorite_patterns: vec![PatternType::Workflow, PatternType::Collaboration],
            },
        );

        personas
    }

    /// Analyze contexts for cross-domain patterns
    pub fn analyze_for_patterns(
        &mut self,
        contexts: &[GatheredContext],
    ) -> Vec<CrossDomainPattern> {
        let mut new_patterns = Vec::new();

        // Extract potential patterns from contexts
        for context in contexts {
            let extracted = self.extract_patterns_from_context(context);

            for (pattern_type, description, keywords) in extracted {
                let pattern_id =
                    self.find_or_create_pattern(pattern_type, description, keywords, context);

                if let Some(pattern) = self.patterns.get(&pattern_id) {
                    if pattern.occurrences.len() == 1 {
                        // Newly created pattern
                        new_patterns.push(pattern.clone());
                    }
                }
            }
        }

        // Update pattern strengths
        self.update_pattern_strengths();

        new_patterns
    }

    /// Extract patterns from a single context
    fn extract_patterns_from_context(
        &self,
        context: &GatheredContext,
    ) -> Vec<(PatternType, String, Vec<String>)> {
        let mut patterns = Vec::new();

        // Analyze content for patterns
        let content_str = match &context.content {
            super::ContextContent::Text(t) => t.clone(),
            super::ContextContent::Json(j) => j.to_string(),
            _ => return patterns,
        };

        // Look for algorithmic patterns
        if content_str.contains("wave") && content_str.contains("decay") {
            patterns.push((
                PatternType::Algorithm,
                "Wave decay pattern".to_string(),
                vec![
                    "wave".to_string(),
                    "decay".to_string(),
                    "temporal".to_string(),
                ],
            ));
        }

        if content_str.contains("resonance") || content_str.contains("peak") {
            patterns.push((
                PatternType::Algorithm,
                "Resonance detection".to_string(),
                vec![
                    "resonance".to_string(),
                    "peak".to_string(),
                    "frequency".to_string(),
                ],
            ));
        }

        // Look for architectural patterns
        if content_str.contains("observer") || content_str.contains("event") {
            patterns.push((
                PatternType::Architecture,
                "Event-driven architecture".to_string(),
                vec![
                    "observer".to_string(),
                    "event".to_string(),
                    "reactive".to_string(),
                ],
            ));
        }

        // Look for collaboration patterns
        if content_str.contains("together") && content_str.contains("solved") {
            patterns.push((
                PatternType::Collaboration,
                "Collaborative problem solving".to_string(),
                vec![
                    "collaboration".to_string(),
                    "solution".to_string(),
                    "teamwork".to_string(),
                ],
            ));
        }

        patterns
    }

    /// Find existing or create new pattern
    fn find_or_create_pattern(
        &mut self,
        pattern_type: PatternType,
        description: String,
        keywords: Vec<String>,
        context: &GatheredContext,
    ) -> String {
        // Check if pattern already exists
        let existing_id = self
            .patterns
            .iter()
            .find(|(_, pattern)| {
                pattern.pattern_type == pattern_type
                    && pattern.keywords.iter().any(|k| keywords.contains(k))
            })
            .map(|(id, _)| id.clone());

        if let Some(id) = existing_id {
            // Add occurrence to existing pattern
            let occurrence = PatternOccurrence {
                project_path: context
                    .source_path
                    .parent()
                    .unwrap_or(&context.source_path)
                    .to_path_buf(),
                session_id: format!("session_{}", context.timestamp.timestamp()),
                timestamp: context.timestamp,
                context: self.extract_context_snippet(&context.content),
                ai_tool: context.ai_tool.clone(),
                relevance_score: context.relevance_score,
            };

            if let Some(pattern) = self.patterns.get_mut(&id) {
                pattern.occurrences.push(occurrence);
                pattern.last_seen = context.timestamp;
            }

            return id;
        }

        // Create new pattern
        let pattern_id = format!(
            "pattern_{}",
            chrono::Utc::now().timestamp_nanos_opt().unwrap_or(0)
        );
        let pattern = CrossDomainPattern {
            pattern_id: pattern_id.clone(),
            pattern_type,
            description,
            occurrences: vec![PatternOccurrence {
                project_path: context
                    .source_path
                    .parent()
                    .unwrap_or(&context.source_path)
                    .to_path_buf(),
                session_id: format!("session_{}", context.timestamp.timestamp()),
                timestamp: context.timestamp,
                context: self.extract_context_snippet(&context.content),
                ai_tool: context.ai_tool.clone(),
                relevance_score: context.relevance_score,
            }],
            keywords,
            strength: 0.1, // Initial strength
            first_seen: context.timestamp,
            last_seen: context.timestamp,
        };

        self.patterns.insert(pattern_id.clone(), pattern);
        pattern_id
    }

    /// Extract a snippet from context content
    fn extract_context_snippet(&self, content: &super::ContextContent) -> String {
        match content {
            super::ContextContent::Text(t) => t.chars().take(200).collect(),
            super::ContextContent::Json(j) => j.to_string().chars().take(200).collect(),
            _ => "[Binary content]".to_string(),
        }
    }

    /// Update pattern strengths based on occurrences
    fn update_pattern_strengths(&mut self) {
        for pattern in self.patterns.values_mut() {
            // Strength based on: occurrence count, recency, consistency
            let occurrence_factor = (pattern.occurrences.len() as f32).ln() / 10.0;

            let recency_factor = {
                let days_old = (Utc::now() - pattern.last_seen).num_days() as f32;
                1.0 / (1.0 + days_old / 30.0)
            };

            let consistency_factor = {
                let unique_projects = pattern
                    .occurrences
                    .iter()
                    .map(|o| &o.project_path)
                    .collect::<HashSet<_>>()
                    .len();
                (unique_projects as f32).ln() / 5.0
            };

            pattern.strength = (occurrence_factor + recency_factor + consistency_factor) / 3.0;
            pattern.strength = pattern.strength.min(1.0);
        }
    }

    /// Generate cross-session insights
    pub fn generate_insights(&mut self, min_pattern_strength: f32) -> Vec<CrossSessionInsight> {
        let mut insights = Vec::new();

        // Find patterns that appear in multiple projects
        for pattern in self.patterns.values() {
            if pattern.strength < min_pattern_strength {
                continue;
            }

            if pattern.occurrences.len() > 2 {
                let insight = CrossSessionInsight {
                    insight_id: format!(
                        "insight_{}",
                        chrono::Utc::now().timestamp_nanos_opt().unwrap_or(0)
                    ),
                    insight_type: InsightType::Generalization,
                    content: format!(
                        "The '{}' pattern appears across {} different contexts. \
                         This suggests a fundamental approach that transcends specific domains.",
                        pattern.description,
                        pattern.occurrences.len()
                    ),
                    source_sessions: pattern
                        .occurrences
                        .iter()
                        .map(|o| o.session_id.clone())
                        .collect(),
                    applicable_domains: self.extract_domains(&pattern.occurrences),
                    confidence: pattern.strength,
                    wave_signature: MemoryWave::new_with_band(
                        FrequencyBand::Gamma, // High-frequency insight
                        pattern.strength,
                        0.0,
                        0.1, // Slow decay rate for valuable insights
                    ),
                };

                insights.push(insight.clone());
                self.insights.insert(insight.insight_id.clone(), insight);
            }
        }

        insights
    }

    /// Extract domains from pattern occurrences
    fn extract_domains(&self, occurrences: &[PatternOccurrence]) -> Vec<String> {
        occurrences
            .iter()
            .map(|o| {
                o.project_path
                    .file_name()
                    .and_then(|n| n.to_str())
                    .unwrap_or("unknown")
                    .to_string()
            })
            .collect::<HashSet<_>>()
            .into_iter()
            .collect()
    }

    /// Suggest relevant insights for current context
    pub fn suggest_relevant_insights(
        &self,
        current_project: &std::path::Path,
        keywords: &[String],
    ) -> Vec<CrossSessionInsight> {
        let mut relevant = Vec::new();

        for insight in self.insights.values() {
            // Check keyword relevance
            let keyword_score = keywords
                .iter()
                .filter(|k| insight.content.to_lowercase().contains(&k.to_lowercase()))
                .count() as f32
                / keywords.len().max(1) as f32;

            // Check if insight applies to similar domains
            let project_name = current_project
                .file_name()
                .and_then(|n| n.to_str())
                .unwrap_or("");

            let domain_relevance = if insight
                .applicable_domains
                .iter()
                .any(|d| d.contains(project_name) || project_name.contains(d))
            {
                1.0
            } else {
                0.5
            };

            let total_relevance = (keyword_score + domain_relevance) / 2.0;

            if total_relevance > 0.3 {
                relevant.push(insight.clone());
            }
        }

        // Sort by relevance
        relevant.sort_by(|a, b| b.confidence.partial_cmp(&a.confidence).unwrap());
        relevant
    }

    /// Invite a persona for temporary consultation
    pub fn invite_persona(
        &self,
        context: &str,
        duration_minutes: u32,
    ) -> Option<PersonaInvitation> {
        // Analyze context to determine best persona
        let context_lower = context.to_lowercase();

        let best_persona =
            if context_lower.contains("performance") || context_lower.contains("optimize") {
                "cheet"
            } else if context_lower.contains("wave")
                || context_lower.contains("memory")
                || context_lower.contains("philosophy")
            {
                "omni"
            } else if context_lower.contains("organize") || context_lower.contains("document") {
                "trish"
            } else {
                return None;
            };

        self.persona_library
            .get(best_persona)
            .map(|persona| PersonaInvitation {
                persona_name: persona.name.clone(),
                expertise_areas: persona.expertise.clone(),
                relevant_sessions: self.find_persona_sessions(best_persona),
                invitation_context: format!(
                    "Inviting {} for {} minutes to help with: {}",
                    persona.name, duration_minutes, context
                ),
                suggested_duration_minutes: duration_minutes,
            })
    }

    /// Find sessions where a persona was active
    fn find_persona_sessions(&self, persona_name: &str) -> Vec<String> {
        // In a real implementation, this would search through historical data
        // For now, return example sessions
        match persona_name {
            "cheet" => vec!["session_14".to_string(), "session_27".to_string()],
            "omni" => vec!["session_8".to_string(), "session_19".to_string()],
            "trish" => vec!["session_22".to_string(), "session_31".to_string()],
            _ => vec![],
        }
    }

    /// Get all cross-domain patterns
    pub fn get_patterns(&self) -> Vec<&CrossDomainPattern> {
        self.patterns.values().collect()
    }

    /// Get patterns by type
    pub fn get_patterns_by_type(&self, pattern_type: PatternType) -> Vec<&CrossDomainPattern> {
        self.patterns
            .values()
            .filter(|p| p.pattern_type == pattern_type)
            .collect()
    }
}

/// Profile for a known persona
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PersonaProfile {
    name: String,
    expertise: Vec<String>,
    personality_traits: Vec<String>,
    favorite_patterns: Vec<PatternType>,
}

/// Connection between projects
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProjectConnection {
    pub project_a: PathBuf,
    pub project_b: PathBuf,
    pub connection_type: ConnectionType,
    pub shared_patterns: Vec<String>, // Pattern IDs
    pub strength: f32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ConnectionType {
    SharedDomain,     // Same problem domain
    SharedTechnology, // Same tech stack
    SharedPatterns,   // Common patterns
    Evolution,        // One evolved from the other
    Complementary,    // Different but complementary
}