feat: Add persistent chat history with directory isolation

Implements persistent chat history that survives CLI restarts and is isolated by working directory.

Features:
- Chat history persists across CLI sessions using SQLite database
- History is isolated per working directory (/project/a vs /project/b)
- Up arrow navigation works with persistent history
- Dual cleanup limits: max 100 entries per directory, 1000 total
- Silent failure: history issues don't break CLI functionality
- Filters out empty/whitespace-only inputs

Implementation:
- Database table: chat_history(input TEXT, cwd TEXT) with index on cwd
- Uses existing database infrastructure and Os abstraction
- Transactional insert+cleanup for data consistency
- Early return for empty inputs to avoid unnecessary DB operations

Files modified:
- crates/chat-cli/src/database/mod.rs: Added ensure_chat_history_table(), add_chat_history_entry(), get_chat_history()
- crates/chat-cli/src/cli/chat/input_source.rs: Load history on startup, save on input

Edge cases handled:
- Database failures (silent)
- Empty/whitespace inputs (filtered)
- Working directory access failures (fallback to default)
- Unicode/special characters (parameterized queries)

Author: jmmoser

crates/chat-cli/src/cli/chat/cli/clear.rs

@@ -14,13 +14,14 @@ use crate::cli::chat::{
     ChatSession,
     ChatState,
 };
