st/

m8_context_aware.rs

// Context-Aware .m8 Reader - Progressive detail on demand! 🎯
// "Like RAM banking on the C64 - load only what you need!" - Hue

use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContextualM8 {
    pub frequency: f64,
    pub essence: String,
    pub keywords: Vec<String>,
    pub depth_level: u8, // 0=summary, 1=overview, 2=detailed, 3=full
    pub children: HashMap<String, f64>, // child_name -> frequency
    pub context_triggers: HashMap<String, String>, // keyword -> expansion_path
}

pub struct ContextAwareReader {
    cache: HashMap<PathBuf, ContextualM8>,
    current_context: Vec<String>, // Current conversation keywords
    expansion_threshold: f64,     // Similarity threshold for auto-expansion
}

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

impl ContextAwareReader {
    pub fn new() -> Self {
        Self {
            cache: HashMap::new(),
            current_context: Vec::new(),
            expansion_threshold: 0.7,
        }
    }

    /// Load .m8 with minimal context (just essence)
    pub fn load_minimal(&mut self, path: &Path) -> Result<String> {
        let m8 = self.load_m8(path)?;

        // Return just the essence - super minimal
        Ok(format!(
            "📍 {}: {}",
            path.file_name().unwrap_or_default().to_string_lossy(),
            m8.essence
        ))
    }

    /// Load with smart context based on current conversation
    pub fn load_contextual(&mut self, path: &Path, context_keywords: &[String]) -> Result<String> {
        let m8 = self.load_m8(path)?;

        // Calculate relevance score
        let relevance = self.calculate_relevance(&m8, context_keywords);

        // Determine detail level based on relevance
        let detail_level = if relevance > 0.9 {
            3 // Full detail - highly relevant!
        } else if relevance > 0.7 {
            2 // Detailed
        } else if relevance > 0.5 {
            1 // Overview
        } else {
            0 // Just summary
        };

        self.format_by_detail_level(&m8, detail_level, path)
    }

    /// Calculate how relevant this .m8 is to current context
    fn calculate_relevance(&self, m8: &ContextualM8, context_keywords: &[String]) -> f64 {
        let mut score = 0.0;
        let mut _matches = 0;

        for keyword in context_keywords {
            let keyword_lower = keyword.to_lowercase();

            // Check essence
            if m8.essence.to_lowercase().contains(&keyword_lower) {
                score += 1.0;
                _matches += 1;
            }

            // Check keywords
            for m8_keyword in &m8.keywords {
                if m8_keyword.to_lowercase().contains(&keyword_lower) {
                    score += 0.8;
                    _matches += 1;
                }
            }

            // Check triggers
            if m8.context_triggers.contains_key(keyword) {
                score += 2.0; // Strong signal!
                _matches += 1;
            }
        }

        if context_keywords.is_empty() {
            return 0.0;
        }

        // Normalize by number of keywords
        (score / context_keywords.len() as f64).min(1.0)
    }

    /// Format output based on detail level
    fn format_by_detail_level(&self, m8: &ContextualM8, level: u8, path: &Path) -> Result<String> {
        let mut output = String::new();

        match level {
            0 => {
                // Minimal - just essence
                output.push_str(&format!("• {}\n", m8.essence));
            }
            1 => {
                // Overview - essence + keywords
                output.push_str(&format!("📂 {} ({:.1}Hz)\n", path.display(), m8.frequency));
                output.push_str(&format!("  {}\n", m8.essence));
                output.push_str(&format!("  Keywords: {}\n", m8.keywords.join(", ")));
            }
            2 => {
                // Detailed - include children
                output.push_str(&format!("📂 {} ({:.1}Hz)\n", path.display(), m8.frequency));
                output.push_str(&format!("  📝 {}\n", m8.essence));
                output.push_str(&format!("  🏷️ Keywords: {}\n", m8.keywords.join(", ")));

                if !m8.children.is_empty() {
                    output.push_str("  📁 Children:\n");
                    for (child, freq) in &m8.children {
                        output.push_str(&format!("    • {} ({:.1}Hz)\n", child, freq));
                    }
                }
            }
            3 => {
                // Full detail - everything including triggers
                output.push_str(&format!("╭{}\n", "─".repeat(50)));
                output.push_str(&format!("│ 📂 {} \n", path.display()));
                output.push_str(&format!("│ 🌊 Frequency: {:.1}Hz\n", m8.frequency));
                output.push_str(&format!("│ 📝 {}\n", m8.essence));
                output.push_str(&format!("│ 🏷️ Keywords: {}\n", m8.keywords.join(", ")));

                if !m8.children.is_empty() {
                    output.push_str("│ 📁 Children:\n");
                    for (child, freq) in &m8.children {
                        output.push_str(&format!("│   • {} ({:.1}Hz)\n", child, freq));
                    }
                }

                if !m8.context_triggers.is_empty() {
                    output.push_str("│ 🎯 Context Triggers:\n");
                    for (trigger, expansion) in &m8.context_triggers {
                        output.push_str(&format!("│   {} → {}\n", trigger, expansion));
                    }
                }

                output.push_str(&format!("╰{}\n", "─".repeat(50)));
            }
            _ => output = format!("• {}\n", m8.essence),
        }

        Ok(output)
    }

