@pheem49/mint 1.4.2 → 1.5.1

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.assertPathCapability(filePath, 'write');
                     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,8 @@ async function executeAutonomousTask(taskDescription, notifyCallback) {
                     break;
                 case 'delete_file':
                     const delPath = expandHome(actionObj.target);
+                    safetyManager.assertActionAllowed({ type: 'delete_file', target: delPath });
+                    safetyManager.assertPathCapability(delPath, 'write');
                     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');
         }

package/src/AI_Brain/memory_store.js

@@ -25,12 +25,32 @@ try {
 
 function getDbPath() {
     const fileName = 'mint-knowledge.sqlite'; // shared DB with knowledge_base
-    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('[Memory] Migrated database from Electron userData');
+            } catch (e) { console.error('[Memory] Migration from Electron failed:', e); }
+        } else if (fs.existsSync(legacyDb)) {
+            try {
+                fs.copyFileSync(legacyDb, dbPath);
+                console.log('[Memory] Migrated database from ~/.mint');
+            } catch (e) { console.error('[Memory] 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;
 }
 
 // ── Lazy DatabaseSync init ─────────────────────────────────────────────────
@@ -45,6 +65,10 @@ function getDb() {
     if (dbInstance) return dbInstance;
     const Database = getDatabaseSync();
     dbInstance = new Database(getDbPath());
+    
+    // Enable WAL mode for better concurrency
+    dbInstance.exec('PRAGMA journal_mode = WAL;');
+    dbInstance.exec('PRAGMA synchronous = NORMAL;');
 
     dbInstance.exec(`
         -- User profile: arbitrary key-value pairs
@@ -69,17 +93,49 @@ function getDb() {
             last_used DATETIME DEFAULT CURRENT_TIMESTAMP
         );
 
+        -- Raw episodic memories of user/assistant turns.
+        CREATE TABLE IF NOT EXISTS interaction_memories (
+            id          INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_text   TEXT NOT NULL,
+            ai_text     TEXT NOT NULL,
+            keywords    TEXT DEFAULT '',
+            created_at  DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+
         -- Response Cache: For repetitive exact queries
         CREATE TABLE IF NOT EXISTS response_cache (
             query_hash TEXT PRIMARY KEY,
             response   TEXT NOT NULL,
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP
         );
+
+        -- Learned skill/instruction documents imported from local files.
+        CREATE TABLE IF NOT EXISTS learned_skills (
+            id         INTEGER PRIMARY KEY AUTOINCREMENT,
+            name       TEXT NOT NULL,
+            source_path TEXT NOT NULL UNIQUE,
+            content    TEXT NOT NULL,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
     `);
 
     return dbInstance;
 }
 
+function ensureLearnedSkillsTable() {
+    getDb().exec(`
+        CREATE TABLE IF NOT EXISTS learned_skills (
+            id          INTEGER PRIMARY KEY AUTOINCREMENT,
+            name        TEXT NOT NULL,
+            source_path TEXT NOT NULL UNIQUE,
+            content     TEXT NOT NULL,
+            created_at  DATETIME DEFAULT CURRENT_TIMESTAMP,
+            updated_at  DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+    `);
+}
+
 // ── Profile helpers ────────────────────────────────────────────────────────
 function setProfile(key, value) {
     try {
@@ -94,6 +150,19 @@ function setProfile(key, value) {
     }
 }
 
+function deleteProfile(key) {
+    try {
+        getDb().prepare('DELETE FROM user_profile WHERE key = ?').run(key);
+    } catch (err) {
+        console.error('[Memory] deleteProfile error:', err.message);
+    }
+}
+
+function clearConversationScopedProfile() {
+    deleteProfile('preferred_language');
+    clearResponseCache();
+}
+
 function getProfile(key, defaultValue = null) {
     try {
         const row = getDb().prepare('SELECT value FROM user_profile WHERE key = ?').get(key);
@@ -166,6 +235,116 @@ function getTopPatterns(limit = 8) {
     }
 }
 
+const MAX_INTERACTION_MEMORIES = 1000;
+
+function stripRelevantMemoryBlock(text) {
+    return String(text || '')
+        .replace(/\n?\[Relevant long-term memory for this user message\][\s\S]*?\[End relevant memory\]\n?/g, '\n')
+        .replace(/^\s*\[Relevant long-term memory for this user message\][\s\S]*?\[End relevant memory\]\s*/g, '')
+        .replace(/\n?\[LOCAL KNOWLEDGE BASE - USE THIS CONTEXT TO ANSWER\][\s\S]*/g, '')
+        .trim();
+}
+
+function addInteractionMemory(userMessage, aiResponseText, keywords = []) {
+    try {
+        const db = getDb();
+        db.prepare(`
+            INSERT INTO interaction_memories (user_text, ai_text, keywords)
+            VALUES (?, ?, ?)
+        `).run(
+            String(userMessage || '').slice(0, 1200),
+            String(aiResponseText || '').slice(0, 1200),
+            keywords.join(',')
+        );
+        db.exec(`
+            DELETE FROM interaction_memories WHERE id NOT IN (
+                SELECT id FROM interaction_memories ORDER BY id DESC LIMIT ${MAX_INTERACTION_MEMORIES}
+            )
+        `);
+    } catch (err) {
+        console.error('[Memory] addInteractionMemory error:', err.message);
+    }
+}
+
+function getRecentInteractions(limit = 5) {
+    try {
+        return getDb()
+            .prepare('SELECT id, user_text, ai_text, keywords, created_at FROM interaction_memories ORDER BY id DESC LIMIT ?')
+            .all(limit);
+    } catch (_) {
+        return [];
+    }
+}
+
+function deleteInteractionMemory(id) {
+    try {
+        const result = getDb().prepare('DELETE FROM interaction_memories WHERE id = ?').run(id);
+        return result.changes > 0;
+    } catch (err) {
+        console.error('[Memory] deleteInteractionMemory error:', err.message);
+        return false;
+    }
+}
+
+function searchInteractions(query, limit = 8) {
+    try {
+        const keywords = extractKeywords(query);
+        const terms = keywords.length > 0 ? keywords : [String(query || '').trim()].filter(Boolean);
+        if (terms.length === 0) return [];
+
+        const rows = [];
+        const seen = new Set();
+        const stmt = getDb().prepare(`
+            SELECT id, user_text, ai_text, keywords, created_at
+            FROM interaction_memories
+            WHERE user_text LIKE ? OR ai_text LIKE ? OR keywords LIKE ?
+            ORDER BY id DESC
+            LIMIT ?
+        `);
+
+        for (const term of terms.slice(0, 5)) {
+            const like = `%${term}%`;
+            for (const row of stmt.all(like, like, like, limit)) {
+                if (!seen.has(row.id)) {
+                    seen.add(row.id);
+                    rows.push(row);
+                    if (rows.length >= limit) return rows;
+                }
+            }
+        }
+        return rows;
+    } catch (_) {
+        return [];
+    }
+}
+
+function clearInteractionMemories() {
+    try {
+        getDb().prepare('DELETE FROM interaction_memories').run();
+    } catch (err) {
+        console.error('[Memory] clearInteractionMemories error:', err.message);
+    }
+}
+
+function exportMemorySnapshot() {
+    try {
+        return {
+            profile: getAllProfile(),
+            session_memories: getRecentMemories(MAX_SESSION_MEMORIES),
+            usage_patterns: getTopPatterns(50),
+            interaction_memories: getRecentInteractions(MAX_INTERACTION_MEMORIES)
+        };
+    } catch (err) {
+        console.error('[Memory] exportMemorySnapshot error:', err.message);
+        return {
+            profile: {},
+            session_memories: [],
+            usage_patterns: [],
+            interaction_memories: []
+        };
+    }
+}
+
 // ── Simple keyword extractor (no external deps) ────────────────────────────
 const STOP_WORDS = new Set([
     'ที่', 'ให้', 'และ', 'ของ', 'กับ', 'ใน', 'บน', 'เป็น', 'อยู่', 'มี', 'ได้', 'the', 'a', 'an',
@@ -183,6 +362,37 @@ function extractKeywords(text) {
         .slice(0, 6);
 }
 
+function cleanProfileValue(value) {
+    return String(value || '')
+        .replace(/[.,!?;:()[\]{}"'`“”‘’]+$/g, '')
+        .replace(/(นะ|น่ะ|ครับ|ค่ะ|คะ|จ้า|จ๊ะ|ฮะ|ค้าบ|ค่า)+$/u, '')
+        .trim();
+}
+
+function extractUserName(text) {
+    const input = String(text || '').trim();
+    const patterns = [
+        /(?:ผม|ฉัน|ชั้น|หนู|เรา|ข้า|ดิฉัน)?\s*ชื่อ(?:เล่น)?\s*(?:คือ|ว่า|เป็น)?\s*([A-Za-z\u0E00-\u0E7F][A-Za-z\u0E00-\u0E7F\s]{0,40})/iu,
+        /(?:เรียก(?:ผม|ฉัน|ชั้น|หนู|เรา)?ว่า)\s*([A-Za-z\u0E00-\u0E7F][A-Za-z\u0E00-\u0E7F\s]{0,40})/iu,
+        /\bmy name is\s+([A-Za-z][A-Za-z\s'-]{0,40})/iu,
+        /\bcall me\s+([A-Za-z][A-Za-z\s'-]{0,40})/iu,
+        /\bi am\s+([A-Za-z][A-Za-z\s'-]{0,40})/iu,
+        /\bi'm\s+([A-Za-z][A-Za-z\s'-]{0,40})/iu
+    ];
+
+    for (const pattern of patterns) {
+        const match = input.match(pattern);
+        if (match && match[1]) {
+            const name = cleanProfileValue(match[1])
+                .split(/\s+(?:and|แล้ว|นะ|ครับ|ค่ะ|คะ)\s+/i)[0]
+                .trim();
+            if (name && name.length <= 40) return name;
+        }
+    }
+
+    return '';
+}
+
 // ── Main public API ────────────────────────────────────────────────────────
 
 /**
@@ -196,12 +406,18 @@ function recordInteraction(userMessage, aiResponseText) {
         // Extract keywords as usage patterns
         const keywords = extractKeywords(userMessage);
         keywords.forEach(kw => recordPattern(kw));
+        addInteractionMemory(userMessage, aiResponseText, keywords);
 
         // Detect preferred language
         const thaiRatio = (userMessage.match(/[\u0E00-\u0E7F]/g) || []).length / userMessage.length;
         if (thaiRatio > 0.3) setProfile('preferred_language', 'thai');
         else setProfile('preferred_language', 'english');
 
+        const userName = extractUserName(userMessage);
+        if (userName) {
+            setProfile('user_name', userName);
+        }
+
         // Detect coding intent (update project activity)
         const codingKeywords = ['code', 'fix', 'debug', 'function', 'class', 'import', 'script',
             'แก้', 'เขียน', 'โค้ด', 'สคริปต์', 'ฟังก์ชัน'];
@@ -231,22 +447,88 @@ function saveSessionSummary(summary, tags = []) {
     addSessionMemory(summary.trim(), tags);
 }
 
+function addLearnedSkill(name, sourcePath, content) {
+    const cleanName = String(name || '').trim() || path.basename(sourcePath || 'skill.md');
+    const cleanPath = path.resolve(String(sourcePath || ''));
+    const cleanContent = String(content || '').trim();
+    if (!cleanContent) {
+        throw new Error('Skill file is empty.');
+    }
+
+    const storedContent = cleanContent.slice(0, 12000);
+    ensureLearnedSkillsTable();
+    const db = getDb();
+    db.prepare(`
+        INSERT INTO learned_skills (name, source_path, content, created_at, updated_at)
+        VALUES (?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+        ON CONFLICT(source_path) DO UPDATE SET
+            name = excluded.name,
+            content = excluded.content,
+            updated_at = CURRENT_TIMESTAMP
+    `).run(cleanName, cleanPath, storedContent);
+
+    return {
+        name: cleanName,
+        source_path: cleanPath,
+        content_length: cleanContent.length,
+        stored_length: storedContent.length
+    };
+}
+
+function getLearnedSkills(limit = 10) {
+    try {
+        ensureLearnedSkillsTable();
+        return getDb().prepare(`
+            SELECT id, name, source_path, content, created_at, updated_at
+            FROM learned_skills
+            ORDER BY updated_at DESC, id DESC
+            LIMIT ?
+        `).all(limit);
+    } catch (err) {
+        console.error('[Memory] getLearnedSkills error:', err.message);
+        return [];
+    }
+}
+
+function deleteLearnedSkill(identifier) {
+    try {
+        ensureLearnedSkillsTable();
+        const input = String(identifier || '').trim();
+        if (!input) return 0;
+
+        const db = getDb();
+        if (/^\d+$/.test(input)) {
+            return db.prepare('DELETE FROM learned_skills WHERE id = ?').run(Number(input)).changes;
+        }
+
+        const resolved = path.resolve(input);
+        return db.prepare('DELETE FROM learned_skills WHERE source_path = ? OR name = ?').run(resolved, input).changes;
+    } catch (err) {
+        console.error('[Memory] deleteLearnedSkill error:', err.message);
+        return 0;
+    }
+}
+
 /**
  * Returns a formatted context string to inject into the AI system prompt.
  * Lightweight — no async calls.
  */
-function getUserContext() {
+function getUserContext(query = '') {
     try {
         const profile = getAllProfile();
         const patterns = getTopPatterns(6);
         const memories = getRecentMemories(3);
+        const interactions = getRecentInteractions(6);
+        const relevantInteractions = query ? searchInteractions(query, 5) : [];
 
         const lines = ['\n\n[LONG-TERM USER CONTEXT — use this to personalize responses]'];
 
         // Profile info
         if (Object.keys(profile).length > 0) {
+            if (profile.user_name)
+                lines.push(`• User name: ${profile.user_name}`);
             if (profile.preferred_language)
-                lines.push(`• Preferred language: ${profile.preferred_language}`);
+                lines.push(`• Previously inferred language: ${profile.preferred_language} (do not override the current user message language)`);
             if (profile.last_active_project)
                 lines.push(`• Last active project: ${profile.last_active_project} (${profile.last_active_project_path || ''})`);
             if (profile.total_interactions)
@@ -269,6 +551,36 @@ function getUserContext() {
             memories.forEach((m, i) => lines.push(`  ${i + 1}. ${m.summary}`));
         }
 
+        if (interactions.length > 0) {
+            lines.push('\nRecent remembered interactions:');
+            interactions.forEach((m, i) => {
+                lines.push(`  ${i + 1}. User: ${m.user_text}`);
+                lines.push(`     Mint: ${m.ai_text}`);
+            });
+        }
+
+        if (relevantInteractions.length > 0) {
+            lines.push('\nRelevant remembered interactions for the current request:');
+            relevantInteractions.forEach((m, i) => {
+                lines.push(`  ${i + 1}. User: ${m.user_text}`);
+                lines.push(`     Mint: ${m.ai_text}`);
+            });
+        }
+
+        const learnedSkills = getLearnedSkills(8);
+        if (learnedSkills.length > 0) {
+            lines.push('\nLearned skill/instruction files:');
+            learnedSkills.forEach((skill, i) => {
+                lines.push(`\n  ${i + 1}. ${skill.name}`);
+                lines.push(`     Source: ${skill.source_path}`);
+                lines.push('     Content:');
+                lines.push(skill.content
+                    .split('\n')
+                    .map(line => `       ${line}`)
+                    .join('\n'));
+            });
+        }
+
         if (lines.length === 1) return ''; // nothing to add
         lines.push('[END USER CONTEXT]\n');
         return lines.join('\n');
@@ -287,7 +599,11 @@ function getCachedResponse(query) {
             // Optional: check TTL (e.g., 24 hours)
             const age = Date.now() - new Date(row.created_at).getTime();
             if (age < 24 * 60 * 60 * 1000) {
-                return JSON.parse(row.response);
+                const parsed = JSON.parse(row.response);
+                if (parsed && typeof parsed.response === 'string') {
+                    parsed.response = stripRelevantMemoryBlock(parsed.response);
+                }
+                return parsed;
             }
         }
     } catch (_) {}
@@ -297,22 +613,50 @@ function getCachedResponse(query) {
 function cacheResponse(query, responseObj) {
     try {
         const hash = crypto.createHash('md5').update(query.trim().toLowerCase()).digest('hex');
+        const sanitized = (responseObj && typeof responseObj === 'object')
+            ? {
+                ...responseObj,
+                response: typeof responseObj.response === 'string'
+                    ? stripRelevantMemoryBlock(responseObj.response)
+                    : responseObj.response
+            }
+            : responseObj;
         getDb().prepare(`
             INSERT INTO response_cache (query_hash, response, created_at)
             VALUES (?, ?, CURRENT_TIMESTAMP)
             ON CONFLICT(query_hash) DO UPDATE SET response = excluded.response, created_at = CURRENT_TIMESTAMP
-        `).run(hash, JSON.stringify(responseObj));
+        `).run(hash, JSON.stringify(sanitized));
     } catch (_) {}
 }
 
+function clearResponseCache() {
+    try {
+        getDb().prepare('DELETE FROM response_cache').run();
+    } catch (err) {
+        console.error('[Memory] clearResponseCache error:', err.message);
+    }
+}
+
 module.exports = {
     recordInteraction,
     saveSessionSummary,
     getUserContext,
     setProfile,
+    deleteProfile,
+    clearConversationScopedProfile,
     getProfile,
+    getAllProfile,
+    addLearnedSkill,
+    getLearnedSkills,
+    deleteLearnedSkill,
     getTopPatterns,
+    getRecentInteractions,
+    searchInteractions,
+    deleteInteractionMemory,
+    clearInteractionMemories,
+    exportMemorySnapshot,
     getRecentMemories,
     getCachedResponse,
-    cacheResponse
+    cacheResponse,
+    clearResponseCache
 };

package/src/Automation_Layer/file_operations.js

@@ -226,7 +226,7 @@ async function openFile(target) {
             // ใช้ exec เพื่อให้รันผ่าน shell และรองรับการทำ fallback
             let cmd = `${platformCmd} "${resolvedPath}"`;
             if (process.platform === 'linux') {
-                cmd = `xdg-open "${resolvedPath}" || gio open "${resolvedPath}" || nautilus "${resolvedPath}"`;
+                cmd = `xdg-open "${resolvedPath}" || gio open "${resolvedPath}" || nautilus "${resolvedPath}" || nemo "${resolvedPath}" || thunar "${resolvedPath}" || dolphin "${resolvedPath}"`;
             }
 
             exec(cmd, (err) => {