move to fork() and exec() + cargo fmt

Author: Snehal-Reddy

src/agent.rs

@@ -167,15 +167,15 @@ pub async fn process_message(
     db: &Arc<BrainDb>,
 ) -> Result<String, AgentError> {
     let mut session = Session::load(Arc::clone(db), chat_id).await?;
-    
+
     // Check if summarization is needed (before building context so summary is included)
     if session.history().len() > summarize::SUMMARIZE_THRESHOLD {
         if let Err(e) = summarize::summarize_if_needed(llm, &mut session, model).await {
             eprintln!("Warning: summarization failed: {}", e);
             // Continue anyway — summarization is optimization
         }
     }
-    
+
     let skills_summary = skills::build_skills_summary(workspace_path)?;
     let tool_summaries = registry.summaries();
 

src/agent/context.rs

@@ -135,7 +135,13 @@ mod tests {
     use super::*;
 
     const WEEKDAYS: &[&str] = &[
-        "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday",
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday",
+        "Sunday",
     ];
 
     #[test]

src/agent/session.rs

@@ -59,12 +59,11 @@ impl Session {
         let db_clone = Arc::clone(&db);
         let chat_id_clone = chat_id.clone();
 
-        let (stored, summary) = tokio::task::spawn_blocking(move || {
-            db_clone.load_session(&chat_id_clone)
-        })
-        .await
-        .map_err(|e| SessionError::Db(format!("spawn_blocking: {e}")))?
-        .map_err(SessionError::from)?;
+        let (stored, summary) =
+            tokio::task::spawn_blocking(move || db_clone.load_session(&chat_id_clone))
+                .await
+                .map_err(|e| SessionError::Db(format!("spawn_blocking: {e}")))?
+                .map_err(SessionError::from)?;
 
         let history = stored
             .into_iter()
@@ -193,10 +192,7 @@ fn message_to_stored(msg: &Message) -> Result<StoredMessage, SessionError> {
     let tool_calls = msg
         .tool_calls
         .as_ref()
-        .map(|tc| {
-            serde_json::to_string(tc)
-                .map_err(|e| SessionError::Serialize(e.to_string()))
-        })
+        .map(|tc| serde_json::to_string(tc).map_err(|e| SessionError::Serialize(e.to_string())))
         .transpose()?;
 
     Ok(StoredMessage {

src/agent/summarize.rs

@@ -77,10 +77,12 @@ pub async fn summarize_if_needed(
 
         let s1 = summarize_batch(llm, part1, "", model).await?;
         let s2 = summarize_batch(llm, part2, "", model).await?;
-        merge_summaries(llm, &s1, &s2, model).await.unwrap_or_else(|_| {
-            // Fallback: concatenate
-            format!("{}\n\n{}", s1, s2)
-        })
+        merge_summaries(llm, &s1, &s2, model)
+            .await
+            .unwrap_or_else(|_| {
+                // Fallback: concatenate
+                format!("{}\n\n{}", s1, s2)
+            })
     } else {
         // Single-pass
         summarize_batch(llm, &valid_messages, &existing_summary, model).await?
@@ -121,10 +123,7 @@ fn estimate_tokens(text: &str) -> usize {
     text.chars().count() / 3
 }
 
-fn filter_valid_messages(
-    messages: &[Message],
-    max_tokens: usize,
-) -> (Vec<Message>, bool) {
+fn filter_valid_messages(messages: &[Message], max_tokens: usize) -> (Vec<Message>, bool) {
     let mut valid = Vec::new();
     let mut omitted = false;
 
@@ -205,7 +204,13 @@ async fn summarize_batch(
     ];
 
     let response = llm
-        .chat_with_params(&msgs, &[], model, Some(SUMMARY_TEMPERATURE), Some(SUMMARY_MAX_TOKENS))
+        .chat_with_params(
+            &msgs,
+            &[],
+            model,
+            Some(SUMMARY_TEMPERATURE),
+            Some(SUMMARY_MAX_TOKENS),
+        )
         .await?;
 
     Ok(response.content.trim().to_string())
@@ -230,7 +235,13 @@ async fn merge_summaries(
     }];
 
     let response = llm
-        .chat_with_params(&msgs, &[], model, Some(SUMMARY_TEMPERATURE), Some(SUMMARY_MAX_TOKENS))
+        .chat_with_params(
+            &msgs,
+            &[],
+            model,
+            Some(SUMMARY_TEMPERATURE),
+            Some(SUMMARY_MAX_TOKENS),
+        )
         .await?;
 
     Ok(response.content.trim().to_string())
@@ -242,23 +253,29 @@ mod tests {
 
     #[test]
     fn should_summarize_returns_false_when_below_threshold() {
-        let history = vec![Message {
-            role: Role::User,
-            content: "test".to_string(),
-            tool_call_id: None,
-            tool_calls: None,
-        }; SUMMARIZE_THRESHOLD];
+        let history = vec![
+            Message {
+                role: Role::User,
+                content: "test".to_string(),
+                tool_call_id: None,
+                tool_calls: None,
+            };
+            SUMMARIZE_THRESHOLD
+        ];
         assert!(!should_summarize(&history));
     }
 
     #[test]
     fn should_summarize_returns_true_when_above_threshold() {
-        let history = vec![Message {
-            role: Role::User,
-            content: "test".to_string(),
-            tool_call_id: None,
-            tool_calls: None,
-        }; SUMMARIZE_THRESHOLD + 1];
+        let history = vec![
+            Message {
+                role: Role::User,
+                content: "test".to_string(),
+                tool_call_id: None,
+                tool_calls: None,
+            };
+            SUMMARIZE_THRESHOLD + 1
+        ];
         assert!(should_summarize(&history));
     }
 

src/bin/test_reqwest.rs

@@ -0,0 +1,11 @@
+#[tokio::main]
+async fn main() {
+    println!("Testing reqwest TLS...");
+    match reqwest::Client::builder().build() {
+        Ok(client) => match client.get("https://api.telegram.org").send().await {
+            Ok(res) => println!("reqwest ok, status: {}", res.status()),
+            Err(e) => println!("reqwest send err: {}", e),
+        },
+        Err(e) => println!("reqwest builder err: {}", e),
+    }
+}

src/bin/test_tokio_process.rs

@@ -0,0 +1,31 @@
+#[tokio::main]
+async fn main() {
+    println!("Testing tokio::process...");
+    match tokio::process::Command::new("echo")
+        .arg("hello from tokio::process")
+        .output()
+        .await
+    {
+        Ok(out) => println!(
+            "tokio::process ok: {:?}",
+            String::from_utf8_lossy(&out.stdout)
+        ),
+        Err(e) => println!("tokio::process err: {}", e),
+    }
+
+    println!("Testing std::process in spawn_blocking...");
+    match tokio::task::spawn_blocking(|| {
+        std::process::Command::new("echo")
+            .arg("hello from std::process")
+            .output()
+    })
+    .await
+    {
+        Ok(Ok(out)) => println!(
+            "std::process ok: {:?}",
+            String::from_utf8_lossy(&out.stdout)
+        ),
+        Ok(Err(e)) => println!("std::process err: {}", e),
+        Err(e) => println!("spawn_blocking err: {}", e),
+    }
+}

src/cron_runner.rs

@@ -32,7 +32,10 @@ pub async fn tick_once(
                     channel: "cron".to_string(),
                 };
                 if inbound_tx.try_send(msg).is_err() {
-                    eprintln!("cron runner: inbound channel full, dropping agent job {}", job.id);
+                    eprintln!(
+                        "cron runner: inbound channel full, dropping agent job {}",
+                        job.id
+                    );
                 }
             }
             JobAction::Direct => {
@@ -42,7 +45,10 @@ pub async fn tick_once(
                     channel: "cron".to_string(),
                 };
                 if outbound_tx.try_send(msg).is_err() {
-                    eprintln!("cron runner: outbound channel full, dropping direct job {}", job.id);
+                    eprintln!(
+                        "cron runner: outbound channel full, dropping direct job {}",
+                        job.id
+                    );
                 }
             }
         }
@@ -157,7 +163,9 @@ mod tests {
                 None,
                 "Later".to_string(),
                 JobAction::Direct,
-                Schedule::Once { at_unix: base + 1000 },
+                Schedule::Once {
+                    at_unix: base + 1000,
+                },
                 1,
             )
             .unwrap();

src/heartbeat.rs

@@ -5,8 +5,8 @@
 //! `channel == "heartbeat"` to call `process_heartbeat_message` instead of `process_message`.
 
 use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicI64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicI64, Ordering};
 use std::time::Duration;
 
 use tokio::sync::mpsc;
@@ -60,7 +60,10 @@ pub fn spawn_heartbeat_runner(
     inbound_tx: mpsc::Sender<InboundMsg>,
     last_chat_id: Arc<AtomicI64>,
 ) -> tokio::task::JoinHandle<()> {
-    assert!(interval_minutes >= 1, "heartbeat interval_minutes must be >= 1");
+    assert!(
+        interval_minutes >= 1,
+        "heartbeat interval_minutes must be >= 1"
+    );
     tokio::spawn(async move {
         let mut interval = tokio::time::interval(Duration::from_secs(interval_minutes * 60));
         // Skip the immediately-firing first tick so the first real tick is one full interval out.

src/llm.rs

@@ -200,7 +200,8 @@ impl HttpProvider {
         tools: &[ToolDef],
         model: &str,
     ) -> Result<LlmResponse, LlmError> {
-        self.chat_with_params(messages, tools, model, None, None).await
+        self.chat_with_params(messages, tools, model, None, None)
+            .await
     }
 
     /// Send chat request with optional temperature and max_tokens. Returns content and tool_calls.

src/main.rs

@@ -3,8 +3,8 @@
 //! Single binary: runs Telegram poller + agent loop. Config: `~/.icrab/config.toml` or env.
 
 use std::path::PathBuf;
-use std::sync::atomic::{AtomicI64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicI64, Ordering};
 
 use tokio::sync::mpsc;
 
@@ -17,12 +17,12 @@ use icrab::llm::HttpProvider;
 use icrab::memory::db::BrainDb;
 use icrab::memory::indexer::VaultIndexer;
 use icrab::sync;
-use icrab::tools::{GitSyncTool, GrepDirTool, SearchChatTool, SearchVaultTool};
 use icrab::telegram::{self, OutboundMsg};
 use icrab::tools;
 use icrab::tools::cron::{CronStore, CronTool};
 use icrab::tools::spawn::SpawnTool;
 use icrab::tools::subagent::SubagentTool;
+use icrab::tools::{GitSyncTool, GrepDirTool, SearchChatTool, SearchVaultTool};
 
 const SUBAGENT_MAX_ITERATIONS: u32 = 10;
 
@@ -67,7 +67,10 @@ async fn main() {
             std::process::exit(1);
         }
     };
-    eprintln!("brain db opened: {}", icrab::workspace::brain_db_path(&workspace).display());
+    eprintln!(
+        "brain db opened: {}",
+        icrab::workspace::brain_db_path(&workspace).display()
+    );
 
     // Kick off the vault indexer in a background task so startup isn't blocked.
     // The indexer walks the workspace and upserts any new/modified .md files
@@ -128,12 +131,10 @@ async fn main() {
     let outbound_tx = telegram::spawn_telegram(&cfg, inbound_tx.clone());
     eprintln!("Telegram poller and sender started");
 
-    let cron_store = Arc::new(
-        CronStore::load(&workspace).unwrap_or_else(|e| {
-            eprintln!("cron store: {}", e);
-            CronStore::empty(&workspace)
-        }),
-    );
+    let cron_store = Arc::new(CronStore::load(&workspace).unwrap_or_else(|e| {
+        eprintln!("cron store: {}", e);
+        CronStore::empty(&workspace)
+    }));
     cron_runner::spawn_cron_runner(
         Arc::clone(&cron_store),
         inbound_tx.clone(),
@@ -158,7 +159,10 @@ async fn main() {
             inbound_tx.clone(),
             Arc::clone(&last_chat_id),
         );
-        eprintln!("heartbeat runner started (interval: {} min)", heartbeat_interval);
+        eprintln!(
+            "heartbeat runner started (interval: {} min)",
+            heartbeat_interval
+        );
     }
 
     drop(inbound_tx);