@pheem49/mint 1.5.5 → 1.6.1

package/src/Automation_Layer/file_operations.js

@@ -1,286 +0,0 @@
-const { execFile } = require('child_process');
-let shell;
-try {
-    shell = require('electron').shell;
-} catch (e) {
-    shell = null;
-}
-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'
-]);
-
-const COMMON_HOME_FOLDERS = ['Downloads', 'Desktop', 'Documents', 'Videos', 'Pictures', 'Music', 'vscode', 'Games'];
-
-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.
- * Also handles '~/' expansion.
- */
-function resolveSmartPath(target) {
-    if (!target) return target;
-
-    const home = os.homedir();
-    // 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 (COMMON_HOME_FOLDERS.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 COMMON_HOME_FOLDERS) {
-        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;
-}
-
-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 directPath = resolveSmartPath(target.trim());
-    if (directPath && path.isAbsolute(directPath) && fs.existsSync(directPath)) {
-        const stat = fs.statSync(directPath);
-        const directType = stat.isDirectory() ? 'dir' : 'file';
-        if (normalizedType === 'any' || normalizedType === directType) {
-            return {
-                success: true,
-                matches: [{ path: directPath, type: directType }]
-            };
-        }
-    }
-
-    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
- * ถ้าเป็นชื่อเดียว จะสร้างบน Desktop
- */
-function createFolder(target) {
-    if (!target) return { success: false, message: 'No folder name provided.' };
-
-    let folderPath = resolveSmartPath(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, folderPath);
-    }
-
-    try {
-        fs.mkdirSync(folderPath, { recursive: true });
-        console.log(`Folder created: ${folderPath}`);
-        return { success: true, path: folderPath };
-    } catch (err) {
-        console.error('createFolder error:', err);
-        return { success: false, message: err.message };
-    }
-}
-
-/**
- * เปิดไฟล์หรือโฟลเดอร์ด้วย default app ของระบบ
- */
-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);
-            return `เกิดข้อผิดพลาดในการเปิดไฟล์: ${result}`;
-        }
-        return true;
-    } else {
-        return new Promise((resolve) => {
-            // บน Linux ลอง xdg-open แล้วค่อย gio open ถ้าอันแรกไม่ทำงาน
-            const { exec } = require('child_process');
-            const platformCmd = process.platform === 'darwin' ? 'open' : (process.platform === 'win32' ? 'start' : 'xdg-open');
-            
-            // ใช้ exec เพื่อให้รันผ่าน shell และรองรับการทำ fallback
-            let cmd = `${platformCmd} "${resolvedPath}"`;
-            if (process.platform === 'linux') {
-                cmd = `xdg-open "${resolvedPath}" || gio open "${resolvedPath}" || nautilus "${resolvedPath}" || nemo "${resolvedPath}" || thunar "${resolvedPath}" || dolphin "${resolvedPath}"`;
-            }
-
-            exec(cmd, (err) => {
-                if (err) {
-                    console.error("Failed to open path:", 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(resolvedPath);
-            return { success: true };
-        } catch (err) {
-            console.error('deleteFile error:', err);
-            return { success: false, message: err.message };
-        }
-    } else {
-        return new Promise((resolve) => {
-            execFile('gio', ['trash', resolvedPath], (err) => {
-                if (err) {
-                    console.error("Failed to trash item via gio trash:", err);
-                    resolve({ success: false, message: err.message });
-                } else {
-                    resolve({ success: true });
-                }
-            });
-        });
-    }
-}
-
-module.exports = { createFolder, openFile, deleteFile, findPath, resolveSmartPath };

package/src/Automation_Layer/open_app.js

@@ -1,85 +0,0 @@
-const { execFile } = require('child_process');
-
-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;
-
-    if (process.platform === 'win32') {
-        await execFilePromise('cmd.exe', ['/c', 'start', '', target]).catch((error) => {
-            console.error(`exec error: ${error}`);
-        });
-        return;
-    }
-
-    if (process.platform === 'darwin') {
-        if (!target.includes('/')) {
-            await tryCommands([
-                { command: 'open', args: ['-X', '-a', target] },
-                { command: 'open', args: ['-a', target] }
-            ]);
-        } else {
-            await execFilePromise('open', [target]).catch((error) => {
-                console.error(`exec error: ${error}`);
-            });
-        }
-        return;
-    }
-
-    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}`);
-        });
-        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,38 +0,0 @@
-const { execFile } = require('child_process');
-
-let shell;
-try {
-    shell = require('electron').shell;
-} catch (e) {
-    shell = null;
-}
-
-function openWebsite(targetUrl) {
-    if (!targetUrl) return;
-    let url = targetUrl;
-    if (!url.startsWith('http')) {
-        url = 'https://' + url;
-    }
-    if (shell) {
-        shell.openExternal(url);
-    } else {
-        // Fallback for Node.js (Linux focus)
-        execFile('xdg-open', [url], (err) => {
-            if (err) console.error("Failed to open URL via xdg_open:", err);
-        });
-    }
-}
-
-function openSearch(query) {
-    if (!query) return;
-    const url = `https://www.google.com/search?q=${encodeURIComponent(query)}`;
-    if (shell) {
-        shell.openExternal(url);
-    } else {
-        execFile('xdg-open', [url], (err) => {
-            if (err) console.error("Failed to open search via xdg-open:", err);
-        });
-    }
-}
-
-module.exports = { openWebsite, openSearch };

package/src/CLI/approval_handler.js

@@ -1,47 +0,0 @@
-'use strict';
-
-const readline = require('readline');
-const { colors } = require('./cli_colors');
-
-/**
- * Prompts the user in the terminal to approve or deny a code-agent action.
- * Used by the non-interactive `mint code <task>` command.
- *
- * @param {{ type: string, label?: string, preview?: string }} request
- * @returns {Promise<boolean>}  true = approved, false = denied
- */
-async function requestCodeApproval(request) {
-    const typeLabel =
-        request.type === 'shell' ? 'Shell Command' :
-        request.type === 'patch' ? 'Patch Edit'    :
-        'File Write';
-
-    console.log(`\n${colors.yellow}${colors.bright}[Approval Required]${colors.reset} ${typeLabel}`);
-    if (request.label)   console.log(`${colors.gray}${request.label}${colors.reset}`);
-    if (Array.isArray(request.warnings) && request.warnings.length > 0) {
-        request.warnings.forEach((warning) => {
-            console.log(`${colors.yellow}Warning:${colors.reset} ${warning}`);
-        });
-    }
-    if (request.preview) console.log(`${colors.gray}${request.preview}${colors.reset}\n`);
-
-    const rl = readline.createInterface({
-        input:  process.stdin,
-        output: process.stdout
-    });
-
-    const answer = await new Promise((resolve) => {
-        rl.question('Approve this action? [y/N]: ', (value) => {
-            rl.close();
-            resolve((value || '').trim().toLowerCase());
-        });
-    });
-
-    const approved = answer === 'y' || answer === 'yes';
-    console.log(approved
-        ? `${colors.mint}[Mint Code] Approved.${colors.reset}\n`
-        : `${colors.pink}[Mint Code] Denied.${colors.reset}\n`);
-    return approved;
-}
-
-module.exports = { requestCodeApproval };