+use crate::os::Os;
 
 #[deny(missing_docs)]
 #[derive(Debug, PartialEq, Args)]
 pub struct ClearArgs;
 
 impl ClearArgs {
-    pub async fn execute(self, session: &mut ChatSession) -> Result<ChatState, ChatError> {
+    pub async fn execute(self, os: &Os, session: &mut ChatSession) -> Result<ChatState, ChatError> {
         execute!(
             session.stderr,
             style::SetForegroundColor(Color::DarkGrey),
@@ -41,7 +42,7 @@ impl ClearArgs {
         )?;
 
         // Setting `exit_on_single_ctrl_c` for better ux: exit the confirmation dialog rather than the CLI
-        let user_input = match session.read_user_input("> ".yellow().to_string().as_str(), true) {
+        let user_input = match session.read_user_input(os, "> ".yellow().to_string().as_str(), true) {
             Some(input) => input,
             None => "".to_string(),
         };

crates/chat-cli/src/cli/chat/cli/mod.rs

@@ -91,7 +91,7 @@ impl SlashCommand {
     pub async fn execute(self, os: &mut Os, session: &mut ChatSession) -> Result<ChatState, ChatError> {
         match self {
             Self::Quit => Ok(ChatState::Exit),
-            Self::Clear(args) => args.execute(session).await,
+            Self::Clear(args) => args.execute(os, session).await,
             Self::Agent(subcommand) => subcommand.execute(os, session).await,
             Self::Profile => {
                 use crossterm::{

crates/chat-cli/src/cli/chat/cli/subscribe.rs

@@ -148,7 +148,7 @@ async fn upgrade_to_pro(os: &mut Os, session: &mut ChatSession) -> Result<(), Ch
         "]: ".dark_grey(),
     );
 
-    let user_input = session.read_user_input(&prompt, true);
+    let user_input = session.read_user_input(os, &prompt, true);
     queue!(
         session.stderr,
         style::SetForegroundColor(Color::Reset),

crates/chat-cli/src/cli/chat/input_source.rs

@@ -33,7 +33,16 @@ mod inner {
 
 impl InputSource {
     pub fn new(os: &Os, sender: PromptQuerySender, receiver: PromptQueryResponseReceiver) -> Result<Self> {
-        Ok(Self(inner::Inner::Readline(rl(os, sender, receiver)?)))
+        let mut rl = rl(os, sender, receiver)?;
+        
+        // Load persistent chat history from database
+        if let Ok(history) = os.database.get_chat_history(os) {
+            for entry in history {
+                let _ = rl.add_history_entry(&entry);
+            }
+        }
+        
+        Ok(Self(inner::Inner::Readline(rl)))
     }
 
     #[cfg(unix)]
@@ -71,19 +80,18 @@ impl InputSource {
         Self(inner::Inner::Mock { index: 0, lines })
     }
 
-    pub fn read_line(&mut self, prompt: Option<&str>) -> Result<Option<String>, ReadlineError> {
+    pub fn read_line(&mut self, prompt: Option<&str>, os: &Os) -> Result<Option<String>, ReadlineError> {
         match &mut self.0 {
             inner::Inner::Readline(rl) => {
                 let prompt = prompt.unwrap_or_default();
                 let curr_line = rl.readline(prompt);
                 match curr_line {
                     Ok(line) => {
                         let _ = rl.add_history_entry(line.as_str());
-
+                        let _ = os.database.add_chat_history_entry(&line, os);
                         if let Some(helper) = rl.helper_mut() {
                             helper.update_hinter_history(&line);
                         }
-
                         Ok(Some(line))
                     },
                     Err(ReadlineError::Interrupted | ReadlineError::Eof) => Ok(None),
@@ -97,6 +105,7 @@ impl InputSource {
         }
     }
 
+    // For testing mock input source without os dependency
     // We're keeping this method for potential future use
     #[allow(dead_code)]
     pub fn set_buffer(&mut self, content: &str) {
@@ -111,16 +120,17 @@ impl InputSource {
 mod tests {
     use super::*;
 
-    #[test]
-    fn test_mock_input_source() {
+    #[tokio::test]
+    async fn test_mock_input_source() {
         let l1 = "Hello,".to_string();
         let l2 = "Line 2".to_string();
         let l3 = "World!".to_string();
         let mut input = InputSource::new_mock(vec![l1.clone(), l2.clone(), l3.clone()]);
+        let os = crate::os::Os::new().await.unwrap();
 
-        assert_eq!(input.read_line(None).unwrap().unwrap(), l1);
-        assert_eq!(input.read_line(None).unwrap().unwrap(), l2);
-        assert_eq!(input.read_line(None).unwrap().unwrap(), l3);
-        assert!(input.read_line(None).unwrap().is_none());
+        assert_eq!(input.read_line(None, &os).unwrap().unwrap(), l1);
+        assert_eq!(input.read_line(None, &os).unwrap().unwrap(), l2);
+        assert_eq!(input.read_line(None, &os).unwrap().unwrap(), l3);
+        assert!(input.read_line(None, &os).unwrap().is_none());
     }
 }

crates/chat-cli/src/cli/chat/mod.rs

@@ -1567,7 +1567,7 @@ impl ChatSession {
             style::SetAttribute(Attribute::Reset)
         )?;
         let prompt = self.generate_tool_trust_prompt();
-        let user_input = match self.read_user_input(&prompt, false) {
+        let user_input = match self.read_user_input(os, &prompt, false) {
             Some(input) => input,
             None => return Ok(ChatState::Exit),
         };
@@ -2566,10 +2566,10 @@ impl ChatSession {
     }
 
     /// Helper function to read user input with a prompt and Ctrl+C handling
-    fn read_user_input(&mut self, prompt: &str, exit_on_single_ctrl_c: bool) -> Option<String> {
+    fn read_user_input(&mut self, os: &Os, prompt: &str, exit_on_single_ctrl_c: bool) -> Option<String> {
         let mut ctrl_c = false;
         loop {
-            match (self.input_source.read_line(Some(prompt)), ctrl_c) {
+            match (self.input_source.read_line(Some(prompt), os), ctrl_c) {
                 (Ok(Some(line)), _) => {
                     if line.trim().is_empty() {
                         continue; // Reprompt if the input is empty

crates/chat-cli/src/database/mod.rs

@@ -62,6 +62,10 @@ const IDC_REGION_KEY: &str = "auth.idc.region";
 const CUSTOMIZATION_STATE_KEY: &str = "api.selectedCustomization";
 const PROFILE_MIGRATION_KEY: &str = "profile.Migrated";
 
+// Chat history limits
+const CHAT_HISTORY_MAX_PER_DIRECTORY: i32 = 100;
+const CHAT_HISTORY_MAX_TOTAL: i32 = 1000;
+
 const MIGRATIONS: &[Migration] = migrations![
     "000_migration_table",
     "001_history_table",
@@ -463,6 +467,71 @@ impl Database {
 
         Ok(map)
     }
+
+    /// Ensure chat history table exists with index
+    fn ensure_chat_history_table(&self) -> Result<(), DatabaseError> {
+        let conn = self.pool.get()?;
+        conn.execute("CREATE TABLE IF NOT EXISTS chat_history (input TEXT NOT NULL, cwd TEXT NOT NULL)", [])?;
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_chat_history_cwd ON chat_history(cwd)", [])?;
+        Ok(())
+    }
+
+    /// Add a chat input to the persistent history
+    pub fn add_chat_history_entry(&self, input: &str, os: &crate::os::Os) -> Result<(), DatabaseError> {
+        // Skip empty or whitespace-only inputs
+        if input.trim().is_empty() {
+            return Ok(());
+        }
+
+        self.ensure_chat_history_table()?;
+        let conn = self.pool.get()?;
+        let cwd = os.env.current_dir().unwrap_or_default().to_string_lossy().to_string();
+
+        let tx = conn.unchecked_transaction()?;
+        tx.execute("INSERT INTO chat_history (input, cwd) VALUES (?1, ?2)", params![input, cwd])?;
+
+        // Keep only last entries per directory
+        tx.execute(
+            "DELETE FROM chat_history WHERE cwd = ?1 AND rowid < (
+                SELECT MIN(rowid) 
+                FROM (
+                    SELECT rowid 
+                    FROM chat_history 
+                    WHERE cwd = ?1 
+                    ORDER BY rowid DESC 
+                    LIMIT ?2
+                )
+            )",
+            params![cwd, CHAT_HISTORY_MAX_PER_DIRECTORY],
+        )?;
+        
+        // Keep only last entries total
+        tx.execute(
+            "DELETE FROM chat_history WHERE rowid < (
+                SELECT MIN(rowid) 
+                FROM (
+                    SELECT rowid 
+                    FROM chat_history 
+                    ORDER BY rowid DESC 
+                    LIMIT ?1
+                )
+            )",
+            params![CHAT_HISTORY_MAX_TOTAL],
+        )?;
+        tx.commit()?;
+
+        Ok(())
+    }
+
+    /// Get all chat history entries for current working directory
+    pub fn get_chat_history(&self, os: &crate::os::Os) -> Result<Vec<String>, DatabaseError> {
+        self.ensure_chat_history_table()?;
+        let conn = self.pool.get()?;
+        let cwd = os.env.current_dir().unwrap_or_default().to_string_lossy().to_string();
+        let mut stmt = conn.prepare("SELECT input FROM chat_history WHERE cwd = ?1")?;
+        let rows = stmt.query_map([cwd], |row| Ok(row.get(0)?))?;
+        rows.collect::<Result<Vec<String>, _>>().map_err(Into::into)
+    }
 }
 
 fn max_migration_version<C: Deref<Target = Connection>>(conn: &C) -> Option<i64> {
@@ -625,4 +694,50 @@ mod tests {
         store.delete_secret(key).await.unwrap();
         assert_eq!(store.get_secret(key).await.unwrap(), None);
     }
+
+    #[tokio::test]
+    async fn chat_history_basic_operations() {
+        let db = Database::new().await.unwrap();
+        let os = crate::os::Os::new().await.unwrap();
+
+        // Add entries
+        db.add_chat_history_entry("test command 1", &os).unwrap();
+        db.add_chat_history_entry("test command 2", &os).unwrap();
+
+        // Retrieve entries
+        let history = db.get_chat_history(&os).unwrap();
+        assert_eq!(history.len(), 2);
+        assert!(history.contains(&"test command 1".to_string()));
+        assert!(history.contains(&"test command 2".to_string()));
+    }
+
+    #[tokio::test]
+    async fn chat_history_empty_input_filtering() {
+        let db = Database::new().await.unwrap();
+        let os = crate::os::Os::new().await.unwrap();
+
+        // Empty and whitespace inputs should be filtered
+        db.add_chat_history_entry("", &os).unwrap();
+        db.add_chat_history_entry("   ", &os).unwrap();
+        db.add_chat_history_entry("\t\n", &os).unwrap();
+        db.add_chat_history_entry("valid command", &os).unwrap();
+
+        let history = db.get_chat_history(&os).unwrap();
+        assert_eq!(history.len(), 1);
+        assert_eq!(history[0], "valid command");
+    }
+
+    #[tokio::test]
+    async fn chat_history_directory_cleanup() {
+        let db = Database::new().await.unwrap();
+        let os = crate::os::Os::new().await.unwrap();
+
+        // Add more than max entries per directory to test cleanup
+        for i in 0..(CHAT_HISTORY_MAX_PER_DIRECTORY + 5) {
+            db.add_chat_history_entry(&format!("command {}", i), &os).unwrap();
+        }
+
+        let history = db.get_chat_history(&os).unwrap();
+        assert!(history.len() == CHAT_HISTORY_MAX_PER_DIRECTORY as usize, "Should cleanup to max entries per directory");
+    }
 }