@pheem49/mint 1.2.1

package/src/AI_Brain/Gemini_API.js

@@ -0,0 +1,419 @@
+const { GoogleGenAI } = require('@google/genai');
+const { readChatHistory, writeChatHistory, clearChatHistory } = require('../System/chat_history_manager');
+const { readConfig } = require('../System/config_manager');
+const pluginManager = require('../Plugins/plugin_manager');
+
+let ai = null;
+let activeApiKey = '';
+const initialEnvKey = (process.env.GEMINI_API_KEY || '').trim();
+const DEFAULT_GEMINI_MODEL = 'gemini-3.1-flash-lite-preview';
+
+const systemInstruction = `You are "Mint" (มิ้นท์), a cute, cheerful, and highly helpful female Local AI Desktop Agent. 
+
+PERSONALITY & TONE:
+- Gender: Female.
+- Persona: Friendly, energetic, polite, and slightly playful.
+- Language: Multi-lingual. **CRITICAL: You MUST detect the language used by the user and respond in that SAME language.** 
+  - If the user speaks English -> Respond 100% in English.
+  - If the user speaks Thai -> Respond 100% in Thai.
+- Politeness: 
+  - **WHEN RESPONDING IN THAI:** ALWAYS use female polite particles such as "ค่ะ", "นะคะ", "นะค๊า", "จ้า". Refer to yourself as "มิ้นท์" or "หนู".
+  - **WHEN RESPONDING IN ENGLISH:** Use a cheerful, polite, and bubbly tone. You can call the user "Master" or "Sir/Madam" playfully.
+- Style: Use a professional, clear, and direct tone. Avoid using emojis unless specifically asked by the user.
+
+NATURAL CHAT FLOW:
+- When helpful, reply in 1–3 short messages instead of one long block.
+- If you send multiple messages, separate each message with a blank line (double newline) so the UI can render them as separate bubbles.
+- Ask at most one short follow-up question when it would clarify or move the task forward. Don't ask unnecessary questions.
+
+GOAL:
+Your goal is to help the user with their queries. If they ask to open an application, open a website, search, manage files, or get system info, you must return an action in the structured JSON format below.
+
+CREATOR INFO:
+- The creator is Pheem49.
+- GitHub: github.com/Pheem49
+- If the user asks who created/built this app or who made you, answer with the creator name and GitHub.
+
+CRITICAL INSTRUCTIONS:
+Always respond exactly with valid JSON containing NO MARKDOWN FORMATTING (do not wrap in \`\`\`json). The JSON must have this structure:
+{
+  "response": "Your conversational reply here (Matches user language).",
+  "action": {
+    "type": "none" | "open_url" | "open_app" | "search" | "web_automation" | "create_folder" | "open_file" | "delete_file" | "clipboard_write" | "system_info" | "plugin" | "learn_file" | "system_automation",
+    "pluginName": "only if type is plugin",
+    "target": "target string based on type or plugin instruction"
+  }
+}
+
+Examples:
+Input: "Hi, what is your name?"
+Output: { "response": "Hello! My name is Mint, your personal AI assistant. How can I help you today?", "action": { "type": "none", "target": "" } }
+
+Input: "หวัดดีจ้า ชื่ออะไรเหรอ"
+Output: { "response": "สวัสดีค่ะ! หนูชื่อมิ้นท์นะคะ เป็นผู้ช่วย AI ประจำตัวของคุณค่ะ มีอะไรให้มิ้นท์ช่วยไหมคะ?", "action": { "type": "none", "target": "" } }
+
+Input: "Create a folder named Projects"
+Output: { "response": "Sure thing! I'm creating a folder named 'Projects' for you right now.", "action": { "type": "create_folder", "target": "Projects" } }
+
+Input: "วันนี้วันที่เท่าไร" or "What date is today?" or "today's date" or "วันเวลา"
+Output: { "response": "แป๊บนึงนะคะ มิ้นท์จะดูให้ค่า", "action": { "type": "system_info", "target": "" } }
+
+NOTE: For date/time queries, ALWAYS use action type "system_info" with an EMPTY target string "". NEVER use target "date" or any city name for date queries.
+
+Input: "อากาศวันนี้เป็นยังไง" or "What's the weather in Bangkok?"
+Output: { "response": "มิ้นท์ไปดูอากาศให้เลยนะคะ", "action": { "type": "system_info", "target": "Bangkok" } }
+`;
+
+function resolveApiKey() {
+  let settingsKey = '';
+  try {
+    const cfg = readConfig();
+    settingsKey = (cfg.apiKey || '').trim();
+  } catch (e) {
+    settingsKey = '';
+  }
+
+  const envKey = initialEnvKey;
+  // Settings override .env if present; otherwise fallback to .env
+  const selectedKey = settingsKey || envKey || '';
+
+  if (selectedKey !== (process.env.GEMINI_API_KEY || '')) {
+    process.env.GEMINI_API_KEY = selectedKey;
+  }
+
+  activeApiKey = selectedKey;
+  return selectedKey;
+}
+
+function initAiClient() {
+  ai = new GoogleGenAI({ apiKey: activeApiKey });
+}
+
+function resolveGeminiModel() {
+  try {
+    const cfg = readConfig();
+    const model = (cfg.geminiModel || '').trim();
+    return model || DEFAULT_GEMINI_MODEL;
+  } catch (e) {
+    return DEFAULT_GEMINI_MODEL;
+  }
+}
+
+// Chat session — maintains conversation history within the session
+let chat = null;
+let activeModel = resolveGeminiModel();
+let lastLoggedModel = '';
+const MAX_HISTORY_MESSAGES = 20; // Keep only the last 20 messages (approx 10 turns)
+
+function createChat(history = []) {
+  // Load plugins and get dynamic description for the prompt
+  pluginManager.loadPlugins();
+  const dynamicPrompt = systemInstruction + pluginManager.getPromptDescriptions();
+
+  // Truncate history to avoid slow responses and high token usage
+  const truncatedHistory = history.slice(-MAX_HISTORY_MESSAGES);
+
+  activeModel = resolveGeminiModel();
+  if (activeModel && activeModel !== lastLoggedModel) {
+    console.log(`[Gemini] Using model: ${activeModel}`);
+    lastLoggedModel = activeModel;
+  }
+  chat = ai.chats.create({
+    model: activeModel,
+    config: {
+      systemInstruction: dynamicPrompt,
+      responseMimeType: "application/json"
+    },
+    history: truncatedHistory
+  });
+}
+
+// Initialize on startup
+resolveApiKey();
+initAiClient();
+createChat(readChatHistory());
+
+const { searchKnowledge } = require('./knowledge_base');
+
+async function handleChat(message, base64Image = null, base64Audio = null) {
+  try {
+    const config = readConfig();
+    const provider = config.aiProvider || 'gemini';
+
+    // Ensure API Key is loaded and Client is initialized before every chat
+    const currentKey = resolveApiKey();
+    if (!currentKey) {
+       return { 
+           response: "I couldn't find your Gemini API Key. Please run 'mint onboard' to set it up!", 
+           action: { type: "none", target: "" } 
+       };
+    }
+
+    if (!ai || activeApiKey !== currentKey) {
+        initAiClient();
+        createChat(readChatHistory());
+    }
+
+    let finalMessage = message;
+    
+    // Inject Local RAG Context
+    if (message && message.trim().length > 0) {
+        const retrievedDocs = await searchKnowledge(message);
+        if (retrievedDocs && retrievedDocs.length > 0) {
+            let contextString = `\n\n[LOCAL KNOWLEDGE BASE - USE THIS CONTEXT TO ANSWER]\n`;
+            retrievedDocs.forEach(doc => {
+                contextString += `Source: ${doc.source}\nContent: ${doc.text}\n\n`;
+            });
+            finalMessage = message + contextString;
+        }
+    }
+
+    if (provider === 'ollama') {
+        const axios = require('axios');
+        return await handleOllamaChat(finalMessage, base64Image, base64Audio, config, axios);
+    }
+
+    const desiredModel = resolveGeminiModel();
+    if (!chat || activeModel !== desiredModel) {
+        createChat(readChatHistory());
+    }
+
+    let aiResponse;
+    const parts = [];
+    if (finalMessage) {
+        parts.push({ text: finalMessage });
+    } else if (base64Audio && !base64Image) {
+        // Provide a guiding prompt when only audio is provided to ensure Gemini follows instructions
+        parts.push({ text: "Please listen to this voice command and respond in Thai with the appropriate JSON action if needed." });
+    } else if (!base64Image && !base64Audio) {
+        parts.push({ text: "Analyze this input." });
+    }
+
+    if (base64Image) {
+        const base64Data = base64Image.replace(/^data:image\/\w+;base64,/, '');
+        parts.push({
+            inlineData: { mimeType: "image/png", data: base64Data }
+        });
+    }
+
+    if (base64Audio) {
+        // Extract MIME type from the data URI if present, fallback to audio/webm
+        let mimeType = "audio/webm";
+        const mimeMatch = base64Audio.match(/^data:(audio\/\w+);base64,/);
+        if (mimeMatch) {
+            mimeType = mimeMatch[1];
+        }
+        
+        const base64Data = base64Audio.replace(/^data:audio\/\w+;base64,/, '');
+        parts.push({
+            inlineData: { mimeType: mimeType, data: base64Data }
+        });
+    }
+
+    aiResponse = await chat.sendMessage({ message: parts });
+
+    writeChatHistory(chat.getHistory(true));
+
+    const outputText = aiResponse.text;
+    let parsedResult;
+    try {
+      parsedResult = JSON.parse(outputText);
+    } catch (e) {
+      // Fallback in case the model failed to return pure JSON
+      console.error("Failed to parse JSON directly:", e);
+      const jsonMatch = outputText.match(/```json\n([\s\S]*?)\n```/) || outputText.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        parsedResult = JSON.parse(jsonMatch[jsonMatch.length > 1 ? 1 : 0]);
+      } else {
+        parsedResult = {
+          response: outputText,
+          action: { type: "none", target: "" }
+        };
+      }
+    }
+    return parsedResult;
+
+  } catch (error) {
+    console.error("AI API Error:", error);
+    throw error;
+  }
+}
+
+async function handleOllamaChat(finalMessage, base64Image, base64Audio, config, axios) {
+    const history = readChatHistory() || [];
+    pluginManager.loadPlugins();
+    
+    const ollamaMessages = [
+        { role: 'system', content: systemInstruction + pluginManager.getPromptDescriptions() }
+    ];
+    
+    for (const msg of history.slice(-MAX_HISTORY_MESSAGES)) {
+        const role = msg.role === 'model' ? 'assistant' : 'user';
+        let text = '';
+        if (Array.isArray(msg.parts)) {
+             text = msg.parts.map(p => p.text || '').join('\n');
+        }
+        if (text) ollamaMessages.push({ role, content: text });
+    }
+    
+    let currentContent = finalMessage || 'Analyze this input.';
+    let images = [];
+    if (base64Image) {
+        images.push(base64Image.replace(/^data:image\/\w+;base64,/, ''));
+    }
+    
+    if (base64Audio && !base64Image && !finalMessage) {
+        currentContent = "Please analyze this audio requirement based on text if any was transacted, otherwise reply with appropriate action.";
+    }
+    
+    const userMessage = { role: 'user', content: currentContent };
+    if (images.length > 0) userMessage.images = images;
+    
+    ollamaMessages.push(userMessage);
+    
+    const response = await axios.post('http://localhost:11434/api/chat', {
+        model: config.ollamaModel || 'llama3:latest',
+        messages: ollamaMessages,
+        format: 'json',
+        stream: false
+    });
+    
+    const outputText = response.data.message.content;
+    
+    history.push({ role: 'user', parts: [{ text: currentContent }] });
+    history.push({ role: 'model', parts: [{ text: outputText }] });
+    writeChatHistory(history.slice(-MAX_HISTORY_MESSAGES));
+    
+    let parsedResult;
+    try {
+        parsedResult = JSON.parse(outputText);
+    } catch(e) {
+        const jsonMatch = outputText.match(/```json\n([\s\S]*?)\n```/) || outputText.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            parsedResult = JSON.parse(jsonMatch[jsonMatch.length > 1 ? 1 : 0]);
+        } else {
+            parsedResult = { response: outputText, action: { type: "none", target: "" } };
+        }
+    }
+    return parsedResult;
+}
+
+function resetChat() {
+  clearChatHistory();
+  createChat([]);
+  console.log("Chat history cleared.");
+}
+
+function refreshApiKeyFromConfig() {
+  const prevKey = activeApiKey;
+  const nextKey = resolveApiKey();
+  if (nextKey !== prevKey) {
+    initAiClient();
+    createChat(readChatHistory());
+  }
+  return { key: nextKey, updated: nextKey !== prevKey };
+}
+
+function historyToTranscript(history) {
+  if (!Array.isArray(history)) return [];
+
+  const transcript = [];
+  for (const content of history) {
+    const sender = content.role === 'user' ? 'user' : 'ai';
+    let text = Array.isArray(content.parts)
+      ? content.parts
+        .map((part) => typeof part.text === 'string' ? part.text : '')
+        .filter(Boolean)
+        .join('\n')
+      : '';
+
+    if (sender === 'ai' && text.trim()) {
+      try {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed.response === 'string' && parsed.response.trim()) {
+          text = parsed.response;
+        }
+      } catch {
+        // Keep original text if it is not JSON.
+      }
+    }
+
+    if (!text.trim()) continue;
+    transcript.push({ sender, text });
+  }
+  return transcript;
+}
+
+async function getChatTranscript() {
+    if (chat) {
+        return historyToTranscript(await chat.getHistory(true));
+    }
+    return historyToTranscript(readChatHistory());
+}
+
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isRetryableTranslateError(err) {
+    const status = err?.status ?? err?.error?.code ?? err?.code;
+    return status === 502 || status === 503;
+}
+
+/**
+ * Super fast, single-turn vision translation
+ * Extracts English text from the image and translates it to Thai.
+ */
+async function translateImageContent(base64Image) {
+    const maxAttempts = 3;
+    const retryDelayMs = [1000, 2500];
+
+    try {
+        const base64Data = base64Image.replace(/^data:image\/\w+;base64,/, '');
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            try {
+                const response = await ai.models.generateContent({
+                    model: resolveGeminiModel(),
+                    contents: [
+                        {
+                            role: 'user',
+                            parts: [
+                                { text: "Extract any English text you see in this image and translate it to Thai. Return ONLY the Thai translation. If there is no text, return 'ไม่พบข้อความ'." },
+                                { inlineData: { mimeType: "image/png", data: base64Data } }
+                            ]
+                        }
+                    ]
+                });
+
+                return {
+                    text: response.text,
+                    retryableFailure: false
+                };
+            } catch (err) {
+                const shouldRetry = isRetryableTranslateError(err) && attempt < maxAttempts;
+                if (shouldRetry) {
+                    const delayMs = retryDelayMs[attempt - 1] ?? retryDelayMs[retryDelayMs.length - 1];
+                    console.warn(`Live translation retry ${attempt}/${maxAttempts - 1} after ${delayMs}ms due to ${err.status || err.code || 'retryable error'}`);
+                    await sleep(delayMs);
+                    continue;
+                }
+
+                throw err;
+            }
+        }
+    } catch (err) {
+        console.error("Live translation error:", err);
+        return {
+            text: "ขออภัย เกิดข้อผิดพลาดในการแปล",
+            retryableFailure: isRetryableTranslateError(err)
+        };
+    }
+}
+
+module.exports = {
+    handleChat,
+    resetChat,
+    getChatTranscript,
+    translateImageContent,
+    refreshApiKeyFromConfig
+};

