@pheem49/mint 1.6.4 → 1.7.1

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

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use crossterm::event::{self, Event, KeyCode};
 use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
-use mint_core::{load_config, save_config};
+use mint_core::{load_config, native_plugins, save_config};
 use std::io::{self, Write};
 
 struct ToolOption {
@@ -13,15 +13,6 @@ struct ToolOption {
 pub async fn run() -> Result<Option<String>> {
     let mut config = load_config()?;
 
-    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
-    println!("\x1b[32m       Mint CLI Tool Manager Wizard\x1b[0m");
-    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
-    println!("Configure which agent tools are enabled or disabled:");
-    println!(
-        "  \x1b[90m[Keyboard Controls: ↑/↓: Navigate | Space: Toggle | a: All | i: Invert | Enter: Confirm]\x1b[0m"
-    );
-    println!();
-
     let mut options = vec![
         ToolOption {
             name: "list_files (List Workspace Files)",
@@ -178,7 +169,7 @@ pub async fn run() -> Result<Option<String>> {
     ];
 
     let mut cursor = 0;
-    print_options(&options, cursor);
+    redraw_phase_1(&options, cursor);
     enable_raw_mode()?;
 
     loop {
@@ -204,8 +195,7 @@ pub async fn run() -> Result<Option<String>> {
                                     cursor = options.len() - 1;
                                 }
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", options.len());
-                                print_options(&options, cursor);
+                                redraw_phase_1(&options, cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Down => {
@@ -215,15 +205,13 @@ pub async fn run() -> Result<Option<String>> {
                                     cursor = 0;
                                 }
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", options.len());
-                                print_options(&options, cursor);
+                                redraw_phase_1(&options, cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Char(' ') => {
                                 options[cursor].enabled = !options[cursor].enabled;
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", options.len());
-                                print_options(&options, cursor);
+                                redraw_phase_1(&options, cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Char('a') => {
@@ -231,8 +219,7 @@ pub async fn run() -> Result<Option<String>> {
                                     opt.enabled = true;
                                 }
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", options.len());
-                                print_options(&options, cursor);
+                                redraw_phase_1(&options, cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Char('i') => {
@@ -240,8 +227,7 @@ pub async fn run() -> Result<Option<String>> {
                                     opt.enabled = !opt.enabled;
                                 }
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", options.len());
-                                print_options(&options, cursor);
+                                redraw_phase_1(&options, cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Enter => {
@@ -270,15 +256,135 @@ pub async fn run() -> Result<Option<String>> {
     config.disabled_tools = disabled;
     save_config(&config)?;
 
-    println!("\x1b[32mSuccessfully updated tool configurations!\x1b[0m\n");
+    println!("\x1b[32mSuccessfully updated agent tool configurations!\x1b[0m\n");
 
-    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
-    println!("\x1b[32m       Choose where to run Mint AI Agent\x1b[0m");
-    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
-    println!("Select the environment you want to launch:");
-    println!("  \x1b[90m[Keyboard Controls: ↑/↓: Navigate | Enter: Confirm]\x1b[0m");
+    let all_native = native_plugins();
+    let allowed_plugins: std::collections::HashSet<String> = config
+        .extra
+        .get("allowedNativePlugins")
+        .and_then(|v| v.as_array())
+        .map(|arr| {
+            arr.iter()
+                .filter_map(|v| v.as_str().map(|s| s.to_string()))
+                .collect()
+        })
+        .unwrap_or_else(|| {
+            vec![
+                "dev_tools".to_string(),
+                "system_metrics".to_string(),
+                "github".to_string(),
+            ]
+            .into_iter()
+            .collect()
+        });
+
+    let mut native_options: Vec<ToolOption> = all_native
+        .iter()
+        .map(|p| {
+            let has_all_permission = allowed_plugins.contains("*");
+            let is_enabled = has_all_permission || allowed_plugins.contains(p.name);
+            ToolOption {
+                name: p.name,
+                key: p.name,
+                enabled: is_enabled,
+            }
+        })
+        .collect();
+
+    let mut native_cursor = 0;
+    redraw_phase_2(&native_options, native_cursor);
+    enable_raw_mode()?;
+
+    loop {
+        match event::poll(std::time::Duration::from_millis(100)) {
+            Ok(true) => {
+                if let Event::Key(key_event) = event::read()? {
+                    if key_event.kind == event::KeyEventKind::Press {
+                        let is_ctrl_c = matches!(key_event.code, KeyCode::Char('c'))
+                            && key_event
+                                .modifiers
+                                .contains(crossterm::event::KeyModifiers::CONTROL);
+                        if is_ctrl_c {
+                            disable_raw_mode()?;
+                            println!("\n\x1b[31mSetup cancelled.\x1b[0m");
+                            return Ok(None);
+                        }
+
+                        match key_event.code {
+                            KeyCode::Up => {
+                                if native_cursor > 0 {
+                                    native_cursor -= 1;
+                                } else {
+                                    native_cursor = native_options.len() - 1;
+                                }
+                                disable_raw_mode()?;
+                                redraw_phase_2(&native_options, native_cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Down => {
+                                if native_cursor < native_options.len() - 1 {
+                                    native_cursor += 1;
+                                } else {
+                                    native_cursor = 0;
+                                }
+                                disable_raw_mode()?;
+                                redraw_phase_2(&native_options, native_cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Char(' ') => {
+                                native_options[native_cursor].enabled =
+                                    !native_options[native_cursor].enabled;
+                                disable_raw_mode()?;
+                                redraw_phase_2(&native_options, native_cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Char('a') => {
+                                for opt in &mut native_options {
+                                    opt.enabled = true;
+                                }
+                                disable_raw_mode()?;
+                                redraw_phase_2(&native_options, native_cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Char('i') => {
+                                for opt in &mut native_options {
+                                    opt.enabled = !opt.enabled;
+                                }
+                                disable_raw_mode()?;
+                                redraw_phase_2(&native_options, native_cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Enter => {
+                                break;
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+            }
+            Ok(false) => {}
+            Err(_) => {
+                break;
+            }
+        }
+    }
+    disable_raw_mode()?;
     println!();
 
+    let enabled_natives: Vec<serde_json::Value> = native_options
+        .iter()
+        .filter(|o| o.enabled)
+        .map(|o| serde_json::Value::String(o.key.to_string()))
+        .collect();
+
+    config.extra.insert(
+        "allowedNativePlugins".to_string(),
+        serde_json::Value::Array(enabled_natives),
+    );
+    save_config(&config)?;
+
+    println!("\x1b[32mSuccessfully updated native plugins configurations!\x1b[0m\n");
+
     let run_options = vec![
         ToolOption {
             name: "1. CLI (Interactive Terminal Assistant)",
@@ -298,7 +404,7 @@ pub async fn run() -> Result<Option<String>> {
     ];
 
     let mut run_cursor = 0;
-    print_run_options(&run_options, run_cursor);
+    redraw_phase_3(&run_options, run_cursor);
     enable_raw_mode()?;
 
     loop {
@@ -324,8 +430,7 @@ pub async fn run() -> Result<Option<String>> {
                                     run_cursor = run_options.len() - 1;
                                 }
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", run_options.len());
-                                print_run_options(&run_options, run_cursor);
+                                redraw_phase_3(&run_options, run_cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Down => {
@@ -335,8 +440,7 @@ pub async fn run() -> Result<Option<String>> {
                                     run_cursor = 0;
                                 }
                                 disable_raw_mode()?;
-                                print!("\x1b[{}A\x1b[J", run_options.len());
-                                print_run_options(&run_options, run_cursor);
+                                redraw_phase_3(&run_options, run_cursor);
                                 enable_raw_mode()?;
                             }
                             KeyCode::Enter => {
@@ -388,3 +492,40 @@ fn print_run_options(options: &[ToolOption], cursor: usize) {
     }
     let _ = io::stdout().flush();
 }
+
+fn redraw_phase_1(options: &[ToolOption], cursor: usize) {
+    print!("\x1b[2J\x1b[1;1H");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("\x1b[32m       Mint CLI Tool Manager Wizard\x1b[0m");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("Configure which agent tools are enabled or disabled:");
+    println!(
+        "  \x1b[90m[Keyboard Controls: ↑/↓: Navigate | Space: Toggle | a: All | i: Invert | Enter: Confirm]\x1b[0m"
+    );
+    println!();
+    print_options(options, cursor);
+}
+
+fn redraw_phase_2(options: &[ToolOption], cursor: usize) {
+    print!("\x1b[2J\x1b[1;1H");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("\x1b[32m       Configure Native Plugins Access\x1b[0m");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("Select which native plugins are allowed to run:");
+    println!(
+        "  \x1b[90m[Keyboard Controls: ↑/↓: Navigate | Space: Toggle | a: All | i: Invert | Enter: Confirm]\x1b[0m"
+    );
+    println!();
+    print_options(options, cursor);
+}
+
+fn redraw_phase_3(options: &[ToolOption], cursor: usize) {
+    print!("\x1b[2J\x1b[1;1H");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("\x1b[32m       Choose where to run Mint AI Agent\x1b[0m");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("Select the environment you want to launch:");
+    println!("  \x1b[90m[Keyboard Controls: ↑/↓: Navigate | Enter: Confirm]\x1b[0m");
+    println!();
+    print_run_options(options, cursor);
+}

package/crates/mint-core/src/api_server.rs

@@ -272,6 +272,41 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         .await;
                     }
                 }
+                ("POST", "/api/interactions/agent-activity") => {
+                    #[derive(Deserialize)]
+                    #[serde(rename_all = "camelCase")]
+                    struct SaveAgentActivityRequest {
+                        interaction_id: i64,
+                        activity: Vec<AgentProgress>,
+                    }
+
+                    if let Ok(payload) = serde_json::from_str::<SaveAgentActivityRequest>(body) {
+                        if let Ok(memory) = MemoryStore::open_default() {
+                            match serde_json::to_string(&payload.activity) {
+                                Ok(activity_json) => {
+                                    if memory
+                                        .set_interaction_agent_activity_json(
+                                            payload.interaction_id,
+                                            &activity_json,
+                                        )
+                                        .is_ok()
+                                    {
+                                        send_json_response(socket, "200 OK", "{\"status\":\"ok\"}")
+                                            .await;
+                                        return;
+                                    }
+                                }
+                                Err(_) => {}
+                            }
+                        }
+                    }
+                    send_json_response(
+                        socket,
+                        "400 Bad Request",
+                        "{\"status\":\"invalid agent activity payload\"}",
+                    )
+                    .await;
+                }
                 ("GET", "/api/pictures") => match list_saved_pictures() {
                     Ok(mut pictures) => {
                         for picture in &mut pictures {

package/crates/mint-core/src/config.rs

@@ -310,7 +310,7 @@ fn runtime_extra_defaults() -> BTreeMap<String, Value> {
         "notionPageId": "",
         "notionTitleProperty": "Name",
         "allowedShellModes": ["readOnly", "test", "mutating", "network"],
-        "allowedNativePlugins": ["dev_tools", "system_metrics"],
+        "allowedNativePlugins": ["dev_tools", "system_metrics", "github"],
         "allowedMcpTools": {},
         "mcpServers": {}
     }))
@@ -380,7 +380,7 @@ mod tests {
         );
         assert_eq!(
             config.extra["allowedNativePlugins"],
-            serde_json::json!(["dev_tools", "system_metrics"])
+            serde_json::json!(["dev_tools", "system_metrics", "github"])
         );
         assert_eq!(config.extra["allowedMcpTools"], serde_json::json!({}));
     }

package/crates/mint-core/src/memory.rs

@@ -36,6 +36,8 @@ pub struct InteractionMemory {
     pub model: String,
     pub fallback_provider: Option<String>,
     pub created_at: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub agent_activity: Option<serde_json::Value>,
 }
 
 #[derive(Debug, Clone, Serialize, PartialEq, Eq)]
@@ -172,7 +174,7 @@ impl MemoryStore {
         ensure_builtin_chat_sessions(&connection)?;
         ensure_chat_session_row(&connection, &chat_id)?;
         let mut statement = connection.prepare(
-            "SELECT id, chat_id, user_text, ai_text, provider, model, fallback_provider, created_at
+            "SELECT id, chat_id, user_text, ai_text, provider, model, fallback_provider, created_at, agent_activity_json
              FROM interaction_memories
              WHERE chat_id = ?1
              ORDER BY id DESC
@@ -202,6 +204,20 @@ impl MemoryStore {
         rows.collect::<Result<Vec<_>, _>>().map_err(Into::into)
     }
 
+    pub fn set_interaction_agent_activity_json(
+        &self,
+        interaction_id: i64,
+        activity_json: &str,
+    ) -> Result<usize, MemoryError> {
+        let connection = self.connection()?;
+        Ok(connection.execute(
+            "UPDATE interaction_memories
+             SET agent_activity_json = ?2
+             WHERE id = ?1",
+            params![interaction_id, activity_json],
+        )?)
+    }
+
     pub fn clear_interactions(&self) -> Result<usize, MemoryError> {
         self.clear_interactions_for_chat(DEFAULT_CONVERSATION_ID)
     }
@@ -551,6 +567,12 @@ fn initialize(
         "fallback_provider",
         "TEXT DEFAULT NULL",
     )?;
+    ensure_column(
+        connection,
+        "interaction_memories",
+        "agent_activity_json",
+        "TEXT DEFAULT NULL",
+    )?;
     ensure_column(
         connection,
         "chat_sessions",
@@ -612,6 +634,9 @@ fn learned_skill_row(row: &rusqlite::Row<'_>) -> Result<LearnedSkill, rusqlite::
 }
 
 fn interaction_row(row: &rusqlite::Row<'_>) -> Result<InteractionMemory, rusqlite::Error> {
+    let agent_activity = row
+        .get::<_, Option<String>>(8)?
+        .and_then(|raw| serde_json::from_str(&raw).ok());
     Ok(InteractionMemory {
         id: row.get(0)?,
         chat_id: row.get(1)?,
@@ -621,6 +646,7 @@ fn interaction_row(row: &rusqlite::Row<'_>) -> Result<InteractionMemory, rusqlit
         model: row.get(5)?,
         fallback_provider: row.get(6)?,
         created_at: row.get(7)?,
+        agent_activity,
     })
 }
 

package/crates/mint-core/src/orchestration.rs

@@ -385,7 +385,7 @@ pub fn build_system_prompt(config: &MintConfig) -> String {
             "- write_file: {\"path\":\"new/relative/path\",\"fileContent\":\"full file content\"}",
         );
     }
-    input_formats.push("- finish: {\"summary\":\"concise final answer\",\"verification\":\"checks run or not run\"}");
+    input_formats.push("- finish: {\"summary\":\"concise final answer in Thai when the user writes Thai\",\"verification\":\"checks run or not run\"}");
 
     let input_formats_str = input_formats.join("\n");
 

package/crates/mint-core/src/plugins.rs

@@ -84,6 +84,10 @@ pub fn native_plugins() -> Vec<NativePlugin> {
             name: "notion",
             description: "Create notes, read databases, and append blocks through Notion API.",
         },
+        NativePlugin {
+            name: "github",
+            description: "List issues, view issues, list pull requests, or check PR status via gh CLI.",
+        },
     ]
 }
 
@@ -104,6 +108,7 @@ pub async fn execute_native_plugin(
         "gmail" => gmail(config, instruction).await,
         "google_calendar" => calendar(config, instruction).await,
         "notion" => notion(config, instruction).await,
+        "github" => github(instruction),
         _ => Err(PluginError::UnknownPlugin(name.into())),
     }
 }
@@ -229,6 +234,36 @@ fn spotify(instruction: &str) -> Result<String, PluginError> {
     run("playerctl", &args)
 }
 
+fn github(instruction: &str) -> Result<String, PluginError> {
+    let parts = instruction.split_whitespace().collect::<Vec<_>>();
+    match parts.as_slice() {
+        ["list_issues"] | ["issue", "list"] => run("gh", &["issue", "list", "--limit", "10"]),
+        ["view_issue", id] | ["issue", "view", id] => {
+            if id.chars().all(|c| c.is_ascii_digit()) {
+                run("gh", &["issue", "view", id])
+            } else {
+                invalid(
+                    "github",
+                    "view_issue/issue view requires a numeric issue ID",
+                )
+            }
+        }
+        ["list_prs"] | ["pr", "list"] => run("gh", &["pr", "list", "--limit", "10"]),
+        ["pr_status"] | ["pr", "status"] => run("gh", &["pr", "status"]),
+        ["view_pr", id] | ["pr", "view", id] => {
+            if id.chars().all(|c| c.is_ascii_digit()) {
+                run("gh", &["pr", "view", id])
+            } else {
+                invalid("github", "view_pr/pr view requires a numeric PR ID")
+            }
+        }
+        _ => invalid(
+            "github",
+            "expected list_issues, view_issue <id>, list_prs, pr_status, or view_pr <id>",
+        ),
+    }
+}
+
 fn system_metrics(instruction: &str) -> Result<String, PluginError> {
     let uptime = fs::read_to_string("/proc/uptime")
         .ok()

package/crates/mint-core/tests/memory_persistence.rs

@@ -57,6 +57,34 @@ fn stores_recent_interactions_with_provider_metadata() {
     assert_eq!(interactions[1].fallback_provider, None);
 }
 
+#[test]
+fn stores_and_reads_interaction_agent_activity() {
+    let store = store("agent-activity");
+    let interaction_id = store
+        .add_interaction_with_metadata("hello", "hi", "gemini", "gemini-test")
+        .unwrap();
+    store
+        .set_interaction_agent_activity_json(
+            interaction_id,
+            r#"[{"type":"Thought","data":{"thought":"step one"}}]"#,
+        )
+        .unwrap();
+
+    let interactions = store.recent_interactions(1).unwrap();
+    assert_eq!(interactions.len(), 1);
+    let activity = interactions[0]
+        .agent_activity
+        .as_ref()
+        .and_then(|value| value.as_array())
+        .cloned()
+        .unwrap_or_default();
+    assert_eq!(activity.len(), 1);
+    assert_eq!(
+        activity[0].get("type").and_then(|value| value.as_str()),
+        Some("Thought")
+    );
+}
+
 #[test]
 fn preserves_chat_history_when_store_is_reopened() {
     let path = test_path("reopen-history", "sqlite");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pheem49/mint",
-  "version": "1.6.4",
+  "version": "1.7.1",
   "description": "A native Tauri desktop AI assistant with a Rust backend and React UI.",
   "scripts": {
     "dev:web": "vite --config vite.config.web.ts",
@@ -27,7 +27,17 @@
     "cli": "cargo run -p mint-cli --",
     "postinstall": "cargo build -p mint-cli --release && mkdir -p bin && cp target/release/mint bin/mint"
   },
-  "keywords": [],
+  "keywords": [
+    "mint",
+    "tauri",
+    "ai",
+    "assistant",
+    "desktop",
+    "cli",
+    "rust",
+    "react",
+    "agent"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Pheem49/Mint.git"

package/src/renderer/src/agentProgress.ts

@@ -0,0 +1,39 @@
+import type { AgentProgress, InteractionMemory } from './tauri'
+
+export function thoughtsFrom(progress: AgentProgress[]): string[] {
+  return progress
+    .filter((event) => event.type === 'Thought')
+    .map((event) => (event as Extract<AgentProgress, { type: 'Thought' }>).data.thought)
+    .filter(Boolean)
+}
+
+export function trimAgentProgress(progress: AgentProgress[], maxNonThought = 20): AgentProgress[] {
+  if (progress.length === 0) return progress
+  const keptNonThought = new Set(
+    progress.filter((event) => event.type !== 'Thought').slice(-maxNonThought),
+  )
+  return progress.filter((event) => event.type === 'Thought' || keptNonThought.has(event))
+}
+
+export function hasAgentToolActivity(progress: AgentProgress[]): boolean {
+  return progress.some((event) => event.type === 'ToolStart' || event.type === 'ToolEnd')
+}
+
+export function mergeActivitySnapshots(
+  current: Record<string, AgentProgress[]>,
+  interactions: InteractionMemory[],
+): Record<string, AgentProgress[]> {
+  const merged = { ...current }
+  for (const interaction of interactions) {
+    const key = String(interaction.id)
+    if (interaction.agentActivity?.length && !merged[key]) {
+      merged[key] = interaction.agentActivity
+    }
+  }
+  return merged
+}
+
+export function parseAgentActivity(value: unknown): AgentProgress[] | undefined {
+  if (!Array.isArray(value)) return undefined
+  return value as AgentProgress[]
+}