@pheem49/mint 1.2.3 → 1.3.0

package/src/Automation_Layer/file_operations.js

@@ -9,6 +9,50 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
+/**
+ * Smartly resolves a path.
+ * If a path starts with '/' but doesn't exist at root, checks if it exists relative to home.
+ * Also handles '~/' expansion.
+ */
+function resolveSmartPath(target) {
+    if (!target) return target;
+
+    const home = os.homedir();
+    const commonFolders = ['Downloads', 'Desktop', 'Documents', 'Videos', 'Pictures', 'Music', 'vscode', 'Games'];
+
+    // 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(home, target.substring(1));
+        if (fs.existsSync(homeRelative)) return homeRelative;
+    }
+
+    // 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;
+    }
+
+    // 5. Try searching the filename in all common folders
+    for (const folder of commonFolders) {
+        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
@@ -17,12 +61,12 @@ const os = require('os');
 function createFolder(target) {
     if (!target) return { success: false, message: 'No folder name provided.' };
 
-    let folderPath = target;
+    let folderPath = resolveSmartPath(target);
 
-    // ถ้าไม่ใช่ absolute path ให้สร้างบน Desktop
-    if (!path.isAbsolute(target)) {
+    // If still not absolute (was just a name), default to Desktop
+    if (!path.isAbsolute(folderPath)) {
         const desktopPath = path.join(os.homedir(), 'Desktop');
-        folderPath = path.join(desktopPath, target);
+        folderPath = path.join(desktopPath, folderPath);
     }
 
     try {
@@ -40,24 +84,44 @@ function createFolder(target) {
  */
 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(target);
-        if (result) console.error('openFile error:', result);
+        const result = await shell.openPath(resolvedPath);
+        if (result) {
+            console.error('openFile error:', result);
+            return `เกิดข้อผิดพลาดในการเปิดไฟล์: ${result}`;
+        }
     } else {
-        exec(`xdg-open "${target}"`, (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)
  */
 async function deleteFile(target) {
     if (!target) return { success: false, message: 'No path provided.' };
+    const resolvedPath = resolveSmartPath(target);
+
     if (shell) {
         try {
-            await shell.trashItem(target);
+            await shell.trashItem(resolvedPath);
             return { success: true };
         } catch (err) {
             console.error('deleteFile error:', err);
@@ -65,7 +129,7 @@ async function deleteFile(target) {
         }
     } else {
         return new Promise((resolve) => {
-            exec(`gio trash "${target}"`, (err) => {
+            exec(`gio trash "${resolvedPath}"`, (err) => {
                 if (err) {
                     console.error("Failed to trash item via gio trash:", err);
                     resolve({ success: false, message: err.message });

package/src/CLI/chat_router.js

@@ -0,0 +1,166 @@
+const fs = require('fs');
+const path = require('path');
+const { GoogleGenAI } = require('@google/genai');
+const { executeCodeTask } = require('./code_agent');
+const { readConfig } = 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;
+
+    appendMessage('system', `Routing this request to Code Mode for workspace: ${process.cwd()}`);
+    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,
+            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
+};