Enhanced Insights with daily summary embeddings

Bump to 0.5.0. Added daily summary generation job

src/ai/sms_client.rs

@@ -91,6 +91,118 @@ impl SmsApiClient {
             .await
     }
 
+    /// Fetch all messages for a specific contact across all time
+    /// Used for embedding generation - retrieves complete message history
+    /// Handles pagination automatically if the API returns a limited number of results
+    pub async fn fetch_all_messages_for_contact(&self, contact: &str) -> Result<Vec<SmsMessage>> {
+        let start_ts = chrono::DateTime::parse_from_rfc3339("2000-01-01T00:00:00Z")
+            .unwrap()
+            .timestamp();
+        let end_ts = chrono::Utc::now().timestamp();
+
+        log::info!(
+            "Fetching all historical messages for contact: {}",
+            contact
+        );
+
+        let mut all_messages = Vec::new();
+        let mut offset = 0;
+        let limit = 1000; // Fetch in batches of 1000
+
+        loop {
+            log::debug!("Fetching batch at offset {} for contact {}", offset, contact);
+
+            let batch = self.fetch_messages_paginated(
+                start_ts,
+                end_ts,
+                Some(contact),
+                None,
+                limit,
+                offset
+            ).await?;
+
+            let batch_size = batch.len();
+            all_messages.extend(batch);
+
+            log::debug!("Fetched {} messages (total so far: {})", batch_size, all_messages.len());
+
+            // If we got fewer messages than the limit, we've reached the end
+            if batch_size < limit {
+                break;
+            }
+
+            offset += limit;
+        }
+
+        log::info!(
+            "Fetched {} total messages for contact {}",
+            all_messages.len(),
+            contact
+        );
+
+        Ok(all_messages)
+    }
+
+    /// Internal method to fetch messages with pagination support
+    async fn fetch_messages_paginated(
+        &self,
+        start_ts: i64,
+        end_ts: i64,
+        contact: Option<&str>,
+        center_timestamp: Option<i64>,
+        limit: usize,
+        offset: usize,
+    ) -> Result<Vec<SmsMessage>> {
+        let mut url = format!(
+            "{}/api/messages/by-date-range/?start_date={}&end_date={}&limit={}&offset={}",
+            self.base_url, start_ts, end_ts, limit, offset
+        );
+
+        if let Some(contact_name) = contact {
+            url.push_str(&format!("&contact={}", urlencoding::encode(contact_name)));
+        }
+
+        if let Some(ts) = center_timestamp {
+            url.push_str(&format!("&timestamp={}", ts));
+        }
+
+        log::debug!("Fetching SMS messages from: {}", url);
+
+        let mut request = self.client.get(&url);
+
+        if let Some(token) = &self.token {
+            request = request.header("Authorization", format!("Bearer {}", token));
+        }
+
+        let response = request.send().await?;
+
+        log::debug!("SMS API response status: {}", response.status());
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let error_body = response.text().await.unwrap_or_default();
+            log::error!("SMS API request failed: {} - {}", status, error_body);
+            return Err(anyhow::anyhow!(
+                "SMS API request failed: {} - {}",
+                status,
+                error_body
+            ));
+        }
+
+        let data: SmsApiResponse = response.json().await?;
+
+        Ok(data
+            .messages
+            .into_iter()
+            .map(|m| SmsMessage {
+                contact: m.contact_name,
+                body: m.body,
+                timestamp: m.date,
+                is_sent: m.type_ == 2,
+            })
+            .collect())
+    }
+
     /// Internal method to fetch messages with optional contact filter and timestamp sorting
     async fn fetch_messages(
         &self,