@pheem49/mint 1.4.0 → 1.4.1

package/src/AI_Brain/Gemini_API.js

@@ -58,11 +58,13 @@ Always respond exactly with valid JSON containing NO MARKDOWN FORMATTING (do not
 {
   "response": "Your conversational reply here (Matches user language).",
   "action": {
-    "type": "none" | "open_url" | "open_app" | "search" | "web_automation" | "create_folder" | "open_file" | "open_folder" | "delete_file" | "clipboard_write" | "system_info" | "plugin" | "learn_file" | "learn_folder" | "system_automation" | "mcp_tool" | "mouse_click" | "mouse_move" | "type_text" | "key_tap",
+    "type": "none" | "open_url" | "open_app" | "search" | "web_automation" | "create_folder" | "open_file" | "open_folder" | "find_path" | "delete_file" | "clipboard_write" | "system_info" | "plugin" | "learn_file" | "learn_folder" | "system_automation" | "mcp_tool" | "mouse_click" | "mouse_move" | "type_text" | "key_tap",
 
     "pluginName": "only if type is plugin",
     "server": "only if type is mcp_tool (server name)",
     "target": "target string based on type (tool name if mcp_tool, text to type if type_text, key name if key_tap)",
+    "pathType": "optional for find_path: 'file' | 'dir' | 'any'",
+    "openAfter": true,
     "x": 0-1000, // required for mouse_click and mouse_move
     "y": 0-1000, // required for mouse_click and mouse_move
     "button": 1 | 2 | 3, // optional for mouse_click, 1=left, 2=middle, 3=right
@@ -86,6 +88,12 @@ Output: { "response": "สวัสดีค่ะ! หนูชื่อมิ
 Input: "Create a folder named Projects"
 Output: { "response": "Sure thing! I'm creating a folder named 'Projects' for you right now.", "action": { "type": "create_folder", "target": "Projects" } }
 
+Input: "หาโฟลเดอร์ xidaidai ให้หน่อย" or "find the xidaidai folder"
+Output: { "response": "ได้เลยค่ะ มิ้นท์จะค้นหาโฟลเดอร์ xidaidai ให้", "action": { "type": "find_path", "target": "xidaidai", "pathType": "dir", "openAfter": false } }
+
+Input: "เปิดโฟลเดอร์ xidaidai ให้หน่อย" or "open the xidaidai folder"
+Output: { "response": "ได้เลยค่ะ มิ้นท์จะหาแล้วเปิดโฟลเดอร์ xidaidai ให้", "action": { "type": "find_path", "target": "xidaidai", "pathType": "dir", "openAfter": true } }
+
 Input: "วันนี้วันที่เท่าไร" or "What date is today?" or "today's date" or "วันเวลา"
 Output: { "response": "แป๊บนึงนะคะ มิ้นท์จะดูให้ค่า", "action": { "type": "system_info", "target": "" } }
 
@@ -165,6 +173,13 @@ function resolveGeminiModel() {
   }
 }
 
+function getProviderAttemptOrder(config) {
+  const provider = config.aiProvider || 'gemini';
+  const availableProviders = getAvailableProviders(config);
+  const alternates = availableProviders.filter(p => p !== provider);
+  return [provider, ...alternates];
+}
+
 // Chat session — maintains conversation history within the session
 let chat = null;
 let activeModel = resolveGeminiModel();
@@ -214,21 +229,6 @@ function shouldUseKnowledgeSearch(message) {
 async function handleChat(message, base64Image = null, base64Audio = null) {
   try {
     const config = readConfig();
-    const provider = config.aiProvider || 'gemini';
-
-    // Ensure API Key is loaded and Client is initialized before every chat
-    const currentKey = resolveApiKey();
-    if (!currentKey) {
-       return { 
-           response: "I couldn't find your Gemini API Key. Please run 'mint onboard' to set it up!", 
-           action: { type: "none", target: "" } 
-       };
-    }
-
-    if (!ai || activeApiKey !== currentKey) {
-        initAiClient();
-        createChat(readChatHistory());
-    }
 
     let finalMessage = message;
     
@@ -245,13 +245,7 @@ async function handleChat(message, base64Image = null, base64Audio = null) {
         }
     }
 
-    const { getAvailableProviders } = require('../System/config_manager');
-    const availableProviders = getAvailableProviders(config);
-    
-    // Ensure the requested provider is prioritized. If not available, fallback to the first available.
-    let providersToTry = [provider];
-    const alternates = availableProviders.filter(p => p !== provider);
-    providersToTry = providersToTry.concat(alternates);
+    const providersToTry = getProviderAttemptOrder(config);
 
     for (let i = 0; i < providersToTry.length; i++) {
         const currentProv = providersToTry[i];
@@ -272,6 +266,23 @@ async function handleChat(message, base64Image = null, base64Audio = null) {
                 return await handleHuggingFaceChat(finalMessage, base64Image, config);
             }
 
+            const currentKey = resolveApiKey();
+            if (!currentKey) {
+                if (i === providersToTry.length - 1) {
+                    return {
+                        response: "I couldn't find your Gemini API Key. Please run 'mint onboard' to set it up!",
+                        action: { type: "none", target: "" }
+                    };
+                }
+                console.warn("[Fallback System] Gemini API key missing. Skipping Gemini provider.");
+                continue;
+            }
+
+            if (!ai || activeApiKey !== currentKey) {
+                initAiClient();
+                createChat(readChatHistory());
+            }
+
             return await handleGeminiChat(finalMessage, base64Image, base64Audio);
         } catch (error) {
             console.error(`[Fallback System] Provider '${currentProv}' failed:`, error.message);
@@ -887,5 +898,8 @@ module.exports = {
     resetChat,
     getChatTranscript,
     translateImageContent,
-    refreshApiKeyFromConfig
+    refreshApiKeyFromConfig,
+    _helpers: {
+        getProviderAttemptOrder
+    }
 };

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);
         });
     }

package/src/CLI/chat_router.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const { GoogleGenAI } = require('@google/genai');
-const { executeCodeTask } = require('./code_agent');
+const { executeCodeTask, _helpers: codeAgentHelpers } = require('./code_agent');
 const { readConfig, getAvailableProviders } = require('../System/config_manager');
 
 const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
@@ -26,7 +26,19 @@ Return JSON only:
 }
 
 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.`;
+Choose "chat" for general conversation, factual Q&A, small/simple requests, non-code assistant tasks, or direct file-system actions like finding/opening a folder or file by name.
+Only choose "code" for substantial coding work that likely needs multiple steps, workspace inspection, edits, verification, or project-wide reasoning.`;
+
+function isDirectFilesystemActionRequest(text) {
+    const input = (text || '').trim().toLowerCase();
+    if (!input) return false;
+
+    const filesystemActionPattern = /(open|find|locate|search for|look for|หา|ค้นหา|เปิด)/;
+    const filesystemTargetPattern = /(folder|directory|dir|file|โฟลเดอร์|ไฟล์|ไดเรกทอรี)/;
+    const codeOperationPattern = /(inspect|review|refactor|debug|implement|edit|change|fix|explain|analyze|สำรวจ|รีวิว|รีแฟกเตอร์|แก้|อธิบาย|วิเคราะห์)/;
+
+    return filesystemActionPattern.test(input) && filesystemTargetPattern.test(input) && !codeOperationPattern.test(input);
+}
 
 function workspaceLooksLikeCodebase(workspaceRoot) {
     const markers = [
@@ -45,13 +57,27 @@ function detectCodeIntentHeuristic(text, workspaceRoot = process.cwd()) {
     const input = (text || '').trim().toLowerCase();
     if (!input) return false;
     if (input.startsWith('/code ')) return true;
+    if (isDirectFilesystemActionRequest(input)) return false;
+
+    return isLargeCodeTaskRequest(input, workspaceRoot);
+}
+
+function isLargeCodeTaskRequest(text, workspaceRoot = process.cwd()) {
+    const input = (text || '').trim().toLowerCase();
+    if (!input) return false;
+    if (!workspaceLooksLikeCodebase(workspaceRoot)) return false;
 
     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);
+    const strongTaskSignal = /failing tests?|run tests?|verify|verification|bug|issue|error|refactor|implement|feature|patch|edit|modify|analyze the project|แก้บั๊ก|รันเทสต์|ทดสอบ|ตรวจสอบ|ยืนยันผล|รีแฟกเตอร์|เพิ่มฟีเจอร์|แก้โค้ด|วิเคราะห์โปรเจค/.test(input);
+    const multiStepSignal = /and|then|พร้อม|แล้ว|จากนั้น|ทั้ง|ทั่วทั้ง|ทั้งโปรเจค|project-wide|entire project|whole project/.test(input);
 
-    return workspaceLooksLikeCodebase(workspaceRoot) && (referencesProject || ((hasCodeKeyword || hasThaiCodeKeyword) && asksForAction));
+    if (referencesProject && strongTaskSignal) return true;
+    if ((hasCodeKeyword || hasThaiCodeKeyword) && asksForAction && strongTaskSignal) return true;
+    if ((hasCodeKeyword || hasThaiCodeKeyword) && multiStepSignal && asksForAction) return true;
+    return false;
 }
 
 function getRouterClient() {
@@ -71,7 +97,7 @@ function summarizeWorkspace(workspaceRoot) {
         .join(', ') || '(no obvious code markers)';
 }
 
-async function detectCodeIntent(text, workspaceRoot = process.cwd()) {
+async function detectCodeIntent(text, workspaceRoot = process.cwd(), history = []) {
     const input = (text || '').trim();
     if (!input) {
         return { route: 'chat', reason: 'Empty input.' };
@@ -81,6 +107,10 @@ async function detectCodeIntent(text, workspaceRoot = process.cwd()) {
         return { route: 'code', reason: 'Explicit /code command.' };
     }
 
+    if (isDirectFilesystemActionRequest(input)) {
+        return { route: 'chat', reason: 'Direct file-system action request.' };
+    }
+
     const heuristicRoute = detectCodeIntentHeuristic(input, workspaceRoot);
     const routerClient = getRouterClient();
     if (!routerClient) {
@@ -103,7 +133,8 @@ async function detectCodeIntent(text, workspaceRoot = process.cwd()) {
                     text: [
                         `Workspace: ${workspaceRoot}`,
                         `Workspace markers: ${summarizeWorkspace(workspaceRoot)}`,
-                        `Message: ${input}`
+                        `Context (Last 5 turns): ${history.slice(-10).map(m => `${m.sender}: ${m.text}`).join('\n')}`,
+                        `Current Message: ${input}`
                     ].join('\n')
                 }]
             }]
@@ -112,6 +143,12 @@ async function detectCodeIntent(text, workspaceRoot = process.cwd()) {
         const textOutput = typeof response.text === 'function' ? response.text() : response.text;
         const parsed = JSON.parse(textOutput);
         const route = parsed.route === 'code' ? 'code' : 'chat';
+        if (route === 'code' && !isLargeCodeTaskRequest(input, workspaceRoot)) {
+            return {
+                route: 'chat',
+                reason: 'Request looks small enough for normal chat.'
+            };
+        }
         return {
             route,
             reason: parsed.reason || (route === 'code' ? 'Model classified as code.' : 'Model classified as chat.')
@@ -126,21 +163,11 @@ async function detectCodeIntent(text, workspaceRoot = process.cwd()) {
 
 async function runChatRoutedTask(input, context) {
     const text = input.startsWith('/code ') ? input.slice('/code '.length).trim() : input;
-    const { appendMessage, setThinking, requestApproval, setMode } = context;
+    const { appendMessage, setThinking, requestApproval, setMode, history } = 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';
-    }
+    const preferredProvider = codeAgentHelpers.selectSupportedCodeProvider(config, availableProviders);
 
     appendMessage('system', `Routing this request to Code Mode for workspace: ${process.cwd()} using [${preferredProvider}]`);
     if (setMode) setMode('Code');
@@ -157,6 +184,7 @@ async function runChatRoutedTask(input, context) {
             cwd: process.cwd(),
             requestApproval,
             provider: preferredProvider,
+            history: history,
             onProgress: (message) => appendMessage('system', `[Code] ${message}`)
         });
         clearInterval(timer);
@@ -177,5 +205,10 @@ async function runChatRoutedTask(input, context) {
 
 module.exports = {
     detectCodeIntent,
-    runChatRoutedTask
+    runChatRoutedTask,
+    _helpers: {
+        detectCodeIntentHeuristic,
+        isDirectFilesystemActionRequest,
+        isLargeCodeTaskRequest
+    }
 };