@pheem49/mint 1.2.4 → 1.4.0

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/Automation_Layer/file_operations.js

@@ -17,36 +17,42 @@ const os = require('os');
 function resolveSmartPath(target) {
     if (!target) return target;
 
-    // 1. If it exists as is (absolute or relative to CWD), use it
-    if (fs.existsSync(target)) return target;
-
+    const home = os.homedir();
     const commonFolders = ['Downloads', 'Desktop', 'Documents', 'Videos', 'Pictures', 'Music', 'vscode', 'Games'];
 
-    // 2. If it starts with / and doesn't exist at root, try home directory
+    // 1. If it's already an absolute path and exists, use it
+    if (path.isAbsolute(target) && fs.existsSync(target)) return target;
+
+    // 2. If it starts with ~/ expand it
+    if (target.startsWith('~/')) {
+        const expanded = path.join(home, target.substring(2));
+        if (fs.existsSync(expanded)) return expanded;
+    }
+
+    // 3. If it starts with / but doesn't exist at root, try home directory
     if (target.startsWith('/')) {
-        const homeRelative = path.join(os.homedir(), target.substring(1));
+        const homeRelative = path.join(home, target.substring(1));
         if (fs.existsSync(homeRelative)) return homeRelative;
-        
-        const cwdRelative = path.join(process.cwd(), target.substring(1));
-        if (fs.existsSync(cwdRelative)) return cwdRelative;
-
-        const firstPart = target.split('/')[1];
-        if (commonFolders.includes(firstPart)) return homeRelative;
     }
 
-    // 3. Handle ~ manually
-    if (target.startsWith('~/')) {
-        return path.join(os.homedir(), target.substring(2));
+    // 4. Check if the target itself starts with a common folder (e.g., "Downloads/resume.pdf")
+    const parts = target.split(/[/\\]/);
+    const firstPart = parts[0];
+    if (commonFolders.includes(firstPart)) {
+        const potentialPath = path.join(home, target);
+        if (fs.existsSync(potentialPath)) return potentialPath;
     }
 
-    // 4. If it's just a name, search in common folders
+    // 5. Try searching the filename in all common folders
     for (const folder of commonFolders) {
-        const potentialPath = path.join(os.homedir(), folder, target);
+        const potentialPath = path.join(home, folder, target);
         if (fs.existsSync(potentialPath)) return potentialPath;
     }
 
+    // 6. Final fallback: just return as is (might be relative to CWD)
     return target;
 }
+
 /**
  * สร้างโฟลเดอร์ใหม่
  * target: ชื่อโฟลเดอร์ หรือ absolute path
@@ -80,16 +86,32 @@ async function openFile(target) {
     if (!target) return;
     const resolvedPath = resolveSmartPath(target);
     
+    if (!fs.existsSync(resolvedPath)) {
+        console.error(`[OpenFile] File not found: ${resolvedPath}`);
+        return `ไม่พบไฟล์หรือโฟลเดอร์: ${target} ค่ะ`;
+    }
+
     if (shell) {
         const result = await shell.openPath(resolvedPath);
-        if (result) console.error('openFile error:', result);
+        if (result) {
+            console.error('openFile error:', result);
+            return `เกิดข้อผิดพลาดในการเปิดไฟล์: ${result}`;
+        }
     } else {
-        exec(`xdg-open "${resolvedPath}"`, (err) => {
-            if (err) console.error("Failed to open path via xdg-open:", err);
+        return new Promise((resolve) => {
+            exec(`xdg-open "${resolvedPath}"`, (err) => {
+                if (err) {
+                    console.error("Failed to open path via xdg-open:", err);
+                    resolve(`ไม่สามารถเปิดไฟล์ได้ค่ะ: ${err.message}`);
+                } else {
+                    resolve(true);
+                }
+            });
         });
     }
 }
 
+
 /**
  * ลบไฟล์หรือโฟลเดอร์ (ย้ายไป Trash)
  */

package/src/CLI/chat_router.js

@@ -0,0 +1,181 @@
+const fs = require('fs');
+const path = require('path');
+const { GoogleGenAI } = require('@google/genai');
+const { executeCodeTask } = require('./code_agent');
+const { readConfig, getAvailableProviders } = require('../System/config_manager');
+
+const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
+
+const CODE_KEYWORDS = [
+    'code', 'repo', 'repository', 'project', 'workspace', 'file', 'files', 'readme',
+    'package.json', 'bug', 'fix', 'refactor', 'test', 'tests', 'build', 'lint',
+    'implement', 'feature', 'cli', 'function', 'module', 'component', 'diff'
+];
+
+const THAI_CODE_KEYWORDS = [
+    'โค้ด', 'โปรเจค', 'โปรเจ็กต์', 'ไฟล์', 'รีโป', 'บั๊ก', 'แก้', 'ทดสอบ', 'เทสต์',
+    'รีแฟกเตอร์', 'ฟีเจอร์', 'คอมโพเนนต์', 'ฟังก์ชัน', 'อ่าน', 'สำรวจ', 'โครงสร้าง'
+];
+
+const ROUTER_PROMPT = `You classify whether a chat message should be routed to a coding agent for the current local workspace.
+
+Return JSON only:
+{
+  "route": "code" | "chat",
+  "reason": "short explanation"
+}
+
+Choose "code" when the user is asking to inspect, edit, review, debug, explain, refactor, verify, or otherwise operate on the current project/workspace/codebase/files.
+Choose "chat" for general conversation, factual Q&A, or non-code assistant tasks.`;
+
+function workspaceLooksLikeCodebase(workspaceRoot) {
+    const markers = [
+        'package.json',
+        '.git',
+        'src',
+        'README.md',
+        'tsconfig.json',
+        'Cargo.toml',
+        'pyproject.toml'
+    ];
+    return markers.some(marker => fs.existsSync(path.join(workspaceRoot, marker)));
+}
+
+function detectCodeIntentHeuristic(text, workspaceRoot = process.cwd()) {
+    const input = (text || '').trim().toLowerCase();
+    if (!input) return false;
+    if (input.startsWith('/code ')) return true;
+
+    const hasCodeKeyword = CODE_KEYWORDS.some(keyword => input.includes(keyword));
+    const hasThaiCodeKeyword = THAI_CODE_KEYWORDS.some(keyword => input.includes(keyword));
+    const referencesProject = /โปรเจคนี้|โปรเจ็กต์นี้|this project|this repo|this repository|codebase|workspace/.test(input);
+    const asksForAction = /สำรวจ|ดู|แก้|เพิ่ม|ลบ|ปรับ|ตรวจ|วิเคราะห์|implement|inspect|explore|fix|update|change|refactor|review|explain|debug/.test(input);
+
+    return workspaceLooksLikeCodebase(workspaceRoot) && (referencesProject || ((hasCodeKeyword || hasThaiCodeKeyword) && asksForAction));
+}
+
+function getRouterClient() {
+    const config = readConfig();
+    const apiKey = (config.apiKey || process.env.GEMINI_API_KEY || '').trim();
+    if (!apiKey) return null;
+    return {
+        ai: new GoogleGenAI({ apiKey }),
+        model: (config.geminiModel || DEFAULT_GEMINI_MODEL).trim() || DEFAULT_GEMINI_MODEL
+    };
+}
+
+function summarizeWorkspace(workspaceRoot) {
+    const candidates = ['package.json', 'README.md', 'src', '.git'];
+    return candidates
+        .filter(item => fs.existsSync(path.join(workspaceRoot, item)))
+        .join(', ') || '(no obvious code markers)';
+}
+
+async function detectCodeIntent(text, workspaceRoot = process.cwd()) {
+    const input = (text || '').trim();
+    if (!input) {
+        return { route: 'chat', reason: 'Empty input.' };
+    }
+
+    if (input.startsWith('/code ')) {
+        return { route: 'code', reason: 'Explicit /code command.' };
+    }
+
+    const heuristicRoute = detectCodeIntentHeuristic(input, workspaceRoot);
+    const routerClient = getRouterClient();
+    if (!routerClient) {
+        return {
+            route: heuristicRoute ? 'code' : 'chat',
+            reason: heuristicRoute ? 'Heuristic code intent match.' : 'Heuristic chat fallback.'
+        };
+    }
+
+    try {
+        const response = await routerClient.ai.models.generateContent({
+            model: routerClient.model,
+            config: {
+                systemInstruction: ROUTER_PROMPT,
+                responseMimeType: 'application/json'
+            },
+            contents: [{
+                role: 'user',
+                parts: [{
+                    text: [
+                        `Workspace: ${workspaceRoot}`,
+                        `Workspace markers: ${summarizeWorkspace(workspaceRoot)}`,
+                        `Message: ${input}`
+                    ].join('\n')
+                }]
+            }]
+        });
+
+        const textOutput = typeof response.text === 'function' ? response.text() : response.text;
+        const parsed = JSON.parse(textOutput);
+        const route = parsed.route === 'code' ? 'code' : 'chat';
+        return {
+            route,
+            reason: parsed.reason || (route === 'code' ? 'Model classified as code.' : 'Model classified as chat.')
+        };
+    } catch (error) {
+        return {
+            route: heuristicRoute ? 'code' : 'chat',
+            reason: heuristicRoute ? 'Heuristic fallback after router error.' : 'Chat fallback after router error.'
+        };
+    }
+}
+
+async function runChatRoutedTask(input, context) {
+    const text = input.startsWith('/code ') ? input.slice('/code '.length).trim() : input;
+    const { appendMessage, setThinking, requestApproval, setMode } = context;
+
+    const config = readConfig();
+    const availableProviders = getAvailableProviders(config);
+    
+    // Smart Routing Priority for Code Tasks
+    let preferredProvider = config.aiProvider || 'gemini'; 
+    
+    // If preferred isn't actually available, try best available
+    if (!availableProviders.includes(preferredProvider)) {
+        if (availableProviders.includes('anthropic')) preferredProvider = 'anthropic';
+        else if (availableProviders.includes('openai')) preferredProvider = 'openai';
+        else if (availableProviders.includes('gemini')) preferredProvider = 'gemini';
+        else preferredProvider = availableProviders[0] || 'gemini';
+    }
+
+    appendMessage('system', `Routing this request to Code Mode for workspace: ${process.cwd()} using [${preferredProvider}]`);
+    if (setMode) setMode('Code');
+
+    let seconds = 0;
+    setThinking(true, seconds);
+    const timer = setInterval(() => {
+        seconds++;
+        setThinking(true, seconds);
+    }, 1000);
+
+    try {
+        const result = await executeCodeTask(text, {
+            cwd: process.cwd(),
+            requestApproval,
+            provider: preferredProvider,
+            onProgress: (message) => appendMessage('system', `[Code] ${message}`)
+        });
+        clearInterval(timer);
+        setThinking(false);
+        appendMessage('assistant', [
+            `Code Mode finished.`,
+            result.summary,
+            `Verification: ${result.verification}`
+        ].join('\n'));
+    } catch (error) {
+        clearInterval(timer);
+        setThinking(false);
+        appendMessage('error', error.message);
+    } finally {
+        if (setMode) setMode('Chat');
+    }
+}
+
+module.exports = {
+    detectCodeIntent,
+    runChatRoutedTask
+};