@pheem49/mint 1.15.0 → 1.16.0

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

@@ -62,6 +62,7 @@ pub struct AgentOptions {
     pub pinned_mcp_server: Option<String>,
     /// Chat ID / session ID for this turn. Defaults to `CHAT_CLI_ID` if omitted.
     pub chat_id: Option<String>,
+    pub image_name: Option<String>,
     /// Full-screen UI event sink. When present, agent output never writes
     /// directly to stdout and stdin remains owned by the TUI controller.
     pub tui: Option<crate::interactive::TuiHandle>,
@@ -387,6 +388,10 @@ fn tui_approval(
         _ => ApprovalOutcome::Denied,
     };
     Ok(match approval {
+        AgentApproval::SkillWrite { path, diff, .. } => yes_no(
+            "Save skill?",
+            format!("Changes instructions used in future tasks.\nPath: {path}\n\n{diff}"),
+        ),
         AgentApproval::WriteFile { path, diff, .. } => tui_persistable_approval(
             tui,
             "write_file",
@@ -515,6 +520,141 @@ fn tui_approval(
     })
 }
 
+pub(crate) fn mcp_progress_notes(event: &AgentProgress) -> Option<Vec<String>> {
+    Some(match event {
+        AgentProgress::ToolDiscovery {
+            server,
+            tool,
+            message,
+        } => vec![format!("[MCP discovery {server}/{tool}] {message}")],
+        AgentProgress::DeviceState {
+            server,
+            tool,
+            update,
+            ..
+        } => vec![format!(
+            "[Device {server}/{tool}] {:?}: {} (target {}, actual {})",
+            update.state, update.message, update.target, update.actual
+        )],
+        AgentProgress::ToolProgress {
+            server,
+            tool,
+            update,
+            ..
+        } => {
+            let detail = update
+                .total
+                .map(|total| format!("{:.0}%", update.progress / total * 100.0))
+                .unwrap_or_else(|| format!("{}s", update.elapsed_secs));
+            vec![format!(
+                "[MCP {server}/{tool}] {detail} {}",
+                update.message.as_deref().unwrap_or_default()
+            )]
+        }
+        AgentProgress::ToolArtifacts {
+            artifacts,
+            warnings,
+            ..
+        } => {
+            let mut notes = artifacts
+                .iter()
+                .map(|artifact| {
+                    let location = artifact.uri.clone().unwrap_or_else(|| {
+                        mint_core::integrations::mcp_result::artifact_directory()
+                            .unwrap_or_default()
+                            .join(&artifact.id)
+                            .display()
+                            .to_string()
+                    });
+                    format!("[MCP {}] {}: {location}", artifact.kind, artifact.name)
+                })
+                .collect::<Vec<_>>();
+            notes.extend(
+                warnings
+                    .iter()
+                    .map(|warning| format!("[MCP warning] {warning}")),
+            );
+            notes
+        }
+        _ => return None,
+    })
+}
+
+pub(crate) fn publish_mcp_progress(
+    tui: Option<&crate::interactive::TuiHandle>,
+    event: &AgentProgress,
+) -> bool {
+    let Some(notes) = mcp_progress_notes(event) else {
+        return false;
+    };
+    for note in notes {
+        if let Some(tui) = tui {
+            tui.push_notice(note);
+        } else {
+            println!("{note}");
+        }
+    }
+    true
+}
+
+pub(crate) fn run_summary_lines(
+    summary: &mint_core::orchestration::RunTelemetrySummary,
+) -> Vec<String> {
+    let failed_tools: Vec<_> = summary
+        .tool_timeline
+        .iter()
+        .filter(|record| !record.success)
+        .collect();
+    let outcome = if !failed_tools.is_empty() {
+        format!(
+            "{YELLOW}⚠ Completed with {} failure{}{RESET}",
+            failed_tools.len(),
+            if failed_tools.len() == 1 { "" } else { "s" }
+        )
+    } else if summary.outcome == "ROLLED_BACK" {
+        format!("{YELLOW}↺ Rolled back{RESET}")
+    } else if summary.outcome == "FAILED" {
+        format!("{RED}✗ Failed{RESET}")
+    } else {
+        format!("{GREEN}✓ Completed{RESET}")
+    };
+    let file_count = summary.files_changed.len();
+    let mut lines = vec![format!(
+        "  {outcome} {DIM}in {:.1}s · {} tool{} · {} file{} changed{RESET}",
+        summary.duration_secs,
+        summary.tool_calls_count,
+        if summary.tool_calls_count == 1 {
+            ""
+        } else {
+            "s"
+        },
+        file_count,
+        if file_count == 1 { "" } else { "s" },
+    )];
+
+    if file_count > 0 {
+        let mut names: Vec<String> = summary
+            .files_changed
+            .iter()
+            .take(6)
+            .map(|path| display_tool_target(path))
+            .collect();
+        if file_count > names.len() {
+            names.push(format!("+{} more", file_count - names.len()));
+        }
+        lines.push(format!("    {DIM}└ {}{RESET}", names.join(", ")));
+    }
+    for record in failed_tools.into_iter().take(3) {
+        let target = if record.target.is_empty() {
+            record.action.clone()
+        } else {
+            format!("{} [{}]", record.action, truncate_line(&record.target, 72))
+        };
+        lines.push(format!("    {RED}└ {target} failed{RESET}"));
+    }
+    lines
+}
+
 pub async fn run_code_agent_with_options(
     task: &str,
     root: &Path,
@@ -525,8 +665,26 @@ pub async fn run_code_agent_with_options(
     queued_out: Arc<Mutex<Vec<String>>>,
     draft_out: Arc<Mutex<Option<String>>>,
 ) -> Result<AgentResult> {
+    let target_chat_id = options.chat_id.as_deref().unwrap_or(CHAT_CLI_ID);
+    let receipt = crate::image::prepare_attachments(
+        config,
+        target_chat_id,
+        task,
+        image_data_uri.as_deref(),
+        video_data_uri.as_deref(),
+        options.image_name.as_deref(),
+    )
+    .await?;
+    if receipt.is_some()
+        && let Some(tui) = &options.tui
+    {
+        tui.set_notice("Attachments saved to Library");
+    }
     let started_at = Instant::now();
     crate::interactive::clear_last_thought();
+    if let Some(tui) = &options.tui {
+        tui.reset_thoughts();
+    }
     let thinking_verb = random_thinking_verb();
     let approval_active = Arc::new(AtomicBool::new(false));
     let agent_done = Arc::new(AtomicBool::new(false));
@@ -590,6 +748,21 @@ pub async fn run_code_agent_with_options(
         let _guard = ApprovalGuard(Arc::clone(&approve_approval_active));
 
         match approval {
+            AgentApproval::SkillWrite { path, diff, .. } => {
+                let (additions, deletions) = diff_stats(diff);
+                print_diff_header("Save skill", path, additions, deletions);
+                print_colored_diff(diff);
+                Ok(
+                    if confirm_pausing_interrupt(
+                        "Save these instructions for future tasks?",
+                        &approve_approval_active,
+                    ) {
+                        ApprovalOutcome::Approved
+                    } else {
+                        ApprovalOutcome::Denied
+                    },
+                )
+            }
             AgentApproval::WriteFile { path, diff, .. } => confirm_with_persistence(
                 "write_file",
                 path,
@@ -798,18 +971,18 @@ pub async fn run_code_agent_with_options(
                         break;
                     }
                     if timer_tool_running.load(Ordering::Relaxed) == 0 {
-                        status.thinking = Some(
-                            if let Some((attempt, max_attempts)) = status.waiting_for_network {
-                                waiting_for_network_label(attempt, max_attempts)
-                            } else {
-                                let context_suffix = context_pct_suffix(status.context_pct);
-                                let tokens_suffix = live_tokens_suffix(&status);
-                                format!(
-                                    "{thinking_verb} ({}{tokens_suffix}{context_suffix} • Esc to interrupt)",
-                                    format_elapsed(timer_started_at.elapsed())
-                                )
-                            },
-                        );
+                        status.thinking = Some(if let Some(started) = status.compaction_started {
+                            compaction_label(started.elapsed())
+                        } else if let Some((attempt, max_attempts)) = status.waiting_for_network {
+                            waiting_for_network_label(attempt, max_attempts)
+                        } else {
+                            let context_suffix = context_pct_suffix(status.context_pct);
+                            let tokens_suffix = live_tokens_suffix(&status);
+                            format!(
+                                "{thinking_verb} ({}{tokens_suffix}{context_suffix} • Esc to interrupt)",
+                                format_elapsed(timer_started_at.elapsed())
+                            )
+                        });
                     }
                     render_live_status(&mut status);
                 }
@@ -831,7 +1004,15 @@ pub async fn run_code_agent_with_options(
         mint_core::avatar_bridge::AvatarBridgeConfig::from_mint_config(config),
     );
     let progress_cb = |progress: AgentProgress| {
+        if !options.fast_mode
+            && let Some(tui) = &options.tui
+        {
+            tui.tool_progress(&progress);
+        }
         avatar_bridge.on_agent_progress(&progress);
+        if publish_mcp_progress(options.tui.as_ref(), &progress) {
+            return;
+        }
         match progress {
             AgentProgress::Thinking {
                 elapsed_secs,
@@ -888,6 +1069,37 @@ pub async fn run_code_agent_with_options(
                     render_live_status(&mut status);
                 }
             }
+            AgentProgress::ContextCompaction {
+                subagent,
+                status: phase,
+                message,
+            } => {
+                if !options.fast_mode
+                    && let Ok(mut status) = progress_live_status.lock()
+                {
+                    update_context_compaction(
+                        &mut status,
+                        &phase,
+                        subagent.as_deref(),
+                        Instant::now(),
+                    );
+                    if phase == "started" {
+                        status.thinking = Some(compaction_label(Duration::ZERO));
+                    } else {
+                        print_timeline_note(&mut status, &message, started_at.elapsed(), None);
+                        status.context_pct = None;
+                        status.thinking = Some(if let Some(started) = status.compaction_started {
+                            compaction_label(started.elapsed())
+                        } else {
+                            format!(
+                                "{thinking_verb} ({} • Esc to interrupt)",
+                                format_elapsed(started_at.elapsed())
+                            )
+                        });
+                    }
+                    render_live_status(&mut status);
+                }
+            }
             AgentProgress::WaitingForNetwork {
                 attempt,
                 max_attempts,
@@ -927,6 +1139,9 @@ pub async fn run_code_agent_with_options(
                     let elapsed = Duration::from_millis(elapsed_ms);
                     let elapsed_str = crate::interactive::format_thought_elapsed(elapsed);
                     crate::interactive::append_thought_delta(&id, &delta, &elapsed_str);
+                    if let Some(tui) = &options.tui {
+                        tui.append_thought_delta(&id, &delta, elapsed);
+                    }
                 }
             }
             AgentProgress::ExtendedThinking {
@@ -945,11 +1160,7 @@ pub async fn run_code_agent_with_options(
                     let elapsed = elapsed_ms
                         .map(Duration::from_millis)
                         .unwrap_or_else(|| started_at.elapsed());
-                    // Extended thinking gets the same timeline-note treatment
-                    // as regular Thought — `print_timeline_note` already
-                    // distinguishes internal CoT (long) from short notes via
-                    // `is_internal_cot` and renders accordingly.
-                    print_timeline_note(&mut status, &thought, elapsed, id.as_deref());
+                    print_extended_thinking(&mut status, &thought, elapsed, id.as_deref());
                     status.thinking = None;
                     status.waiting_for_network = None;
                     render_live_status(&mut status);
@@ -959,6 +1170,7 @@ pub async fn run_code_agent_with_options(
                 action,
                 input,
                 subagent,
+                ..
             } => {
                 progress_tool_running.fetch_add(1, Ordering::Relaxed);
                 if !options.fast_mode
@@ -1001,13 +1213,26 @@ pub async fn run_code_agent_with_options(
                         return;
                     }
                     if action == "read_file"
-                        && let Some(path) = input.get("path").and_then(|v| v.as_str())
-                        && skill_name_for_read_path(path).is_some()
+                        && let Some(skill_name) = input
+                            .get("skill_name")
+                            .and_then(|v| v.as_str())
+                            .map(str::to_owned)
+                            .or_else(|| {
+                                input
+                                    .get("path")
+                                    .and_then(|v| v.as_str())
+                                    .and_then(skill_name_for_read_path)
+                            })
                     {
-                        // The agent chose to read a skill file on its own initiative
-                        // (as opposed to the human typing `$skillname`). Skip the
-                        // generic explored-files grouping — ToolEnd below renders a
-                        // dedicated Skill(...) card for this instead.
+                        if let Ok(mut status) = progress_live_status.lock() {
+                            status.thinking = None;
+                            status.waiting_for_network = None;
+                            status.tasks.push(TaskEntry {
+                                label: format!("Reading skill: {skill_name}"),
+                                output: Vec::new(),
+                            });
+                            render_live_status(&mut status);
+                        }
                         return;
                     }
                     if let Some(label) = explored_action_label(&action, &input) {
@@ -1039,6 +1264,7 @@ pub async fn run_code_agent_with_options(
                 input,
                 result,
                 subagent,
+                ..
             } => {
                 let remaining = progress_tool_running
                     .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |running| {
@@ -1112,13 +1338,29 @@ pub async fn run_code_agent_with_options(
                         }
                         render_live_status(&mut status);
                     } else if action == "read_file"
-                        && let Some(path) = input.get("path").and_then(|v| v.as_str())
-                        && let Some(skill_name) = skill_name_for_read_path(path)
+                        && let Some(skill_name) = input
+                            .get("skill_name")
+                            .and_then(|v| v.as_str())
+                            .map(str::to_owned)
+                            .or_else(|| {
+                                input
+                                    .get("path")
+                                    .and_then(|v| v.as_str())
+                                    .and_then(skill_name_for_read_path)
+                            })
                         && let Ok(mut status) = progress_live_status.lock()
                     {
                         status.thinking = None;
                         status.waiting_for_network = None;
-                        status.tasks.push(skill_card(&skill_name));
+                        if let Some(task) = status
+                            .tasks
+                            .iter_mut()
+                            .rev()
+                            .find(|task| task.label == format!("Reading skill: {skill_name}"))
+                        {
+                            task.label = skill_read_label(&skill_name, &result);
+                            task.output = command_output_preview(&result);
+                        }
                         render_live_status(&mut status);
                     } else if action == "memory_recall" {
                         let skill_names = skill_names_from_memory_recall(&result);
@@ -1128,7 +1370,10 @@ pub async fn run_code_agent_with_options(
                             status.thinking = None;
                             status.waiting_for_network = None;
                             for name in skill_names {
-                                status.tasks.push(skill_card(&name));
+                                status.tasks.push(TaskEntry {
+                                    label: format!("Found skill: {name}"),
+                                    output: Vec::new(),
+                                });
                             }
                             render_live_status(&mut status);
                         }
@@ -1144,6 +1389,10 @@ pub async fn run_code_agent_with_options(
                     status.web_sources.extend(sources);
                 }
             }
+            AgentProgress::ToolDiscovery { .. }
+            | AgentProgress::DeviceState { .. }
+            | AgentProgress::ToolProgress { .. }
+            | AgentProgress::ToolArtifacts { .. } => {}
             AgentProgress::PlanUpdated { plan } => {
                 if let Ok(mut status) = progress_live_status.lock() {
                     status.thinking = None;
@@ -1178,58 +1427,7 @@ pub async fn run_code_agent_with_options(
                     status.waiting_for_network = None;
                     commit_activity_snapshot(&mut status);
 
-                    let failed_tools: Vec<_> = summary
-                        .tool_timeline
-                        .iter()
-                        .filter(|record| !record.success)
-                        .collect();
-                    let outcome = if !failed_tools.is_empty() {
-                        format!(
-                            "{YELLOW}⚠ Completed with {} failure{}{RESET}",
-                            failed_tools.len(),
-                            if failed_tools.len() == 1 { "" } else { "s" }
-                        )
-                    } else if summary.outcome == "ROLLED_BACK" {
-                        format!("{YELLOW}↺ Rolled back{RESET}")
-                    } else if summary.outcome == "FAILED" {
-                        format!("{RED}✗ Failed{RESET}")
-                    } else {
-                        format!("{GREEN}✓ Completed{RESET}")
-                    };
-                    let file_count = summary.files_changed.len();
-                    let mut lines = vec![format!(
-                        "  {outcome} {DIM}in {:.1}s · {} tool{} · {} file{} changed{RESET}",
-                        summary.duration_secs,
-                        summary.tool_calls_count,
-                        if summary.tool_calls_count == 1 {
-                            ""
-                        } else {
-                            "s"
-                        },
-                        file_count,
-                        if file_count == 1 { "" } else { "s" },
-                    )];
-
-                    if file_count > 0 {
-                        let mut names: Vec<String> = summary
-                            .files_changed
-                            .iter()
-                            .take(6)
-                            .map(|path| display_tool_target(path))
-                            .collect();
-                        if file_count > names.len() {
-                            names.push(format!("+{} more", file_count - names.len()));
-                        }
-                        lines.push(format!("    {DIM}└ {}{RESET}", names.join(", ")));
-                    }
-                    for record in failed_tools.into_iter().take(3) {
-                        let target = if record.target.is_empty() {
-                            record.action.clone()
-                        } else {
-                            format!("{} [{}]", record.action, truncate_line(&record.target, 72))
-                        };
-                        lines.push(format!("    {RED}└ {target} failed{RESET}"));
-                    }
+                    let lines = run_summary_lines(&summary);
                     insert_permanent_lines(&mut status, &lines);
                 }
             }
@@ -1246,22 +1444,32 @@ pub async fn run_code_agent_with_options(
 
     let target_chat_id = options.chat_id.as_deref().unwrap_or(CHAT_CLI_ID);
 
-    let agent_loop = orchestrate_agent_loop(
-        config,
-        task,
-        root,
-        image_data_uri,
-        None,
-        video_data_uri,
-        Some(target_chat_id),
-        None,
-        user_name.as_deref(),
-        options.pinned_mcp_server.as_deref(),
-        options.fast_mode,
-        options.plan_mode,
-        approve_cb,
-        progress_cb,
-        on_chunk,
+    let agent_loop = mint_core::with_turn_start_listener(
+        target_chat_id.to_owned(),
+        move |id| {
+            if let Some(receipt) = &receipt
+                && let Err(error) = receipt.bind(id)
+            {
+                eprintln!("Library reference: {error}")
+            }
+        },
+        orchestrate_agent_loop(
+            config,
+            task,
+            root,
+            image_data_uri,
+            None,
+            video_data_uri,
+            Some(target_chat_id),
+            None,
+            user_name.as_deref(),
+            options.pinned_mcp_server.as_deref(),
+            options.fast_mode,
+            options.plan_mode,
+            approve_cb,
+            progress_cb,
+            on_chunk,
+        ),
     );
     let res = tokio::select! {
         res = agent_loop => res,
@@ -1601,6 +1809,26 @@ mod command_output_preview_tests {
 mod skill_card_tests {
     use super::*;
 
+    #[test]
+    fn skill_labels_distinguish_full_load_failure_and_preview() {
+        assert_eq!(
+            skill_read_label("review", "[Loaded skill: review]\nbody"),
+            "Loaded skill: review"
+        );
+        assert_eq!(
+            skill_read_label("review", "Error: denied"),
+            "Failed to read skill: review"
+        );
+        assert_eq!(
+            skill_read_label("review", "Blocked by hook: denied"),
+            "Failed to read skill: review"
+        );
+        assert_eq!(
+            skill_read_label("review", "1 | header"),
+            "Read skill preview: review"
+        );
+    }
+
     #[test]
     fn recognizes_workspace_skill_paths() {
         assert_eq!(