package/src/AI_Brain/autonomous_brain.js

@@ -0,0 +1,139 @@
+const { GoogleGenAI } = require('@google/genai');
+const { readConfig } = require('../System/config_manager');
+const { performWebAutomation } = require('../Automation_Layer/browser_automation');
+const { createFolder, deleteFile } = require('../Automation_Layer/file_operations');
+const { searchKnowledge } = require('./knowledge_base');
+const fs = require('fs');
+const path = require('path');
+
+const os = require('os');
+
+const DEFAULT_GEMINI_MODEL = 'gemini-3.1-flash-lite-preview';
+
+function expandHome(filePath) {
+    if (filePath.startsWith('~/')) {
+        return path.join(os.homedir(), filePath.slice(2));
+    }
+    return filePath;
+}
+
+const AUTONOMOUS_SYSTEM_PROMPT = `You are the "Mint Autonomous Brain". Your goal is to fulfill complex tasks by breaking them down into steps.
+You operate in a ReAct loop: Thought -> Action -> Observation -> Thought...
+
+CRITICAL INSTRUCTIONS:
+1. Respond ONLY with valid JSON. NO MARKDOWN.
+2. For BASH/Terminal commands: Use the "propose_bash" action. You are NOT allowed to run them yourself.
+3. For Web tasks: Use "web_automation".
+4. For File tasks: Use "create_folder", "write_file", "delete_file".
+5. For Knowledge: Use "knowledge_search".
+
+JSON Structure:
+{
+  "thought": "Your reasoning about the current state and what to do next.",
+  "action": "web_automation" | "create_folder" | "write_file" | "delete_file" | "knowledge_search" | "propose_bash" | "done",
+  "target": "The input for the action (URL/Path/Query/Filename/Command/Final Result)",
+  "data": "Optional extra data (e.g., content for write_file)"
+}
+
+TOOL DETAILS:
+- "web_automation": Use for any task requiring a browser. Target is the natural language instruction for the browser.
+- "create_folder": Target is the folder name/path.
+- "write_file": Target is the file path. Data is the content. Prefer using "~/Desktop" or "~/Documents" for home-relative paths.
+- "delete_file": Target is the file path. (User will be notified).
+- "knowledge_search": Target is the query for the local RAG.
+- "propose_bash": Target is the bash command to show to the user. ALWAYS use SINGLE QUOTES (') for strings containing special characters like "!" to avoid Bash history expansion errors (e.g., use 'Pop!_OS' instead of "Pop!_OS").
+- "done": Target is the final summary of what was accomplished.
+`;
+
+async function executeAutonomousTask(taskDescription, notifyCallback) {
+    const config = readConfig();
+    const modelName = config.geminiModel || DEFAULT_GEMINI_MODEL;
+    const apiKey = config.apiKey || process.env.GEMINI_API_KEY;
+    
+    // Use the custom chat creation pattern from the project
+    const ai = new GoogleGenAI({ apiKey });
+    const chat = ai.chats.create({
+        model: modelName,
+        config: {
+            systemInstruction: AUTONOMOUS_SYSTEM_PROMPT,
+            responseMimeType: "application/json"
+        },
+        history: []
+    });
+
+    let currentObservation = `Task: ${taskDescription}\nWhat is your first step?`;
+    let maxSteps = 10;
+    let step = 0;
+    let result = null;
+
+    while (step < maxSteps) {
+        step++;
+        if (notifyCallback) notifyCallback(`Step ${step}: Thinking...`);
+
+        try {
+            const response = await chat.sendMessage({ message: [{ text: currentObservation }] });
+            const text = response.text;
+            const actionObj = JSON.parse(text);
+
+            console.log(`[Brain] Thought: ${actionObj.thought}`);
+            console.log(`[Brain] Action: ${actionObj.action} -> ${actionObj.target}`);
+
+            if (actionObj.action === 'done') {
+                result = actionObj.target;
+                break;
+            }
+
+            // Execute the action
+            let observation = "";
+            switch (actionObj.action) {
+                case 'web_automation':
+                    if (notifyCallback) notifyCallback(`🌐 มิ้นท์กำลังเข้าเว็บเพื่อ ${actionObj.target}...`);
+                    observation = await performWebAutomation(actionObj.target);
+                    break;
+                case 'create_folder':
+                    const folderPath = expandHome(actionObj.target);
+                    if (notifyCallback) notifyCallback(`📁 กำลังสร้างโฟลเดอร์: ${actionObj.target}`);
+                    const resFolder = createFolder(folderPath);
+                    observation = resFolder.success ? `Folder created at ${resFolder.path}` : `Failed: ${resFolder.message}`;
+                    break;
+                case 'write_file':
+                    const filePath = expandHome(actionObj.target);
+                    if (notifyCallback) notifyCallback(`✍️ กำลังบันทึกไฟล์: ${actionObj.target}`);
+                    try {
+                        fs.writeFileSync(filePath, actionObj.data || '');
+                        observation = `File written successfully to ${actionObj.target}`;
+                    } catch (e) {
+                        observation = `Failed to write file: ${e.message}`;
+                    }
+                    break;
+                case 'delete_file':
+                    const delPath = expandHome(actionObj.target);
+                    if (notifyCallback) notifyCallback(`🗑️ มิ้นท์ขอย้ายไฟล์ไปที่ถังขยะ: ${actionObj.target}`);
+                    const resDel = await deleteFile(delPath);
+                    observation = resDel.success ? "File moved to trash." : `Failed: ${resDel.message}`;
+                    break;
+                case 'knowledge_search':
+                    if (notifyCallback) notifyCallback(`🔍 กำลังหาข้อมูลในเครื่อง: ${actionObj.target}`);
+                    const docs = await searchKnowledge(actionObj.target);
+                    observation = (docs && docs.length > 0) ? `Found: ${docs.map(d => d.text).join('\n')}` : "No information found in local knowledge base.";
+                    break;
+                case 'propose_bash':
+                    if (notifyCallback) notifyCallback(`💡 มิ้นท์เสนอให้รันคำสั่ง: ${actionObj.target}`);
+                    observation = `USER NOTIFIED of bash command: ${actionObj.target}. Note: You must wait for user to run it manually. If you can continue without it, do so. Otherwise, indicate you are waiting or done with this phase.`;
+                    break;
+                default:
+                    observation = `Unknown action: ${actionObj.action}`;
+            }
+
+            currentObservation = `Observation: ${observation}`;
+
+        } catch (err) {
+            console.error('[AutonomousBrain] Error during loop:', err);
+            currentObservation = `Error occurred: ${err.message}. Please try a different approach or conclude if task is impossible.`;
+        }
+    }
+
+    return result || "Task reached maximum steps without a final result.";
+}
+
+module.exports = { executeAutonomousTask };

