feat: add clear command to reset DB without losing session

Author: dgrr

src/cmd/clear.rs

@@ -0,0 +1,142 @@
+use crate::out;
+use crate::store::Store;
+use crate::Cli;
+use anyhow::Result;
+use clap::Args;
+use std::io::{self, Write};
+
+#[derive(Args, Debug, Clone)]
+pub struct ClearArgs {
+    /// Only clear chats and messages
+    #[arg(long)]
+    pub chats: bool,
+
+    /// Only clear contacts
+    #[arg(long)]
+    pub contacts: bool,
+
+    /// Skip confirmation prompt
+    #[arg(long, short = 'y')]
+    pub confirm: bool,
+}
+
+pub async fn run(cli: &Cli, args: &ClearArgs) -> Result<()> {
+    let store_dir = cli.store_dir();
+    let store = Store::open(&store_dir).await?;
+
+    // Determine what to clear
+    let clear_all = !args.chats && !args.contacts;
+    let clear_chats = clear_all || args.chats;
+    let clear_contacts = clear_all || args.contacts;
+
+    // Get counts before clearing
+    let counts = get_counts(&store, clear_chats, clear_contacts).await?;
+
+    if counts.total() == 0 {
+        if cli.json {
+            out::write_json(&serde_json::json!({
+                "cleared": false,
+                "reason": "nothing to clear"
+            }))?;
+        } else {
+            println!("Nothing to clear.");
+        }
+        return Ok(());
+    }
+
+    // Show what will be deleted
+    if !cli.json && !args.confirm {
+        println!("This will delete:");
+        if clear_chats {
+            println!("  - {} messages", counts.messages);
+            println!("  - {} chats", counts.chats);
+            println!("  - {} topics", counts.topics);
+        }
+        if clear_contacts {
+            println!("  - {} contacts", counts.contacts);
+        }
+        println!();
+        print!("Are you sure? [y/N] ");
+        io::stdout().flush()?;
+
+        let mut input = String::new();
+        io::stdin().read_line(&mut input)?;
+        let input = input.trim().to_lowercase();
+
+        if input != "y" && input != "yes" {
+            println!("Aborted.");
+            return Ok(());
+        }
+    }
+
+    // Perform the deletion
+    let deleted = clear_tables(&store, clear_chats, clear_contacts).await?;
+
+    if cli.json {
+        out::write_json(&serde_json::json!({
+            "cleared": true,
+            "deleted": {
+                "messages": deleted.messages,
+                "chats": deleted.chats,
+                "topics": deleted.topics,
+                "contacts": deleted.contacts
+            }
+        }))?;
+    } else {
+        println!("Cleared:");
+        if clear_chats {
+            println!("  - {} messages", deleted.messages);
+            println!("  - {} chats", deleted.chats);
+            println!("  - {} topics", deleted.topics);
+        }
+        if clear_contacts {
+            println!("  - {} contacts", deleted.contacts);
+        }
+    }
+
+    Ok(())
+}
+
+#[derive(Default)]
+struct Counts {
+    messages: u64,
+    chats: u64,
+    topics: u64,
+    contacts: u64,
+}
+
+impl Counts {
+    fn total(&self) -> u64 {
+        self.messages + self.chats + self.topics + self.contacts
+    }
+}
+
+async fn get_counts(store: &Store, chats: bool, contacts: bool) -> Result<Counts> {
+    let mut counts = Counts::default();
+
+    if chats {
+        counts.messages = store.count_messages().await?;
+        counts.chats = store.count_chats().await?;
+        counts.topics = store.count_topics().await?;
+    }
+    if contacts {
+        counts.contacts = store.count_contacts().await?;
+    }
+
+    Ok(counts)
+}
+
+async fn clear_tables(store: &Store, chats: bool, contacts: bool) -> Result<Counts> {
+    let mut deleted = Counts::default();
+
+    if chats {
+        deleted.messages = store.clear_messages().await?;
+        deleted.topics = store.clear_topics().await?;
+        deleted.chats = store.clear_chats().await?;
+    }
+    if contacts {
+        deleted.contacts = store.clear_contacts().await?;
+    }
+
+    Ok(deleted)
+}

