fix(cli): add date filtering options to sessions command

Fixes bounty issue #1662

Added --days, --since, and --until options to the sessions command to allow
users to filter sessions by date range. Users can now:
- Filter sessions from the last N days: cortex sessions --days 7
- Filter sessions since a date: cortex sessions --since 2024-01-01
- Filter sessions until a date: cortex sessions --until 2024-12-31
- Combine filters: cortex sessions --since 2024-01-01 --until 2024-06-30

Author: factorydroid

cortex-cli/src/main.rs

@@ -304,6 +304,18 @@ struct SessionsCommand {
     /// Show all sessions including from other directories
     #[arg(long)]
     all: bool,
+
+    /// Filter sessions from the last N days
+    #[arg(long, short = 'd')]
+    days: Option<u32>,
+
+    /// Filter sessions since a specific date (YYYY-MM-DD format)
+    #[arg(long)]
+    since: Option<String>,
+
+    /// Filter sessions until a specific date (YYYY-MM-DD format)
+    #[arg(long)]
+    until: Option<String>,
 }
 
 /// Config command.
@@ -478,7 +490,15 @@ async fn main() -> Result<()> {
             }
         },
         Some(Commands::Resume(resume_cli)) => run_resume(resume_cli).await,
-        Some(Commands::Sessions(sessions_cli)) => list_sessions(sessions_cli.all).await,
+        Some(Commands::Sessions(sessions_cli)) => {
+            list_sessions(
+                sessions_cli.all,
+                sessions_cli.days,
+                sessions_cli.since,
+                sessions_cli.until,
+            )
+            .await
+        }
         Some(Commands::Export(export_cli)) => export_cli.run().await,
         Some(Commands::Import(import_cli)) => import_cli.run().await,
         Some(Commands::Config(config_cli)) => show_config(config_cli).await,
@@ -680,7 +700,14 @@ async fn run_resume(resume_cli: ResumeCommand) -> Result<()> {
     Ok(())
 }
 
