Implement /clear + tests + update Readme

Author: Snehal-Reddy

README.md

@@ -26,7 +26,7 @@ I tried a few options of OpenClaw alternatives. They were bloated with complex d
 
 - **Telegram Interface:** Chat natively. It reads, thinks, uses tools, and replies.
 - **Workspace Integration:** Reads and writes files directly in your Obsidian vault. It knows what you wrote yesterday because it can read your daily notes.
-- **Local Memory & Search:** SQLite-backed persistence with FTS5. The agent can search your entire vault or your chat history blazingly fast.
+- **Local Memory & Search:** SQLite-backed persistence with FTS5. The agent can search your entire vault or your chat history blazingly fast. Send `/clear` to archive the current conversation and start fresh — old messages stay in the database and remain searchable.
 - **Background Subagents:** Tell it to "Search the web for X and summarize it." It spawns a background agent, freeing up the main chat, and messages you when it's done.
 - **Cron & Heartbeat:** Schedule recurring tasks or reminders (e.g., "Summarize unread messages every hour").
 - **Basic Tools:**

src/agent/session.rs

@@ -119,6 +119,20 @@ impl Session {
         Ok(())
     }
 
+    /// Rotate to a fresh session for `chat_id`, archiving the old one in place.
+    ///
+    /// Old messages remain in `chat_history` under their previous `session_id`
+    /// and are still searchable via FTS.  The next `Session::load` for this
+    /// `chat_id` will start with an empty history and a new `session_id`.
+    pub async fn reset(db: Arc<BrainDb>, chat_id: &str) -> Result<(), SessionError> {
+        let chat_id = chat_id.to_string();
+        tokio::task::spawn_blocking(move || db.reset_session_id(&chat_id))
+            .await
+            .map_err(|e| SessionError::Db(format!("spawn_blocking: {e}")))?
+            .map_err(SessionError::from)?;
+        Ok(())
+    }
+
     // -----------------------------------------------------------------------
     // Mutation helpers
     // -----------------------------------------------------------------------
@@ -333,6 +347,55 @@ mod tests {
         assert_eq!(session.history().first().unwrap().content, "msg 5");
     }
 
+    // ── Session::reset archives old session and starts fresh ──────────────────
+
+    #[tokio::test]
+    async fn session_reset_starts_fresh_history() {
+        let (_tmp, db) = temp_db();
+
+        // Build up some history and save it
+        let mut s = Session::load(Arc::clone(&db), "chat").await.unwrap();
+        s.add_user_message("before clear");
+        s.save().await.unwrap();
+        let old_sid = s.session_id().to_string();
+
+        // Reset — rotates to a new session_id
+        Session::reset(Arc::clone(&db), "chat").await.unwrap();
+
+        // Loading now gives an empty history with a different session_id
+        let fresh = Session::load(Arc::clone(&db), "chat").await.unwrap();
+        assert!(fresh.history().is_empty(), "history must be empty after reset");
+        assert!(fresh.summary().is_empty(), "summary must be cleared after reset");
+        assert_ne!(
+            fresh.session_id(),
+            old_sid,
+            "session_id must rotate after reset"
+        );
+    }
+
+    #[tokio::test]
+    async fn session_reset_preserves_old_messages_in_db() {
+        let (_tmp, db) = temp_db();
+
+        let mut s = Session::load(Arc::clone(&db), "chat").await.unwrap();
+        let old_sid = s.session_id().to_string();
+        s.add_user_message("archived message");
+        s.save().await.unwrap();
+
+        Session::reset(Arc::clone(&db), "chat").await.unwrap();
+
+        // Old messages are still in chat_history under the previous session_id
+        let inner_db = Arc::clone(&db);
+        let (old_msgs, _) = tokio::task::spawn_blocking(move || {
+            inner_db.load_session("chat", &old_sid)
+        })
+        .await
+        .unwrap()
+        .unwrap();
+        assert_eq!(old_msgs.len(), 1);
+        assert_eq!(old_msgs[0].content, "archived message");
+    }
+
     // ── All pending inserts reach the DB even when history is capped ──────────
 
     #[tokio::test]

src/main.rs

@@ -9,6 +9,7 @@ use std::sync::atomic::{AtomicI64, Ordering};
 use tokio::sync::mpsc;
 
 use icrab::agent;
+use icrab::agent::session::Session;
 use icrab::agent::subagent_manager::SubagentManager;
 use icrab::config;
 use icrab::cron_runner;
@@ -182,7 +183,15 @@ async fn main() {
         };
         let chat_id_str = msg.chat_id.to_string();
 