    /// Auto-expand based on conversation context
    pub fn auto_expand(&mut self, root_path: &Path, keywords: &[String]) -> Result<Vec<String>> {
        let mut expansions = Vec::new();

        // Scan for .m8 files
        for entry in fs::read_dir(root_path)? {
            let entry = entry?;
            let path = entry.path();

            if path.extension().and_then(|s| s.to_str()) == Some("m8") {
                let content = self.load_contextual(&path, keywords)?;
                let m8 = self.load_m8(&path)?;

                // Check if we should drill down
                let relevance = self.calculate_relevance(&m8, keywords);
                if relevance > self.expansion_threshold {
                    expansions.push(content);

                    // Recursively expand highly relevant children
                    if relevance > 0.9 && path.is_dir() {
                        let child_expansions = self.auto_expand(&path, keywords)?;
                        expansions.extend(child_expansions);
                    }
                }
            }
        }

        Ok(expansions)
    }

    /// Load and cache .m8 file
    fn load_m8(&mut self, path: &Path) -> Result<ContextualM8> {
        if let Some(cached) = self.cache.get(path) {
            return Ok(cached.clone());
        }

        // For now, create a mock .m8 (would load real file)
        let m8 = if path.to_string_lossy().contains("8b.is") {
            ContextualM8 {
                frequency: 88.8,
                essence: "8b.is website - Company portal for 8-bit inspired AI services"
                    .to_string(),
                keywords: vec![
                    "8b.is".to_string(),
                    "website".to_string(),
                    "portal".to_string(),
                ],
                depth_level: 0,
                children: HashMap::from([
                    ("frontend".to_string(), 92.3),
                    ("api".to_string(), 87.5),
                    ("docs".to_string(), 45.2),
                ]),
                context_triggers: HashMap::from([
                    ("website".to_string(), "frontend/".to_string()),
                    ("API".to_string(), "api/".to_string()),
                    ("documentation".to_string(), "docs/".to_string()),
                ]),
            }
        } else if path.to_string_lossy().contains("smart-tree") {
            ContextualM8 {
                frequency: 42.73,
                essence: "Smart Tree - AI-optimized directory visualization with consciousness"
                    .to_string(),
                keywords: vec![
                    "smart-tree".to_string(),
                    "MCP".to_string(),
                    "consciousness".to_string(),
                ],
                depth_level: 0,
                children: HashMap::from([("src".to_string(), 87.2), ("docs".to_string(), 33.7)]),
                context_triggers: HashMap::from([
                    ("tokenizer".to_string(), "src/tokenizer.rs".to_string()),
                    ("memory".to_string(), "src/memory_manager.rs".to_string()),
                    (
                        "consciousness".to_string(),
                        "src/m8_consciousness.rs".to_string(),
                    ),
                ]),
            }
        } else {
            ContextualM8 {
                frequency: 50.0,
                essence: format!("Directory: {}", path.display()),
                keywords: vec![],
                depth_level: 0,
                children: HashMap::new(),
                context_triggers: HashMap::new(),
            }
        };

        self.cache.insert(path.to_path_buf(), m8.clone());
        Ok(m8)
    }

    /// Update context based on current conversation
    pub fn update_context(&mut self, keywords: Vec<String>) {
        self.current_context = keywords;
    }
}

/// Example usage showing progressive loading
pub fn demonstrate_context_awareness() -> Result<()> {
    let mut reader = ContextAwareReader::new();

    println!("🎯 Context-Aware .m8 Loading Demo\n");
    println!("{}\n", "=".repeat(60));

    // Scenario 1: No context - minimal loading
    println!("📍 No context (just browsing):");
    let minimal = reader.load_contextual(Path::new("/projects/smart-tree/.m8"), &[])?;
    println!("{}\n", minimal);

    // Scenario 2: Talking about websites - medium detail
    println!("💬 Context: 'website'");
    let website_context =
        reader.load_contextual(Path::new("/projects/8b.is/.m8"), &["website".to_string()])?;
    println!("{}\n", website_context);

    // Scenario 3: Talking about 8b.is specifically - full detail!
    println!("💬 Context: '8b.is website API'");
    let specific_context = reader.load_contextual(
        Path::new("/projects/8b.is/.m8"),
        &[
            "8b.is".to_string(),
            "website".to_string(),
            "API".to_string(),
        ],
    )?;
    println!("{}\n", specific_context);

    // Scenario 4: Auto-expansion based on triggers
    println!("🔍 Auto-expanding based on 'tokenizer' keyword:");
    let expansions = reader.auto_expand(
        Path::new("/projects/smart-tree"),
        &["tokenizer".to_string()],
    )?;
    for expansion in expansions {
        println!("{}", expansion);
    }

    Ok(())
}

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

    #[test]
    fn test_relevance_calculation() {
        let reader = ContextAwareReader::new();

        let m8 = ContextualM8 {
            frequency: 42.0,
            essence: "Smart Tree project".to_string(),
            keywords: vec!["tree".to_string(), "visualization".to_string()],
            depth_level: 0,
            children: HashMap::new(),
            context_triggers: HashMap::from([("tree".to_string(), "src/".to_string())]),
        };

        // High relevance
        let score = reader.calculate_relevance(&m8, &["tree".to_string()]);
        assert!(score > 0.9);

        // Medium relevance
        let score = reader.calculate_relevance(&m8, &["visualization".to_string()]);
        assert!(score > 0.5);

        // Low relevance
        let score = reader.calculate_relevance(&m8, &["random".to_string()]);
        assert!(score < 0.3);
    }
}