@pheem49/mint 1.6.3 → 1.7.0

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

@@ -7,10 +7,10 @@ use std::{
 };
 
 use mint_core::{
-    CHAT_CLI_ID, Capability, ChatRequest, CodeEdit, CodePatchHunk, KnowledgeStore, MemoryStore,
-    MintConfig, TaskStore, apply_code_edits, assert_path_capability, build_code_patch,
+    CHAT_CLI_ID, Capability, ChatRequest, CodeEdit, CodePatchHunk, ImageGenRequest, KnowledgeStore,
+    MemoryStore, MintConfig, TaskStore, apply_code_edits, assert_path_capability, build_code_patch,
     build_symbol_index, classify_shell_command, config_path, create_folder, execute_native_plugin,
-    fetch_github_repo_summary, find_paths, index_semantic_code, initialize_config,
+    fetch_github_repo_summary, find_paths, generate_images, index_semantic_code, initialize_config,
     inspect_code_plan, list_code_files, load_config, native_plugins,
     orchestrate_chat_stream_with_fallback, orchestrate_chat_with_fallback, parse_github_url,
     propose_code_edits, read_code_file, repository_summary, run_shell_command, search_code,
@@ -180,6 +180,23 @@ enum Command {
     Onboard,
     /// Interactively manage enabled agent tools.
     Setup,
+    /// Generate an image from a text prompt using NanoBanana (Gemini image model).
+    Imagine {
+        /// Text description of the image to generate.
+        prompt: String,
+        /// Aspect ratio: 1:1, 16:9, 9:16, or 4:3 [default: 1:1]
+        #[arg(long, default_value = "1:1")]
+        aspect: String,
+        /// Number of images to generate (1–4) [default: 1]
+        #[arg(long, default_value_t = 1)]
+        count: u8,
+        /// Negative prompt — elements to avoid in the image
+        #[arg(long)]
+        negative: Option<String>,
+        /// Save the first generated image to this path
+        #[arg(long)]
+        output: Option<PathBuf>,
+    },
 }
 
 #[derive(Debug, Subcommand)]
@@ -926,6 +943,72 @@ async fn main() -> Result<()> {
                     launch_mint_target(target).await?;
                 }
             }
+            Command::Imagine {
+                prompt,
+                aspect,
+                count,
+                negative,
+                output,
+            } => {
+                let config = load_config()?;
+                let count = count.clamp(1, 4);
+                eprint!("{DIM}✦ Generating {count} image(s)...{RESET}");
+                let _ = std::io::stderr().flush();
+                let request = ImageGenRequest {
+                    prompt: prompt.clone(),
+                    negative_prompt: negative,
+                    aspect_ratio: Some(aspect),
+                    num_images: Some(count),
+                    model: None,
+                    provider: None,
+                };
+                match generate_images(&config, &request).await {
+                    Ok(result) => {
+                        eprintln!(
+                            "\r{MINT}✦ Generated {} image(s)         {RESET}",
+                            result.images.len()
+                        );
+                        let data_uris: Vec<String> = result
+                            .images
+                            .iter()
+                            .map(|img| img.data_uri.clone())
+                            .collect();
+                        match mint_core::save_chat_images(
+                            data_uris,
+                            Some(result.provider.clone()),
+                            Some(prompt.clone()),
+                        ) {
+                            Ok(saved) => {
+                                for entry in &saved {
+                                    println!("{MINT}✓{RESET} Saved: {}", entry.path.display());
+                                }
+                                // If --output specified, copy first image there
+                                if let (Some(out_path), Some(first)) = (&output, saved.first()) {
+                                    match std::fs::copy(&first.path, out_path) {
+                                        Ok(_) => println!(
+                                            "{MINT}✓{RESET} Copied to: {}",
+                                            out_path.display()
+                                        ),
+                                        Err(e) => eprintln!(
+                                            "{WARN}Warning: could not copy to output path: {e}{RESET}"
+                                        ),
+                                    }
+                                }
+                                if let Some(desc) = &result.description {
+                                    if !desc.is_empty() {
+                                        println!("\n{DIM}{desc}{RESET}");
+                                    }
+                                }
+                            }
+                            Err(e) => eprintln!("{ERROR}Failed to save images: {e}{RESET}"),
+                        }
+                    }
+                    Err(e) => {
+                        eprintln!("{ERROR}✗ Image generation failed: {e}{RESET}");
+                        anyhow::bail!("image generation failed: {e}");
+                    }
+                }
+            }
         },
     }
     Ok(())
@@ -1001,6 +1084,284 @@ async fn launch_mint_target(target: String) -> Result<()> {
     Ok(())
 }
 
