Smart Tree - ST

//! Temporal aspects of context gathering //! //! This module adds time-based features to context gathering, allowing for //! understanding how project context evolves over time. use chrono::{DateTime, Datelike, Duration, TimeZone, Timelike, Utc}; use serde::{Deserialize, Serialize}; use std::collections::{BTreeMap, HashMap}; use super::{ContextType, GatheredContext}; /// Temporal resolution for context analysis #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] pub enum TemporalResolution { Hour, Day, Week, Month, Quarter, Year, } impl TemporalResolution { /// Get the duration for this resolution pub fn duration(&self) -> Duration { match self { Self::Hour => Duration::hours(1), Self::Day => Duration::days(1), Self::Week => Duration::weeks(1), Self::Month => Duration::days(30), // Approximate Self::Quarter => Duration::days(90), Self::Year => Duration::days(365), } } /// Truncate a datetime to this resolution pub fn truncate(&self, dt: DateTime<Utc>) -> DateTime<Utc> { match self { Self::Hour => Utc .with_ymd_and_hms(dt.year(), dt.month(), dt.day(), dt.hour(), 0, 0) .single() .unwrap_or(dt), Self::Day => Utc .with_ymd_and_hms(dt.year(), dt.month(), dt.day(), 0, 0, 0) .single() .unwrap_or(dt), Self::Week => { let days_since_monday = dt.weekday().num_days_from_monday(); let start_of_week = dt - Duration::days(days_since_monday as i64); Utc.with_ymd_and_hms( start_of_week.year(), start_of_week.month(), start_of_week.day(), 0, 0, 0, ) .single() .unwrap_or(dt) } Self::Month => Utc .with_ymd_and_hms(dt.year(), dt.month(), 1, 0, 0, 0) .single() .unwrap_or(dt), Self::Quarter => { let quarter_month = ((dt.month() - 1) / 3) * 3 + 1; Utc.with_ymd_and_hms(dt.year(), quarter_month, 1, 0, 0, 0) .single() .unwrap_or(dt) } Self::Year => Utc .with_ymd_and_hms(dt.year(), 1, 1, 0, 0, 0) .single() .unwrap_or(dt), } } } /// Temporal context analyzer pub struct TemporalContextAnalyzer { pub contexts: Vec<GatheredContext>, resolution: TemporalResolution, } impl TemporalContextAnalyzer { pub fn new(contexts: Vec<GatheredContext>, resolution: TemporalResolution) -> Self { Self { contexts, resolution, } } /// Group contexts by time period pub fn group_by_time(&self) -> BTreeMap<DateTime<Utc>, Vec<&GatheredContext>> { let mut groups = BTreeMap::new(); for context in &self.contexts { let period = self.resolution.truncate(context.timestamp); groups.entry(period).or_insert_with(Vec::new).push(context); } groups } /// Calculate activity intensity over time pub fn activity_timeline(&self) -> Vec<TimelinePoint> { let groups = self.group_by_time(); let mut timeline = Vec::new(); for (time, contexts) in groups { let intensity = contexts.len() as f32; let avg_relevance = contexts.iter().map(|c| c.relevance_score).sum::<f32>() / contexts.len() as f32; timeline.push(TimelinePoint { timestamp: time, activity_count: contexts.len(), intensity, average_relevance: avg_relevance, dominant_type: Self::get_dominant_type(&contexts), tools_used: Self::get_tools_used(&contexts), }); } timeline } /// Detect temporal patterns pub fn detect_patterns(&self) -> TemporalPatterns { let timeline = self.activity_timeline(); // Detect work sessions (clusters of activity) let sessions = self.detect_work_sessions(&timeline); // Find peak activity times let peak_times = self.find_peak_times(&timeline); // Calculate momentum (increasing/decreasing activity) let momentum = self.calculate_momentum(&timeline); // Detect periodic patterns let periodic_patterns = self.detect_periodic_patterns(&timeline); TemporalPatterns { work_sessions: sessions, peak_times, momentum, periodic_patterns, total_duration: self.calculate_total_duration(), active_days: self.count_active_days(), } } /// Create a temporal wave representation pub fn create_temporal_waves(&self) -> TemporalWaveGrid { let mut grid = TemporalWaveGrid::new(self.resolution); let groups = self.group_by_time(); for (time, contexts) in groups { // Create waves for each time period for context in contexts { let wave = TemporalWave { timestamp: time, frequency: self.calculate_frequency(context), amplitude: context.relevance_score, phase: self.calculate_phase(context), decay_rate: self.calculate_decay_rate(&time), context_type: context.content_type.clone(), tool: context.ai_tool.clone(), }; grid.add_wave(wave); } } grid } /// Apply temporal decay to relevance scores pub fn apply_temporal_decay(&mut self, half_life_days: f32) { let now = Utc::now(); for context in &mut self.contexts { let age_days = (now - context.timestamp).num_days() as f32; let decay_factor = 0.5_f32.powf(age_days / half_life_days); context.relevance_score *= decay_factor; } // Re-sort by decayed relevance self.contexts .sort_by(|a, b| b.relevance_score.partial_cmp(&a.relevance_score).unwrap()); } // Helper methods fn get_dominant_type(contexts: &[&GatheredContext]) -> ContextType { let mut type_counts = HashMap::new(); for context in contexts { *type_counts.entry(context.content_type.clone()).or_insert(0) += 1; } type_counts .into_iter() .max_by_key(|(_, count)| *count) .map(|(ctx_type, _)| ctx_type) .unwrap_or(ContextType::Configuration) } fn get_tools_used(contexts: &[&GatheredContext]) -> Vec<String> { let mut tools = contexts .iter() .map(|c| c.ai_tool.clone()) .collect::<Vec<_>>(); tools.sort(); tools.dedup(); tools } fn detect_work_sessions(&self, timeline: &[TimelinePoint]) -> Vec<WorkSession> { let mut sessions = Vec::new(); let mut current_session: Option<WorkSession> = None; let session_gap = match self.resolution { TemporalResolution::Hour => Duration::hours(4), TemporalResolution::Day => Duration::days(3), _ => Duration::weeks(1), }; for point in timeline.iter() { if let Some(ref mut session) = current_session { let gap = point.timestamp - session.end_time; if gap > session_gap { // End current session and start new one sessions.push(session.clone()); current_session = Some(WorkSession { start_time: point.timestamp, end_time: point.timestamp, total_activities: point.activity_count, average_intensity: point.intensity, }); } else { // Continue current session session.end_time = point.timestamp; session.total_activities += point.activity_count; session.average_intensity = (session.average_intensity + point.intensity) / 2.0; } } else { // Start first session current_session = Some(WorkSession { start_time: point.timestamp, end_time: point.timestamp, total_activities: point.activity_count, average_intensity: point.intensity, }); } } if let Some(session) = current_session { sessions.push(session); } sessions } fn find_peak_times(&self, timeline: &[TimelinePoint]) -> Vec<PeakTime> { let mut peaks = timeline .iter() .map(|point| PeakTime { timestamp: point.timestamp, intensity: point.intensity, resolution: self.resolution, }) .collect::<Vec<_>>(); // Sort by intensity and take top 10 peaks.sort_by(|a, b| b.intensity.partial_cmp(&a.intensity).unwrap()); peaks.truncate(10); peaks } fn calculate_momentum(&self, timeline: &[TimelinePoint]) -> f32 { if timeline.len() < 2 { return 0.0; } // Calculate trend over recent periods let recent_count = timeline.len().min(10); let recent = &timeline[timeline.len() - recent_count..]; let mut momentum = 0.0; for i in 1..recent.len() { let change = recent[i].intensity - recent[i - 1].intensity; momentum += change * (i as f32 / recent.len() as f32); // Weight recent changes more } momentum / recent.len() as f32 } fn detect_periodic_patterns(&self, timeline: &[TimelinePoint]) -> Vec<PeriodicPattern> { let mut patterns = Vec::new(); // Check for daily patterns (if resolution allows) if matches!(self.resolution, TemporalResolution::Hour) { if let Some(pattern) = self.detect_daily_pattern(timeline) { patterns.push(pattern); } } // Check for weekly patterns if matches!( self.resolution, TemporalResolution::Day | TemporalResolution::Hour ) { if let Some(pattern) = self.detect_weekly_pattern(timeline) { patterns.push(pattern); } } patterns } fn detect_daily_pattern(&self, timeline: &[TimelinePoint]) -> Option<PeriodicPattern> { // Group by hour of day let mut hour_activities = HashMap::new(); for point in timeline { let hour = point.timestamp.hour(); hour_activities .entry(hour) .or_insert_with(Vec::new) .push(point.intensity); } // Find peak hours let mut peak_hours = hour_activities .iter() .map(|(hour, intensities)| { let avg = intensities.iter().sum::<f32>() / intensities.len() as f32; (*hour, avg) }) .collect::<Vec<_>>(); peak_hours.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); if peak_hours.is_empty() { return None; } Some(PeriodicPattern { period_type: "daily".to_string(), peak_periods: peak_hours .iter() .take(3) .map(|(h, _)| format!("{:02}:00", h)) .collect(), strength: 0.0, // TODO: Calculate pattern strength }) } fn detect_weekly_pattern(&self, timeline: &[TimelinePoint]) -> Option<PeriodicPattern> { // Group by day of week let mut day_activities = HashMap::new(); for point in timeline { let day = point.timestamp.weekday(); day_activities .entry(day) .or_insert_with(Vec::new) .push(point.intensity); } // Find peak days let mut peak_days = day_activities .iter() .map(|(day, intensities)| { let avg = intensities.iter().sum::<f32>() / intensities.len() as f32; (*day, avg) }) .collect::<Vec<_>>(); peak_days.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); if peak_days.is_empty() { return None; } Some(PeriodicPattern { period_type: "weekly".to_string(), peak_periods: peak_days .iter() .take(3) .map(|(d, _)| format!("{:?}", d)) .collect(), strength: 0.0, // TODO: Calculate pattern strength }) } fn calculate_total_duration(&self) -> Duration { if self.contexts.is_empty() { return Duration::zero(); } let min_time = self.contexts.iter().map(|c| c.timestamp).min().unwrap(); let max_time = self.contexts.iter().map(|c| c.timestamp).max().unwrap(); max_time - min_time } fn count_active_days(&self) -> usize { let mut days = self .contexts .iter() .map(|c| c.timestamp.date_naive()) .collect::<Vec<_>>(); days.sort(); days.dedup(); days.len() } fn calculate_frequency(&self, context: &GatheredContext) -> f32 { // Map context type to frequency band match context.content_type { ContextType::ChatHistory => 0.1, ContextType::ProjectSettings => 0.05, ContextType::CodeSnippets => 0.2, ContextType::Documentation => 0.08, ContextType::Configuration => 0.06, ContextType::SearchHistory => 0.15, ContextType::Bookmarks => 0.07, ContextType::CustomPrompts => 0.12, ContextType::ModelPreferences => 0.04, ContextType::WorkspaceState => 0.09, } } fn calculate_phase(&self, context: &GatheredContext) -> f32 { // Use timestamp to create phase offset let minutes_since_epoch = context.timestamp.timestamp() / 60; ((minutes_since_epoch % 360) as f32) * std::f32::consts::PI / 180.0 } fn calculate_decay_rate(&self, time: &DateTime<Utc>) -> f32 { let age_days = (Utc::now() - *time).num_days() as f32; 1.0 / (1.0 + age_days / 30.0) // Decay over 30 days } } /// Point on the activity timeline #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TimelinePoint { pub timestamp: DateTime<Utc>, pub activity_count: usize, pub intensity: f32, pub average_relevance: f32, pub dominant_type: ContextType, pub tools_used: Vec<String>, } /// Detected temporal patterns #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TemporalPatterns { pub work_sessions: Vec<WorkSession>, pub peak_times: Vec<PeakTime>, pub momentum: f32, pub periodic_patterns: Vec<PeriodicPattern>, pub total_duration: Duration, pub active_days: usize, } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct WorkSession { pub start_time: DateTime<Utc>, pub end_time: DateTime<Utc>, pub total_activities: usize, pub average_intensity: f32, } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PeakTime { pub timestamp: DateTime<Utc>, pub intensity: f32, pub resolution: TemporalResolution, } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PeriodicPattern { pub period_type: String, pub peak_periods: Vec<String>, pub strength: f32, } /// Temporal wave representation #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TemporalWave { pub timestamp: DateTime<Utc>, pub frequency: f32, pub amplitude: f32, pub phase: f32, pub decay_rate: f32, pub context_type: ContextType, pub tool: String, } /// Grid of temporal waves pub struct TemporalWaveGrid { resolution: TemporalResolution, waves: Vec<TemporalWave>, time_slots: BTreeMap<DateTime<Utc>, Vec<usize>>, // Time -> wave indices } impl TemporalWaveGrid { pub fn new(resolution: TemporalResolution) -> Self { Self { resolution, waves: Vec::new(), time_slots: BTreeMap::new(), } } pub fn add_wave(&mut self, wave: TemporalWave) { let time_slot = self.resolution.truncate(wave.timestamp); let wave_idx = self.waves.len(); self.waves.push(wave); self.time_slots.entry(time_slot).or_default().push(wave_idx); } /// Get interference pattern at a specific time pub fn get_interference_at(&self, time: DateTime<Utc>) -> f32 { let time_slot = self.resolution.truncate(time); if let Some(indices) = self.time_slots.get(&time_slot) { let mut total = 0.0; for &idx in indices { let wave = &self.waves[idx]; let age_factor = wave.decay_rate; let value = wave.amplitude * age_factor * (2.0 * std::f32::consts::PI * wave.frequency * time.timestamp() as f32 + wave.phase) .sin(); total += value; } total / indices.len() as f32 } else { 0.0 } } /// Navigate through time to find interesting moments pub fn find_resonance_peaks(&self) -> Vec<DateTime<Utc>> { let mut peaks = Vec::new(); for (&time, indices) in &self.time_slots { if indices.len() > 3 { // Multiple waves at same time let interference = self.get_interference_at(time); if interference.abs() > 0.7 { peaks.push(time); } } } peaks } }