@pheem49/mint 1.5.5 → 1.6.1

package/crates/mint-core/src/tasks.rs

@@ -0,0 +1,308 @@
+use std::{
+    fs,
+    path::PathBuf,
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum TaskError {
+    #[error("unable to determine the user config directory")]
+    ConfigDirectoryUnavailable,
+    #[error("unable to create task directory {path}: {source}")]
+    CreateDirectory {
+        path: PathBuf,
+        source: std::io::Error,
+    },
+    #[error("unable to read tasks file {path}: {source}")]
+    Read {
+        path: PathBuf,
+        source: std::io::Error,
+    },
+    #[error("unable to parse tasks file {path}: {source}")]
+    Parse {
+        path: PathBuf,
+        source: serde_json::Error,
+    },
+    #[error("unable to serialize tasks: {0}")]
+    Serialize(serde_json::Error),
+    #[error("unable to write tasks file {path}: {source}")]
+    Write {
+        path: PathBuf,
+        source: std::io::Error,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct Task {
+    pub id: String,
+    pub description: String,
+    pub status: String,
+    pub created_at: String,
+    pub updated_at: String,
+    #[serde(default)]
+    pub steps: Vec<Value>,
+    #[serde(default)]
+    pub subtasks: Vec<Value>,
+    #[serde(default)]
+    pub checkpoints: Vec<Value>,
+    #[serde(default)]
+    pub artifacts: Vec<Value>,
+    #[serde(default)]
+    pub retry_count: u32,
+    #[serde(default = "default_max_retries")]
+    pub max_retries: u32,
+    #[serde(default)]
+    pub last_checkpoint_at: Option<String>,
+    #[serde(default)]
+    pub result: Option<Value>,
+    #[serde(flatten)]
+    pub extra: serde_json::Map<String, Value>,
+}
+
+#[derive(Clone)]
+pub struct TaskStore {
+    path: PathBuf,
+}
+
+impl TaskStore {
+    pub fn open_default() -> Result<Self, TaskError> {
+        Ok(Self::open(tasks_path()?))
+    }
+
+    pub fn open(path: impl Into<PathBuf>) -> Self {
+        Self { path: path.into() }
+    }
+
+    pub fn list(&self) -> Result<Vec<Task>, TaskError> {
+        if !self.path.exists() {
+            return Ok(Vec::new());
+        }
+        let raw = fs::read_to_string(&self.path).map_err(|source| TaskError::Read {
+            path: self.path.clone(),
+            source,
+        })?;
+        serde_json::from_str(&raw).map_err(|source| TaskError::Parse {
+            path: self.path.clone(),
+            source,
+        })
+    }
+
+    pub fn add(&self, description: impl Into<String>) -> Result<Task, TaskError> {
+        let now = timestamp();
+        let task = Task {
+            id: now.clone(),
+            description: description.into(),
+            status: "pending".into(),
+            created_at: now.clone(),
+            updated_at: now,
+            steps: Vec::new(),
+            subtasks: Vec::new(),
+            checkpoints: Vec::new(),
+            artifacts: Vec::new(),
+            retry_count: 0,
+            max_retries: default_max_retries(),
+            last_checkpoint_at: None,
+            result: None,
+            extra: serde_json::Map::new(),
+        };
+        let mut tasks = self.list()?;
+        tasks.push(task.clone());
+        self.write(&tasks)?;
+        Ok(task)
+    }
+
+    pub fn get(&self, id: &str) -> Result<Option<Task>, TaskError> {
+        Ok(self.list()?.into_iter().find(|task| task.id == id))
+    }
+
+    pub fn pending(&self) -> Result<Option<Task>, TaskError> {
+        Ok(self
+            .list()?
+            .into_iter()
+            .find(|task| task.status == "pending"))
+    }
+
+    pub fn update_status(
+        &self,
+        id: &str,
+        status: &str,
+        result: Option<Value>,
+    ) -> Result<Option<Task>, TaskError> {
+        self.mutate(id, |task| {
+            task.status = status.into();
+            if result.is_some() {
+                task.result = result;
+            }
+        })
+    }
+
+    pub fn add_checkpoint(
+        &self,
+        id: &str,
+        mut checkpoint: Value,
+    ) -> Result<Option<Task>, TaskError> {
+        self.mutate(id, |task| {
+            let time = timestamp();
+            let checkpoint_id = format!("{id}-checkpoint-{}", task.checkpoints.len() + 1);
+            if let Some(value) = checkpoint.as_object_mut() {
+                value.entry("id").or_insert(Value::String(checkpoint_id));
+                value.entry("time").or_insert(Value::String(time.clone()));
+            }
+            task.last_checkpoint_at = Some(time);
+            task.steps.push(checkpoint.clone());
+            task.checkpoints.push(checkpoint);
+        })
+    }
+
+    pub fn add_artifact(&self, id: &str, mut artifact: Value) -> Result<Option<Task>, TaskError> {
+        self.mutate(id, |task| {
+            if let Some(value) = artifact.as_object_mut() {
+                value.entry("id").or_insert(Value::String(format!(
+                    "{id}-artifact-{}",
+                    task.artifacts.len() + 1
+                )));
+                value
+                    .entry("time")
+                    .or_insert_with(|| Value::String(timestamp()));
+            }
+            task.artifacts.push(artifact);
+        })
+    }
+
+    pub fn fail_with_retry(&self, id: &str, message: &str) -> Result<Option<Task>, TaskError> {
+        self.mutate(id, |task| {
+            task.retry_count += 1;
+            task.status = if task.retry_count <= task.max_retries {
+                "pending"
+            } else {
+                "failed"
+            }
+            .into();
+            task.result = Some(Value::String(message.into()));
+            let checkpoint = serde_json::json!({
+                "id": format!("{id}-checkpoint-{}", task.checkpoints.len() + 1),
+                "time": timestamp(),
+                "phase": if task.status == "pending" { "retry_scheduled" } else { "failed" },
+                "message": message,
+                "retryCount": task.retry_count,
+                "maxRetries": task.max_retries,
+            });
+            task.steps.push(checkpoint.clone());
+            task.checkpoints.push(checkpoint);
+        })
+    }
+
+    pub fn resume_running(&self) -> Result<Vec<Task>, TaskError> {
+        let mut tasks = self.list()?;
+        let mut resumed = Vec::new();
+        for task in &mut tasks {
+            if task.status != "running" {
+                continue;
+            }
+            task.status = "pending".into();
+            task.updated_at = timestamp();
+            let checkpoint = serde_json::json!({
+                "id": format!("{}-checkpoint-{}", task.id, task.checkpoints.len() + 1),
+                "time": timestamp(),
+                "phase": "resume_after_restart",
+                "message": "Task was running during shutdown and has been re-queued.",
+            });
+            task.steps.push(checkpoint.clone());
+            task.checkpoints.push(checkpoint);
+            resumed.push(task.clone());
+        }
+        self.write(&tasks)?;
+        Ok(resumed)
+    }
+
+    pub fn clear_completed(&self) -> Result<usize, TaskError> {
+        let tasks = self.list()?;
+        let count = tasks.len();
+        let retained = tasks
+            .into_iter()
+            .filter(|task| matches!(task.status.as_str(), "pending" | "running"))
+            .collect::<Vec<_>>();
+        let removed = count.saturating_sub(retained.len());
+        self.write(&retained)?;
+        Ok(removed)
+    }
+
+    fn mutate(&self, id: &str, update: impl FnOnce(&mut Task)) -> Result<Option<Task>, TaskError> {
+        let mut tasks = self.list()?;
+        let Some(task) = tasks.iter_mut().find(|task| task.id == id) else {
+            return Ok(None);
+        };
+        update(task);
+        task.updated_at = timestamp();
+        let task = task.clone();
+        self.write(&tasks)?;
+        Ok(Some(task))
+    }
+
+    fn write(&self, tasks: &[Task]) -> Result<(), TaskError> {
+        if let Some(directory) = self.path.parent() {
+            fs::create_dir_all(directory).map_err(|source| TaskError::CreateDirectory {
+                path: directory.to_path_buf(),
+                source,
+            })?;
+        }
+        let raw = serde_json::to_string_pretty(tasks).map_err(TaskError::Serialize)?;
+        fs::write(&self.path, format!("{raw}\n")).map_err(|source| TaskError::Write {
+            path: self.path.clone(),
+            source,
+        })
+    }
+}
+
+pub fn tasks_path() -> Result<PathBuf, TaskError> {
+    dirs::config_dir()
+        .map(|directory| directory.join("mint").join("tasks.json"))
+        .ok_or(TaskError::ConfigDirectoryUnavailable)
+}
+
+fn timestamp() -> String {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis()
+        .to_string()
+}
+
+fn default_max_retries() -> u32 {
+    1
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn test_path(name: &str) -> PathBuf {
+        std::env::temp_dir().join(format!("mint-task-{name}-{}.json", std::process::id()))
+    }
+
+    #[test]
+    fn clears_finished_tasks_but_keeps_active_tasks() {
+        let path = test_path("clear");
+        let store = TaskStore::open(&path);
+        store
+            .write(&[
+                Task {
+                    status: "completed".into(),
+                    ..store.add("done").unwrap()
+                },
+                Task {
+                    status: "pending".into(),
+                    ..store.add("todo").unwrap()
+                },
+            ])
+            .unwrap();
+        assert_eq!(store.clear_completed().unwrap(), 1);
+        assert_eq!(store.list().unwrap().len(), 1);
+        let _ = fs::remove_file(path);
+    }
+}

package/crates/mint-core/src/tts.rs

@@ -0,0 +1,92 @@
+use serde::Serialize;
+
+const MAX_GOOGLE_TTS_CHARS: usize = 200;
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TtsUrl {
+    pub short_text: String,
+    pub url: String,
+}
+
+pub fn google_tts_urls(text: &str, language: &str) -> Vec<TtsUrl> {
+    let chunks = split_text(text, MAX_GOOGLE_TTS_CHARS);
+    let total = chunks.len();
+    chunks
+        .into_iter()
+        .enumerate()
+        .map(|(index, chunk)| TtsUrl {
+            url: format!(
+                "https://translate.google.com/translate_tts?ie=UTF-8&q={}&tl={}&client=tw-ob&idx={index}&total={total}&textlen={}",
+                encode_component(&chunk),
+                encode_component(language),
+                chunk.chars().count()
+            ),
+            short_text: chunk,
+        })
+        .collect()
+}
+
+fn split_text(text: &str, max_length: usize) -> Vec<String> {
+    let mut remaining = text.split_whitespace().collect::<Vec<_>>().join(" ");
+    let mut chunks = Vec::new();
+    while remaining.chars().count() > max_length {
+        let char_boundary = remaining
+            .char_indices()
+            .nth(max_length)
+            .map(|(index, _)| index)
+            .unwrap_or(remaining.len());
+        let boundary = remaining
+            .char_indices()
+            .take_while(|(index, _)| *index <= char_boundary)
+            .filter(|(_, character)| matches!(character, '.' | '?' | '!' | ',' | ' '))
+            .map(|(index, _)| index)
+            .last()
+            .filter(|index| *index > 0)
+            .unwrap_or(char_boundary);
+        chunks.push(remaining[..boundary].trim().to_owned());
+        remaining = remaining[boundary..].trim().to_owned();
+    }
+    if !remaining.is_empty() {
+        chunks.push(remaining);
+    }
+    chunks
+}
+
+fn encode_component(value: &str) -> String {
+    value
+        .bytes()
+        .map(|byte| match byte {
+            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
+                (byte as char).to_string()
+            }
+            b' ' => "+".into(),
+            _ => format!("%{byte:02X}"),
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn splits_long_text_for_google_tts() {
+        let chunks = split_text(&"a ".repeat(150), MAX_GOOGLE_TTS_CHARS);
+        assert!(chunks.len() > 1);
+        assert!(
+            chunks
+                .iter()
+                .all(|chunk| chunk.len() <= MAX_GOOGLE_TTS_CHARS)
+        );
+    }
+
+    #[test]
+    fn encodes_tts_query() {
+        assert!(
+            google_tts_urls("hello mint", "en")[0]
+                .url
+                .contains("q=hello+mint")
+        );
+    }
+}

package/crates/mint-core/src/weather.rs

@@ -0,0 +1,93 @@
+use serde::Serialize;
+use serde_json::Value;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum WeatherError {
+    #[error("weather city is required")]
+    MissingCity,
+    #[error("weather request failed: {0}")]
+    Request(#[from] reqwest::Error),
+    #[error("weather location was not found: {0}")]
+    LocationNotFound(String),
+    #[error("weather response did not include {0}")]
+    MissingValue(String),
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WeatherReport {
+    pub location: String,
+    pub data: String,
+    pub temperature_celsius: f64,
+    pub apparent_temperature_celsius: f64,
+    pub humidity_percent: f64,
+    pub wind_speed_kmh: f64,
+    pub weather_code: i64,
+}
+
+pub async fn weather(city: &str) -> Result<WeatherReport, WeatherError> {
+    let city = city.trim();
+    if city.is_empty() {
+        return Err(WeatherError::MissingCity);
+    }
+    let client = crate::HTTP_CLIENT.clone();
+    let geocode: Value = client
+        .get("https://geocoding-api.open-meteo.com/v1/search")
+        .query(&[("name", city), ("count", "1"), ("language", "en")])
+        .send()
+        .await?
+        .error_for_status()?
+        .json()
+        .await?;
+    let place = geocode["results"]
+        .as_array()
+        .and_then(|results| results.first())
+        .ok_or_else(|| WeatherError::LocationNotFound(city.into()))?;
+    let latitude = number(place, "latitude")?;
+    let longitude = number(place, "longitude")?;
+    let current: Value = client
+        .get("https://api.open-meteo.com/v1/forecast")
+        .query(&[
+            ("latitude", latitude.to_string()),
+            ("longitude", longitude.to_string()),
+            (
+                "current",
+                "temperature_2m,relative_humidity_2m,apparent_temperature,weather_code,wind_speed_10m".into(),
+            ),
+        ])
+        .send()
+        .await?
+        .error_for_status()?
+        .json()
+        .await?;
+    let current = &current["current"];
+    let temperature = number(current, "temperature_2m")?;
+    let apparent = number(current, "apparent_temperature")?;
+    let humidity = number(current, "relative_humidity_2m")?;
+    let wind = number(current, "wind_speed_10m")?;
+    let code = current["weather_code"].as_i64().unwrap_or_default();
+    let location = [place["name"].as_str(), place["country"].as_str()]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>()
+        .join(", ");
+    Ok(WeatherReport {
+        data: format!(
+            "{location}: {:.1} C, feels like {:.1} C, humidity {:.0}%, wind {:.1} km/h",
+            temperature, apparent, humidity, wind
+        ),
+        location,
+        temperature_celsius: temperature,
+        apparent_temperature_celsius: apparent,
+        humidity_percent: humidity,
+        wind_speed_kmh: wind,
+        weather_code: code,
+    })
+}
+
+fn number(value: &Value, key: &str) -> Result<f64, WeatherError> {
+    value[key]
+        .as_f64()
+        .ok_or_else(|| WeatherError::MissingValue(key.into()))
+}

package/crates/mint-core/src/web_search.rs

@@ -0,0 +1,200 @@
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use crate::MintConfig;
+
+#[derive(Debug, Error)]
+pub enum WebSearchError {
+    #[error("no web search API key configured (set googleSearchApiKey or braveSearchApiKey)")]
+    NoApiKey,
+    #[error("web search request failed: {0}")]
+    Request(String),
+    #[error("web search response was empty or unparseable")]
+    EmptyResponse,
+}
+
+fn sanitize_reqwest_error(err: reqwest::Error) -> WebSearchError {
+    let mut msg = err.to_string();
+    if let Some(pos) = msg.find("https://www.googleapis.com") {
+        let mut end_pos = msg.len();
+        for (idx, ch) in msg[pos..].char_indices() {
+            if ch == ' '
+                || ch == ')'
+                || ch == '"'
+                || ch == '\''
+                || ch == ']'
+                || ch == '}'
+                || ch == '>'
+            {
+                end_pos = pos + idx;
+                break;
+            }
+        }
+        msg.replace_range(pos..end_pos, "https://www.googleapis.com/customsearch/v1");
+    }
+    if let Some(pos) = msg.find("https://api.search.brave.com") {
+        let mut end_pos = msg.len();
+        for (idx, ch) in msg[pos..].char_indices() {
+            if ch == ' '
+                || ch == ')'
+                || ch == '"'
+                || ch == '\''
+                || ch == ']'
+                || ch == '}'
+                || ch == '>'
+            {
+                end_pos = pos + idx;
+                break;
+            }
+        }
+        msg.replace_range(
+            pos..end_pos,
+            "https://api.search.brave.com/res/v1/web/search",
+        );
+    }
+    WebSearchError::Request(msg)
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SearchHit {
+    pub title: String,
+    pub url: String,
+    pub snippet: String,
+}
+
+/// Search the web using the first configured provider (Google → Brave).
+/// Returns the search hits and the name of the provider used.
+pub async fn search(
+    query: &str,
+    limit: usize,
+    config: &MintConfig,
+) -> Result<(Vec<SearchHit>, String), WebSearchError> {
+    let google_key = config
+        .extra
+        .get("googleSearchApiKey")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .trim()
+        .to_owned();
+    let google_cx = config
+        .extra
+        .get("googleSearchCx")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .trim()
+        .to_owned();
+    let brave_key = config
+        .extra
+        .get("braveSearchApiKey")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .trim()
+        .to_owned();
+
+    let mut last_err = None;
+
+    if !google_key.is_empty() && !google_cx.is_empty() {
+        match google_search(query, limit, &google_key, &google_cx).await {
+            Ok(hits) => {
+                if !hits.is_empty() {
+                    return Ok((hits, "Google".to_owned()));
+                }
+            }
+            Err(e) => {
+                last_err = Some(e);
+            }
+        }
+    }
+
+    if !brave_key.is_empty() {
+        match brave_search(query, limit, &brave_key).await {
+            Ok(hits) => {
+                return Ok((hits, "Brave".to_owned()));
+            }
+            Err(e) => {
+                last_err = Some(e);
+            }
+        }
+    }
+
+    Err(last_err.unwrap_or(WebSearchError::NoApiKey))
+}
+
+async fn google_search(
+    query: &str,
+    limit: usize,
+    api_key: &str,
+    cx: &str,
+) -> Result<Vec<SearchHit>, WebSearchError> {
+    let client = crate::HTTP_CLIENT.clone();
+    let num_str = limit.min(10).to_string();
+    let response: serde_json::Value = client
+        .get("https://www.googleapis.com/customsearch/v1")
+        .query(&[
+            ("key", api_key),
+            ("cx", cx),
+            ("q", query),
+            ("num", num_str.as_str()),
+        ])
+        .send()
+        .await
+        .map_err(sanitize_reqwest_error)?
+        .error_for_status()
+        .map_err(sanitize_reqwest_error)?
+        .json()
+        .await
+        .map_err(sanitize_reqwest_error)?;
+
+    let items = response["items"]
+        .as_array()
+        .ok_or(WebSearchError::EmptyResponse)?;
+
+    Ok(items
+        .iter()
+        .take(limit)
+        .filter_map(|item| {
+            Some(SearchHit {
+                title: item["title"].as_str()?.to_owned(),
+                url: item["link"].as_str()?.to_owned(),
+                snippet: item["snippet"].as_str().unwrap_or("").to_owned(),
+            })
+        })
+        .collect())
+}
+
+async fn brave_search(
+    query: &str,
+    limit: usize,
+    api_key: &str,
+) -> Result<Vec<SearchHit>, WebSearchError> {
+    let client = crate::HTTP_CLIENT.clone();
+    let response: serde_json::Value = client
+        .get("https://api.search.brave.com/res/v1/web/search")
+        .header("Accept", "application/json")
+        .header("X-Subscription-Token", api_key)
+        .query(&[("q", query), ("count", &limit.to_string())])
+        .send()
+        .await
+        .map_err(sanitize_reqwest_error)?
+        .error_for_status()
+        .map_err(sanitize_reqwest_error)?
+        .json()
+        .await
+        .map_err(sanitize_reqwest_error)?;
+
+    let results = response["web"]["results"]
+        .as_array()
+        .ok_or(WebSearchError::EmptyResponse)?;
+
+    Ok(results
+        .iter()
+        .take(limit)
+        .filter_map(|item| {
+            Some(SearchHit {
+                title: item["title"].as_str()?.to_owned(),
+                url: item["url"].as_str()?.to_owned(),
+                snippet: item["description"].as_str().unwrap_or("").to_owned(),
+            })
+        })
+        .collect())
+}