@pheem49/mint 1.6.3 → 1.7.0

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

@@ -5,6 +5,7 @@ pub mod chat;
 pub mod code_tools;
 pub mod config;
 pub mod files;
+pub mod image_gen;
 pub mod knowledge;
 pub mod mcp;
 pub mod memory;
@@ -39,6 +40,9 @@ pub use config::{
     set_config_value,
 };
 pub use files::{FileOperationError, PathKind, PathMatch, create_folder, find_paths};
+pub use image_gen::{
+    GeneratedImage, ImageGenError, ImageGenRequest, ImageGenResponse, generate_images,
+};
 pub use knowledge::{
     KnowledgeError, KnowledgeHit, KnowledgeSource, KnowledgeStore, extract_document_text,
 };

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,33 @@ 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.3",
+  "version": "1.7.0",
   "description": "A native Tauri desktop AI assistant with a Rust backend and React UI.",
   "scripts": {
     "dev:web": "vite --config vite.config.web.ts",

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[]
+}