@pheem49/mint 1.3.0 → 1.4.1

package/src/AI_Brain/memory_store.js

@@ -0,0 +1,318 @@
+/**
+ * Mint Long-Term Memory Store
+ * ---------------------------
+ * Persists user preferences, session summaries, and usage patterns
+ * across all Mint sessions using SQLite (same DB as knowledge_base).
+ *
+ * Auto-injects a "User Context" block into the system prompt so Mint
+ * remembers who it's talking to even after restart.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { readConfig } = require('../System/config_manager');
+
+// ── Electron-safe app path ──────────────────────────────────────────────────
+let app;
+try {
+    const electron = require('electron');
+    app = electron.app;
+} catch (_) {
+    app = null;
+}
+
+function getDbPath() {
+    const fileName = 'mint-knowledge.sqlite'; // shared DB with knowledge_base
+    if (app && app.getPath) {
+        return path.join(app.getPath('userData'), fileName);
+    }
+    const mintDir = path.join(os.homedir(), '.mint');
+    if (!fs.existsSync(mintDir)) fs.mkdirSync(mintDir, { recursive: true });
+    return path.join(mintDir, fileName);
+}
+
+// ── Lazy DatabaseSync init ─────────────────────────────────────────────────
+let DatabaseSync = null;
+function getDatabaseSync() {
+    if (!DatabaseSync) ({ DatabaseSync } = require('node:sqlite'));
+    return DatabaseSync;
+}
+
+let dbInstance = null;
+function getDb() {
+    if (dbInstance) return dbInstance;
+    const Database = getDatabaseSync();
+    dbInstance = new Database(getDbPath());
+
+    dbInstance.exec(`
+        -- User profile: arbitrary key-value pairs
+        CREATE TABLE IF NOT EXISTS user_profile (
+            key        TEXT PRIMARY KEY,
+            value      TEXT,
+            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+
+        -- Condensed summaries of past sessions
+        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
+        );
+
+        -- Frequently used topics / commands
+        CREATE TABLE IF NOT EXISTS usage_patterns (
+            pattern   TEXT PRIMARY KEY,
+            count     INTEGER DEFAULT 1,
+            last_used 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
+        );
+    `);
+
+    return dbInstance;
+}
+
+// ── Profile helpers ────────────────────────────────────────────────────────
+function setProfile(key, value) {
+    try {
+        const db = getDb();
+        db.prepare(`
+            INSERT INTO user_profile (key, value, updated_at)
+            VALUES (?, ?, CURRENT_TIMESTAMP)
+            ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = CURRENT_TIMESTAMP
+        `).run(key, String(value));
+    } catch (err) {
+        console.error('[Memory] setProfile error:', err.message);
+    }
+}
+
+function getProfile(key, defaultValue = null) {
+    try {
+        const row = getDb().prepare('SELECT value FROM user_profile WHERE key = ?').get(key);
+        return row ? row.value : defaultValue;
+    } catch (_) {
+        return defaultValue;
+    }
+}
+
+function getAllProfile() {
+    try {
+        const rows = getDb().prepare('SELECT key, value FROM user_profile').all();
+        return Object.fromEntries(rows.map(r => [r.key, r.value]));
+    } catch (_) {
+        return {};
+    }
+}
+
+// ── Session memory helpers ─────────────────────────────────────────────────
+const MAX_SESSION_MEMORIES = 20; // keep last N summaries
+
+function addSessionMemory(summary, tags = []) {
+    try {
+        const db = getDb();
+        db.prepare('INSERT INTO session_memories (summary, tags) VALUES (?, ?)').run(
+            summary.slice(0, 800), // cap length
+            tags.join(',')
+        );
+        // Prune oldest beyond limit
+        db.exec(`
+            DELETE FROM session_memories WHERE id NOT IN (
+                SELECT id FROM session_memories ORDER BY id DESC LIMIT ${MAX_SESSION_MEMORIES}
+            )
+        `);
+    } catch (err) {
+        console.error('[Memory] addSessionMemory error:', err.message);
+    }
+}
+
+function getRecentMemories(limit = 5) {
+    try {
+        return getDb()
+            .prepare('SELECT summary, tags, created_at FROM session_memories ORDER BY id DESC LIMIT ?')
+            .all(limit);
+    } catch (_) {
+        return [];
+    }
+}
+
+// ── Usage pattern helpers ──────────────────────────────────────────────────
+function recordPattern(pattern) {
+    try {
+        const db = getDb();
+        db.prepare(`
+            INSERT INTO usage_patterns (pattern, count, last_used)
+            VALUES (?, 1, CURRENT_TIMESTAMP)
+            ON CONFLICT(pattern) DO UPDATE
+            SET count = count + 1, last_used = CURRENT_TIMESTAMP
+        `).run(pattern.slice(0, 120));
+    } catch (_) {}
+}
+
+function getTopPatterns(limit = 8) {
+    try {
+        return getDb()
+            .prepare('SELECT pattern, count FROM usage_patterns ORDER BY count DESC, last_used DESC LIMIT ?')
+            .all(limit);
+    } catch (_) {
+        return [];
+    }
+}
+
+// ── Simple keyword extractor (no external deps) ────────────────────────────
+const STOP_WORDS = new Set([
+    'ที่', 'ให้', 'และ', 'ของ', 'กับ', 'ใน', 'บน', 'เป็น', 'อยู่', 'มี', 'ได้', 'the', 'a', 'an',
+    'is', 'are', 'was', 'were', 'it', 'in', 'on', 'at', 'for', 'to', 'of', 'with', 'and', 'or',
+    'this', 'that', 'i', 'you', 'me', 'my', 'your', 'can', 'do', 'be', 'will', 'please', 'how',
+    'what', 'which', 'when', 'where', 'why', 'help', 'want', 'need', 'make', 'create', 'get', 'run'
+]);
+
+function extractKeywords(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\u0E00-\u0E7F\s]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 2 && !STOP_WORDS.has(w))
+        .slice(0, 6);
+}
+
+// ── Main public API ────────────────────────────────────────────────────────
+
+/**
+ * Called after every successful chat turn.
+ * Extracts patterns & infers preferences — runs async, non-blocking.
+ */
+function recordInteraction(userMessage, aiResponseText) {
+    try {
+        if (!userMessage || !aiResponseText) return;
+
+        // Extract keywords as usage patterns
+        const keywords = extractKeywords(userMessage);
+        keywords.forEach(kw => recordPattern(kw));
+
+        // 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');
+
+        // Detect coding intent (update project activity)
+        const codingKeywords = ['code', 'fix', 'debug', 'function', 'class', 'import', 'script',
+            'แก้', 'เขียน', 'โค้ด', 'สคริปต์', 'ฟังก์ชัน'];
+        if (codingKeywords.some(k => userMessage.toLowerCase().includes(k))) {
+            const cwd = process.cwd();
+            if (cwd !== os.homedir()) {
+                setProfile('last_active_project', path.basename(cwd));
+                setProfile('last_active_project_path', cwd);
+            }
+        }
+
+        // Update interaction counter
+        const count = parseInt(getProfile('total_interactions', '0'), 10);
+        setProfile('total_interactions', String(count + 1));
+        setProfile('last_seen', new Date().toISOString());
+    } catch (err) {
+        console.error('[Memory] recordInteraction error:', err.message);
+    }
+}
+
+/**
+ * Saves a condensed summary of a completed conversation.
+ * Call this when user clears history or after N turns.
+ */
+function saveSessionSummary(summary, tags = []) {
+    if (!summary || summary.trim().length < 10) return;
+    addSessionMemory(summary.trim(), tags);
+}
+
+/**
+ * Returns a formatted context string to inject into the AI system prompt.
+ * Lightweight — no async calls.
+ */
+function getUserContext() {
+    try {
+        const profile = getAllProfile();
+        const patterns = getTopPatterns(6);
+        const memories = getRecentMemories(3);
+
+        const lines = ['\n\n[LONG-TERM USER CONTEXT — use this to personalize responses]'];
+
+        // Profile info
+        if (Object.keys(profile).length > 0) {
+            if (profile.preferred_language)
+                lines.push(`• Preferred language: ${profile.preferred_language}`);
+            if (profile.last_active_project)
+                lines.push(`• Last active project: ${profile.last_active_project} (${profile.last_active_project_path || ''})`);
+            if (profile.total_interactions)
+                lines.push(`• Total interactions with Mint: ${profile.total_interactions}`);
+            if (profile.last_seen) {
+                const d = new Date(profile.last_seen);
+                lines.push(`• Last session: ${d.toLocaleDateString('th-TH')} ${d.toLocaleTimeString('th-TH', { hour: '2-digit', minute: '2-digit' })}`);
+            }
+        }
+
+        // Usage patterns
+        if (patterns.length > 0) {
+            const topTopics = patterns.map(p => p.pattern).join(', ');
+            lines.push(`• Frequent topics/tools: ${topTopics}`);
+        }
+
+        // Past session memories
+        if (memories.length > 0) {
+            lines.push('\nRecent session summaries:');
+            memories.forEach((m, i) => lines.push(`  ${i + 1}. ${m.summary}`));
+        }
+
+        if (lines.length === 1) return ''; // nothing to add
+        lines.push('[END USER CONTEXT]\n');
+        return lines.join('\n');
+    } catch (err) {
+        console.error('[Memory] getUserContext error:', err.message);
+        return '';
+    }
+}
+
+// ── Response Cache helpers ────────────────────────────────────────────────
+function getCachedResponse(query) {
+    try {
+        const hash = crypto.createHash('md5').update(query.trim().toLowerCase()).digest('hex');
+        const row = getDb().prepare('SELECT response, created_at FROM response_cache WHERE query_hash = ?').get(hash);
+        if (row) {
+            // 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);
+            }
+        }
+    } catch (_) {}
+    return null;
+}
+
+function cacheResponse(query, responseObj) {
+    try {
+        const hash = crypto.createHash('md5').update(query.trim().toLowerCase()).digest('hex');
+        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));
+    } catch (_) {}
+}
+
+module.exports = {
+    recordInteraction,
+    saveSessionSummary,
+    getUserContext,
+    setProfile,
+    getProfile,
+    getTopPatterns,
+    getRecentMemories,
+    getCachedResponse,
+    cacheResponse
+};