+fn is_table_line(line: &str) -> bool {
+    let trimmed = line.trim();
+    trimmed.starts_with('|') && trimmed.ends_with('|') && trimmed.len() > 1
+}
+
+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
+}
+
+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)
+}
+
+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
+}
+
+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)
+}
+
+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_str("│");
+        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_str("│");
+        }
+        rendered.push('\n');
+        rendered.push_str(&draw_border("├", "┼", "┤", "─", &col_widths));
+    }
+
+    for (r_idx, row) in data_rows.iter().enumerate() {
+        rendered.push_str("│");
+        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_str("│");
+        }
+        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
+}
+
+struct CliStreamFormatter {
+    line_buffer: String,
+    table_buffer: Vec<String>,
+    in_code_block: bool,
+}
+
+impl CliStreamFormatter {
+    fn new() -> Self {
+        Self {
+            line_buffer: String::new(),
+            table_buffer: Vec::new(),
+            in_code_block: false,
+        }
+    }
+
+    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');
+            } 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');
+                }
+            }
+        }
+    }
+
+    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();
+    }
+}
+
 struct ActionStreamFilter {
     buffer: String,
     in_action: bool,
@@ -1210,10 +1571,15 @@ async fn handle_slash_command(
                 ("/paste [prompt]", "Attach image from clipboard"),
                 ("Ctrl+V", "Paste clipboard image as [Image #1]"),
                 ("/learn <path>", "Import a persistent .md or .txt skill"),
+                ("/plugins <name> [prompt]", "Generate a skill.md file for a plugin/skill"),
                 ("/memory list", "Show recent interactions"),
                 ("/memory clear", "Clear all interactions"),
                 ("/memory get <key>", "Read a profile value"),
                 ("/memory set <key> <val>", "Store a profile value"),
+                (
+                    "/image-provider [name]",
+                    "List image gen providers or switch default provider",
+                ),
                 ("/mcp list", "List configured MCP servers"),
                 ("/mcp allow <server> <tool>", "Allow an MCP tool"),
                 ("/stats", "Show session statistics"),
@@ -1270,6 +1636,55 @@ async fn handle_slash_command(
             Some(SlashResult::Handled)
         }
 
+        "/image-provider" => {
+            let mut available = Vec::new();
+            if !session.config.api_key.trim().is_empty() {
+                available.push("nanobanana");
+            }
+            if !session.config.openai_api_key.trim().is_empty() {
+                available.push("dalle");
+            }
+            if !session.config.stability_api_key.trim().is_empty() {
+                available.push("stability");
+            }
+            if !session.config.ideogram_api_key.trim().is_empty() {
+                available.push("ideogram");
+            }
+            if !session.config.replicate_api_key.trim().is_empty() {
+                available.push("replicate");
+            }
+            if available.is_empty() {
+                available.push("nanobanana");
+            }
+
+            if rest.is_empty() {
+                println!("\n{BLUE}Configured image generation providers:{RESET}");
+                for p in &available {
+                    let active = if p == &session.config.image_gen_provider.as_str() {
+                        format!(" {MINT}← active{RESET}")
+                    } else {
+                        String::new()
+                    };
+                    println!("  {p}{active}");
+                }
+                println!();
+            } else {
+                if available.contains(&rest) {
+                    session.config.image_gen_provider = rest.to_owned();
+                    match mint_core::save_config(&session.config) {
+                        Ok(()) => println!(
+                            "{DIM}Switched default image provider to: {}{RESET}\n",
+                            session.config.image_gen_provider
+                        ),
+                        Err(error) => println!("{ERROR}Config error:{RESET} {error}"),
+                    }
+                } else {
+                    println!("{ERROR}Provider '{rest}' is not configured or invalid.{RESET}\n");
+                }
+            }
+            Some(SlashResult::Handled)
+        }
+
         "/clear" | "/reset" => {
             println!("Clear conversation history? [y/N] ");
             if let Ok(true) = confirm("Clear conversation history? [y/N] ") {
@@ -1540,6 +1955,101 @@ async fn handle_slash_command(
 
         "/exit" | "/quit" => Some(SlashResult::Exit),
 
+        "/plugins" | "/plugin" => {
+            let (plugin_name, prompt) = rest
+                .split_once(char::is_whitespace)
+                .map(|(p, r)| (p, r.trim()))
+                .unwrap_or((rest, ""));
+
+            if plugin_name.is_empty() {
+                println!("\n{BLUE}────────────────────────────────────────────{RESET}");
+                println!("{MINT}  Available Plugins & Skills{RESET}");
+                println!("{BLUE}────────────────────────────────────────────{RESET}");
+                
+                println!("{MINT}Native Plugins:{RESET}");
+                for p in native_plugins() {
+                    println!("  - {BLUE}{:<20}{RESET} {}", p.name, p.description);
+                }
+                
+                println!("\n{MINT}Custom Skills/Plugins (Active):{RESET}");
+                let mut active_skills = std::collections::HashSet::new();
+                if let Ok(memory) = MemoryStore::open_default() {
+                    match memory.learned_skills(100) {
+                        Ok(skills) => {
+                            if skills.is_empty() {
+                                println!("  {DIM}(No custom skills/plugins learned yet. Use '/learn <path>' to add one.){RESET}");
+                            } else {
+                                for s in &skills {
+                                    println!("  - {BLUE}{:<20}{RESET} {}", s.name, s.source_path);
+                                    
+                                    // Try to store canonicalized active path
+                                    if let Ok(canon) = Path::new(&s.source_path).canonicalize() {
+                                        active_skills.insert(canon);
+                                    } else {
+                                        active_skills.insert(PathBuf::from(&s.source_path));
+                                    }
+                                }
+                            }
+                        }
+                        Err(e) => println!("  {ERROR}Error loading custom skills: {e}{RESET}"),
+                    }
+                }
+
+                // Scan local workspace skills directory
+                let local_skills_dir = session.current_dir.join("skills");
+                if local_skills_dir.is_dir() {
+                    if let Ok(entries) = fs::read_dir(&local_skills_dir) {
+                        let mut local_files = Vec::new();
+                        for entry in entries.flatten() {
+                            let path = entry.path();
+                            if path.is_file() {
+                                if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
+                                    if matches!(ext.to_ascii_lowercase().as_str(), "md" | "txt") {
+                                        if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
+                                            if let Ok(canon_path) = path.canonicalize() {
+                                                local_files.push((name.to_owned(), canon_path));
+                                            } else {
+                                                local_files.push((name.to_owned(), path));
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        
+                        let inactive_files: Vec<_> = local_files
+                            .into_iter()
+                            .filter(|(_, full_path)| !active_skills.contains(full_path))
+                            .map(|(name, _)| name)
+                            .collect();
+
+                        if !inactive_files.is_empty() {
+                            println!("\n{MINT}Local Skill Files (Found but not learned/active yet):{RESET}");
+                            for file in inactive_files {
+                                println!("  - {WARN}{:<20}{RESET} skills/{} {DIM}(Type '/learn skills/{}' to activate){RESET}", file, file, file);
+                            }
+                        }
+                    }
+                }
+
+                println!();
+                Some(SlashResult::Handled)
+            } else {
+                let agent_prompt = if prompt.is_empty() {
+                    format!(
+                        "Create a skill markdown file for the plugin '{}' at the path 'skills/{}.md' in the workspace. Write the appropriate instructions inside.",
+                        plugin_name, plugin_name
+                    )
+                } else {
+                    format!(
+                        "Create a skill markdown file for the plugin '{}' at the path 'skills/{}.md' in the workspace based on these instructions: {}",
+                        plugin_name, plugin_name, prompt
+                    )
+                };
+                Some(SlashResult::ForwardToAgent(agent_prompt))
+            }
+        }
+
         "/code" => {
             if rest.is_empty() {
                 println!("{WARN}/code requires a task description{RESET}\n");
@@ -1788,6 +2298,7 @@ async fn run_interactive_chat() -> Result<()> {
             let sent_image = image_uri.clone();
             let mut first_chunk = true;
             let mut filter = ActionStreamFilter::new();
+            let mut formatter = CliStreamFormatter::new();
 
             let stream_result = orchestrate_chat_stream_with_fallback(
                 &session.config,
@@ -1806,7 +2317,11 @@ async fn run_interactive_chat() -> Result<()> {
                         print!("\r\x1b[2K{MINT}Mint:{RESET} ");
                     }
                     filter.process_chunk(&chunk, |text| {
-                        print!("{}", text);
+                        for c in text.chars() {
+                            formatter.process_char(c, |formatted_c| {
+                                print!("{}", formatted_c);
+                            });
+                        }
                     });
                     let _ = io::stdout().flush();
                 },
@@ -1814,7 +2329,14 @@ async fn run_interactive_chat() -> Result<()> {
             .await;
 
             let actions = filter.finalize(|text| {
-                print!("{}", text);
+                for c in text.chars() {
+                    formatter.process_char(c, |formatted_c| {
+                        print!("{}", formatted_c);
+                    });
+                }
+            });
+            formatter.finalize(|formatted_c| {
+                print!("{}", formatted_c);
             });
             let _ = io::stdout().flush();
 
@@ -1884,11 +2406,16 @@ const AUTOCOMPLETE_COMMANDS: &[(&str, &str)] = &[
     ("/help", "Show help menu"),
     ("/fast", "Toggle fast mode (hide thinking traces)"),
     ("/models", "List AI providers or switch active provider"),
+    (
+        "/image-provider",
+        "List image gen providers or switch default provider",
+    ),
     ("/clear", "Clear conversation history"),
     ("/cd", "Change active workspace directory"),
     ("/image", "Attach image from disk"),
     ("/paste", "Attach image from clipboard"),
     ("/learn", "Import persistent skill/instruction"),
+    ("/plugins", "List or generate plugins/skills"),
     ("/memory", "Manage long-term memory store"),
     ("/mcp", "List configured MCP servers"),
     ("/stats", "Show session statistics"),
@@ -1963,9 +2490,9 @@ fn draw_input_box(
             let highlight_idx = tab_index.map(|idx| idx % matches.len());
             for (i, (cmd, desc)) in matches.iter().enumerate() {
                 if Some(i) == highlight_idx {
-                    println!("  {BLUE}▶ {:<12}{RESET} {DIM}- {}{RESET}", cmd, desc);
+                    println!("  {BLUE}▶ {:<16}{RESET} {DIM}- {}{RESET}", cmd, desc);
                 } else {
-                    println!("    {DIM}{:<12} - {}{RESET}", cmd, desc);
+                    println!("    {DIM}{:<16} - {}{RESET}", cmd, desc);
                 }
             }
         }