-async fn list_sessions(show_all: bool) -> Result<()> {
+async fn list_sessions(
+    show_all: bool,
+    days: Option<u32>,
+    since: Option<String>,
+    until: Option<String>,
+) -> Result<()> {
+    use chrono::{DateTime, NaiveDate, Utc};
+
     let config = cortex_engine::Config::default();
     let sessions = cortex_engine::list_sessions(&config.cortex_home)?;
 
@@ -693,58 +720,146 @@ async fn list_sessions(show_all: bool) -> Result<()> {
         return Ok(());
     }
 
-    let current_dir = std::env::current_dir().ok();
-    let filtered: Vec<_> = if show_all {
-        sessions.iter().collect()
+    // Parse date filters
+    let now = Utc::now();
+    let since_date: Option<DateTime<Utc>> = if let Some(days_val) = days {
+        Some(now - chrono::Duration::days(days_val as i64))
+    } else if let Some(ref since_str) = since {
+        match NaiveDate::parse_from_str(since_str, "%Y-%m-%d") {
+            Ok(date) => Some(
+                date.and_hms_opt(0, 0, 0)
+                    .unwrap()
+                    .and_local_timezone(Utc)
+                    .unwrap(),
+            ),
+            Err(_) => {
+                eprintln!(
+                    "Warning: Invalid --since date format '{}'. Expected YYYY-MM-DD.",
+                    since_str
+                );
+                None
+            }
+        }
     } else {
-        sessions
-            .iter()
-            .filter(|s| current_dir.as_ref().is_none_or(|cwd| s.cwd == *cwd))
-            .collect()
+        None
+    };
+
+    let until_date: Option<DateTime<Utc>> = if let Some(ref until_str) = until {
+        match NaiveDate::parse_from_str(until_str, "%Y-%m-%d") {
+            Ok(date) => Some(
+                date.and_hms_opt(23, 59, 59)
+                    .unwrap()
+                    .and_local_timezone(Utc)
+                    .unwrap(),
+            ),
+            Err(_) => {
+                eprintln!(
+                    "Warning: Invalid --until date format '{}'. Expected YYYY-MM-DD.",
+                    until_str
+                );
+                None
+            }
+        }
+    } else {
+        None
     };
 
-    let display_sessions = if filtered.is_empty() {
+    let current_dir = std::env::current_dir().ok();
+
+    // Apply all filters: directory, since, and until
+    let filtered: Vec<_> = sessions
+        .iter()
+        .filter(|s| {
+            // Directory filter
+            if !show_all && current_dir.as_ref().is_some_and(|cwd| s.cwd != *cwd) {
+                return false;
+            }
+
+            // Parse session timestamp for date filtering
+            if since_date.is_some() || until_date.is_some() {
+                if let Ok(session_time) = DateTime::parse_from_rfc3339(&s.timestamp) {
+                    let session_utc = session_time.with_timezone(&Utc);
+                    if let Some(ref since) = since_date {
+                        if session_utc < *since {
+                            return false;
+                        }
+                    }
+                    if let Some(ref until) = until_date {
+                        if session_utc > *until {
+                            return false;
+                        }
+                    }
+                }
+            }
+
+            true
+        })
+        .collect();
+
+    let display_sessions = if filtered.is_empty() && since_date.is_none() && until_date.is_none() {
         &sessions
     } else {
         &filtered.iter().map(|s| (*s).clone()).collect()
     };
 
-    println!("Recent Sessions{}:", if show_all { " (all)" } else { "" });
-    println!("{:-<80}", "");
+    // Build header with active filters
+    let mut filter_info = String::new();
+    if show_all {
+        filter_info.push_str(" (all)");
+    }
+    if let Some(days_val) = days {
+        filter_info.push_str(&format!(" (last {} days)", days_val));
+    } else {
+        if since_date.is_some() {
+            filter_info.push_str(&format!(" (since {})", since.as_deref().unwrap_or("")));
+        }
+        if until_date.is_some() {
+            filter_info.push_str(&format!(" (until {})", until.as_deref().unwrap_or("")));
+        }
+    }
 
-    for session in display_sessions.iter().take(15) {
-        let model = session.model.as_deref().unwrap_or("unknown");
-        let date = if session.timestamp.len() >= 19 {
-            session.timestamp[..19].replace('T', " ")
-        } else {
-            session.timestamp.clone()
-        };
+    println!("Recent Sessions{}:", filter_info);
+    println!("{:-<80}", "");
 
-        let branch_info = session
-            .git_branch
-            .as_ref()
-            .map(|b| format!(" [{b}]"))
-            .unwrap_or_default();
+    if display_sessions.is_empty() {
+        println!("No sessions match the specified filters.");
+    } else {
+        for session in display_sessions.iter().take(15) {
+            let model = session.model.as_deref().unwrap_or("unknown");
+            let date = if session.timestamp.len() >= 19 {
+                session.timestamp[..19].replace('T', " ")
+            } else {
+                session.timestamp.clone()
+            };
 
-        println!(
-            "{} | {} | {} msgs | {}{branch_info}",
-            &session.id[..8.min(session.id.len())],
-            date,
-            session.message_count,
-            model,
-        );
-        println!("  {}", session.cwd.display());
-    }
+            let branch_info = session
+                .git_branch
+                .as_ref()
+                .map(|b| format!(" [{b}]"))
+                .unwrap_or_default();
+
+            println!(
+                "{} | {} | {} msgs | {}{branch_info}",
+                &session.id[..8.min(session.id.len())],
+                date,
+                session.message_count,
+                model,
+            );
+            println!("  {}", session.cwd.display());
+        }
 
-    if display_sessions.len() > 15 {
-        println!("\n... and {} more sessions", display_sessions.len() - 15);
+        if display_sessions.len() > 15 {
+            println!("\n... and {} more sessions", display_sessions.len() - 15);
+        }
     }
 
     println!("\nTo resume: Cortex resume <session-id>");
     println!("          Cortex resume --last");
     if !show_all {
         println!("          Cortex sessions --all  (show all directories)");
     }
+    println!("          Cortex sessions --days 7  (last 7 days)");
+    println!("          Cortex sessions --since 2024-01-01 --until 2024-12-31  (date range)");
     Ok(())
 }