package/src/AI_Brain/proactive_engine.js

@@ -1,7 +1,4 @@
 const { GoogleGenAI } = require('@google/genai');
-const path = require('path');
-const fs = require('fs');
-const { app } = require('electron');
 const { readConfig } = require('../System/config_manager');
 
 // ============================================================
@@ -76,11 +73,8 @@ function resolveGeminiModel() {
 
 function getMinSuggestionIntervalMs() {
     try {
-        const CONFIG_PATH = path.join(app.getPath('userData'), 'mint-config.json');
-        if (fs.existsSync(CONFIG_PATH)) {
-            const cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
-            return (cfg.proactiveCooldown || 120) * 1000;
-        }
+        const cfg = readConfig();
+        return (cfg.proactiveCooldown || 120) * 1000;
     } catch {
         // ignore
     }

package/src/Automation_Layer/file_operations.js

@@ -1,4 +1,4 @@
-const { exec } = require('child_process');
+const { execFile } = require('child_process');
 let shell;
 try {
     shell = require('electron').shell;
@@ -9,6 +9,22 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
+const IGNORED_DIRECTORY_NAMES = new Set([
+    '.git',
+    'node_modules',
+    '.cache',
+    'dist',
+    'build',
+    'coverage'
+]);
+
+function getSearchRoots() {
+    return Array.from(new Set([
+        process.cwd(),
+        os.homedir()
+    ]));
+}
+
 /**
  * Smartly resolves a path.
  * If a path starts with '/' but doesn't exist at root, checks if it exists relative to home.
@@ -53,6 +69,109 @@ function resolveSmartPath(target) {
     return target;
 }
 
+function findPath(target, options = {}) {
+    if (!target || !target.trim()) {
+        return { success: false, message: 'No search query provided.', matches: [] };
+    }
+
+    const normalizedType = ['file', 'dir', 'any'].includes(options.type) ? options.type : 'any';
+    const loweredQuery = target.trim().toLowerCase();
+    const exactMatches = [];
+    const partialMatches = [];
+    const visited = new Set();
+    const maxResults = options.maxResults || 20;
+    const searchRoots = Array.isArray(options.roots) && options.roots.length > 0
+        ? options.roots
+        : getSearchRoots();
+
+    function buildMatch(entryPath, entryType, rootPath, exactNameMatch) {
+        const relativeToCwd = path.relative(process.cwd(), entryPath);
+        const pathDepth = entryPath.split(path.sep).length;
+        return {
+            path: entryPath,
+            type: entryType,
+            exactNameMatch,
+            inCurrentWorkspace: !relativeToCwd.startsWith('..') && !path.isAbsolute(relativeToCwd),
+            pathDepth,
+            rootPath
+        };
+    }
+
+    function sortMatches(matches) {
+        return matches.sort((a, b) => {
+            if (a.exactNameMatch !== b.exactNameMatch) return a.exactNameMatch ? -1 : 1;
+            if (a.inCurrentWorkspace !== b.inCurrentWorkspace) return a.inCurrentWorkspace ? -1 : 1;
+            if (a.pathDepth !== b.pathDepth) return a.pathDepth - b.pathDepth;
+            return a.path.localeCompare(b.path);
+        });
+    }
+
+    function visit(currentPath, rootPath) {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(currentPath, { withFileTypes: true });
+        } catch (_) {
+            return;
+        }
+
+        for (const entry of entries) {
+            const absoluteEntryPath = path.join(currentPath, entry.name);
+            if (visited.has(absoluteEntryPath)) continue;
+            visited.add(absoluteEntryPath);
+
+            const entryType = entry.isDirectory() ? 'dir' : 'file';
+            if (entry.isDirectory() && IGNORED_DIRECTORY_NAMES.has(entry.name)) {
+                continue;
+            }
+            const relativePath = path.relative(rootPath, absoluteEntryPath);
+            const searchablePath = relativePath || entry.name;
+            const matchesType = normalizedType === 'any' || normalizedType === entryType;
+            const lowerEntryName = entry.name.toLowerCase();
+            const exactNameMatch = lowerEntryName === loweredQuery;
+            const partialMatch = lowerEntryName.includes(loweredQuery) || searchablePath.toLowerCase().includes(loweredQuery);
+
+            if (matchesType && partialMatch) {
+                const match = buildMatch(absoluteEntryPath, entryType, rootPath, exactNameMatch);
+                if (exactNameMatch) {
+                    exactMatches.push(match);
+                    if (exactMatches.length >= maxResults) return;
+                } else if (exactMatches.length === 0) {
+                    partialMatches.push(match);
+                    if (partialMatches.length >= maxResults) return;
+                }
+            }
+
+            if (entry.isDirectory() && exactMatches.length < maxResults && partialMatches.length < maxResults) {
+                visit(absoluteEntryPath, rootPath);
+                if (exactMatches.length >= maxResults || partialMatches.length >= maxResults) return;
+            }
+        }
+    }
+
+    for (const rootPath of searchRoots) {
+        if (!fs.existsSync(rootPath)) continue;
+        visit(rootPath, rootPath);
+        if (exactMatches.length >= maxResults || partialMatches.length >= maxResults) break;
+    }
+
+    const matches = exactMatches.length > 0
+        ? sortMatches(exactMatches).slice(0, maxResults)
+        : sortMatches(partialMatches).slice(0, maxResults);
+
+    if (matches.length === 0) {
+        return {
+            success: false,
+            message: `ไม่พบ${normalizedType === 'dir' ? 'โฟลเดอร์' : normalizedType === 'file' ? 'ไฟล์' : 'ไฟล์หรือโฟลเดอร์'}ที่ตรงกับ "${target}" ค่ะ`,
+            matches: []
+        };
+    }
+
+    return {
+        success: true,
+        matches: matches.map(({ path: matchPath, type }) => ({ path: matchPath, type }))
+    };
+}
+
 /**
  * สร้างโฟลเดอร์ใหม่
  * target: ชื่อโฟลเดอร์ หรือ absolute path
@@ -99,7 +218,7 @@ async function openFile(target) {
         }
     } else {
         return new Promise((resolve) => {
-            exec(`xdg-open "${resolvedPath}"`, (err) => {
+            execFile('xdg-open', [resolvedPath], (err) => {
                 if (err) {
                     console.error("Failed to open path via xdg-open:", err);
                     resolve(`ไม่สามารถเปิดไฟล์ได้ค่ะ: ${err.message}`);
@@ -129,7 +248,7 @@ async function deleteFile(target) {
         }
     } else {
         return new Promise((resolve) => {
-            exec(`gio trash "${resolvedPath}"`, (err) => {
+            execFile('gio', ['trash', resolvedPath], (err) => {
                 if (err) {
                     console.error("Failed to trash item via gio trash:", err);
                     resolve({ success: false, message: err.message });
@@ -141,4 +260,4 @@ async function deleteFile(target) {
     }
 }
 
-module.exports = { createFolder, openFile, deleteFile };
+module.exports = { createFolder, openFile, deleteFile, findPath };

package/src/Automation_Layer/open_app.js

@@ -1,56 +1,85 @@
-const { exec } = require('child_process');
+const { execFile } = require('child_process');
 
-function openApp(target) {
+function execFilePromise(command, args) {
+    return new Promise((resolve, reject) => {
+        execFile(command, args, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+
+async function tryCommands(commands) {
+    let lastError = null;
+    for (const { command, args } of commands) {
+        try {
+            await execFilePromise(command, args);
+            return true;
+        } catch (error) {
+            lastError = error;
+        }
+    }
+
+    if (lastError) {
+        console.error(`exec error: ${lastError}`);
+    }
+    return false;
+}
+
+async function openApp(target) {
     if (!target) return;
 
-    let cmd = '';
     if (process.platform === 'win32') {
-        cmd = `start "" "${target}"`;
-    } else if (process.platform === 'darwin') {
-        if (!target.includes('/')) {
-            cmd = `open -X -a "${target}" || open -a "${target}"`;
-        } else {
-            cmd = `open "${target}"`;
-        }
-    } else {
-        const tLower = target.toLowerCase();
-        const tCapitalized = target.charAt(0).toUpperCase() + target.slice(1).toLowerCase();
-        
-        // Try common linux patterns: gtk-launch, exact name, lowercase, flatpak
+        await execFilePromise('cmd.exe', ['/c', 'start', '', target]).catch((error) => {
+            console.error(`exec error: ${error}`);
+        });
+        return;
+    }
+
+    if (process.platform === 'darwin') {
         if (!target.includes('/')) {
-            const patterns = [
-                `gtk-launch ${target}`,
-                `gtk-launch ${tLower}`,
-                `gtk-launch ${tCapitalized}`,
-                `gtk-launch com.${tLower}app.${tCapitalized}`,
-                `gtk-launch com.${tLower}.${tCapitalized}`,
-                target,
-                tLower,
-                `flatpak run ${target}`, // In case target is already ID
-                `flatpak run com.${tLower}app.${tCapitalized}`,
-                `flatpak run com.${tLower}.${tCapitalized}`,
-                `flatpak run com.${tLower}.Browser`,
-                `flatpak run com.${tLower}.${target}`,
-                `flatpak run com.valvesoftware.Steam`,
-                `flatpak run net.lutris.Lutris`,
-                `snap run ${tLower}`
-            ];
-            cmd = patterns.join(' || ');
+            await tryCommands([
+                { command: 'open', args: ['-X', '-a', target] },
+                { command: 'open', args: ['-a', target] }
+            ]);
         } else {
-            cmd = `xdg-open "${target}"`;
+            await execFilePromise('open', [target]).catch((error) => {
+                console.error(`exec error: ${error}`);
+            });
         }
+        return;
     }
 
-    exec(cmd, (error) => {
-        if (error) {
+    const tLower = target.toLowerCase();
+    const tCapitalized = target.charAt(0).toUpperCase() + target.slice(1).toLowerCase();
+
+    if (target.includes('/')) {
+        await execFilePromise('xdg-open', [target]).catch((error) => {
             console.error(`exec error: ${error}`);
-            if (process.platform !== 'win32') {
-                exec(target.toLowerCase(), (err2) => {
-                    if (err2) console.error("Fallback lowercase exec failed:", err2);
-                });
-            }
-        }
-    });
+        });
+        return;
+    }
+
+    await tryCommands([
+        { command: 'gtk-launch', args: [target] },
+        { command: 'gtk-launch', args: [tLower] },
+        { command: 'gtk-launch', args: [tCapitalized] },
+        { command: 'gtk-launch', args: [`com.${tLower}app.${tCapitalized}`] },
+        { command: 'gtk-launch', args: [`com.${tLower}.${tCapitalized}`] },
+        { command: target, args: [] },
+        { command: tLower, args: [] },
+        { command: 'flatpak', args: ['run', target] },
+        { command: 'flatpak', args: ['run', `com.${tLower}app.${tCapitalized}`] },
+        { command: 'flatpak', args: ['run', `com.${tLower}.${tCapitalized}`] },
+        { command: 'flatpak', args: ['run', `com.${tLower}.Browser`] },
+        { command: 'flatpak', args: ['run', `com.${tLower}.${target}`] },
+        { command: 'flatpak', args: ['run', 'com.valvesoftware.Steam'] },
+        { command: 'flatpak', args: ['run', 'net.lutris.Lutris'] },
+        { command: 'snap', args: ['run', tLower] }
+    ]);
 }
 
 module.exports = { openApp };

package/src/Automation_Layer/open_website.js

@@ -1,4 +1,4 @@
-const { exec } = require('child_process');
+const { execFile } = require('child_process');
 
 let shell;
 try {
@@ -17,7 +17,7 @@ function openWebsite(targetUrl) {
         shell.openExternal(url);
     } else {
         // Fallback for Node.js (Linux focus)
-        exec(`xdg-open "${url}"`, (err) => {
+        execFile('xdg-open', [url], (err) => {
             if (err) console.error("Failed to open URL via xdg_open:", err);
         });
     }
@@ -29,7 +29,7 @@ function openSearch(query) {
     if (shell) {
         shell.openExternal(url);
     } else {
-        exec(`xdg-open "${url}"`, (err) => {
+        execFile('xdg-open', [url], (err) => {
             if (err) console.error("Failed to open search via xdg-open:", err);
         });
     }