@pheem49/mint 1.16.0 → 1.18.0

package/apps/mint-companion/src-tauri/src/main.rs

@@ -1,4 +1,6 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+mod compact;
+
 use futures_util::{SinkExt, StreamExt};
 use mint_companion_protocol::{Command, Event, HostDescriptor, VERSION};
 use serde::{Deserialize, Serialize};
@@ -27,8 +29,14 @@ fn valid_endpoint(endpoint: &str) -> bool {
 #[serde(default, rename_all = "camelCase")]
 struct Settings {
     host_id: String,
+    host_identity: String,
+    host_peers: Vec<String>,
+    speech_auto: bool,
+    speech_muted: bool,
+    speech_volume: f64,
     chat_id: String,
     scale: f64,
+    offset_y: f64,
     expression: i32,
     accessory: u32,
     locked: bool,
@@ -45,8 +53,14 @@ impl Default for Settings {
     fn default() -> Self {
         Self {
             host_id: String::new(),
+            host_identity: String::new(),
+            host_peers: Vec::new(),
+            speech_auto: false,
+            speech_muted: false,
+            speech_volume: 1.0,
             chat_id: String::new(),
             scale: 1.0,
+            offset_y: 0.0,
             expression: -1,
             accessory: 0,
             locked: false,
@@ -73,6 +87,9 @@ struct Client {
 struct Host {
     host_id: String,
     name: String,
+    identity: Option<String>,
+    surface: Option<mint_companion_protocol::Surface>,
+    speech: bool,
 }
 fn settings_path() -> Result<PathBuf, String> {
     dirs::config_dir()
@@ -172,10 +189,15 @@ async fn discover_hosts() -> Result<Vec<Host>, String> {
             Event::Snapshot {
                 host_id,
                 version: VERSION,
+                surface,
+                speech,
                 ..
             } if host_id == id => Some(Host {
                 host_id: id,
                 name: host.name,
+                identity: host.identity,
+                surface,
+                speech,
             }),
             _ => None,
         }
@@ -275,6 +297,84 @@ fn connect_host(
     });
     *state.task.lock().unwrap() = Some(task);
 }
+#[tauri::command]
+async fn open_conversation(
+    host_id: String,
+    chat_id: String,
+    new_terminal: bool,
+) -> Result<mint_companion_protocol::NavigationOutcome, String> {
+    let host = descriptor(&host_id)?;
+    tokio::time::timeout(std::time::Duration::from_secs(12), async {
+        let mut socket = open(&host).await?;
+        let command = Command::OpenChat {
+            chat_id,
+            new_terminal,
+        };
+        socket
+            .send(Message::Text(
+                serde_json::to_string(&command)
+                    .map_err(|error| error.to_string())?
+                    .into(),
+            ))
+            .await
+            .map_err(|error| error.to_string())?;
+        while let Some(message) = socket.next().await {
+            let message = message.map_err(|error| error.to_string())?;
+            if let Message::Text(text) = message {
+                let event: Event =
+                    serde_json::from_str(&text).map_err(|error| error.to_string())?;
+                match event {
+                    Event::Navigation { outcome } => {
+                        let _ = socket.close(None).await;
+                        return Ok(outcome);
+                    }
+                    Event::Error { message, .. } => return Err(message),
+                    _ => {}
+                }
+            }
+        }
+        Err("Mint disconnected before confirming navigation. Try again after checking Mint.".into())
+    })
+    .await
+    .map_err(|_| "Mint did not confirm navigation. Check Mint before trying again.".to_string())?
+}
+
+#[tauri::command]
+async fn speech_request(
+    host_id: String,
+    request: mint_companion_protocol::SpeechRequest,
+) -> Result<mint_companion_protocol::SpeechReply, String> {
+    let host = descriptor(&host_id)?;
+    tokio::time::timeout(std::time::Duration::from_secs(15), async {
+        let mut socket = open(&host).await?;
+        let command = Command::Speech { request };
+        socket
+            .send(Message::Text(
+                serde_json::to_string(&command)
+                    .map_err(|e| e.to_string())?
+                    .into(),
+            ))
+            .await
+            .map_err(|e| e.to_string())?;
+        while let Some(message) = socket.next().await {
+            let message = message.map_err(|e| e.to_string())?;
+            if let Message::Text(text) = message {
+                match serde_json::from_str::<Event>(&text).map_err(|e| e.to_string())? {
+                    Event::Speech { reply } => {
+                        let _ = socket.close(None).await;
+                        return Ok(reply);
+                    }
+                    Event::Error { message, .. } => return Err(message),
+                    _ => {}
+                }
+            }
+        }
+        Err("Mint disconnected while preparing speech".into())
+    })
+    .await
+    .map_err(|_| "Mint speech request timed out".to_string())?
+}
+
 #[tauri::command]
 async fn send_command(state: tauri::State<'_, Client>, command: Command) -> Result<(), String> {
     let sender = state
@@ -298,6 +398,11 @@ fn save_settings(
     state: tauri::State<'_, Client>,
     mut settings: Settings,
 ) -> Result<(), String> {
+    settings.speech_volume = if settings.speech_volume.is_finite() {
+        settings.speech_volume.clamp(0.0, 1.0)
+    } else {
+        1.0
+    };
     settings.scale = settings.scale.clamp(0.5, 1.5);
     settings.expression = settings.expression.clamp(-1, 5);
     settings.accessory = settings.accessory.min(3);
@@ -323,18 +428,73 @@ fn save_settings(
     Ok(())
 }
 #[tauri::command]
-fn hide_window(app: tauri::AppHandle) {
-    if let Some(window) = app.get_webview_window("main") {
-        let _ = window.hide();
+fn quit_app(app: tauri::AppHandle) {
+    app.exit(0);
+}
+#[tauri::command]
+fn window_dimensions(window: tauri::WebviewWindow) -> Result<(u32, u32), String> {
+    let scale = window.scale_factor().map_err(|error| error.to_string())?;
+    let size = window
+        .inner_size()
+        .map_err(|error| error.to_string())?
+        .to_logical::<u32>(scale);
+    Ok((size.width, size.height))
+}
+
+#[tauri::command]
+fn resize_companion(window: tauri::WebviewWindow, width: u32, height: u32) -> Result<(), String> {
+    if window
+        .state::<compact::CompactWindow>()
+        .active
+        .load(Ordering::Acquire)
+    {
+        return Err("Expand Companion before resizing it".into());
+    }
+    window.unmaximize().map_err(|error| error.to_string())?;
+    window
+        .set_size(tauri::LogicalSize::new(
+            width.clamp(340, 2000),
+            height.clamp(560, 2000),
+        ))
+        .map_err(|error| error.to_string())
+}
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RelativeCursorPosition {
+    pub x: f64,
+    pub y: f64,
+}
+
+pub fn calculate_relative_cursor(
+    cursor_x: f64,
+    cursor_y: f64,
+    win_x: i32,
+    win_y: i32,
+    scale_factor: f64,
+) -> RelativeCursorPosition {
+    let scale = if scale_factor <= 0.0 || !scale_factor.is_finite() {
+        1.0
+    } else {
+        scale_factor
+    };
+    RelativeCursorPosition {
+        x: (cursor_x - win_x as f64) / scale,
+        y: (cursor_y - win_y as f64) / scale,
     }
-    let _ = app.emit("companion-visible", false);
 }
+
 #[tauri::command]
-fn quit_app(app: tauri::AppHandle) {
-    app.exit(0);
+fn get_cursor_position(window: tauri::WebviewWindow) -> Option<RelativeCursorPosition> {
+    let cursor = window.cursor_position().ok()?;
+    let win_pos = window.outer_position().ok()?;
+    let scale = window.scale_factor().unwrap_or(1.0);
+    Some(calculate_relative_cursor(
+        cursor.x, cursor.y, win_pos.x, win_pos.y, scale,
+    ))
 }
 fn show(app: &tauri::AppHandle) {
     if let Some(window) = app.get_webview_window("main") {
+        let _ = compact::set_compact(window.clone(), false);
         let _ = window.show();
         let _ = window.unminimize();
         let _ = window.set_focus();
@@ -344,6 +504,7 @@ fn show(app: &tauri::AppHandle) {
 fn main() {
     tauri::Builder::default()
         .manage(Client::default())
+        .manage(compact::CompactWindow::default())
         .setup(|app| {
             let settings = read_settings();
             if let Some(window) = app.get_webview_window("main") {
@@ -351,8 +512,8 @@ fn main() {
                 window.set_decorations(settings.normal_window)?;
                 if settings.x.is_some() {
                     window.set_size(tauri::PhysicalSize::new(
-                        settings.width.clamp(340, 3200),
-                        settings.height.clamp(560, 3200),
+                        settings.width.clamp(340, 10000),
+                        settings.height.clamp(560, 10000),
                     ))?;
                 } else {
                     window.set_size(tauri::LogicalSize::new(480.0, 800.0))?;
@@ -408,13 +569,27 @@ fn main() {
         })
         .on_window_event(|window, event| match event {
             tauri::WindowEvent::Moved(position) => {
+                if window
+                    .state::<compact::CompactWindow>()
+                    .active
+                    .load(Ordering::Acquire)
+                {
+                    return;
+                }
                 let state = window.state::<Client>();
                 let mut settings = state.settings.lock().unwrap();
                 settings.x = Some(position.x);
                 settings.y = Some(position.y);
                 let _ = persist(&settings);
             }
-            tauri::WindowEvent::Resized(size) if size.width > 0 && size.height > 0 => {
+            tauri::WindowEvent::Resized(size) if size.width >= 340 && size.height >= 560 => {
+                if window
+                    .state::<compact::CompactWindow>()
+                    .active
+                    .load(Ordering::Acquire)
+                {
+                    return;
+                }
                 let state = window.state::<Client>();
                 let mut settings = state.settings.lock().unwrap();
                 settings.width = size.width;
@@ -424,13 +599,18 @@ fn main() {
             _ => {}
         })
         .invoke_handler(tauri::generate_handler![
+            compact::set_compact,
+            window_dimensions,
+            resize_companion,
             discover_hosts,
+            open_conversation,
+            speech_request,
             connect_host,
             send_command,
             load_settings,
             save_settings,
-            hide_window,
-            quit_app
+            quit_app,
+            get_cursor_position
         ])
         .run(tauri::generate_context!())
         .expect("Failed to launch Mint Companion");
@@ -465,4 +645,31 @@ mod tests {
             assert!(!valid_endpoint(endpoint));
         }
     }
+    #[test]
+    fn relative_cursor_calculation_handles_offsets_and_dpi_scale() {
+        let origin = calculate_relative_cursor(1440.0, 100.0, 1440, 100, 1.0);
+        assert_eq!(origin, RelativeCursorPosition { x: 0.0, y: 0.0 });
+
+        let left = calculate_relative_cursor(440.0, 50.0, 1440, 100, 1.0);
+        assert_eq!(
+            left,
+            RelativeCursorPosition {
+                x: -1000.0,
+                y: -50.0
+            }
+        );
+
+        let scaled = calculate_relative_cursor(1640.0, 300.0, 1440, 100, 2.0);
+        assert_eq!(scaled, RelativeCursorPosition { x: 100.0, y: 100.0 });
+
+        let fallback = calculate_relative_cursor(1500.0, 200.0, 1440, 100, 0.0);
+        assert_eq!(fallback, RelativeCursorPosition { x: 60.0, y: 100.0 });
+    }
+    #[test]
+    fn settings_deserialization_defaults_offset_y() {
+        let json = r#"{"hostId":"","chatId":"","scale":1.2}"#;
+        let s: Settings = serde_json::from_str(json).unwrap();
+        assert_eq!(s.offset_y, 0.0);
+        assert_eq!(s.scale, 1.2);
+    }
 }

package/apps/mint-companion/vite.config.ts

@@ -1,3 +1,4 @@
 import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
-export default defineConfig({ base: './', plugins: [react()], build: { outDir: '../../out/companion', emptyOutDir: true }, server: { port: 9001, strictPort: true } })
+import tailwindcss from '@tailwindcss/vite'
+export default defineConfig({ base: './', plugins: [react(), tailwindcss()], build: { outDir: '../../out/companion', emptyOutDir: true }, server: { port: 9001, strictPort: true } })

package/crates/mint-cli/src/agent/diff_render.rs

@@ -49,68 +49,90 @@ pub(super) fn print_diff_header(action: &str, path: &str, additions: usize, dele
     );
 }
 
-/// Prints one diff row as a full-width color band (like a diff viewer's gutter
-/// highlight), padding `content` with spaces out to the terminal width so the
-/// background color fills the row instead of just wrapping the text.
-pub(super) fn print_diff_band(bg: &str, line_num: usize, content: &str, term_width: usize) {
-    let line_num_str = format!("{:>5}", line_num);
-    let prefix_visible_len = 2 + line_num_str.chars().count() + 1;
-    // Use the app's East-Asian/Thai-combining-mark-aware width, not a raw
-    // char count — a naive count over/under-shoots the true terminal column
-    // width for wide glyphs and zero-width Thai marks, leaving the band short
-    // of (or past) the terminal edge.
-    let available_width = term_width.saturating_sub(prefix_visible_len).max(1);
-    let blank_line_num = " ".repeat(line_num_str.chars().count());
-
-    // A code/diff line longer than the terminal is hard-wrapped (never
-    // word-wrapped, which would collapse indentation) into multiple physical
-    // lines so the colored band never overflows past the terminal edge — the
-    // same class of bug the markdown table renderer had.
-    for (i, wrapped_line) in markdown::hard_wrap(content, available_width)
-        .into_iter()
-        .enumerate()
-    {
-        let line_label = if i == 0 {
-            &line_num_str
-        } else {
-            &blank_line_num
-        };
-        let content_len = crate::interactive::string_visual_width(&wrapped_line);
-        let pad_len = available_width.saturating_sub(content_len);
-        println!(
-            "  {DIM}{line_label}{RESET} {bg}{wrapped_line}{}{RESET}",
-            " ".repeat(pad_len)
-        );
-    }
-}
-
-pub(super) fn print_colored_diff(diff: &str) {
-    let (term_width, _) = markdown::terminal_size_or_default();
-    let term_width = term_width as usize;
+pub(crate) fn format_colored_diff_lines(diff: &str, term_width: usize) -> Vec<String> {
+    let term_width = term_width.max(20);
+    let mut out = Vec::new();
     let mut current_old_line = 1;
     let mut current_new_line = 1;
 
+    let push_band = |out: &mut Vec<String>, bg: &str, line_num: usize, content: &str| {
+        let line_num_str = format!("{:>5}", line_num);
+        let prefix_visible_len = 2 + line_num_str.chars().count() + 1;
+        let available_width = term_width.saturating_sub(prefix_visible_len).max(1);
+        let blank_line_num = " ".repeat(line_num_str.chars().count());
+
+        for (i, wrapped_line) in markdown::hard_wrap(content, available_width)
+            .into_iter()
+            .enumerate()
+        {
+            let line_label = if i == 0 {
+                &line_num_str
+            } else {
+                &blank_line_num
+            };
+            let content_len = crate::interactive::string_visual_width(&wrapped_line);
+            let pad_len = available_width.saturating_sub(content_len);
+            out.push(format!(
+                "  {DIM}{line_label}{RESET} {bg}{wrapped_line}{}{RESET}",
+                " ".repeat(pad_len)
+            ));
+        }
+    };
+
     for line in diff.lines() {
         if line.starts_with("@@") {
-            // Still track line numbers from the hunk header, just don't print
-            // the raw unified-diff header/marker lines — they're noise here.
             if let Some((old_s, new_s)) = parse_hunk_header(line) {
                 current_old_line = old_s;
                 current_new_line = new_s;
             }
         } else if line.starts_with("--- ") || line.starts_with("+++ ") {
-            // skip: raw diff file-header lines aren't useful in an approval prompt
+            // skip raw diff file-header lines
         } else if let Some(content) = line.strip_prefix('-') {
-            print_diff_band(BG_DEL, current_old_line, content, term_width);
+            push_band(&mut out, BG_DEL, current_old_line, content);
             current_old_line += 1;
         } else if let Some(content) = line.strip_prefix('+') {
-            print_diff_band(BG_ADD, current_new_line, content, term_width);
+            push_band(&mut out, BG_ADD, current_new_line, content);
             current_new_line += 1;
         } else {
             let line_num_str = format!("{:>5}", current_new_line);
             current_old_line += 1;
             current_new_line += 1;
-            println!("  {DIM}{line_num_str}{RESET} {line}");
+            out.push(format!("  {DIM}{line_num_str}{RESET} {line}"));
         }
     }
+    out
+}
+
+#[allow(dead_code)]
+pub(crate) fn render_diff_to_ratatui_lines(
+    diff: &str,
+    term_width: usize,
+) -> Vec<ratatui::text::Line<'static>> {
+    let ansi_joined = format_colored_diff_lines(diff, term_width).join("\n");
+    if let Ok(parsed) = ansi_joined.into_text() {
+        parsed.lines
+    } else {
+        diff.lines()
+            .map(|l| ratatui::text::Line::raw(l.to_string()))
+            .collect()
+    }
+}
+
+pub(super) fn print_colored_diff(diff: &str) {
+    let (term_width, _) = markdown::terminal_size_or_default();
+    for line in format_colored_diff_lines(diff, term_width as usize) {
+        println!("{line}");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn render_diff_to_ratatui_lines_formats_hunks_at_requested_width() {
+        let diff = "@@ -1,2 +1,2 @@\n-old line\n+new line\n context";
+        let lines = render_diff_to_ratatui_lines(diff, 60);
+        assert_eq!(lines.len(), 3);
+    }
 }

package/crates/mint-cli/src/agent/live_status.rs

@@ -21,7 +21,7 @@ pub(super) fn extract_domain(url: &str) -> String {
 /// Parse (title, url) pairs from the formatted `web_search` ToolEnd result text.
 /// The format produced by orchestration.rs is:
 ///   1. Title\n   URL: https://...\n   Snippet\n
-pub(super) fn parse_web_search_sources(result: &str) -> Vec<(String, String)> {
+pub(crate) fn parse_web_search_sources(result: &str) -> Vec<(String, String)> {
     let mut sources = Vec::new();
     let mut current_title: Option<String> = None;
     for line in result.lines() {
@@ -46,6 +46,39 @@ pub(super) fn parse_web_search_sources(result: &str) -> Vec<(String, String)> {
     sources
 }
 
+pub(crate) const MAX_TUI_WEB_SOURCES: usize = 5;
+
+/// Formats web search sources for display in Full-Screen TUI transcripts.
+/// Caps the list at `limit` items (default 5), and appends a `Ctrl+O view web_search` hint
+/// when additional sources exist so users know they can view the full list via tool details.
+pub(crate) fn format_tui_web_sources(sources: &[(String, String)], limit: usize) -> String {
+    if sources.is_empty() {
+        return String::new();
+    }
+    let total = sources.len();
+    let display_items: Vec<_> = sources
+        .iter()
+        .take(limit)
+        .enumerate()
+        .map(|(index, (title, url))| format!("{}. {title}\n   {url}", index + 1))
+        .collect();
+
+    let mut out = format!("Sources:\n{}", display_items.join("\n"));
+    if total > limit {
+        let remaining = total - limit;
+        out.push_str(&format!(
+            "\n{}  … [+{} more sources] · {}{}{}{}",
+            crate::terminal_theme::ANSI_MUTED,
+            remaining,
+            crate::terminal_theme::ANSI_RESET,
+            crate::terminal_theme::ANSI_BLUE,
+            "Ctrl+O view web_search",
+            crate::terminal_theme::ANSI_RESET,
+        ));
+    }
+    out
+}
+
 /// Playful gerunds shown in place of "Thinking" while the model is working,
 /// picked once per turn so the label doesn't change mid-flight.
 const THINKING_VERBS: &[&str] = &[
@@ -171,8 +204,16 @@ fn ramp_estimate(estimated: u64, elapsed_secs: f64) -> u64 {
 }
 
 pub(super) fn render_live_summary(summary: &str) {
+    use std::io::IsTerminal;
     let (tw, _) = markdown::terminal_size_or_default();
     let width = tw as usize;
+    let total_lines = summary.lines().count().max(1);
+    let pace_delay = if io::stdout().is_terminal() {
+        let per_line_ms = (500 / total_lines as u64).clamp(4, 16);
+        Duration::from_millis(per_line_ms)
+    } else {
+        Duration::ZERO
+    };
 
     let mut is_first = true;
     let mut table_buffer: Vec<String> = Vec::new();
@@ -186,6 +227,10 @@ pub(super) fn render_live_summary(summary: &str) {
         if !table_buffer.is_empty() {
             print_table_block(&table_buffer, &mut is_first);
             table_buffer.clear();
+            if !pace_delay.is_zero() {
+                let _ = io::stdout().flush();
+                std::thread::sleep(pace_delay);
+            }
         }
 
         let indent = if is_first { "" } else { "  " };
@@ -201,6 +246,10 @@ pub(super) fn render_live_summary(summary: &str) {
         } else {
             print!("\n{wrapped}");
         }
+        if !pace_delay.is_zero() {
+            let _ = io::stdout().flush();
+            std::thread::sleep(pace_delay);
+        }
     }
 
     if !table_buffer.is_empty() {
@@ -511,13 +560,14 @@ pub(super) fn explored_action_label(
 }
 
 pub(super) fn display_tool_target(path: &str) -> String {
-    if path.trim().is_empty() {
-        ".".into()
+    let trimmed = path.trim();
+    if trimmed.is_empty() || trimmed == "." || trimmed == "./" {
+        "workspace".into()
     } else {
-        Path::new(path)
+        Path::new(trimmed)
             .file_name()
             .and_then(|name| name.to_str())
-            .unwrap_or(path)
+            .unwrap_or(trimmed)
             .into()
     }
 }
@@ -1494,8 +1544,16 @@ pub(super) fn ran_command_labels(action: &str, input: &serde_json::Value) -> Opt
         "run_shell" => input
             .get("command")
             .or_else(|| input.get("cmd"))
+            .or_else(|| input.get("script"))
+            .or_else(|| input.get("exec"))
+            .or_else(|| input.get("code"))
+            .or_else(|| input.get("bash"))
+            .or_else(|| input.get("sh"))
             .and_then(|v| v.as_str())
-            .filter(|command| !command.trim().is_empty())
+            .filter(|command| {
+                let trimmed = command.trim();
+                !trimmed.is_empty() && !mint_core::is_dummy_value(trimmed)
+            })
             .map(|command| vec![command.trim().to_owned()]),
         "shell_output" | "kill_shell" => input
             .get("job_id")