convo_path across & add size col for fur convo

Author: andrewrgarcia

src/commands/conversation.rs

@@ -1,5 +1,5 @@
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use serde_json::{Value, json};
 use clap::Parser;
 use chrono::{DateTime, Local, Utc};
@@ -44,31 +44,46 @@ pub fn run_conversation(args: ThreadArgs) {
         let mut conversation_info = Vec::new();
         for tid in threads {
             if let Some(tid_str) = tid.as_str() {
-                let conversation_path = fur_dir.join("threads").join(format!("{}.json", tid_str));
-                if let Ok(content) = fs::read_to_string(conversation_path) {
+                let convo_path = fur_dir.join("threads").join(format!("{}.json", tid_str));
+                if let Ok(content) = fs::read_to_string(&convo_path) {
                     if let Ok(conversation_json) = serde_json::from_str::<Value>(&content) {
-                        let title = conversation_json["title"].as_str().unwrap_or("Untitled").to_string();
-                        let created_raw = conversation_json["created_at"].as_str().unwrap_or("");
-                        let msg_count = conversation_json["messages"]
+                        let title = conversation_json["title"]
+                            .as_str()
+                            .unwrap_or("Untitled")
+                            .to_string();
+
+                        let created_raw =
+                            conversation_json["created_at"].as_str().unwrap_or("");
+                        let msg_ids = conversation_json["messages"]
                             .as_array()
-                            .map(|a| a.len())
-                            .unwrap_or(0);
+                            .map(|a| a.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect::<Vec<_>>())
+                            .unwrap_or_default();
+
+                        let msg_count = msg_ids.len();
 
                         // Parse created_at safely
-                        let parsed_time = DateTime::parse_from_rfc3339(created_raw)
-                            .map(|dt| dt.with_timezone(&Utc))
-                            .unwrap_or_else(|_| Utc::now());
-                        let local_time: DateTime<Local> = DateTime::from(parsed_time);
+                        let parsed_time =
+                            DateTime::parse_from_rfc3339(created_raw)
+                                .map(|dt| dt.with_timezone(&Utc))
+                                .unwrap_or_else(|_| Utc::now());
+                        let local_time: DateTime<Local> =
+                            DateTime::from(parsed_time);
                         let date_str = local_time.format("%Y-%m-%d").to_string();
                         let time_str = local_time.format("%H:%M").to_string();
 
+                        // Compute total footprint (JSON + markdown attachments)
+                        let size_bytes = compute_conversation_size(fur_dir, tid_str, &msg_ids);
+                        let size_mb =
+                            (size_bytes as f64 / (1024.0 * 1024.0)).min(9999.0);
+
                         conversation_info.push((
                             tid_str.to_string(),
                             title,
                             date_str,
                             time_str,
                             msg_count,
                             parsed_time,
+                            size_mb,
                         ));
                     }
                 }
@@ -79,20 +94,31 @@ pub fn run_conversation(args: ThreadArgs) {
         conversation_info.sort_by(|a, b| b.5.cmp(&a.5));
 
         // Build rows and track active index
-        for (i, (tid, title, date, time, msg_count, _)) in conversation_info.iter().enumerate() {
+        for (i, (tid, title, date, time, msg_count, _, size_mb)) in
+            conversation_info.iter().enumerate()
+        {
             let short_id = &tid[..8];
+
             rows.push(vec![
                 short_id.to_string(),
                 title.to_string(),
                 format!("{} | {}", date, time),
                 msg_count.to_string(),
+                format!("{:.2} MB", size_mb),
             ]);
+
             if tid == active {
                 active_idx = Some(i);
             }
         }
 
-        render_table("Threads", &["ID", "Title", "Created", "#Msgs"], rows, active_idx);
+        render_table(
+            "Threads",
+            &["ID", "Title", "Created", "#Msgs", "Size"],
+            rows,
+            active_idx,
+        );
+
         return;
     }
 
@@ -110,7 +136,8 @@ pub fn run_conversation(args: ThreadArgs) {
 
         let mut found = threads.iter().find(|&s| s == &tid);
         if found.is_none() {
-            let matches: Vec<&String> = threads.iter().filter(|s| s.starts_with(&tid)).collect();
+            let matches: Vec<&String> =
+                threads.iter().filter(|s| s.starts_with(&tid)).collect();
             if matches.len() == 1 {
                 found = Some(matches[0]);
             } else if matches.len() > 1 {
@@ -129,13 +156,69 @@ pub fn run_conversation(args: ThreadArgs) {
 
         index["active_thread"] = json!(tid_full);
         index["current_message"] = serde_json::Value::Null;
-        fs::write(&index_path, serde_json::to_string_pretty(&index).unwrap()).unwrap();
+        fs::write(
+            &index_path,
+            serde_json::to_string_pretty(&index).unwrap(),
+        )
+        .unwrap();
+
+        let convo_path =
+            fur_dir.join("threads").join(format!("{}.json", tid_full));
+        let content = fs::read_to_string(convo_path).unwrap();
+        let conversation_json: Value =
+            serde_json::from_str(&content).unwrap();
+        let title =
+            conversation_json["title"].as_str().unwrap_or("Untitled");
+
+        println!(
+            "✔️ Switched active conversation to {} \"{}\"",
+            &tid_full[..8],
+            title
+        );
+    }
+}
+
+
+/// Computes total storage: conversation.json + all message JSONs + all markdown attachments.
+fn compute_conversation_size(
+    fur_dir: &Path,
+    tid: &str,
+    msg_ids: &[String],
+) -> u64 {
+    let mut total: u64 = 0;
+
+    // Add main conversation JSON
+    let convo_path = fur_dir.join("threads").join(format!("{}.json", tid));
+    total += file_size(&convo_path);
 
-        let conversation_path = fur_dir.join("threads").join(format!("{}.json", tid_full));
-        let content = fs::read_to_string(conversation_path).unwrap();
-        let conversation_json: Value = serde_json::from_str(&content).unwrap();
-        let title = conversation_json["title"].as_str().unwrap_or("Untitled");
+    // Add all messages JSON
+    total += get_message_file_sizes(fur_dir, msg_ids);
 
-        println!("✔️ Switched active conversation to {} \"{}\"", &tid_full[..8], title);
+    total
+}
+
+fn get_message_file_sizes(fur_dir: &Path, msg_ids: &[String]) -> u64 {
+    let mut total = 0;
+
+    for mid in msg_ids {
+        // message JSON
+        let msg_path = fur_dir.join("messages").join(format!("{}.json", mid));
+        total += file_size(&msg_path);
+
+        // check for markdown pointer inside JSON
+        if let Ok(content) = fs::read_to_string(&msg_path) {
+            if let Ok(json) = serde_json::from_str::<Value>(&content) {
+                if let Some(markdown_rel) = json["markdown"].as_str() {
+                    let md_path = fur_dir.join(markdown_rel);
+                    total += file_size(&md_path);
+                }
+            }
+        }
     }
+
+    total
+}
+
+fn file_size(path: &PathBuf) -> u64 {
+    fs::metadata(path).map(|m| m.len()).unwrap_or(0)
 }

src/commands/jot/core.rs

@@ -87,18 +87,18 @@ pub fn update_conversation(ctx: &FurContext, msg_id: &str, parent: Option<&str>)
         return;
     }
 
-    let conversation_path = ctx
+    let convo_path = ctx
         .fur_dir
         .join("threads")
         .join(format!("{}.json", ctx.conversation_id));
 
-    let mut conversation = read_json(&conversation_path);
+    let mut conversation = read_json(&convo_path);
 
     if let Some(arr) = conversation["messages"].as_array_mut() {
         arr.push(json!(msg_id));
     }
 
-    write_json(&conversation_path, &conversation);
+    write_json(&convo_path, &conversation);
 }
 
 fn attach_to_parent(fur_dir: &Path, parent_id: &str, message_id: &str) {

src/commands/jump.rs

@@ -22,8 +22,8 @@ pub fn run_jump(args: JumpArgs) -> Result<(), Box<dyn std::error::Error>> {
     let mut index: Value = serde_json::from_str(&index_data).unwrap();
 
     let conversation_id = index["active_thread"].as_str().unwrap();
-    let conversation_path = Path::new(".fur/threads").join(format!("{}.json", conversation_id));
-    let conversation_data = fs::read_to_string(conversation_path).expect("❌ Couldn't read conversation file");
+    let convo_path = Path::new(".fur/threads").join(format!("{}.json", conversation_id));
+    let conversation_data = fs::read_to_string(convo_path).expect("❌ Couldn't read conversation file");
     let conversation: Value = serde_json::from_str(&conversation_data).unwrap();
 
     let current_id = index["current_message"].as_str().unwrap_or_default();

src/commands/new.rs

@@ -124,8 +124,8 @@ fn run_new_internal(
     let conversation_meta = make_conversation_metadata(&name, &conversation_id);
 
     // --- Write conversation ---
-    let conversation_path = fur_dir.join("threads").join(format!("{}.json", conversation_id));
-    fs::write(&conversation_path, serde_json::to_string_pretty(&conversation_meta).unwrap())
+    let convo_path = fur_dir.join("threads").join(format!("{}.json", conversation_id));
+    fs::write(&convo_path, serde_json::to_string_pretty(&conversation_meta).unwrap())
         .expect("Could not write conversation file");
 
     // --- Update index ---

src/commands/printed.rs

@@ -23,9 +23,9 @@ pub fn run_printed(out: Option<String>, verbose: bool) {
     }
 
     // --- Load active conversation metadata ---
-    let conversation_path = fur_dir.join("threads").join(format!("{}.json", active_id));
+    let convo_path = fur_dir.join("threads").join(format!("{}.json", active_id));
     let conversation_json: Value =
-        serde_json::from_str(&fs::read_to_string(&conversation_path).unwrap()).unwrap();
+        serde_json::from_str(&fs::read_to_string(&convo_path).unwrap()).unwrap();
 
     let title = conversation_json["title"].as_str().unwrap_or("untitled");
     let id = conversation_json["id"].as_str().unwrap_or("unknown");

src/commands/save.rs

@@ -33,9 +33,9 @@ pub fn run_save(args: SaveArgs) {
         }
     };
 
-    let conversation_path = fur_dir.join("threads").join(format!("{}.json", conversation_id));
+    let convo_path = fur_dir.join("threads").join(format!("{}.json", conversation_id));
     let conversation: Value =
-        serde_json::from_str(&fs::read_to_string(&conversation_path).expect("❌ Cannot read conversation"))
+        serde_json::from_str(&fs::read_to_string(&convo_path).expect("❌ Cannot read conversation"))
             .unwrap();
 
     let title = conversation["title"].as_str().unwrap_or("Untitled");

src/commands/status/core.rs

@@ -12,8 +12,8 @@ pub fn load_index_and_conversation(fur_dir: &Path)
     let conversation_id = index["active_thread"].as_str().unwrap_or("");
     let current = index["current_message"].as_str().unwrap_or("").to_string();
 
-    let conversation_path = fur_dir.join("threads").join(format!("{}.json", conversation_id));
-    let conversation: Value = read_json(&conversation_path);
+    let convo_path = fur_dir.join("threads").join(format!("{}.json", conversation_id));
+    let conversation: Value = read_json(&convo_path);
 
     (index, conversation, current)
 }

src/commands/status/mod.rs

@@ -38,8 +38,8 @@ pub fn run_status(args: StatusArgs) {
         load_index_and_conversation(&fur_dir);
 
     if let Some(ref tid) = args.conversation_override {
-        let conversation_path = fur_dir.join("tmp").join(format!("{}.json", tid));
-        if let Ok(content) = fs::read_to_string(&conversation_path) {
+        let convo_path = fur_dir.join("tmp").join(format!("{}.json", tid));
+        if let Ok(content) = fs::read_to_string(&convo_path) {
             if let Ok(tmp_conversation) = serde_json::from_str::<Value>(&content) {
                 conversation = tmp_conversation;
             }

src/commands/timeline.rs

@@ -42,8 +42,8 @@ pub fn run_timeline(args: TimelineArgs) {
         index["active_thread"].as_str().unwrap_or("")
     };
 
-    let conversation_path = fur_dir.join("threads").join(format!("{}.json", conversation_id));
-    let conversation_json: Value = serde_json::from_str(&fs::read_to_string(&conversation_path).unwrap()).unwrap();
+    let convo_path = fur_dir.join("threads").join(format!("{}.json", conversation_id));
+    let conversation_json: Value = serde_json::from_str(&fs::read_to_string(&convo_path).unwrap()).unwrap();
 
     let conversation_title = conversation_json["title"].as_str().unwrap_or("Untitled");
 

src/commands/tree.rs

@@ -31,9 +31,9 @@ pub fn run_tree(args: TreeArgs) {
     } else {
         index_data["active_thread"].as_str().unwrap_or("")
     };
-    let conversation_path = fur_dir.join("threads").join(format!("{}.json", conversation_id));
+    let convo_path = fur_dir.join("threads").join(format!("{}.json", conversation_id));
     let conversation_data: Value =
-        serde_json::from_str(&fs::read_to_string(&conversation_path).expect("❌ Cannot read conversation"))
+        serde_json::from_str(&fs::read_to_string(&convo_path).expect("❌ Cannot read conversation"))
             .unwrap();
 
     // Load avatars.json once