src/cmd/mod.rs

@@ -1,5 +1,6 @@
 pub mod auth;
 pub mod chats;
+pub mod clear;
 pub mod contacts;
 pub mod folders;
 pub mod messages;
@@ -22,6 +23,8 @@ pub enum Command {
     Auth(auth::AuthArgs),
     /// Sync messages from Telegram
     Sync(sync::SyncArgs),
+    /// Clear local database (keeps session)
+    Clear(clear::ClearArgs),
     /// List and show chats
     Chats {
         #[command(subcommand)]
@@ -76,6 +79,7 @@ pub async fn run(cli: Cli) -> anyhow::Result<()> {
     match &cli.command {
         Command::Auth(args) => auth::run(&cli, args).await,
         Command::Sync(args) => sync::run(&cli, args).await,
+        Command::Clear(args) => clear::run(&cli, args).await,
         Command::Chats { cmd } => chats::run(&cli, cmd).await,
         Command::Messages { cmd } => messages::run(&cli, cmd).await,
         Command::Send(args) => send::run(&cli, args).await,

src/store/mod.rs

@@ -923,6 +923,68 @@ impl Store {
         }
     }
 
+    // --- Count methods (for clear command) ---
+
+    pub async fn count_messages(&self) -> Result<u64> {
+        let mut rows = self.conn.query("SELECT COUNT(*) FROM messages", ()).await?;
+        if let Some(row) = rows.next().await? {
+            Ok(row.get::<i64>(0)? as u64)
+        } else {
+            Ok(0)
+        }
+    }
+
+    pub async fn count_chats(&self) -> Result<u64> {
+        let mut rows = self.conn.query("SELECT COUNT(*) FROM chats", ()).await?;
+        if let Some(row) = rows.next().await? {
+            Ok(row.get::<i64>(0)? as u64)
+        } else {
+            Ok(0)
+        }
+    }
+
+    pub async fn count_topics(&self) -> Result<u64> {
+        let mut rows = self.conn.query("SELECT COUNT(*) FROM topics", ()).await?;
+        if let Some(row) = rows.next().await? {
+            Ok(row.get::<i64>(0)? as u64)
+        } else {
+            Ok(0)
+        }
+    }
+
+    pub async fn count_contacts(&self) -> Result<u64> {
+        let mut rows = self.conn.query("SELECT COUNT(*) FROM contacts", ()).await?;
+        if let Some(row) = rows.next().await? {
+            Ok(row.get::<i64>(0)? as u64)
+        } else {
+            Ok(0)
+        }
+    }
+
+    // --- Clear methods (for clear command) ---
+
+    pub async fn clear_messages(&self) -> Result<u64> {
+        // Also clear FTS table if it exists
+        let _ = self.conn.execute("DELETE FROM messages_fts", ()).await;
+        let affected = self.conn.execute("DELETE FROM messages", ()).await?;
+        Ok(affected)
+    }
+
+    pub async fn clear_chats(&self) -> Result<u64> {
+        let affected = self.conn.execute("DELETE FROM chats", ()).await?;
+        Ok(affected)
+    }
+
+    pub async fn clear_topics(&self) -> Result<u64> {
+        let affected = self.conn.execute("DELETE FROM topics", ()).await?;
+        Ok(affected)
+    }
+
+    pub async fn clear_contacts(&self) -> Result<u64> {
+        let affected = self.conn.execute("DELETE FROM contacts", ()).await?;
+        Ok(affected)
+    }
+
     /// Get the oldest message ID for a chat (lowest message ID).
     /// Returns None if no messages exist for the chat.
     pub async fn get_oldest_message_id(