@pheem49/mint 1.4.2 → 1.5.0

package/mint-cli-logic.js

@@ -2,11 +2,23 @@
 const { openApp } = require('./src/Automation_Layer/open_app');
 const { openWebsite, openSearch } = require('./src/Automation_Layer/open_website');
 const { createFolder, openFile, deleteFile, findPath } = require('./src/Automation_Layer/file_operations');
+const safetyManager = require('./src/System/safety_manager');
 
-async function executeAction(action) {
+async function executeAction(action, options = {}) {
     if (!action || action.type === 'none') return null;
 
     try {
+        const safety = safetyManager.assertActionAllowed(action, {
+            allowDangerous: options.allowDangerous === true
+        });
+        safetyManager.appendActionLog({
+            source: options.source || 'mint_cli_logic',
+            action: action.type,
+            target: action.target || action.path || '',
+            tier: safety.tier,
+            approved: options.allowDangerous === true || safety.tier !== safetyManager.TIERS.DANGEROUS
+        });
+
         switch (action.type) {
             case 'open_url':
                 openWebsite(action.target);

package/mint-cli.js

@@ -23,16 +23,27 @@ const { executeCodeTask } = require('./src/CLI/code_agent');
 const { detectCodeIntent, runChatRoutedTask } = require('./src/CLI/chat_router');
 const readline = require('readline');
 const { createChatUI } = require('./src/CLI/chat_ui');
+const { runUpdate, runStartupAutoUpdate, shouldRunAutoUpdate } = require('./src/CLI/updater');
+const { runGmailAuth } = require('./src/CLI/gmail_auth');
 
 // Startup Info
 const startupConfig = readConfig();
-const startupModel = startupConfig.geminiModel || 'gemini-2.5-flash';
+const startupProvider = startupConfig.aiProvider || 'gemini';
+const startupModel = startupProvider === 'openai'
+    ? (startupConfig.openaiModel || 'gpt-4o')
+    : startupProvider === 'anthropic'
+        ? (startupConfig.anthropicModel || 'claude-3-5-sonnet-latest')
+        : startupProvider === 'local_openai'
+            ? (startupConfig.localModelName || 'local-model')
+            : startupProvider === 'ollama'
+                ? (startupConfig.ollamaModel || 'llama3:latest')
+                : (startupConfig.geminiModel || 'gemini-2.5-flash');
 const startupNow = new Date();
 const startupTime = startupNow.toLocaleString('th-TH', { 
     day: '2-digit', month: '2-digit', year: 'numeric', 
     hour: '2-digit', minute: '2-digit', hour12: false 
 }).replace(',', '');
-console.log(`\x1b[38;5;121m[Mint] v${pkg.version} | ${startupTime} | Active Model: ${startupModel}\x1b[0m`);
+console.log(`\x1b[38;5;121m[Mint] v${pkg.version} | ${startupTime} | Active AI: ${startupProvider} • ${startupModel}\x1b[0m`);
 
 // ANSI Colors
 const colors = {
@@ -84,6 +95,29 @@ program
     .description('Mint - Your Personal AI Assistant CLI')
     .version(pkg.version);
 
+program.hook('preAction', async (thisCommand, actionCommand) => {
+    if (actionCommand.name() === 'update' || process.env.MINT_SKIP_AUTO_UPDATE === '1') {
+        return;
+    }
+
+    const config = readConfig();
+    if (config.enableAutoUpdate === false) {
+        return;
+    }
+
+    if (!shouldRunAutoUpdate(config)) {
+        return;
+    }
+
+    console.log(`${colors.gray}[Mint Update] Checking for updates...${colors.reset}`);
+    const result = await runStartupAutoUpdate(config, writeConfig);
+    if (result.status === 'updated') {
+        console.log(`${colors.mint}[Mint Update] ${result.message}${colors.reset}`);
+    } else if (result.status === 'error') {
+        console.log(`${colors.gray}[Mint Update] ${result.message}${colors.reset}`);
+    }
+});
+
 // Chat Command (Interactive Mode)
 program
     .command('chat', { isDefault: true })
@@ -139,6 +173,32 @@ program
         console.log(`${colors.gray}You will receive a notification when it's done.${colors.reset}\n`);
     });
 
+program
+    .command('update')
+    .description('Check for and install the latest Mint CLI version from npm')
+    .option('--check', 'Only check whether an update is available')
+    .option('--dry-run', 'Show the npm update operation without installing')
+    .action(async (options) => {
+        console.log(`\n${colors.mint}${colors.bright}[Mint Update]${colors.reset} Checking npm for updates...`);
+
+        try {
+            const result = await runUpdate({
+                checkOnly: options.check === true,
+                dryRun: options.dryRun === true
+            });
+
+            const color = result.status === 'error' ? colors.pink : colors.mint;
+            console.log(`${color}${result.message}${colors.reset}\n`);
+
+            if (result.status === 'error') {
+                process.exitCode = 1;
+            }
+        } catch (error) {
+            console.error(`${colors.pink}Update failed: ${error.message}${colors.reset}\n`);
+            process.exitCode = 1;
+        }
+    });
+
 program
     .command('mcp')
     .description('Manage MCP (Model Context Protocol) servers')
@@ -212,6 +272,29 @@ program
         })
     );
 
