@pheem49/mint 1.14.0 → 1.16.0

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

@@ -21,6 +21,7 @@ mod plugins_cli;
 mod setup;
 mod skills;
 mod subagent_wizard;
+pub(crate) mod terminal_theme;
 mod updater;
 
 pub use commands::Command;
@@ -29,12 +30,13 @@ pub use interactive::{
     run_interactive_chat, run_interactive_chat_with_options,
 };
 
-pub const RESET: &str = "\x1b[0m";
-pub const MINT: &str = "\x1b[32m";
-pub const BLUE: &str = "\x1b[38;2;78;201;216m";
-pub const DIM: &str = "\x1b[90m";
-pub const ERROR: &str = "\x1b[31m";
-pub const WARN: &str = "\x1b[33m";
+pub const RESET: &str = terminal_theme::ANSI_RESET;
+pub const BOLD: &str = terminal_theme::ANSI_BOLD;
+pub const MINT: &str = terminal_theme::ANSI_ACCENT;
+pub const BLUE: &str = terminal_theme::ANSI_BLUE;
+pub const DIM: &str = terminal_theme::ANSI_MUTED;
+pub const ERROR: &str = terminal_theme::ANSI_ERROR;
+pub const WARN: &str = terminal_theme::ANSI_WARNING;
 
 pub(crate) async fn run_code_agent_with_saved_image(
     task: &str,
@@ -44,18 +46,28 @@ pub(crate) async fn run_code_agent_with_saved_image(
     video_data_uri: Option<String>,
     options: agent::AgentOptions,
 ) -> Result<(Vec<String>, Option<String>)> {
-    let sent_image = image_data_uri.clone();
-    let sent_video = video_data_uri.clone();
     // Follow-up messages the user typed into the queueing box while this
     // turn was still running (see `agent::run_code_agent_with_options`)
     // land here; the caller is responsible for dispatching them. On error
     // the queue is dropped along with the interrupted turn.
     let queue = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
-    // The box's leftover, not-yet-submitted text (typed but no Enter yet) at
-    // the moment the turn ended — same idea as `queue` above, but for the one
-    // partial entry that was never confirmed, so the caller can hand it back
-    // as the next prompt's starting text instead of dropping it silently.
     let draft = std::sync::Arc::new(std::sync::Mutex::new(None));
+    let target_chat_id = options
+        .chat_id
+        .clone()
+        .unwrap_or_else(|| mint_core::CHAT_CLI_ID.to_string());
+    if mint_core::is_cli_chat_id(&target_chat_id)
+        && let Ok(memory) = mint_core::MemoryStore::open_default()
+    {
+        let branch = mint_core::git::get_current_branch(current_dir);
+        let lang = mint_core::git::detect_project_language(current_dir);
+        let _ = memory.register_cli_session(
+            &target_chat_id,
+            Some(&current_dir.to_string_lossy()),
+            branch.as_deref(),
+            lang.as_deref(),
+        );
+    }
     let result = agent::run_code_agent_with_options(
         task,
         current_dir,
@@ -68,25 +80,18 @@ pub(crate) async fn run_code_agent_with_saved_image(
     )
     .await;
     result?;
-    // This turn just committed a row to the workspace-scoped "cli" chat_id
-    // (see `scoped_chat_id`) — raise live_sync's watermark past it so the
-    // next poll tick doesn't mistake the user's own just-sent message for
-    // one that arrived from another surface (web/desktop).
+    // This turn just committed a row to the session's chat_id
+    // — raise live_sync's watermark past it so the next poll tick doesn't mistake
+    // the user's own just-sent message for one that arrived from another surface.
     if let Ok(memory) = mint_core::MemoryStore::open_default()
         && let Ok(rows) = memory.recent_interactions_for_chat(
-            &mint_core::scoped_chat_id(
-                mint_core::CHAT_CLI_ID,
-                Some(&current_dir.to_string_lossy()),
-            ),
+            &mint_core::scoped_chat_id(&target_chat_id, Some(&current_dir.to_string_lossy())),
             1,
         )
         && let Some(row) = rows.first()
     {
         mint_core::live_sync::note_own_interaction(row.id);
     }
-    // Save any attached images and videos that were sent with the task
-    image::save_sent_image_after_send(sent_image.as_deref(), task);
-    image::save_sent_image_after_send(sent_video.as_deref(), task);
     let queued = queue
         .lock()
         .map(|mut q| std::mem::take(&mut *q))
@@ -160,6 +165,11 @@ pub(crate) async fn run_oneshot_agent_task(
         plan_mode,
         queueing: false,
         pinned_mcp_server,
+        chat_id: None,
+        image_name: image_path
+            .and_then(|path| path.file_name())
+            .map(|name| name.to_string_lossy().into_owned()),
+        tui: None,
     };
 
     let queue = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
@@ -199,7 +209,6 @@ pub(crate) async fn run_oneshot_agent_task(
         mint_core::live_sync::note_own_interaction(row.id);
     }
 
-    image::save_sent_image_after_send(image_data_uri.as_deref(), task);
     Ok(())
 }
 
@@ -250,10 +259,22 @@ pub struct Cli {
     #[arg(long, global = true)]
     pub plan: bool,
 
+    /// Explicitly use the full-screen interactive chat interface
+    #[arg(long, global = true, conflicts_with = "classic")]
+    pub tui: bool,
+
+    /// Use the classic scrolling interactive interface
+    #[arg(long, global = true, conflicts_with = "tui")]
+    pub classic: bool,
+
     /// Attach an image file to the prompt
     #[arg(long, global = true)]
     pub image: Option<PathBuf>,
 
+    /// Resume a previous conversation session, or open the interactive session picker
+    #[arg(short = 'r', long, global = true)]
+    pub resume: Option<Option<String>>,
+
     #[command(subcommand)]
     pub command: Option<Command>,
 
@@ -266,7 +287,7 @@ pub struct Cli {
 fn install_panic_hook() {
     let default_hook = std::panic::take_hook();
     std::panic::set_hook(Box::new(move |info| {
-        let _ = crossterm::terminal::disable_raw_mode();
+        interactive::restore_terminal();
         log_panic_to_file(&info.to_string());
         default_hook(info);
     }));
@@ -298,6 +319,10 @@ fn log_panic_to_file(message: &str) {
 
 #[tokio::main]
 async fn main() -> Result<()> {
+    if std::env::args().nth(1).as_deref() == Some("--mint-mod-host") {
+        return mint_mod_runtime::worker_main().map_err(anyhow::Error::msg);
+    }
+    let _background_shutdown = mint_core::bg_shell::ShutdownGuard;
     install_panic_hook();
     let mut cli = Cli::parse();
 
@@ -306,6 +331,7 @@ async fn main() -> Result<()> {
     }
 
     let mut config = load_config()?;
+    mint_core::companion::start();
     if let Some(ref m) = cli.model {
         apply_temporary_model_override(&mut config, m);
     }
@@ -327,7 +353,22 @@ async fn main() -> Result<()> {
             } else {
                 mint_core::channels::start_channels();
                 mint_core::start_cron_scheduler();
-                run_interactive_chat_with_options(cli.model, cli.fast, cli.plan).await?;
+                let resume_id = if let Some(ref r_opt) = cli.resume {
+                    match r_opt {
+                        Some(id) => Some(id.clone()),
+                        None => Some("__prompt__".to_string()),
+                    }
+                } else {
+                    None
+                };
+                interactive::run_interactive_chat_with_session(
+                    cli.model,
+                    cli.fast,
+                    cli.plan,
+                    resume_id,
+                    !cli.classic,
+                )
+                .await?;
             }
         }
         Some(cmd) => {
@@ -339,6 +380,7 @@ async fn main() -> Result<()> {
     // its shutdown signal) funnels back here on a clean exit. `SESSIONS` is a
     // `static`, so `McpSession::Drop` won't run at process teardown — do it
     // explicitly so we don't leave orphaned MCP server processes behind.
+    mint_core::companion::shutdown();
     mint_core::close_all_mcp_sessions();
     Ok(())
 }
@@ -361,6 +403,27 @@ mod cli_tests {
         assert_eq!(cli.prompt, vec!["explain this function"]);
     }
 
+    #[test]
+    fn parse_tui_flag() {
+        let cli = Cli::try_parse_from(["mint", "--tui"]).unwrap();
+        assert!(cli.tui);
+        assert!(!cli.classic);
+        assert!(cli.command.is_none());
+        assert!(cli.prompt.is_empty());
+    }
+
+    #[test]
+    fn parse_classic_flag() {
+        let cli = Cli::try_parse_from(["mint", "--classic"]).unwrap();
+        assert!(cli.classic);
+        assert!(!cli.tui);
+    }
+
+    #[test]
+    fn tui_and_classic_conflict() {
+        assert!(Cli::try_parse_from(["mint", "--tui", "--classic"]).is_err());
+    }
+
     #[test]
     fn parse_oneshot_unquoted_prompt_words() {
         let cli = Cli::try_parse_from(["mint", "fix", "all", "tests"]).unwrap();
@@ -469,3 +532,7 @@ mod cli_tests {
         }
     }
 }
+
+mod mods_cli;
+
+mod mods_ui;

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

@@ -146,6 +146,11 @@ pub(crate) fn hard_wrap(text: &str, max_width: usize) -> Vec<String> {
 }
 
 pub fn render_markdown_table(table_lines: &[String]) -> String {
+    let (term_width, _) = terminal_size_or_default();
+    render_markdown_table_with_width(table_lines, term_width)
+}
+
+fn render_markdown_table_with_width(table_lines: &[String], term_width: u16) -> String {
     let mut rows: Vec<Vec<String>> = Vec::new();
     for line in table_lines {
         let trimmed = line.trim();
@@ -229,7 +234,6 @@ pub fn render_markdown_table(table_lines: &[String]) -> String {
     // that no longer fits gets word-wrapped below rather than left to overflow
     // and break the border characters (see `wrap_cell_text`).
     if num_cols > 0 {
-        let (term_width, _) = terminal_size_or_default();
         // Each column contributes `width + 2` (one space of padding either
         // side) plus one border character; there's one extra border character
         // closing the row.
@@ -310,7 +314,10 @@ pub fn render_markdown_table(table_lines: &[String]) -> String {
         rendered.push_str(&render_wrapped_row(
             header,
             &col_widths,
-            Some(("\x1b[1;36m", "\x1b[0m")),
+            Some((
+                crate::terminal_theme::ANSI_BLUE_BOLD,
+                crate::terminal_theme::ANSI_RESET,
+            )),
         ));
         rendered.push_str(&draw_border("├", "┼", "┤", "─", &col_widths));
     }
@@ -368,10 +375,10 @@ mod table_tests {
             "| --- | --- |",
             &format!("| x | {long_cell} |"),
         ]);
-        let rendered = render_markdown_table(&table);
+        let rendered = render_markdown_table_with_width(&table, 80);
         assert_borders_aligned(&rendered);
-        // Falls back to 80 columns when no real terminal is attached (test
-        // harness has no TTY), so every physical line must fit within that.
+        // The test pins the renderer to 80 columns so its result does not
+        // depend on whether the test process inherited a real TTY.
         for line in rendered.lines() {
             assert!(
                 unicode_width(line) <= 80,

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

@@ -61,6 +61,11 @@ pub fn edit(
     Ok(update_mcp_server(name, command, args, env, icon)?)
 }
 
+pub fn set_timeout(name: &str, value: &str) -> Result<bool> {
+    let seconds = mint_core::mcp::parse_mcp_timeout(value)?;
+    Ok(mint_core::mcp::set_mcp_timeout(name, seconds)?)
+}
+
 pub fn registry() -> &'static [McpRegistryEntry] {
     mcp_registry()
 }

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

@@ -0,0 +1,6 @@
+fn main() {
+    if let Err(error) = mint_mod_runtime::worker_main() {
+        eprintln!("{error}");
+        std::process::exit(1);
+    }
+}

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

@@ -0,0 +1,62 @@
+use anyhow::{Result, bail};
+
+pub(crate) async fn run(chat: &str, args: &[String]) -> Result<()> {
+    let root = std::env::current_dir()?;
+    let action = args.first().map(String::as_str).unwrap_or("list");
+    let id = args.get(1).map(String::as_str).unwrap_or("");
+    match action {
+        "test" => {
+            let report = mint_core::mods::test_mod(&root, id).map_err(anyhow::Error::msg)?;
+            println!("{}", serde_json::to_string_pretty(&report)?);
+            if report["failed"].as_u64().unwrap_or(0) > 0 {
+                bail!("Mod tests failed");
+            }
+        }
+        "hot-reload" => bail!("Use /mods hot-reload on|off inside an interactive Mint session"),
+        "run-tools" => {
+            let chat = mint_core::scoped_chat_id(chat, Some(&root.to_string_lossy()));
+            let requests =
+                mint_core::mods::pending_requests(&root, &chat).map_err(anyhow::Error::msg)?;
+            for request in requests {
+                println!(
+                    "{} requests {}\n{}\nRun this request? [y/N]",
+                    request["modId"],
+                    request["action"],
+                    serde_json::to_string_pretty(&request["input"])?
+                );
+                let mut answer = String::new();
+                std::io::stdin().read_line(&mut answer)?;
+                if !answer.trim().eq_ignore_ascii_case("y") {
+                    continue;
+                }
+                let op = serde_json::from_value(
+                    serde_json::json!({"workspacePath":root,"chatId":chat,"action":"run_request","command":request["id"],"grantPermissions":true}),
+                )?;
+                mint_core::mods::operate_async(op)
+                    .await
+                    .map_err(anyhow::Error::msg)?;
+            }
+        }
+        _ => {
+            if action == "enable" && id.is_empty() {
+                bail!("Usage: mint mods enable <id> [chat|workspace|global] [--grant-permissions]");
+            }
+            println!(
+                "{}",
+                mint_core::mods::slash(
+                    &root,
+                    chat,
+                    &format!(
+                        "/mods {}",
+                        args.iter()
+                            .map(|arg| format!("'{}'", arg.replace('\'', "'\"'\"'")))
+                            .collect::<Vec<_>>()
+                            .join(" ")
+                    )
+                )
+                .map_err(anyhow::Error::msg)?
+            );
+        }
+    }
+    Ok(())
+}

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

@@ -0,0 +1,187 @@
+use ratatui::{
+    style::{Color, Style},
+    text::{Line, Span},
+};
+use serde_json::Value;
+#[derive(Clone)]
+pub(crate) struct Control {
+    pub id: String,
+    pub instance: String,
+    pub action: String,
+    pub label: String,
+    pub input: bool,
+    pub value: String,
+}
+fn clean(text: &str) -> String {
+    text.chars()
+        .filter(|c| !c.is_control() || *c == '\n')
+        .take(4096)
+        .collect()
+}
+pub(crate) fn node_lines(node: &Value) -> Vec<String> {
+    match node["type"].as_str().unwrap_or("") {
+        "text" | "badge" => clean(node["text"].as_str().unwrap_or(""))
+            .lines()
+            .map(str::to_owned)
+            .collect(),
+        "stack" => node["children"]
+            .as_array()
+            .into_iter()
+            .flatten()
+            .flat_map(node_lines)
+            .collect(),
+        "button" => vec![format!(
+            "[ {} ]",
+            clean(node["label"].as_str().unwrap_or(""))
+        )],
+        "input" => vec![format!(
+            "{}: {}",
+            clean(node["label"].as_str().unwrap_or("")),
+            node["value"].as_str().unwrap_or("")
+        )],
+        "progress" => vec![format!(
+            "{}: {:.0}/{:.0}",
+            clean(node["label"].as_str().unwrap_or("")),
+            node["value"].as_f64().unwrap_or(0.0),
+            node["max"].as_f64().unwrap_or(1.0)
+        )],
+        "table" => {
+            let mut lines = vec![
+                node["columns"]
+                    .as_array()
+                    .map(|c| {
+                        c.iter()
+                            .map(|s| clean(s.as_str().unwrap_or("")))
+                            .collect::<Vec<_>>()
+                            .join(" | ")
+                    })
+                    .unwrap_or_default(),
+            ];
+            for row in node["rows"].as_array().into_iter().flatten() {
+                lines.push(
+                    row.as_array()
+                        .map(|r| {
+                            r.iter()
+                                .map(|v| {
+                                    clean(
+                                        &v.as_str()
+                                            .map(str::to_owned)
+                                            .unwrap_or_else(|| v.to_string()),
+                                    )
+                                })
+                                .collect::<Vec<_>>()
+                                .join(" | ")
+                        })
+                        .unwrap_or_default(),
+                );
+            }
+            lines
+        }
+        _ => vec![],
+    }
+}
+fn styled_lines(node: &Value, inherited: Style) -> Vec<Line<'static>> {
+    let color = match node["color"].as_str() {
+        Some("yellow") => Some(Color::Yellow),
+        Some("cyan") => Some(Color::Cyan),
+        Some("blue") => Some(Color::Blue),
+        Some("magenta") => Some(Color::Magenta),
+        Some("red") => Some(Color::Red),
+        Some("default") => Some(Color::Reset),
+        _ => None,
+    };
+    let style = color.map(|c| inherited.fg(c)).unwrap_or(inherited);
+    if node["type"] == "stack" {
+        let children = node["children"].as_array().into_iter().flatten();
+        if node["direction"] == "row" {
+            let mut spans = vec![];
+            for child in children {
+                let lines = styled_lines(child, style);
+                for line in lines {
+                    if !spans.is_empty() {
+                        spans.push(Span::raw(" "));
+                    }
+                    spans.extend(line.spans);
+                }
+            }
+            vec![Line::from(spans)]
+        } else {
+            children
+                .flat_map(|child| styled_lines(child, style))
+                .collect()
+        }
+    } else {
+        node_lines(node)
+            .into_iter()
+            .map(|text| Line::from(Span::styled(text, style)))
+            .collect()
+    }
+}
+pub(crate) fn controls(mods: &[Value]) -> Vec<Control> {
+    fn walk(node: &Value, m: &Value, result: &mut Vec<Control>) {
+        if matches!(node["type"].as_str(), Some("button" | "input")) {
+            result.push(Control {
+                id: m["id"].as_str().unwrap_or("").into(),
+                instance: m["instanceId"].as_str().unwrap_or("").into(),
+                action: node["action"].as_str().unwrap_or("").into(),
+                label: clean(node["label"].as_str().unwrap_or("")),
+                input: node["type"] == "input",
+                value: node["value"].as_str().unwrap_or("").into(),
+            });
+        }
+        for child in node["children"].as_array().into_iter().flatten() {
+            walk(child, m, result);
+        }
+    }
+    let mut result = vec![];
+    for m in mods {
+        if m["enabled"] == true {
+            walk(&m["snapshot"]["ui"]["above_composer"], m, &mut result);
+            walk(&m["snapshot"]["ui"]["side_panel"], m, &mut result);
+        }
+    }
+    result
+}
+pub(crate) fn slot_lines(mods: &[Value], slot: &str) -> Vec<Line<'static>> {
+    let mut lines = vec![];
+    for m in mods {
+        if m["enabled"] != true {
+            continue;
+        }
+        if slot == "side_panel" {
+            lines.push(Line::raw(clean(m["name"].as_str().unwrap_or("Mod"))));
+        }
+        lines.extend(styled_lines(&m["snapshot"]["ui"][slot], Style::default()));
+        if let Some(error) = m["error"].as_str() {
+            lines.push(Line::raw(format!("Error: {}", clean(error))));
+        }
+        if let Some(error) = m["reloadError"].as_str() {
+            lines.push(Line::raw(format!("Reload: {}", clean(error))));
+        }
+    }
+    lines
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn keyboard_controls_include_actions_from_both_ui_slots() {
+        let mods = vec![
+            json!({"id":"example","enabled":true,"instanceId":"revision",
+            "snapshot":{"ui":{
+                "above_composer":{"type":"button","label":"Inspect","action":"inspect"},
+                "side_panel":{"type":"input","label":"Draft","action":"save","value":"existing"}
+            }}}),
+        ];
+        let available = controls(&mods);
+        assert_eq!(available.len(), 2);
+        assert!(
+            available
+                .iter()
+                .any(|c| c.action == "inspect" && c.instance == "revision")
+        );
+    }
+}