-        let reply = if msg.channel == "heartbeat" {
+        let reply = if msg.text.trim() == "/clear" {
+            match Session::reset(Arc::clone(&db), &chat_id_str).await {
+                Ok(()) => "Session cleared. Starting fresh! 🦀".to_string(),
+                Err(e) => {
+                    eprintln!("clear session error: {}", e);
+                    format!("Error clearing session: {}.", e)
+                }
+            }
+        } else if msg.channel == "heartbeat" {
             match agent::process_heartbeat_message(
                 &llm,
                 &registry,

src/memory/db.rs

@@ -211,6 +211,29 @@ impl BrainDb {
     // Chat history operations
     // -----------------------------------------------------------------------
 
+    /// Force-rotate to a brand-new session for `chat_id`.
+    ///
+    /// Generates a fresh UUID, stores it as `current_session_id` in
+    /// `chat_summary`, and resets `summary` to `""`.  Old messages remain
+    /// intact in `chat_history` under their previous `session_id`.
+    pub fn reset_session_id(&self, chat_id: &str) -> Result<String, DbError> {
+        let conn = self
+            .conn
+            .lock()
+            .map_err(|e| DbError(format!("lock: {e}")))?;
+
+        let new_id = uuid::Uuid::new_v4().to_string();
+        conn.execute(
+            "INSERT INTO chat_summary (chat_id, current_session_id, summary)
+             VALUES (?1, ?2, '')
+             ON CONFLICT(chat_id) DO UPDATE
+                 SET current_session_id = excluded.current_session_id,
+                     summary            = ''",
+            params![chat_id, &new_id],
+        )?;
+        Ok(new_id)
+    }
+
     /// Return the active `session_id` UUID for `chat_id`, creating and
     /// persisting a new one if none exists yet.
     pub fn get_or_create_session_id(&self, chat_id: &str) -> Result<String, DbError> {
@@ -608,6 +631,78 @@ mod tests {
         assert!(db2.health_check());
     }
 
+    // ── reset_session_id ─────────────────────────────────────────────────────
+
+    #[test]
+    fn reset_session_id_returns_new_uuid() {
+        let (_tmp, db) = temp_db();
+        let sid1 = db.get_or_create_session_id("chat").unwrap();
+        let sid2 = db.reset_session_id("chat").unwrap();
+        assert_ne!(sid1, sid2, "reset must produce a different session_id");
+        assert_eq!(sid2.len(), 36);
+    }
+
+    #[test]
+    fn reset_session_id_clears_summary() {
+        let (_tmp, db) = temp_db();
+        let sid = db.get_or_create_session_id("chat").unwrap();
+        db.append_session("chat", &sid, &[], "old summary").unwrap();
+
+        db.reset_session_id("chat").unwrap();
+        let new_sid = db.get_or_create_session_id("chat").unwrap();
+        // The session_id must have changed and the summary must be empty
+        assert_ne!(sid, new_sid);
+        let (_, summary) = db.load_session("chat", &new_sid).unwrap();
+        assert_eq!(summary, "");
+    }
+
+    #[test]
+    fn reset_session_id_keeps_old_messages() {
+        let (_tmp, db) = temp_db();
+        let old_sid = db.get_or_create_session_id("chat").unwrap();
+        db.append_session(
+            "chat",
+            &old_sid,
+            &[StoredMessage {
+                role: "user".into(),
+                content: "preserved".into(),
+                tool_call_id: None,
+                tool_calls: None,
+            }],
+            "",
+        )
+        .unwrap();
+
+        db.reset_session_id("chat").unwrap();
+
+        // Old messages still retrievable by their original session_id
+        let (old_msgs, _) = db.load_session("chat", &old_sid).unwrap();
+        assert_eq!(old_msgs.len(), 1);
+        assert_eq!(old_msgs[0].content, "preserved");
+    }
+
+    #[test]
+    fn reset_session_id_new_session_starts_empty() {
+        let (_tmp, db) = temp_db();
+        let old_sid = db.get_or_create_session_id("chat").unwrap();
+        db.append_session(
+            "chat",
+            &old_sid,
+            &[StoredMessage {
+                role: "user".into(),
+                content: "old".into(),
+                tool_call_id: None,
+                tool_calls: None,
+            }],
+            "",
+        )
+        .unwrap();
+
+        let new_sid = db.reset_session_id("chat").unwrap();
+        let (new_msgs, _) = db.load_session("chat", &new_sid).unwrap();
+        assert!(new_msgs.is_empty(), "new session must start with no messages");
+    }
+
     // ── get_or_create_session_id ─────────────────────────────────────────────
 
     #[test]