feat(sync): add unread count to topic output, prune-after flag

Author: dgrr

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "tgcli"
-version = "0.3.2"
+version = "0.3.3"
 edition = "2021"
 authors = ["Dario <me@dgrp.es>"]
 description = "Telegram CLI tool using grammers (pure Rust MTProto)"

Cargo.toml

@@ -121,6 +121,7 @@ impl App {
                             &topic.title,
                             topic.icon_color,
                             icon_emoji.as_deref(),
+                            topic.unread_count,
                         )
                         .await?;
                     count += 1;

src/app/mod.rs

@@ -42,6 +42,8 @@ pub struct SyncOptions {
     pub concurrency: usize,
     /// If set, only sync this specific chat
     pub chat_filter: Option<i64>,
+    /// After sync, prune messages keeping only the N most recent per chat
+    pub prune_after: Option<usize>,
 }
 
 /// Get media type string and file extension from grammers Media enum
@@ -134,6 +136,7 @@ pub struct TopicSyncSummary {
     pub topic_id: i32,
     pub topic_name: String,
     pub messages_synced: u64,
+    pub unread_count: i32,
 }
 
 /// Summary of messages synced for a single chat
@@ -145,6 +148,8 @@ pub struct ChatSyncSummary {
     /// For forum chats, breakdown by topic
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub topics: Vec<TopicSyncSummary>,
+    /// Unread message count for this chat at sync time
+    pub unread_count: i32,
 }
 
 pub struct SyncResult {
@@ -998,18 +1003,22 @@ impl App {
                     if result.is_forum && !result.topic_counts.is_empty() {
                         let mut topic_summaries = Vec::new();
                         for (tid, msg_count) in &result.topic_counts {
-                            let topic_name = self
+                            let topic = self
                                 .store
                                 .get_topic(result.chat_id, *tid)
                                 .await
                                 .ok()
-                                .flatten()
+                                .flatten();
+                            let topic_name = topic
+                                .as_ref()
                                 .map(|t| t.name.clone())
                                 .unwrap_or_else(|| format!("Topic {}", tid));
+                            let unread_count = topic.map(|t| t.unread_count).unwrap_or(0);
                             topic_summaries.push(TopicSyncSummary {
                                 topic_id: *tid,
                                 topic_name,
                                 messages_synced: *msg_count,
+                                unread_count,
                             });
                         }
                         topic_summaries
@@ -1028,6 +1037,7 @@ impl App {
                                 .find(|t| t.topic_id == new_topic.topic_id)
                             {
                                 existing_topic.messages_synced += new_topic.messages_synced;
+                                existing_topic.unread_count = new_topic.unread_count;
                             } else {
                                 existing.topics.push(new_topic.clone());
                             }
@@ -1038,6 +1048,7 @@ impl App {
                         chat_name: result.chat_name.clone(),
                         messages_synced: result.messages.len() as u64,
                         topics: new_topics,
+                        unread_count: 0, // Not available in msgs-only sync
                     });
             }
         }
@@ -1047,6 +1058,29 @@ impl App {
             chats_processed, messages_stored, concurrency
         );
 
+        // Prune old messages if --prune-after is set
+        if let Some(keep_count) = opts.prune_after {
+            if show_progress {
+                eprint!("Pruning old messages (keeping {} per chat)...", keep_count);
+            }
+            match self.store.prune_all_chats(keep_count).await {
+                Ok(deleted) => {
+                    if show_progress {
+                        eprint!("\r\x1b[K");
+                    }
+                    if deleted > 0 {
+                        eprintln!("Pruned {} old messages", deleted);
+                    }
+                }
+                Err(e) => {
+                    if show_progress {
+                        eprint!("\r\x1b[K");
+                    }
+                    log::warn!("Failed to prune messages: {}", e);
+                }
+            }
+        }
+
         // Convert HashMap to Vec and sort topics by message count descending
         let per_chat: Vec<ChatSyncSummary> = per_chat_map
             .into_values()
@@ -1154,6 +1188,9 @@ impl App {
                     .await?;
             }
 
+            // Track unread_count for filtering output later
+            let unread_count = extract_unread_count(&dialog.raw);
+
             // Fetch messages for this chat
             let peer_ref = PeerRef::from(peer);
             let mut message_iter = client.iter_messages(peer_ref);
@@ -1347,18 +1384,17 @@ impl App {
                 let new_topics: Vec<TopicSyncSummary> = if is_forum && !topic_counts.is_empty() {
                     let mut topic_summaries = Vec::new();
                     for (tid, msg_count) in &topic_counts {
-                        let topic_name = self
-                            .store
-                            .get_topic(id, *tid)
-                            .await
-                            .ok()
-                            .flatten()
+                        let topic = self.store.get_topic(id, *tid).await.ok().flatten();
+                        let topic_name = topic
+                            .as_ref()
                             .map(|t| t.name.clone())
                             .unwrap_or_else(|| format!("Topic {}", tid));
+                        let unread_count = topic.map(|t| t.unread_count).unwrap_or(0);
                         topic_summaries.push(TopicSyncSummary {
                             topic_id: *tid,
                             topic_name,
                             messages_synced: *msg_count,
+                            unread_count,
                         });
                     }
                     topic_summaries
@@ -1371,14 +1407,16 @@ impl App {
                     .entry(id)
                     .and_modify(|existing| {
                         existing.messages_synced += count as u64;
-                        // Merge topics by topic_id
+                        existing.unread_count = unread_count; // Update with latest unread count
+                                                              // Merge topics by topic_id
                         for new_topic in &new_topics {
                             if let Some(existing_topic) = existing
                                 .topics
                                 .iter_mut()
                                 .find(|t| t.topic_id == new_topic.topic_id)
                             {
                                 existing_topic.messages_synced += new_topic.messages_synced;
+                                existing_topic.unread_count = new_topic.unread_count;
                             } else {
                                 existing.topics.push(new_topic.clone());
                             }
@@ -1389,6 +1427,7 @@ impl App {
                         chat_name: name.clone(),
                         messages_synced: count as u64,
                         topics: new_topics,
+                        unread_count,
                     });
             }
         }
@@ -1608,26 +1647,25 @@ impl App {
                 let new_topics: Vec<TopicSyncSummary> = if is_forum && !topic_counts.is_empty() {
                     let mut topic_summaries = Vec::new();
                     for (tid, msg_count) in &topic_counts {
-                        let topic_name = self
-                            .store
-                            .get_topic(id, *tid)
-                            .await
-                            .ok()
-                            .flatten()
+                        let topic = self.store.get_topic(id, *tid).await.ok().flatten();
+                        let topic_name = topic
+                            .as_ref()
                             .map(|t| t.name.clone())
                             .unwrap_or_else(|| format!("Topic {}", tid));
+                        let unread_count = topic.map(|t| t.unread_count).unwrap_or(0);
                         topic_summaries.push(TopicSyncSummary {
                             topic_id: *tid,
                             topic_name,
                             messages_synced: *msg_count,
+                            unread_count,
                         });
                     }
                     topic_summaries
                 } else {
                     Vec::new()
                 };
 
-                // Aggregate into per_chat_map
+                // Aggregate into per_chat_map (archived chats don't have unread info)
                 per_chat_map
                     .entry(id)
                     .and_modify(|existing| {
@@ -1640,6 +1678,7 @@ impl App {
                                 .find(|t| t.topic_id == new_topic.topic_id)
                             {
                                 existing_topic.messages_synced += new_topic.messages_synced;
+                                existing_topic.unread_count = new_topic.unread_count;
                             } else {
                                 existing.topics.push(new_topic.clone());
                             }
@@ -1650,6 +1689,7 @@ impl App {
                         chat_name: name.clone(),
                         messages_synced: count as u64,
                         topics: new_topics,
+                        unread_count: 0, // Archived chats don't have unread info
                     });
             }
         }
@@ -1672,6 +1712,29 @@ impl App {
             );
         }
 
+        // Prune old messages if --prune-after is set
+        if let Some(keep_count) = opts.prune_after {
+            if opts.show_progress {
+                eprint!("Pruning old messages (keeping {} per chat)...", keep_count);
+            }
+            match self.store.prune_all_chats(keep_count).await {
+                Ok(deleted) => {
+                    if opts.show_progress {
+                        eprint!("\r\x1b[K");
+                    }
+                    if deleted > 0 {
+                        eprintln!("Pruned {} old messages", deleted);
+                    }
+                }
+                Err(e) => {
+                    if opts.show_progress {
+                        eprint!("\r\x1b[K");
+                    }
+                    log::warn!("Failed to prune messages: {}", e);
+                }
+            }
+        }
+
         // Convert HashMap to Vec and sort topics by message count descending
         let per_chat: Vec<ChatSyncSummary> = per_chat_map
             .into_values()
@@ -2006,6 +2069,14 @@ async fn download_message_media_static(
     }
 }
 
+/// Extract unread_count from a raw Dialog enum
+fn extract_unread_count(raw: &tl::enums::Dialog) -> i32 {
+    match raw {
+        tl::enums::Dialog::Dialog(d) => d.unread_count,
+        tl::enums::Dialog::Folder(_) => 0,
+    }
+}
+
 /// Returns (kind, name, username, is_forum, access_hash)
 fn peer_info(peer: &Peer) -> (String, String, Option<String>, bool, Option<i64>) {
     match peer {

src/app/sync.rs

@@ -215,6 +215,7 @@ pub async fn run(cli: &Cli, args: &DaemonArgs) -> Result<()> {
                 messages_per_chat: 50,
                 concurrency: 4,
                 chat_filter: None,
+                prune_after: None,
             };
 
             let result = backfill_app.sync(opts).await;

src/cmd/daemon.rs

@@ -46,6 +46,10 @@ pub struct CommonSyncArgs {
     /// Suppress summary output (just show "Sync complete")
     #[arg(long, default_value_t = false)]
     pub quiet: bool,
+
+    /// After sync, prune messages keeping only the N most recent per chat
+    #[arg(long, value_name = "N")]
+    pub prune_after: Option<usize>,
 }
 
 #[derive(Subcommand, Debug, Clone)]
@@ -102,6 +106,7 @@ fn build_sync_options(common: &CommonSyncArgs) -> crate::app::sync::SyncOptions
         messages_per_chat: common.messages_per_chat,
         concurrency: common.concurrency,
         chat_filter: None,
+        prune_after: common.prune_after,
     }
 }
 
@@ -160,21 +165,37 @@ fn print_sync_result(
             );
 
             for chat in &chats_with_messages {
-                println!(
-                    "  {:<width$}  +{} {}",
-                    chat.chat_name,
-                    chat.messages_synced,
-                    plural(chat.messages_synced),
-                    width = max_name_len
-                );
-                // Show topic breakdown for forums
+                // Forum parent: show messages only (no unread)
+                // Regular chat: show messages + unread
+                if !chat.topics.is_empty() {
+                    // Forum parent line - no unread count
+                    println!(
+                        "  {:<width$}  +{} {}",
+                        chat.chat_name,
+                        chat.messages_synced,
+                        plural(chat.messages_synced),
+                        width = max_name_len
+                    );
+                } else {
+                    // Regular chat - show unread
+                    println!(
+                        "  {:<width$}  +{} {} +{} unread",
+                        chat.chat_name,
+                        chat.messages_synced,
+                        plural(chat.messages_synced),
+                        chat.unread_count,
+                        width = max_name_len
+                    );
+                }
+                // Show topic breakdown for forums - with unread count
                 for topic in &chat.topics {
                     if topic.messages_synced > 0 {
                         println!(
-                            "    └ {:<width$}  +{} {}",
+                            "    └ {:<width$}  +{} {} +{} unread",
                             topic.topic_name,
                             topic.messages_synced,
                             plural(topic.messages_synced),
+                            topic.unread_count,
                             width = max_name_len - 4
                         );
                     }