package/src/AI_Brain/behavior_memory.js

@@ -0,0 +1,114 @@
+const fs = require('fs');
+const path = require('path');
+const { app } = require('electron');
+
+// ============================================================
+// Behavior Memory — Tracks user behavior patterns over time
+// ============================================================
+
+const MEMORY_FILE = path.join(app.getPath('userData'), 'behavior_memory.json');
+const MAX_CONTEXT_HISTORY = 20; // Keep last 20 context snapshots
+
+/**
+ * Load memory from disk (or return default empty structure)
+ */
+function loadMemory() {
+    try {
+        if (fs.existsSync(MEMORY_FILE)) {
+            const raw = fs.readFileSync(MEMORY_FILE, 'utf8');
+            return JSON.parse(raw);
+        }
+    } catch (err) {
+        console.error('[BehaviorMemory] Failed to read memory file:', err);
+    }
+
+    // Default empty memory structure
+    return {
+        appFrequency: {},       // { "YouTube": 5, "Google Chrome": 12 }
+        contextHistory: [],     // Last N context strings
+        lastUpdated: null
+    };
+}
+
+/**
+ * Save memory to disk
+ */
+function saveMemory(memory) {
+    try {
+        fs.writeFileSync(MEMORY_FILE, JSON.stringify(memory, null, 2), 'utf8');
+    } catch (err) {
+        console.error('[BehaviorMemory] Failed to save memory:', err);
+    }
+}
+
+/**
+ * Record a new context observation (called after each proactive scan)
+ * @param {string} contextDescription - Short description of what user is doing
+ */
+function recordBehavior(contextDescription) {
+    if (!contextDescription || typeof contextDescription !== 'string') return;
+
+    const memory = loadMemory();
+
+    // Append to context history (capped at MAX)
+    memory.contextHistory.unshift({
+        context: contextDescription,
+        time: new Date().toISOString(),
+        hour: new Date().getHours()
+    });
+    if (memory.contextHistory.length > MAX_CONTEXT_HISTORY) {
+        memory.contextHistory = memory.contextHistory.slice(0, MAX_CONTEXT_HISTORY);
+    }
+
+    // Extract app mentions and bump frequency
+    const appKeywords = [
+        'YouTube', 'Chrome', 'Firefox', 'VS Code', 'Spotify', 'Terminal',
+        'Google', 'Discord', 'Slack', 'Gmail', 'GitHub', 'Figma', 'Notion'
+    ];
+    for (const app of appKeywords) {
+        if (contextDescription.toLowerCase().includes(app.toLowerCase())) {
+            memory.appFrequency[app] = (memory.appFrequency[app] || 0) + 1;
+        }
+    }
+
+    memory.lastUpdated = new Date().toISOString();
+    saveMemory(memory);
+}
+
+/**
+ * Get a summary of behavior patterns for the Gemini prompt
+ * @returns {string} A human-readable behavior summary
+ */
+function getBehaviorSummary() {
+    const memory = loadMemory();
+
+    const parts = [];
+
+    // Top apps by frequency
+    const topApps = Object.entries(memory.appFrequency)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([app, count]) => `${app} (${count}x)`);
+
+    if (topApps.length > 0) {
+        parts.push(`Apps user frequently uses: ${topApps.join(', ')}`);
+    }
+
+    // Recent contexts (last 3)
+    const recentCtx = memory.contextHistory.slice(0, 3).map(c => c.context);
+    if (recentCtx.length > 0) {
+        parts.push(`Recent activities: ${recentCtx.join(' | ')}`);
+    }
+
+    // Time of day
+    const hour = new Date().getHours();
+    let timeOfDay = 'morning';
+    if (hour >= 12 && hour < 17) timeOfDay = 'afternoon';
+    else if (hour >= 17 && hour < 21) timeOfDay = 'evening';
+    else if (hour >= 21 || hour < 5) timeOfDay = 'night';
+    parts.push(`Current time of day: ${timeOfDay}`);
+
+    return parts.join('. ');
+}
+
+module.exports = { recordBehavior, getBehaviorSummary };