@pheem49/mint 1.5.5 → 1.6.1

package/src/CLI/updater.js

@@ -1,230 +0,0 @@
-const { execFile } = require('child_process');
-const pkg = require('../../package.json');
-
-const NPM_COMMAND = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-const DEFAULT_AUTO_UPDATE_INTERVAL_HOURS = 24;
-
-function execFilePromise(command, args, options = {}) {
-    return new Promise((resolve, reject) => {
-        execFile(command, args, options, (error, stdout, stderr) => {
-            if (error) {
-                error.stdout = stdout;
-                error.stderr = stderr;
-                reject(error);
-                return;
-            }
-            resolve({ stdout, stderr });
-        });
-    });
-}
-
-function parseVersion(version) {
-    return String(version || '')
-        .trim()
-        .replace(/^v/, '')
-        .split('-')[0]
-        .split('.')
-        .map((part) => Number.parseInt(part, 10) || 0);
-}
-
-function compareVersions(a, b) {
-    const left = parseVersion(a);
-    const right = parseVersion(b);
-    const length = Math.max(left.length, right.length, 3);
-
-    for (let i = 0; i < length; i++) {
-        const l = left[i] || 0;
-        const r = right[i] || 0;
-        if (l > r) return 1;
-        if (l < r) return -1;
-    }
-    return 0;
-}
-
-function normalizeNpmVersionOutput(output) {
-    const trimmed = String(output || '').trim();
-    if (!trimmed) return '';
-
-    try {
-        const parsed = JSON.parse(trimmed);
-        if (typeof parsed === 'string') return parsed;
-    } catch (err) {
-        // npm may return plain text depending on config/version.
-    }
-
-    return trimmed.replace(/^['"]|['"]$/g, '');
-}
-
-function getAutoUpdateIntervalMs(config = {}) {
-    const hours = Number(config.autoUpdateCheckIntervalHours);
-    const safeHours = Number.isFinite(hours) && hours > 0
-        ? hours
-        : DEFAULT_AUTO_UPDATE_INTERVAL_HOURS;
-    return safeHours * 60 * 60 * 1000;
-}
-
-function shouldRunAutoUpdate(config = {}, now = Date.now()) {
-    if (config.enableAutoUpdate === false) return false;
-
-    const lastCheck = Date.parse(config.lastUpdateCheckAt || '');
-    if (!Number.isFinite(lastCheck)) return true;
-
-    return now - lastCheck >= getAutoUpdateIntervalMs(config);
-}
-
-async function getLatestVersion(packageName = pkg.name) {
-    const { stdout } = await execFilePromise(NPM_COMMAND, ['view', packageName, 'version', '--json'], {
-        maxBuffer: 1024 * 1024,
-        timeout: 30000
-    });
-    return normalizeNpmVersionOutput(stdout);
-}
-
-async function installLatest(packageName = pkg.name, options = {}) {
-    const args = ['install', '-g', `${packageName}@latest`];
-    if (options.dryRun) {
-        args.push('--dry-run');
-    }
-
-    return await execFilePromise(NPM_COMMAND, args, {
-        maxBuffer: 1024 * 1024 * 8,
-        timeout: 5 * 60 * 1000
-    });
-}
-
-function formatUpdateError(error) {
-    const detail = [error.stderr, error.stdout, error.message].filter(Boolean).join('\n').trim();
-    if (/EACCES|permission denied|Access is denied/i.test(detail)) {
-        return [
-            'Update failed because npm does not have permission to modify the global install directory.',
-            `Run manually: npm install -g ${pkg.name}@latest`,
-            'If your npm global packages require sudo, run that command with sudo.'
-        ].join('\n');
-    }
-
-    if (/E404|404 Not Found|not in this registry/i.test(detail)) {
-        return [
-            `Could not find ${pkg.name} on the npm registry.`,
-            'Publish the package first, or update Mint from the source/release channel you installed from.'
-        ].join('\n');
-    }
-
-    return `Update failed: ${detail || 'Unknown npm error'}`;
-}
-
-function formatUpdateCheckError(error) {
-    const detail = [error.stderr, error.stdout, error.message].filter(Boolean).join('\n').trim();
-    if (/E404|404 Not Found|not in this registry/i.test(detail)) {
-        return [
-            `Update check unavailable: ${pkg.name} is not published on the npm registry.`,
-            'This does not mean your local Mint version is outdated.'
-        ].join('\n');
-    }
-
-    if (/ENOTFOUND|ETIMEDOUT|ECONNRESET|ECONNREFUSED|network|timeout/i.test(detail)) {
-        return [
-            'Update check unavailable: npm registry could not be reached.',
-            'This does not mean your local Mint version is outdated.'
-        ].join('\n');
-    }
-
-    return `Update check unavailable: ${detail || 'Unknown npm error'}`;
-}
-
-async function runUpdate(options = {}) {
-    const currentVersion = pkg.version;
-    let latestVersion = '';
-
-    try {
-        latestVersion = await getLatestVersion(pkg.name);
-    } catch (error) {
-        return {
-            status: 'error',
-            currentVersion,
-            latestVersion,
-            message: formatUpdateCheckError(error)
-        };
-    }
-
-    if (!latestVersion) {
-        return {
-            status: 'error',
-            currentVersion,
-            latestVersion: '',
-            message: 'Could not determine the latest Mint version from npm.'
-        };
-    }
-
-    const comparison = compareVersions(currentVersion, latestVersion);
-    if (comparison >= 0) {
-        return {
-            status: 'current',
-            currentVersion,
-            latestVersion,
-            message: `Mint is already up to date (${currentVersion}).`
-        };
-    }
-
-    if (options.checkOnly) {
-        return {
-            status: 'available',
-            currentVersion,
-            latestVersion,
-            message: `Mint ${latestVersion} is available. Current version: ${currentVersion}.`
-        };
-    }
-
-    try {
-        await installLatest(pkg.name, { dryRun: options.dryRun });
-        return {
-            status: options.dryRun ? 'dry-run' : 'updated',
-            currentVersion,
-            latestVersion,
-            message: options.dryRun
-                ? `Dry run complete. Mint would update from ${currentVersion} to ${latestVersion}.`
-                : `Mint updated from ${currentVersion} to ${latestVersion}. Restart mint to use the new version.`
-        };
-    } catch (error) {
-        return {
-            status: 'error',
-            currentVersion,
-            latestVersion,
-            message: formatUpdateError(error)
-        };
-    }
-}
-
-async function runStartupAutoUpdate(config, writeConfig, options = {}) {
-    const now = options.now || Date.now();
-    if (!shouldRunAutoUpdate(config, now)) {
-        return {
-            status: 'skipped',
-            message: 'Auto-update check skipped by cooldown.'
-        };
-    }
-
-    const result = await runUpdate({ checkOnly: false });
-    if (typeof writeConfig === 'function') {
-        writeConfig({
-            ...config,
-            lastUpdateCheckAt: new Date(now).toISOString()
-        });
-    }
-    return result;
-}
-
-module.exports = {
-    compareVersions,
-    getLatestVersion,
-    installLatest,
-    normalizeNpmVersionOutput,
-    runUpdate,
-    runStartupAutoUpdate,
-    shouldRunAutoUpdate,
-    _private: {
-        parseVersion,
-        formatUpdateError,
-        formatUpdateCheckError,
-        getAutoUpdateIntervalMs
-    }
-};

package/src/CLI/workspace_manager.js

@@ -1,90 +0,0 @@
-/**
- * Mint Workspace Manager
- * -----------------------
- * Manages project-specific contexts and persistent workspaces.
- * Stores data in ~/.config/mint/workspaces.json
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-function getWorkspaceFile() {
-    return process.env.MINT_WORKSPACE_FILE || path.join(os.homedir(), '.config', 'mint', 'workspaces.json');
-}
-
-function ensureDir() {
-    const dir = path.dirname(getWorkspaceFile());
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-}
-
-function loadWorkspaces() {
-    const workspaceFile = getWorkspaceFile();
-    ensureDir();
-    if (!fs.existsSync(workspaceFile)) return {};
-    try {
-        return JSON.parse(fs.readFileSync(workspaceFile, 'utf8'));
-    } catch (e) {
-        return {};
-    }
-}
-
-function saveWorkspaces(data) {
-    const workspaceFile = getWorkspaceFile();
-    ensureDir();
-    fs.writeFileSync(workspaceFile, JSON.stringify(data, null, 2));
-}
-
-function isPathInsideWorkspace(currentPath, workspacePath) {
-    const relative = path.relative(workspacePath, currentPath);
-    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
-}
-
-function addWorkspace(name, rootPath, instructions = '') {
-    const workspaces = loadWorkspaces();
-    const absolutePath = path.resolve(rootPath);
-    workspaces[name] = {
-        name,
-        path: absolutePath,
-        instructions,
-        addedAt: new Date().toISOString(),
-        lastAccessed: new Date().toISOString()
-    };
-    saveWorkspaces(workspaces);
-    return workspaces[name];
-}
-
-function removeWorkspace(name) {
-    const workspaces = loadWorkspaces();
-    if (workspaces[name]) {
-        delete workspaces[name];
-        saveWorkspaces(workspaces);
-        return true;
-    }
-    return false;
-}
-
-function getWorkspaceByPath(currentPath) {
-    const workspaces = loadWorkspaces();
-    const absoluteCurrent = path.resolve(currentPath);
-    
-    // Find workspace where current path is inside or equal to workspace path
-    for (const name in workspaces) {
-        const ws = workspaces[name];
-        if (isPathInsideWorkspace(absoluteCurrent, ws.path)) {
-            return ws;
-        }
-    }
-    return null;
-}
-
-function listWorkspaces() {
-    return loadWorkspaces();
-}
-
-module.exports = {
-    addWorkspace,
-    removeWorkspace,
-    getWorkspaceByPath,
-    listWorkspaces
-};

package/src/Channels/brave_search_bridge.js

@@ -1,35 +0,0 @@
-const axios = require('axios');
-
-class BraveSearchBridge {
-    constructor(credentials) {
-        this.apiKey = credentials.apiKey;
-    }
-
-    async search(query) {
-        if (!this.apiKey) {
-            throw new Error('Brave Search API Key is required.');
-        }
-
-        try {
-            const response = await axios.get('https://api.search.brave.com/res/v1/web/search', {
-                params: { q: query, count: 5 },
-                headers: {
-                    'Accept': 'application/json',
-                    'Accept-Encoding': 'gzip',
-                    'X-Subscription-Token': this.apiKey
-                }
-            });
-
-            const results = response.data.web ? response.data.web.results : [];
-            return results.map(item => ({
-                title: item.title,
-                snippet: item.description,
-                link: item.url
-            }));
-        } catch (err) {
-            throw new Error(`Brave Search Failed: ${err.message}`);
-        }
-    }
-}
-
-module.exports = BraveSearchBridge;

package/src/Channels/discord_bridge.js

@@ -1,66 +0,0 @@
-'use strict';
-
-const { requireOptional } = require('../System/optional_require');
-const { handleChat } = require('../AI_Brain/Gemini_API');
-
-class DiscordBridge {
-    constructor(token) {
-        this.token = token;
-        const { Client, GatewayIntentBits, Partials } = requireOptional(
-            'discord.js',
-            'npm install discord.js'
-        );
-        this.client = new Client({
-            intents: [
-                GatewayIntentBits.Guilds,
-                GatewayIntentBits.GuildMessages,
-                GatewayIntentBits.MessageContent,
-                GatewayIntentBits.DirectMessages
-            ],
-            partials: [Partials.Channel]
-        });
-    }
-
-    async connect() {
-        this.client.on('ready', () => {
-            console.log(`[Discord Bridge] Logged in as ${this.client.user.tag}!`);
-        });
-
-        this.client.on('messageCreate', async (message) => {
-            if (message.author.bot) return;
-            const isDM = !message.guild;
-            const isMentioned = message.mentions.has(this.client.user);
-
-            if (isDM || isMentioned) {
-                try {
-                    let cleanContent = message.content;
-                    if (isMentioned) {
-                        cleanContent = message.content
-                            .replace(`<@!${this.client.user.id}>`, '')
-                            .replace(`<@${this.client.user.id}>`, '')
-                            .trim();
-                    }
-                    if (!cleanContent) return;
-                    await message.channel.sendTyping();
-                    const result = await handleChat(cleanContent);
-                    if (result && result.response) {
-                        await message.reply(result.response);
-                    }
-                } catch (err) {
-                    console.error('[Discord Bridge] Error processing message:', err);
-                    await message.reply('ขออภัยค่ะ เกิดข้อผิดพลาดบางอย่างในการประมวลผลข้อความ');
-                }
-            }
-        });
-
-        await this.client.login(this.token);
-    }
-
-    async disconnect() {
-        if (this.client) {
-            await this.client.destroy();
-        }
-    }
-}
-
-module.exports = DiscordBridge;

package/src/Channels/google_search_bridge.js

@@ -1,38 +0,0 @@
-const axios = require('axios');
-
-class GoogleSearchBridge {
-    constructor(credentials) {
-        this.apiKey = credentials.apiKey;
-        this.cx = credentials.cx; // Custom Search Engine ID
-    }
-
-    async search(query) {
-        if (!this.apiKey || !this.cx) {
-            throw new Error('Google Search API Key and CX are required.');
-        }
-
-        try {
-            const response = await axios.get('https://www.googleapis.com/customsearch/v1', {
-                params: {
-                    key: this.apiKey,
-                    cx: this.cx,
-                    q: query,
-                    num: 5
-                }
-            });
-
-            const items = response.data.items || [];
-            return items.map(item => ({
-                title: item.title,
-                snippet: item.snippet,
-                link: item.link
-            }));
-        } catch (err) {
-            throw new Error(err.response && err.response.data && err.response.data.error 
-                ? `Google Search API Error: ${err.response.data.error.message}` 
-                : `Google Search Failed: ${err.message}`);
-        }
-    }
-}
-
-module.exports = GoogleSearchBridge;

package/src/Channels/line_bridge.js

@@ -1,60 +0,0 @@
-'use strict';
-
-const { requireOptional } = require('../System/optional_require');
-const { handleChat } = require('../AI_Brain/Gemini_API');
-
-class LineBridge {
-    constructor(credentials) {
-        this._line    = requireOptional('@line/bot-sdk', 'npm install @line/bot-sdk express');
-        this._express = requireOptional('express',       'npm install @line/bot-sdk express');
-        this.config = {
-            channelAccessToken: credentials.accessToken,
-            channelSecret: credentials.secret,
-        };
-        this.port   = credentials.port || 3000;
-        this.client = new this._line.messagingApi.MessagingApiClient({
-            channelAccessToken: credentials.accessToken
-        });
-        this.app    = this._express();
-    }
-
-    async connect() {
-        this.app.post('/callback', this._line.middleware(this.config), (req, res) => {
-            Promise
-                .all(req.body.events.map(event => this.handleEvent(event)))
-                .then((result) => res.json(result))
-                .catch((err) => {
-                    console.error('[LINE Bridge] Error:', err);
-                    res.status(500).end();
-                });
-        });
-
-        this.server = this.app.listen(this.port, () => {
-            console.log(`[LINE Bridge] Listening for webhooks on port ${this.port}`);
-            console.log(`[LINE Bridge] Webhook URL should be: <YOUR_PUBLIC_URL>/callback`);
-        });
-    }
-
-    async handleEvent(event) {
-        if (event.type !== 'message' || event.message.type !== 'text') {
-            return Promise.resolve(null);
-        }
-        try {
-            const result = await handleChat(event.message.text);
-            if (result && result.response) {
-                return this.client.replyMessage({
-                    replyToken: event.replyToken,
-                    messages: [{ type: 'text', text: result.response }],
-                });
-            }
-        } catch (err) {
-            console.error('[LINE Bridge] Error processing event:', err);
-        }
-    }
-
-    async disconnect() {
-        if (this.server) this.server.close();
-    }
-}
-
-module.exports = LineBridge;

package/src/Channels/slack_bridge.js

@@ -1,48 +0,0 @@
-'use strict';
-
-const { requireOptional } = require('../System/optional_require');
-const { handleChat } = require('../AI_Brain/Gemini_API');
-
-class SlackBridge {
-    constructor(credentials) {
-        const { App } = requireOptional('@slack/bolt', 'npm install @slack/bolt');
-        this.app = new App({
-            token: credentials.botToken,
-            appToken: credentials.appToken,
-            socketMode: true
-        });
-    }
-
-    async connect() {
-        this.app.event('app_mention', async ({ event, say }) => {
-            try {
-                const text = event.text.replace(/<@.*?>/g, '').trim();
-                if (!text) return;
-                const result = await handleChat(text);
-                if (result && result.response) await say(result.response);
-            } catch (err) {
-                console.error('[Slack Bridge] Error processing app_mention:', err);
-            }
-        });
-
-        this.app.event('message', async ({ event, say }) => {
-            if (event.channel_type === 'im') {
-                try {
-                    const result = await handleChat(event.text);
-                    if (result && result.response) await say(result.response);
-                } catch (err) {
-                    console.error('[Slack Bridge] Error processing message:', err);
-                }
-            }
-        });
-
-        await this.app.start();
-        console.log('[Slack Bridge] App started in Socket Mode!');
-    }
-
-    async disconnect() {
-        if (this.app) await this.app.stop();
-    }
-}
-
-module.exports = SlackBridge;

package/src/Channels/telegram_bridge.js

@@ -1,41 +0,0 @@
-'use strict';
-
-const { requireOptional } = require('../System/optional_require');
-const { handleChat } = require('../AI_Brain/Gemini_API');
-
-class TelegramBridge {
-    constructor(token) {
-        this.token = token;
-        const { Telegraf } = requireOptional('telegraf', 'npm install telegraf');
-        this.bot = new Telegraf(token);
-    }
-
-    async connect() {
-        this.bot.start((ctx) => ctx.reply('สวัสดีค่ะ! มิ้นท์พร้อมช่วยเหลือคุณใน Telegram แล้วนะคะ ✨'));
-
-        this.bot.on('text', async (ctx) => {
-            try {
-                await ctx.sendChatAction('typing');
-                const message = ctx.message.text;
-                if (!message) return;
-                const result = await handleChat(message);
-                if (result && result.response) await ctx.reply(result.response);
-            } catch (err) {
-                console.error('[Telegram Bridge] Error processing message:', err);
-                await ctx.reply('ขออภัยค่ะ เกิดข้อผิดพลาดบางอย่างในการประมวลผลข้อความ');
-            }
-        });
-
-        this.bot.launch();
-        console.log('[Telegram Bridge] Bot started!');
-
-        process.once('SIGINT', () => this.bot.stop('SIGINT'));
-        process.once('SIGTERM', () => this.bot.stop('SIGTERM'));
-    }
-
-    async disconnect() {
-        if (this.bot) await this.bot.stop();
-    }
-}
-
-module.exports = TelegramBridge;

package/src/Channels/whatsapp_bridge.js

@@ -1,57 +0,0 @@
-'use strict';
-
-const { requireOptional } = require('../System/optional_require');
-const { handleChat } = require('../AI_Brain/Gemini_API');
-
-class WhatsappBridge {
-    constructor() {
-        // Dynamic require — only loads if user has installed whatsapp-web.js
-        const { Client, LocalAuth } = requireOptional(
-            'whatsapp-web.js',
-            'npm install whatsapp-web.js qrcode-terminal'
-        );
-        this._qrcode = requireOptional('qrcode-terminal', 'npm install qrcode-terminal');
-        this.client = new Client({
-            authStrategy: new LocalAuth({
-                dataPath: require('path').join(require('os').homedir(), '.config', 'mint', 'whatsapp-session')
-            }),
-            puppeteer: {
-                args: ['--no-sandbox']
-            }
-        });
-    }
-
-    async connect() {
-        this.client.on('qr', (qr) => {
-            console.log('[WhatsApp Bridge] Scan this QR code to login:');
-            this._qrcode.generate(qr, { small: true });
-        });
-
-        this.client.on('ready', () => {
-            console.log('[WhatsApp Bridge] Client is ready!');
-        });
-
-        this.client.on('message', async (msg) => {
-            try {
-                const chat = await msg.getChat();
-                if (chat.isGroup) return;
-                const result = await handleChat(msg.body);
-                if (result && result.response) {
-                    await msg.reply(result.response);
-                }
-            } catch (err) {
-                console.error('[WhatsApp Bridge] Error processing message:', err);
-            }
-        });
-
-        await this.client.initialize();
-    }
-
-    async disconnect() {
-        if (this.client) {
-            await this.client.destroy();
-        }
-    }
-}
-
-module.exports = WhatsappBridge;