@pheem49/mint 1.9.0 → 1.10.0

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

@@ -0,0 +1,294 @@
+pub fn is_table_line(line: &str) -> bool {
+    let trimmed = line.trim();
+    trimmed.starts_with('|') && trimmed.ends_with('|') && trimmed.len() > 1
+}
+
+pub fn process_inline_bold(s: &str) -> String {
+    let mut result = String::new();
+    let parts = s.split("**");
+    let mut is_bold = false;
+    for part in parts {
+        if is_bold {
+            result.push_str("\x1b[1m");
+            result.push_str(part);
+            result.push_str("\x1b[0m");
+        } else {
+            result.push_str(part);
+        }
+        is_bold = !is_bold;
+    }
+    result
+}
+
+pub fn format_line(line: &str) -> String {
+    let mut formatted = line.to_string();
+    let trimmed = line.trim_start();
+    if (trimmed.starts_with("- ") || trimmed.starts_with("* ") || trimmed.starts_with("+ "))
+        && trimmed.len() >= 2
+    {
+        let leading_len = line.len() - trimmed.len();
+        let leading_spaces = &line[..leading_len];
+        formatted = format!("{}•{}", leading_spaces, &trimmed[1..]);
+    }
+    process_inline_bold(&formatted)
+}
+
+pub fn unicode_width(s: &str) -> usize {
+    let mut count = 0;
+    for c in s.chars() {
+        let val = c as u32;
+        if (0x0E31..=0x0E31).contains(&val)
+            || (0x0E34..=0x0E3A).contains(&val)
+            || (0x0E47..=0x0E4E).contains(&val)
+        {
+            continue;
+        }
+        if is_cjk(c) {
+            count += 2;
+        } else {
+            count += 1;
+        }
+    }
+    count
+}
+
+pub fn is_cjk(c: char) -> bool {
+    let val = c as u32;
+    (0x4E00..=0x9FFF).contains(&val)
+        || (0x3400..=0x4DBF).contains(&val)
+        || (0x20000..=0x2A6DF).contains(&val)
+        || (0xAC00..=0xD7AF).contains(&val)
+        || (0x3040..=0x309F).contains(&val)
+        || (0x30A0..=0x30FF).contains(&val)
+}
+
+pub fn render_markdown_table(table_lines: &[String]) -> String {
+    let mut rows: Vec<Vec<String>> = Vec::new();
+    for line in table_lines {
+        let trimmed = line.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        let content = &trimmed[1..trimmed.len() - 1];
+        let content_escaped = content.replace("\\|", "\u{0000}");
+        let cols: Vec<String> = content_escaped
+            .split('|')
+            .map(|s| s.replace("\u{0000}", "|").trim().to_string())
+            .collect();
+        rows.push(cols);
+    }
+
+    if rows.is_empty() {
+        return String::new();
+    }
+
+    let mut has_separator = false;
+    let mut separator_idx = None;
+    for (i, row) in rows.iter().enumerate() {
+        if row.iter().all(|col| {
+            col.chars()
+                .all(|c| c == '-' || c == ':' || c == ' ' || c == '\t')
+        }) && !row.is_empty()
+        {
+            has_separator = true;
+            separator_idx = Some(i);
+            break;
+        }
+    }
+
+    let mut data_rows: Vec<Vec<String>> = Vec::new();
+    let mut header_row: Option<Vec<String>> = None;
+
+    if has_separator {
+        let sep_idx = separator_idx.unwrap();
+        if sep_idx > 0 {
+            header_row = Some(rows[sep_idx - 1].clone());
+            for (i, row) in rows.iter().enumerate() {
+                if i != sep_idx && i != sep_idx - 1 {
+                    data_rows.push(row.clone());
+                }
+            }
+        } else {
+            for (i, row) in rows.iter().enumerate() {
+                if i != sep_idx {
+                    data_rows.push(row.clone());
+                }
+            }
+        }
+    } else {
+        header_row = Some(rows[0].clone());
+        data_rows = rows[1..].to_vec();
+    }
+
+    let num_cols = rows.iter().map(|r| r.len()).max().unwrap_or(0);
+    let mut col_widths = vec![0; num_cols];
+
+    if let Some(ref header) = header_row {
+        for (i, col) in header.iter().enumerate() {
+            if i < num_cols {
+                col_widths[i] = col_widths[i].max(unicode_width(col));
+            }
+        }
+    }
+    for row in &data_rows {
+        for (i, col) in row.iter().enumerate() {
+            if i < num_cols {
+                col_widths[i] = col_widths[i].max(unicode_width(col));
+            }
+        }
+    }
+
+    let mut rendered = String::new();
+
+    let draw_border =
+        |left: &str, mid: &str, right: &str, fill: &str, widths: &[usize]| -> String {
+            let mut s = left.to_string();
+            for (i, &w) in widths.iter().enumerate() {
+                s.push_str(&fill.repeat(w + 2));
+                if i < widths.len() - 1 {
+                    s.push_str(mid);
+                }
+            }
+            s.push_str(right);
+            s.push('\n');
+            s
+        };
+
+    rendered.push_str(&draw_border("┌", "┬", "┐", "─", &col_widths));
+
+    if let Some(ref header) = header_row {
+        rendered.push('│');
+        for (i, col) in header.iter().enumerate() {
+            let width = unicode_width(col);
+            let padding = col_widths[i] - width;
+            rendered.push_str(&format!(
+                " \x1b[1;36m{}\x1b[0m{}",
+                col,
+                " ".repeat(padding + 1)
+            ));
+            rendered.push('│');
+        }
+        rendered.push('\n');
+        rendered.push_str(&draw_border("├", "┼", "┤", "─", &col_widths));
+    }
+
+    for (r_idx, row) in data_rows.iter().enumerate() {
+        rendered.push('│');
+        for i in 0..num_cols {
+            let col_val = row.get(i).cloned().unwrap_or_default();
+            let width = unicode_width(&col_val);
+            let padding = col_widths[i] - width;
+            rendered.push_str(&format!(" {}{}", col_val, " ".repeat(padding + 1)));
+            rendered.push('│');
+        }
+        rendered.push('\n');
+
+        if r_idx < data_rows.len() - 1 {
+            rendered.push_str(&draw_border("├", "┼", "┤", "─", &col_widths));
+        }
+    }
+
+    rendered.push_str(draw_border("└", "┴", "┘", "─", &col_widths).trim_end());
+    rendered
+}
+
+pub struct CliStreamFormatter {
+    line_buffer: String,
+    table_buffer: Vec<String>,
+    in_code_block: bool,
+}
+
+impl CliStreamFormatter {
+    pub fn new() -> Self {
+        Self {
+            line_buffer: String::new(),
+            table_buffer: Vec::new(),
+            in_code_block: false,
+        }
+    }
+
+    pub fn process_char(&mut self, c: char, mut print_fn: impl FnMut(char)) {
+        self.line_buffer.push(c);
+        if c == '\n' {
+            let mut line = self.line_buffer.clone();
+            self.line_buffer.clear();
+            if line.ends_with('\n') {
+                line.pop();
+            }
+
+            let trimmed = line.trim();
+            if trimmed.starts_with("```") {
+                self.in_code_block = !self.in_code_block;
+            }
+
+            if self.in_code_block {
+                if !self.table_buffer.is_empty() {
+                    self.flush_table(&mut print_fn);
+                }
+                for ch in line.chars() {
+                    print_fn(ch);
+                }
+                print_fn('\n');
+                for ch in "  ".chars() {
+                    print_fn(ch);
+                }
+            } else {
+                if is_table_line(&line) {
+                    self.table_buffer.push(line);
+                } else {
+                    if !self.table_buffer.is_empty() {
+                        self.flush_table(&mut print_fn);
+                    }
+                    let formatted = format_line(&line);
+                    for ch in formatted.chars() {
+                        print_fn(ch);
+                    }
+                    print_fn('\n');
+                    for ch in "  ".chars() {
+                        print_fn(ch);
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn finalize(&mut self, mut print_fn: impl FnMut(char)) {
+        if !self.line_buffer.is_empty() {
+            let mut line = self.line_buffer.clone();
+            self.line_buffer.clear();
+            if line.ends_with('\n') {
+                line.pop();
+            }
+            if self.in_code_block {
+                if !self.table_buffer.is_empty() {
+                    self.flush_table(&mut print_fn);
+                }
+                for ch in line.chars() {
+                    print_fn(ch);
+                }
+            } else if is_table_line(&line) {
+                self.table_buffer.push(line);
+            } else {
+                if !self.table_buffer.is_empty() {
+                    self.flush_table(&mut print_fn);
+                }
+                let formatted = format_line(&line);
+                for ch in formatted.chars() {
+                    print_fn(ch);
+                }
+            }
+        }
+        if !self.table_buffer.is_empty() {
+            self.flush_table(&mut print_fn);
+        }
+    }
+
+    fn flush_table<F: FnMut(char)>(&mut self, mut print_fn: F) {
+        let rendered = render_markdown_table(&self.table_buffer);
+        for ch in rendered.chars() {
+            print_fn(ch);
+        }
+        print_fn('\n');
+        self.table_buffer.clear();
+    }
+}

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

@@ -75,9 +75,11 @@ const REPLICATE_MODEL_PRESETS: &[&str] = &[
     "black-forest-labs/flux-1.1-pro",
     "black-forest-labs/flux-schnell",
     "stability-ai/sdxl",
-    "bytedance/sdxl-lightning-4step",
 ];
 
+// ── Video Generation Providers ──────────────────────────────────────────────
+const VEO_VIDEO_MODEL_PRESETS: &[&str] = &["veo-2.0-generate-001", "veo-2.0-flash-001"];
+
 pub async fn run() -> Result<()> {
     let mut config = load_config()?;
 
@@ -280,6 +282,19 @@ pub async fn run() -> Result<()> {
             key: "img_replicate",
             enabled: !config.replicate_api_key.is_empty(),
         },
+        // ── Video Generation ─────────────────────────────────────────────────
+        OnboardService {
+            category: "Video Generation",
+            name: "Google Veo (Gemini Videos)  [uses Gemini key]",
+            key: "vid_veo",
+            enabled: !config.api_key.is_empty()
+                && config
+                    .extra
+                    .get("veoModel")
+                    .and_then(|v| v.as_str())
+                    .map(|s| !s.is_empty())
+                    .unwrap_or(false),
+        },
     ];
 
     let mut cursor = 0;
@@ -976,6 +991,34 @@ pub async fn run() -> Result<()> {
         config.replicate_api_key = String::new();
     }
 
+    // Google Veo (Gemini Videos)
+    if is_selected("vid_veo", &services) {
+        println!("\n\x1b[36m--- Google Veo (Gemini Videos) ---\x1b[0m");
+        println!(
+            "\x1b[90mUses the same Gemini API key as Step 1. Select the video generation model.\x1b[0m"
+        );
+        let current_veo_model = config
+            .extra
+            .get("veoModel")
+            .and_then(|v| v.as_str())
+            .unwrap_or("veo-2.0-generate-001")
+            .to_string();
+        let selected_veo_model = prompt_select_or_custom(
+            "Veo Model",
+            static_model_options(VEO_VIDEO_MODEL_PRESETS),
+            Some(&current_veo_model),
+            "Custom Veo model...",
+        )?;
+        config.extra.insert(
+            "veoModel".to_string(),
+            serde_json::Value::String(selected_veo_model),
+        );
+        config.extra.insert(
+            "videoGenProvider".to_string(),
+            serde_json::Value::String("veo".to_string()),
+        );
+    }
+
     save_config(&config)?;
     println!("\x1b[32m✅ Configuration saved successfully!\x1b[0m");
     Ok(())

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,