@pheem49/mint 1.8.2 → 1.10.0

package/crates/mint-cli/src/setup.rs

@@ -175,66 +175,66 @@ pub async fn run() -> Result<Option<String>> {
     loop {
         match event::poll(std::time::Duration::from_millis(100)) {
             Ok(true) => {
-                if let Event::Key(key_event) = event::read()? {
-                    if key_event.kind == event::KeyEventKind::Press {
-                        let is_ctrl_c = matches!(key_event.code, KeyCode::Char('c'))
-                            && key_event
-                                .modifiers
-                                .contains(crossterm::event::KeyModifiers::CONTROL);
-                        if is_ctrl_c {
-                            disable_raw_mode()?;
-                            println!("\n\x1b[31mSetup cancelled.\x1b[0m");
-                            return Ok(None);
-                        }
+                if let Event::Key(key_event) = event::read()?
+                    && key_event.kind == event::KeyEventKind::Press
+                {
+                    let is_ctrl_c = matches!(key_event.code, KeyCode::Char('c'))
+                        && key_event
+                            .modifiers
+                            .contains(crossterm::event::KeyModifiers::CONTROL);
+                    if is_ctrl_c {
+                        disable_raw_mode()?;
+                        println!("\n\x1b[31mSetup cancelled.\x1b[0m");
+                        return Ok(None);
+                    }
 
-                        match key_event.code {
-                            KeyCode::Up => {
-                                if cursor > 0 {
-                                    cursor -= 1;
-                                } else {
-                                    cursor = options.len() - 1;
-                                }
-                                disable_raw_mode()?;
-                                redraw_phase_1(&options, cursor);
-                                enable_raw_mode()?;
-                            }
-                            KeyCode::Down => {
-                                if cursor < options.len() - 1 {
-                                    cursor += 1;
-                                } else {
-                                    cursor = 0;
-                                }
-                                disable_raw_mode()?;
-                                redraw_phase_1(&options, cursor);
-                                enable_raw_mode()?;
-                            }
-                            KeyCode::Char(' ') => {
-                                options[cursor].enabled = !options[cursor].enabled;
-                                disable_raw_mode()?;
-                                redraw_phase_1(&options, cursor);
-                                enable_raw_mode()?;
+                    match key_event.code {
+                        KeyCode::Up => {
+                            if cursor > 0 {
+                                cursor -= 1;
+                            } else {
+                                cursor = options.len() - 1;
                             }
-                            KeyCode::Char('a') => {
-                                for opt in &mut options {
-                                    opt.enabled = true;
-                                }
-                                disable_raw_mode()?;
-                                redraw_phase_1(&options, cursor);
-                                enable_raw_mode()?;
+                            disable_raw_mode()?;
+                            redraw_phase_1(&options, cursor);
+                            enable_raw_mode()?;
+                        }
+                        KeyCode::Down => {
+                            if cursor < options.len() - 1 {
+                                cursor += 1;
+                            } else {
+                                cursor = 0;
                             }
-                            KeyCode::Char('i') => {
-                                for opt in &mut options {
-                                    opt.enabled = !opt.enabled;
-                                }
-                                disable_raw_mode()?;
-                                redraw_phase_1(&options, cursor);
-                                enable_raw_mode()?;
+                            disable_raw_mode()?;
+                            redraw_phase_1(&options, cursor);
+                            enable_raw_mode()?;
+                        }
+                        KeyCode::Char(' ') => {
+                            options[cursor].enabled = !options[cursor].enabled;
+                            disable_raw_mode()?;
+                            redraw_phase_1(&options, cursor);
+                            enable_raw_mode()?;
+                        }
+                        KeyCode::Char('a') => {
+                            for opt in &mut options {
+                                opt.enabled = true;
                             }
-                            KeyCode::Enter => {
-                                break;
+                            disable_raw_mode()?;
+                            redraw_phase_1(&options, cursor);
+                            enable_raw_mode()?;
+                        }
+                        KeyCode::Char('i') => {
+                            for opt in &mut options {
+                                opt.enabled = !opt.enabled;
                             }
-                            _ => {}
+                            disable_raw_mode()?;
+                            redraw_phase_1(&options, cursor);
+                            enable_raw_mode()?;
+                        }
+                        KeyCode::Enter => {
+                            break;
                         }
+                        _ => {}
                     }
                 }
             }
@@ -298,67 +298,67 @@ pub async fn run() -> Result<Option<String>> {
     loop {
         match event::poll(std::time::Duration::from_millis(100)) {
             Ok(true) => {
-                if let Event::Key(key_event) = event::read()? {
-                    if key_event.kind == event::KeyEventKind::Press {
-                        let is_ctrl_c = matches!(key_event.code, KeyCode::Char('c'))
-                            && key_event
-                                .modifiers
-                                .contains(crossterm::event::KeyModifiers::CONTROL);
-                        if is_ctrl_c {
-                            disable_raw_mode()?;
-                            println!("\n\x1b[31mSetup cancelled.\x1b[0m");
-                            return Ok(None);
-                        }
+                if let Event::Key(key_event) = event::read()?
+                    && key_event.kind == event::KeyEventKind::Press
+                {
+                    let is_ctrl_c = matches!(key_event.code, KeyCode::Char('c'))
+                        && key_event
+                            .modifiers
+                            .contains(crossterm::event::KeyModifiers::CONTROL);
+                    if is_ctrl_c {
+                        disable_raw_mode()?;
+                        println!("\n\x1b[31mSetup cancelled.\x1b[0m");
+                        return Ok(None);
+                    }
 
-                        match key_event.code {
-                            KeyCode::Up => {
-                                if native_cursor > 0 {
-                                    native_cursor -= 1;
-                                } else {
-                                    native_cursor = native_options.len() - 1;
-                                }
-                                disable_raw_mode()?;
-                                redraw_phase_2(&native_options, native_cursor);
-                                enable_raw_mode()?;
-                            }
-                            KeyCode::Down => {
-                                if native_cursor < native_options.len() - 1 {
-                                    native_cursor += 1;
-                                } else {
-                                    native_cursor = 0;
-                                }
-                                disable_raw_mode()?;
-                                redraw_phase_2(&native_options, native_cursor);
-                                enable_raw_mode()?;
+                    match key_event.code {
+                        KeyCode::Up => {
+                            if native_cursor > 0 {
+                                native_cursor -= 1;
+                            } else {
+                                native_cursor = native_options.len() - 1;
                             }
-                            KeyCode::Char(' ') => {
-                                native_options[native_cursor].enabled =
-                                    !native_options[native_cursor].enabled;
-                                disable_raw_mode()?;
-                                redraw_phase_2(&native_options, native_cursor);
-                                enable_raw_mode()?;
-                            }
-                            KeyCode::Char('a') => {
-                                for opt in &mut native_options {
-                                    opt.enabled = true;
-                                }
-                                disable_raw_mode()?;
-                                redraw_phase_2(&native_options, native_cursor);
-                                enable_raw_mode()?;
+                            disable_raw_mode()?;
+                            redraw_phase_2(&native_options, native_cursor);
+                            enable_raw_mode()?;
+                        }
+                        KeyCode::Down => {
+                            if native_cursor < native_options.len() - 1 {
+                                native_cursor += 1;
+                            } else {
+                                native_cursor = 0;
                             }
-                            KeyCode::Char('i') => {
-                                for opt in &mut native_options {
-                                    opt.enabled = !opt.enabled;
-                                }
-                                disable_raw_mode()?;
-                                redraw_phase_2(&native_options, native_cursor);
-                                enable_raw_mode()?;
+                            disable_raw_mode()?;
+                            redraw_phase_2(&native_options, native_cursor);
+                            enable_raw_mode()?;
+                        }
+                        KeyCode::Char(' ') => {
+                            native_options[native_cursor].enabled =
+                                !native_options[native_cursor].enabled;
+                            disable_raw_mode()?;
+                            redraw_phase_2(&native_options, native_cursor);
+                            enable_raw_mode()?;
+                        }
+                        KeyCode::Char('a') => {
+                            for opt in &mut native_options {
+                                opt.enabled = true;
                             }
-                            KeyCode::Enter => {
-                                break;
+                            disable_raw_mode()?;
+                            redraw_phase_2(&native_options, native_cursor);
+                            enable_raw_mode()?;
+                        }
+                        KeyCode::Char('i') => {
+                            for opt in &mut native_options {
+                                opt.enabled = !opt.enabled;
                             }
-                            _ => {}
+                            disable_raw_mode()?;
+                            redraw_phase_2(&native_options, native_cursor);
+                            enable_raw_mode()?;
                         }
+                        KeyCode::Enter => {
+                            break;
+                        }
+                        _ => {}
                     }
                 }
             }
@@ -410,44 +410,44 @@ pub async fn run() -> Result<Option<String>> {
     loop {
         match event::poll(std::time::Duration::from_millis(100)) {
             Ok(true) => {
-                if let Event::Key(key_event) = event::read()? {
-                    if key_event.kind == event::KeyEventKind::Press {
-                        let is_ctrl_c = matches!(key_event.code, KeyCode::Char('c'))
-                            && key_event
-                                .modifiers
-                                .contains(crossterm::event::KeyModifiers::CONTROL);
-                        if is_ctrl_c {
-                            disable_raw_mode()?;
-                            println!("\n\x1b[31mRun selection cancelled.\x1b[0m");
-                            return Ok(None);
-                        }
+                if let Event::Key(key_event) = event::read()?
+                    && key_event.kind == event::KeyEventKind::Press
+                {
+                    let is_ctrl_c = matches!(key_event.code, KeyCode::Char('c'))
+                        && key_event
+                            .modifiers
+                            .contains(crossterm::event::KeyModifiers::CONTROL);
+                    if is_ctrl_c {
+                        disable_raw_mode()?;
+                        println!("\n\x1b[31mRun selection cancelled.\x1b[0m");
+                        return Ok(None);
+                    }
 
-                        match key_event.code {
-                            KeyCode::Up => {
-                                if run_cursor > 0 {
-                                    run_cursor -= 1;
-                                } else {
-                                    run_cursor = run_options.len() - 1;
-                                }
-                                disable_raw_mode()?;
-                                redraw_phase_3(&run_options, run_cursor);
-                                enable_raw_mode()?;
-                            }
-                            KeyCode::Down => {
-                                if run_cursor < run_options.len() - 1 {
-                                    run_cursor += 1;
-                                } else {
-                                    run_cursor = 0;
-                                }
-                                disable_raw_mode()?;
-                                redraw_phase_3(&run_options, run_cursor);
-                                enable_raw_mode()?;
+                    match key_event.code {
+                        KeyCode::Up => {
+                            if run_cursor > 0 {
+                                run_cursor -= 1;
+                            } else {
+                                run_cursor = run_options.len() - 1;
                             }
-                            KeyCode::Enter => {
-                                break;
+                            disable_raw_mode()?;
+                            redraw_phase_3(&run_options, run_cursor);
+                            enable_raw_mode()?;
+                        }
+                        KeyCode::Down => {
+                            if run_cursor < run_options.len() - 1 {
+                                run_cursor += 1;
+                            } else {
+                                run_cursor = 0;
                             }
-                            _ => {}
+                            disable_raw_mode()?;
+                            redraw_phase_3(&run_options, run_cursor);
+                            enable_raw_mode()?;
+                        }
+                        KeyCode::Enter => {
+                            break;
                         }
+                        _ => {}
                     }
                 }
             }

package/crates/mint-cli/src/updater.rs

@@ -2,16 +2,41 @@ use std::path::PathBuf;
 use std::process::Command;
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use anyhow::{Context, Result, bail};
+use anyhow::{Result, bail};
 
 const PACKAGE: &str = "@pheem49/mint";
 
 pub fn run(check_only: bool, dry_run: bool, approved: bool) -> Result<()> {
     let current = env!("CARGO_PKG_VERSION");
+
+    use indicatif::{ProgressBar, ProgressStyle};
+    use std::time::Duration;
+
+    let spinner = ProgressBar::new_spinner();
+    spinner.set_style(
+        ProgressStyle::default_spinner()
+            .tick_chars("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏")
+            .template("{spinner:.green} {msg}")
+            .unwrap(),
+    );
+    spinner.set_message("Checking for updates...");
+    spinner.enable_steady_tick(Duration::from_millis(80));
+
     let output = Command::new(npm())
         .args(["view", PACKAGE, "version", "--json"])
-        .output()
-        .context("unable to run npm update check")?;
+        .output();
+
+    let output = match output {
+        Ok(out) => {
+            spinner.finish_and_clear();
+            out
+        }
+        Err(e) => {
+            spinner.finish_and_clear();
+            bail!("unable to run npm update check: {}", e);
+        }
+    };
+
     if !output.status.success() {
         bail!(
             "npm update check failed: {}",
@@ -34,14 +59,31 @@ pub fn run(check_only: bool, dry_run: bool, approved: bool) -> Result<()> {
     if !approved {
         bail!("update installation requires --approve");
     }
+
+    let spinner = ProgressBar::new_spinner();
+    spinner.set_style(
+        ProgressStyle::default_spinner()
+            .tick_chars("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏")
+            .template("{spinner:.green} {msg}")
+            .unwrap(),
+    );
+    spinner.set_message(format!("Updating to {latest} via npm..."));
+    spinner.enable_steady_tick(Duration::from_millis(80));
+
     let mut command = Command::new(npm());
     command.args(["install", "-g", &format!("{PACKAGE}@latest")]);
     if dry_run {
         command.arg("--dry-run");
     }
-    let status = command
-        .status()
-        .context("unable to run npm global update")?;
+    let status = command.status();
+    spinner.finish_and_clear();
+
+    let status = match status {
+        Ok(s) => s,
+        Err(e) => {
+            bail!("unable to run npm global update: {}", e);
+        }
+    };
     if !status.success() {
         bail!("npm global update failed with status {status}");
     }

package/crates/mint-core/Cargo.toml

@@ -17,6 +17,7 @@ rusqlite.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 sha2.workspace = true
+similar.workspace = true
 thiserror.workspace = true
 tokio.workspace = true
 tokio-tungstenite.workspace = true

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

@@ -59,6 +59,7 @@ where
                 chat_id: None,
                 image_data_uri: None,
                 audio_data_uri: None,
+                video_data_uri: None,
                 document_attachment: None,
                 workspace_path: None,
                 agent_id: None,