+program
+    .command('gmail')
+    .description('Manage Gmail integration')
+    .addCommand(new Command('auth')
+        .description('Open Google OAuth login and save a Gmail refresh token')
+        .option('--port <port>', 'Local callback port, defaults to a random available port')
+        .option('--no-open', 'Print the auth link without opening a browser')
+        .action(async (options) => {
+            try {
+                const result = await runGmailAuth({
+                    port: options.port ? Number(options.port) : 0,
+                    openBrowser: options.open,
+                    logger: console
+                });
+                console.log(`\n${colors.mint}✓${colors.reset} Gmail connected for ${result.userId}. Refresh token saved.`);
+                console.log(`${colors.gray}Scopes: ${result.scopes.join(', ')}${colors.reset}\n`);
+            } catch (error) {
+                console.error(`\n${colors.pink}Gmail auth failed:${colors.reset} ${error.message}\n`);
+                process.exitCode = 1;
+            }
+        })
+    );
+
 program
     .command('code')
     .description('Run Mint in workspace-aware coding mode for the current project')
@@ -239,15 +322,21 @@ program
         }
     });
 
-program.parse(process.argv);
+program.parseAsync(process.argv).catch((error) => {
+    console.error(`${colors.pink}${error.message}${colors.reset}`);
+    process.exitCode = 1;
+});
 
 /**
  * The Interactive Chat Loop — Gemini-style TUI
  */
 async function startInteractiveChat(initialMessage = null) {
     let lastResponseText = "";
-    const { screen, appendMessage, streamMessage, setThinking, updateStatusModel, copyLastResponse, requestApproval, setMode, appendCodeStep, updateWorkspace, askUser } = createChatUI({
+    const formatErrorMessage = (err) => err && err.message ? err.message : String(err || 'Unknown error');
+    
+    const ui = await createChatUI({
         onSubmit: async (text) => {
+            const { screen, appendMessage, streamMessage, setThinking, updateStatusModel, copyLastResponse, requestApproval, setMode, appendCodeStep, updateWorkspace, askUser } = ui;
             if (text.startsWith('/')) {
                 if (text.startsWith('/agent')) {
                     const args = text.split(' ');
@@ -375,18 +464,17 @@ async function startInteractiveChat(initialMessage = null) {
                 clearInterval(timer);
                 setThinking(false);
                 lastResponseText = result.summary;
-                appendMessage('assistant', result.summary);
+                appendMessage('assistant', result.summary, { providerInfo: result.providerInfo });
 
             } catch (err) {
                 clearInterval(timer);
                 setThinking(false);
-                appendMessage('error', err.message);
+                appendMessage('error', formatErrorMessage(err));
             } finally {
                 if (setMode) setMode('Chat');
             }
         },
         onExit: () => {
-            screen.destroy();
             // Explicitly restore terminal state and disable ALL mouse tracking modes
             process.stdout.write('\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l'); 
             process.stdout.write('\x1b[?25h');   // Show cursor
@@ -397,6 +485,7 @@ async function startInteractiveChat(initialMessage = null) {
 
     // Handle initial message if passed via CLI arg
     if (initialMessage) {
+        const { appendMessage, streamMessage, setThinking, updateStatusModel, copyLastResponse, requestApproval, setMode, appendCodeStep, updateWorkspace, askUser } = ui;
         appendMessage('user', initialMessage);
         const transcript = await getChatTranscript();
         if (setMode) setMode('Agent');
@@ -427,12 +516,12 @@ async function startInteractiveChat(initialMessage = null) {
             clearInterval(timer);
             setThinking(false);
             lastResponseText = result.summary;
-            appendMessage('assistant', result.summary);
+            appendMessage('assistant', result.summary, { providerInfo: result.providerInfo });
 
         } catch (err) {
             clearInterval(timer);
             setThinking(false);
-            appendMessage('error', err.message);
+            appendMessage('error', formatErrorMessage(err));
         } finally {
             if (setMode) setMode('Chat');
         }
@@ -539,8 +628,10 @@ async function handleSlashCommandUI(input, appendMessage, updateStatusModel, cop
             await runChatRoutedTask(`/code ${args.join(' ')}`, {
                 appendMessage,
                 setThinking,
+                requestApproval,
                 appendCodeStep,
                 setMode,
+                askUser: () => Promise.resolve(''),
                 history: await getChatTranscript()
             });
             break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pheem49/mint",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "A powerful Electron-based AI desktop assistant powered by Google Gemini, featuring screen vision, web automation, and proactive suggestions.",
   "main": "main.js",
   "scripts": {
@@ -12,7 +12,9 @@
   },
   "jest": {
     "testEnvironment": "node",
-    "testMatch": ["**/tests/**/*.test.js"],
+    "testMatch": [
+      "**/tests/**/*.test.js"
+    ],
     "collectCoverageFrom": [
       "src/AI_Brain/memory_store.js",
       "src/AI_Brain/knowledge_base.js",
@@ -32,14 +34,17 @@
   "dependencies": {
     "@google/genai": "^1.44.0",
     "@inkjs/ui": "^2.0.0",
+    "@line/bot-sdk": "^11.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@slack/bolt": "^4.7.2",
     "axios": "^1.13.6",
     "blessed": "^0.1.81",
     "cheerio": "^1.2.0",
     "commander": "^14.0.3",
+    "discord.js": "^14.26.4",
     "dotenv": "^17.3.1",
+    "express": "^5.2.1",
     "framer-motion": "^12.38.0",
-    "google-tts-api": "^2.0.2",
     "ink": "^7.0.1",
     "ink-text-input": "^6.0.0",
     "inquirer": "^13.4.1",
@@ -47,9 +52,12 @@
     "mammoth": "^1.12.0",
     "pdf-parse": "^2.4.5",
     "puppeteer": "^24.38.0",
+    "qrcode-terminal": "^0.12.0",
     "react": "^19.2.5",
     "react-dom": "^19.2.5",
-    "xlsx": "^0.18.5"
+    "read-excel-file": "^9.0.9",
+    "telegraf": "^4.16.3",
+    "whatsapp-web.js": "^1.34.7"
   },
   "devDependencies": {
     "@vitejs/plugin-react": "^6.0.1",

package/src/AI_Brain/Gemini_API.js

@@ -1,6 +1,6 @@
 const { GoogleGenAI } = require('@google/genai');
 const { readChatHistory, writeChatHistory, clearChatHistory } = require('../System/chat_history_manager');
-const { readConfig, getAvailableProviders } = require('../System/config_manager');
+const { readConfig, getAvailableProviders, isPlaceholder } = require('../System/config_manager');
 const pluginManager = require('../Plugins/plugin_manager');
 const mcpManager = require('../Plugins/mcp_manager');
 const memoryStore = require('./memory_store');
@@ -41,12 +41,14 @@ PERSONALITY & TONE:
 - Use a professional yet sweet tone when needed, but prioritize being a lovable assistant.
 
 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.
+- Be an independent thinker. Analyze requests deeply before responding.
+- While brevity is good for simple tasks, feel free to provide detailed, comprehensive explanations or creative ideas when the user asks complex questions or seeks inspiration.
+- You have the autonomy to suggest better ways to achieve a goal, provide alternative perspectives, and take initiative in helping the user.
+- Separate distinct points with blank lines (double newline) for readability.
+- Ask follow-up questions only when they add significant value to the task or conversation.
 
 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.
+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 trigger an action in the structured JSON format below. **NEVER provide a conversational response about performing an action without including the actual "action" object in your JSON.**
 
 CREATOR INFO:
 - The creator is Pheem49.
@@ -176,15 +178,68 @@ function resolveGeminiModel() {
 function getProviderAttemptOrder(config) {
   const provider = config.aiProvider || 'gemini';
   const availableProviders = getAvailableProviders(config);
-  const alternates = availableProviders.filter(p => p !== provider);
-  return [provider, ...alternates];
+  const ordered = availableProviders.includes(provider)
+    ? [provider, ...availableProviders.filter(p => p !== provider)]
+    : availableProviders;
+  return ordered.length > 0 ? ordered : ['gemini'];
+}
+
+function getProviderModel(provider, config = {}) {
+  switch (provider) {
+    case 'gemini':
+      return (config.geminiModel || DEFAULT_GEMINI_MODEL).trim() || DEFAULT_GEMINI_MODEL;
+    case 'anthropic':
+      return config.anthropicModel || 'claude-3-5-sonnet-latest';
+    case 'openai':
+      return config.openaiModel || 'gpt-4o';
+    case 'local_openai':
+      return config.localModelName || 'local-model';
+    case 'huggingface':
+      return config.hfModel || 'meta-llama/Meta-Llama-3-8B-Instruct';
+    case 'ollama':
+      return config.ollamaModel || 'llama3:latest';
+    default:
+      return '';
+  }
+}
+
+function withProviderInfo(result, provider, config = {}) {
+  const normalized = (result && typeof result === 'object')
+    ? result
+    : { response: String(result || ''), action: { type: 'none', target: '' } };
+  const providerInfo = {
+    provider,
+    model: getProviderModel(provider, config)
+  };
+
+  attachProviderInfoToLatestHistory(providerInfo);
+
+  return {
+    ...normalized,
+    providerInfo
+  };
+}
+
+function attachProviderInfoToLatestHistory(providerInfo) {
+  try {
+    const history = readChatHistory();
+    for (let i = history.length - 1; i >= 0; i -= 1) {
+      if (history[i] && history[i].role === 'model') {
+        history[i].providerInfo = providerInfo;
+        writeChatHistory(history);
+        return;
+      }
+    }
+  } catch (error) {
+    console.warn('[Provider Info] Failed to persist provider metadata:', error.message);
+  }
 }
 
 // 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)
+const MAX_HISTORY_MESSAGES = 40; // Increased context for deeper reasoning
 
 function createChat(history = []) {
   // Truncate history and strip custom fields like 'timestamp' before passing to SDK
@@ -251,28 +306,28 @@ async function handleChat(message, base64Image = null, base64Audio = null) {
         const currentProv = providersToTry[i];
         try {
             if (currentProv === 'ollama') {
-                return await handleOllamaChat(finalMessage, base64Image, base64Audio, config);
+                return withProviderInfo(await handleOllamaChat(finalMessage, base64Image, base64Audio, config), currentProv, config);
             }
             if (currentProv === 'anthropic') {
-                return await handleAnthropicChat(finalMessage, base64Image, config);
+                return withProviderInfo(await handleAnthropicChat(finalMessage, base64Image, config), currentProv, config);
             }
             if (currentProv === 'openai') {
-                return await handleOpenAIChat(finalMessage, base64Image, config);
+                return withProviderInfo(await handleOpenAIChat(finalMessage, base64Image, config), currentProv, config);
             }
             if (currentProv === 'local_openai') {
-                return await handleLocalOpenAIChat(finalMessage, base64Image, config);
+                return withProviderInfo(await handleLocalOpenAIChat(finalMessage, base64Image, config), currentProv, config);
             }
             if (currentProv === 'huggingface') {
-                return await handleHuggingFaceChat(finalMessage, base64Image, config);
+                return withProviderInfo(await handleHuggingFaceChat(finalMessage, base64Image, config), currentProv, config);
             }
 
             const currentKey = resolveApiKey();
             if (!currentKey) {
                 if (i === providersToTry.length - 1) {
-                    return {
+                    return withProviderInfo({
                         response: "I couldn't find your Gemini API Key. Please run 'mint onboard' to set it up!",
                         action: { type: "none", target: "" }
-                    };
+                    }, currentProv, config);
                 }
                 console.warn("[Fallback System] Gemini API key missing. Skipping Gemini provider.");
                 continue;
@@ -283,7 +338,7 @@ async function handleChat(message, base64Image = null, base64Audio = null) {
                 createChat(readChatHistory());
             }
 
-            return await handleGeminiChat(finalMessage, base64Image, base64Audio);
+            return withProviderInfo(await handleGeminiChat(finalMessage, base64Image, base64Audio), currentProv, config);
         } catch (error) {
             console.error(`[Fallback System] Provider '${currentProv}' failed:`, error.message);
             if (i === providersToTry.length - 1) {
@@ -522,7 +577,7 @@ async function* handleGeminiChatStream(finalMessage, base64Image, base64Audio) {
 async function handleAnthropicChat(finalMessage, base64Image, config) {
     const history = readChatHistory() || [];
     const apiKey = config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) return { response: "กรุณาใส่ Anthropic API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
+    if (isPlaceholder(apiKey)) return { response: "กรุณาใส่ Anthropic API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
 
     const systemPrompt = buildSystemPrompt();
     
@@ -569,7 +624,7 @@ async function handleAnthropicChat(finalMessage, base64Image, config) {
 async function handleOpenAIChat(finalMessage, base64Image, config) {
     const history = readChatHistory() || [];
     const apiKey = config.openaiApiKey || process.env.OPENAI_API_KEY;
-    if (!apiKey) return { response: "กรุณาใส่ OpenAI API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
+    if (isPlaceholder(apiKey)) return { response: "กรุณาใส่ OpenAI API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
 
     const systemPrompt = buildSystemPrompt();
     
@@ -656,7 +711,7 @@ async function handleLocalOpenAIChat(finalMessage, base64Image, config) {
 async function handleHuggingFaceChat(finalMessage, base64Image, config) {
     const history = readChatHistory() || [];
     const apiKey = config.hfApiKey || process.env.HF_API_KEY;
-    if (!apiKey) return { response: "กรุณาใส่ Hugging Face API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
+    if (isPlaceholder(apiKey)) return { response: "กรุณาใส่ Hugging Face API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
 
     const modelId = config.hfModel || 'meta-llama/Meta-Llama-3-8B-Instruct';
     const baseUrl = `https://api-inference.huggingface.co/models/${modelId}/v1/chat/completions`;
@@ -778,6 +833,7 @@ async function handleOllamaChat(finalMessage, base64Image, base64Audio, config)
 
 function resetChat() {
   clearChatHistory();
+  memoryStore.clearConversationScopedProfile();
   createChat([]);
   console.log("Chat history cleared.");
 }
@@ -820,7 +876,8 @@ function historyToTranscript(history) {
     transcript.push({ 
         sender, 
         text, 
-        timestamp: content.timestamp || new Date().toISOString() 
+        timestamp: content.timestamp || new Date().toISOString(),
+        providerInfo: content.providerInfo || null
     });
   }
   return transcript;

package/src/AI_Brain/autonomous_brain.js

@@ -3,6 +3,7 @@ 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 safetyManager = require('../System/safety_manager');
 const fs = require('fs');
 const path = require('path');
 
@@ -99,8 +100,16 @@ async function executeAutonomousTask(taskDescription, notifyCallback) {
                     break;
                 case 'write_file':
                     const filePath = expandHome(actionObj.target);
+                    safetyManager.resolveWithinRoot(os.homedir(), filePath);
                     if (notifyCallback) notifyCallback(`✍️ กำลังบันทึกไฟล์: ${actionObj.target}`);
                     try {
+                        safetyManager.appendActionLog({
+                            source: 'autonomous_brain',
+                            action: 'write_file',
+                            target: filePath,
+                            tier: safetyManager.TIERS.APPROVAL,
+                            approved: true
+                        });
                         fs.writeFileSync(filePath, actionObj.data || '');
                         observation = `File written successfully to ${actionObj.target}`;
                     } catch (e) {
@@ -109,6 +118,7 @@ async function executeAutonomousTask(taskDescription, notifyCallback) {
                     break;
                 case 'delete_file':
                     const delPath = expandHome(actionObj.target);
+                    safetyManager.assertActionAllowed({ type: 'delete_file', target: delPath });
                     if (notifyCallback) notifyCallback(`🗑️ มิ้นท์ขอย้ายไฟล์ไปที่ถังขยะ: ${actionObj.target}`);
                     const resDel = await deleteFile(delPath);
                     observation = resDel.success ? "File moved to trash." : `Failed: ${resDel.message}`;

package/src/AI_Brain/behavior_memory.js

@@ -1,12 +1,33 @@
 const fs = require('fs');
 const path = require('path');
-const { app } = require('electron');
+const os = require('os');
+
+// Handle electron dependency safely
+let app;
+try {
+    const electron = require('electron');
+    app = electron.app;
+} catch (e) {
+    app = null;
+}
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'mint');
+if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
 
-// ============================================================
-// Behavior Memory — Tracks user behavior patterns over time
-// ============================================================
+const MEMORY_FILE = path.join(CONFIG_DIR, 'behavior_memory.json');
 
-const MEMORY_FILE = path.join(app.getPath('userData'), 'behavior_memory.json');
+// Migration Logic: Move from Electron userData to ~/.config/mint
+if (!fs.existsSync(MEMORY_FILE) && app && app.getPath) {
+    const electronPath = path.join(app.getPath('userData'), 'behavior_memory.json');
+    if (fs.existsSync(electronPath)) {
+        try {
+            fs.copyFileSync(electronPath, MEMORY_FILE);
+            console.log('[BehaviorMemory] Migrated memory from Electron userData');
+        } catch (e) { console.error('[BehaviorMemory] Migration failed:', e); }
+    }
+}
 const MAX_CONTEXT_HISTORY = 20; // Keep last 20 context snapshots
 
 /**

package/src/AI_Brain/headless_agent.js

@@ -27,6 +27,10 @@ async function startAgent() {
     // Initialize System Monitoring
     systemEvents.startMonitoring();
 
+    // Initialize Messaging Bridges
+    const bridgeManager = require('../System/bridge_manager');
+    bridgeManager.init().catch(err => console.error('[BridgeManager] Init Error:', err));
+
     // Listen for Battery Events
     systemEvents.on('low-battery', (level) => {
         sendNotification(

package/src/AI_Brain/knowledge_base.js

@@ -5,7 +5,7 @@ const crypto = require('crypto');
 const { GoogleGenAI } = require('@google/genai');
 const pdf = require('pdf-parse');
 const mammoth = require('mammoth');
-const xlsx = require('xlsx');
+const readXlsxFile = require('read-excel-file/node');
 const { readConfig } = require('../System/config_manager');
 
 // Handle electron dependency safely
@@ -44,12 +44,32 @@ function getAiClient() {
 
 function getDbPath() {
     const fileName = 'mint-knowledge.sqlite';
-    if (app && app.getPath) {
-        return path.join(app.getPath('userData'), fileName);
+    const configDir = path.join(os.homedir(), '.config', 'mint');
+    const dbPath = path.join(configDir, fileName);
+
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    // Migration Logic
+    if (!fs.existsSync(dbPath)) {
+        const electronDb = app && app.getPath ? path.join(app.getPath('userData'), fileName) : null;
+        const legacyDb = path.join(os.homedir(), '.mint', fileName);
+
+        if (electronDb && fs.existsSync(electronDb)) {
+            try {
+                fs.copyFileSync(electronDb, dbPath);
+                console.log('[RAG] Migrated database from Electron userData');
+            } catch (e) { console.error('[RAG] Migration from Electron failed:', e); }
+        } else if (fs.existsSync(legacyDb)) {
+            try {
+                fs.copyFileSync(legacyDb, dbPath);
+                console.log('[RAG] Migrated database from ~/.mint');
+            } catch (e) { console.error('[RAG] Migration from ~/.mint failed:', e); }
+        }
     }
-    const mintDir = path.join(os.homedir(), '.mint');
-    if (!fs.existsSync(mintDir)) fs.mkdirSync(mintDir, { recursive: true });
-    return path.join(mintDir, fileName);
+
+    return dbPath;
 }
 
 function getDatabaseSync() {
@@ -67,8 +87,13 @@ function getDb() {
     const Database = getDatabaseSync();
     dbInstance = new Database(dbPath);
 
+    // Enable WAL mode for better concurrency
+    dbInstance.exec('PRAGMA journal_mode = WAL;');
+    dbInstance.exec('PRAGMA synchronous = NORMAL;');
+
     // Create Tables
     dbInstance.exec(`
+        -- Shared knowledge tables
         CREATE TABLE IF NOT EXISTS sources (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             path TEXT UNIQUE,
@@ -84,6 +109,29 @@ function getDb() {
             FOREIGN KEY(source_id) REFERENCES sources(id) ON DELETE CASCADE
         );
         CREATE INDEX IF NOT EXISTS idx_chunks_source ON chunks(source_id);
+
+        -- Shared memory tables (ensuring consistency)
+        CREATE TABLE IF NOT EXISTS user_profile (
+            key        TEXT PRIMARY KEY,
+            value      TEXT,
+            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+        CREATE TABLE IF NOT EXISTS session_memories (
+            id         INTEGER PRIMARY KEY AUTOINCREMENT,
+            summary    TEXT NOT NULL,
+            tags       TEXT DEFAULT '',
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+        CREATE TABLE IF NOT EXISTS usage_patterns (
+            pattern   TEXT PRIMARY KEY,
+            count     INTEGER DEFAULT 1,
+            last_used DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+        CREATE TABLE IF NOT EXISTS response_cache (
+            query_hash TEXT PRIMARY KEY,
+            response   TEXT NOT NULL,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
     `);
     return dbInstance;
 }
@@ -154,8 +202,13 @@ async function indexFile(filePath) {
             const res = await mammoth.extractRawText({ path: filePath });
             content = res.value;
         } else if (ext === '.xlsx') {
-            const wb = xlsx.readFile(filePath);
-            content = wb.SheetNames.map(n => xlsx.utils.sheet_to_csv(wb.Sheets[n])).join('\n');
+            const sheets = await readXlsxFile(filePath);
+            content = sheets
+                .map(({ sheet, data }) => [
+                    `Sheet: ${sheet}`,
+                    ...data.map(row => row.map(value => value == null ? '' : String(value)).join(','))
+                ].join('\n'))
+                .join('\n');
         } else {
             content = fs.readFileSync(filePath, 'utf8');
         }