@pheem49/mint 1.5.5 → 1.6.1

package/src/CLI/code_session_memory.js

@@ -1,62 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-const { CONFIG_PATH } = require('../System/config_manager');
-
-const SESSION_FILE = path.join(path.dirname(CONFIG_PATH), 'code-sessions.json');
-
-function ensureSessionStore() {
-    if (!fs.existsSync(SESSION_FILE)) {
-        fs.writeFileSync(SESSION_FILE, JSON.stringify({}, null, 2), 'utf8');
-    }
-}
-
-function readAllSessions() {
-    ensureSessionStore();
-    try {
-        return JSON.parse(fs.readFileSync(SESSION_FILE, 'utf8'));
-    } catch (error) {
-        return {};
-    }
-}
-
-function writeAllSessions(data) {
-    ensureSessionStore();
-    fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2), 'utf8');
-}
-
-function getWorkspaceKey(workspaceRoot) {
-    return crypto.createHash('sha1').update(path.resolve(workspaceRoot)).digest('hex');
-}
-
-function readWorkspaceSession(workspaceRoot) {
-    const sessions = readAllSessions();
-    const key = getWorkspaceKey(workspaceRoot);
-    return sessions[key] || {
-        workspaceRoot: path.resolve(workspaceRoot),
-        summary: '',
-        lastTask: '',
-        lastVerification: '',
-        updatedAt: null
-    };
-}
-
-function writeWorkspaceSession(workspaceRoot, updates) {
-    const sessions = readAllSessions();
-    const key = getWorkspaceKey(workspaceRoot);
-    const current = readWorkspaceSession(workspaceRoot);
-    sessions[key] = {
-        ...current,
-        ...updates,
-        workspaceRoot: path.resolve(workspaceRoot),
-        updatedAt: new Date().toISOString()
-    };
-    writeAllSessions(sessions);
-    return sessions[key];
-}
-
-module.exports = {
-    readWorkspaceSession,
-    writeWorkspaceSession,
-    SESSION_FILE
-};

package/src/CLI/gmail_auth.js

@@ -1,210 +0,0 @@
-const http = require('http');
-const { execFile } = require('child_process');
-const crypto = require('crypto');
-const axios = require('axios');
-const { readConfig, writeConfig } = require('../System/config_manager');
-
-const TOKEN_URL = 'https://oauth2.googleapis.com/token';
-const AUTH_URL = 'https://accounts.google.com/o/oauth2/v2/auth';
-const DEFAULT_SCOPES = [
-    'https://www.googleapis.com/auth/gmail.readonly',
-    'https://www.googleapis.com/auth/gmail.compose'
-];
-
-function buildRedirectUri(port) {
-    return `http://127.0.0.1:${port}/oauth2callback`;
-}
-
-function buildAuthUrl({ clientId, redirectUri, state, scopes = DEFAULT_SCOPES }) {
-    const params = new URLSearchParams({
-        client_id: clientId,
-        redirect_uri: redirectUri,
-        response_type: 'code',
-        scope: scopes.join(' '),
-        access_type: 'offline',
-        prompt: 'consent',
-        state
-    });
-
-    return `${AUTH_URL}?${params.toString()}`;
-}
-
-function openBrowser(url) {
-    const command = process.platform === 'darwin'
-        ? 'open'
-        : process.platform === 'win32'
-            ? 'cmd'
-            : 'xdg-open';
-    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
-
-    return new Promise((resolve, reject) => {
-        execFile(command, args, (error) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve();
-        });
-    });
-}
-
-async function exchangeCodeForToken({ clientId, clientSecret, code, redirectUri }) {
-    const params = new URLSearchParams({
-        client_id: clientId,
-        client_secret: clientSecret,
-        code,
-        redirect_uri: redirectUri,
-        grant_type: 'authorization_code'
-    });
-
-    const response = await axios.post(TOKEN_URL, params.toString(), {
-        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
-    });
-
-    return response.data;
-}
-
-function waitForOAuthCode({ port = 0, state, timeoutMs = 180000 }) {
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        let timer = null;
-
-        const finish = (error, value) => {
-            if (settled) return;
-            settled = true;
-            if (timer) clearTimeout(timer);
-            server.close(() => {
-                if (error) reject(error);
-                else resolve(value);
-            });
-        };
-
-        const server = http.createServer((req, res) => {
-            try {
-                const url = new URL(req.url, 'http://127.0.0.1');
-                if (url.pathname !== '/oauth2callback') {
-                    res.writeHead(404, { 'Content-Type': 'text/plain' });
-                    res.end('Not found');
-                    return;
-                }
-
-                const returnedState = url.searchParams.get('state');
-                const error = url.searchParams.get('error');
-                const code = url.searchParams.get('code');
-
-                if (error) {
-                    res.writeHead(400, { 'Content-Type': 'text/plain' });
-                    res.end(`Gmail authorization failed: ${error}`);
-                    finish(new Error(`Gmail authorization failed: ${error}`));
-                    return;
-                }
-
-                if (!code || returnedState !== state) {
-                    res.writeHead(400, { 'Content-Type': 'text/plain' });
-                    res.end('Invalid Gmail authorization response.');
-                    finish(new Error('Invalid Gmail authorization response.'));
-                    return;
-                }
-
-                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-                res.end('<h1>Gmail connected</h1><p>You can close this window and return to Mint.</p>');
-                finish(null, code);
-            } catch (err) {
-                res.writeHead(500, { 'Content-Type': 'text/plain' });
-                res.end('Internal error.');
-                finish(err);
-            }
-        });
-
-        server.on('error', finish);
-        server.listen(port, '127.0.0.1', () => {
-            timer = setTimeout(() => {
-                finish(new Error('Timed out waiting for Gmail authorization callback.'));
-            }, timeoutMs);
-        });
-    });
-}
-
-async function runGmailAuth(options = {}) {
-    const logger = options.logger || console;
-    const config = options.readConfig ? options.readConfig() : readConfig();
-    const clientId = (config.gmailClientId || '').trim();
-    const clientSecret = (config.gmailClientSecret || '').trim();
-    const userId = (config.gmailUserId || 'me').trim() || 'me';
-
-    if (!clientId || !clientSecret) {
-        throw new Error('Missing Gmail OAuth Client ID or Client Secret. Run `mint onboard` and fill Gmail API credentials first.');
-    }
-
-    const state = crypto.randomBytes(16).toString('hex');
-    const actualPort = options.getAuthorizationCode ? Number(options.port || 8787) : await reserveLocalPort(Number(options.port || 0));
-    const redirectUri = buildRedirectUri(actualPort);
-    const codePromise = options.getAuthorizationCode
-        ? null
-        : waitForOAuthCode({
-            port: actualPort,
-            state,
-            timeoutMs: options.timeoutMs || 180000
-        });
-    const authUrl = buildAuthUrl({ clientId, redirectUri, state, scopes: options.scopes || DEFAULT_SCOPES });
-
-    logger.log(`Open this Google OAuth consent link for Gmail (${userId}):\n${authUrl}\n`);
-
-    if (options.openBrowser !== false) {
-        const browserOpener = options.openBrowser || openBrowser;
-        await browserOpener(authUrl);
-    }
-
-    const code = options.getAuthorizationCode
-        ? await options.getAuthorizationCode({ authUrl, state, redirectUri })
-        : await codePromise;
-    const token = await exchangeCodeForToken({
-        clientId,
-        clientSecret,
-        code,
-        redirectUri
-    });
-
-    if (!token.refresh_token) {
-        throw new Error('Google did not return a refresh token. Re-run `mint gmail auth`; the flow uses prompt=consent to request one.');
-    }
-
-    const nextConfig = {
-        ...config,
-        gmailRefreshToken: token.refresh_token,
-        gmailUserId: userId,
-        pluginGmailEnabled: true
-    };
-
-    const writeResult = options.writeConfig ? options.writeConfig(nextConfig) : writeConfig(nextConfig);
-    if (writeResult && writeResult.success === false) {
-        throw new Error(writeResult.message || 'Failed to save Gmail refresh token.');
-    }
-
-    return {
-        success: true,
-        userId,
-        scopes: options.scopes || DEFAULT_SCOPES
-    };
-}
-
-function reserveLocalPort(port = 0) {
-    return new Promise((resolve, reject) => {
-        const server = http.createServer();
-        server.on('error', reject);
-        server.listen(port, '127.0.0.1', () => {
-            const actualPort = server.address().port;
-            server.close(() => resolve(actualPort));
-        });
-    });
-}
-
-module.exports = {
-    DEFAULT_SCOPES,
-    buildRedirectUri,
-    buildAuthUrl,
-    exchangeCodeForToken,
-    waitForOAuthCode,
-    reserveLocalPort,
-    runGmailAuth
-};

package/src/CLI/image_input.js

@@ -1,90 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { execFileSync } = require('child_process');
-
-const IMAGE_MIME_TYPES = {
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.webp': 'image/webp',
-    '.gif': 'image/gif'
-};
-
-function resolveImagePath(imagePath, cwd = process.cwd()) {
-    if (!imagePath || typeof imagePath !== 'string') {
-        throw new Error('Image path is required.');
-    }
-
-    return path.resolve(cwd, imagePath);
-}
-
-function getImageMimeType(imagePath) {
-    const ext = path.extname(imagePath).toLowerCase();
-    const mimeType = IMAGE_MIME_TYPES[ext];
-    if (!mimeType) {
-        throw new Error(`Unsupported image type "${ext || '(none)'}". Supported: ${Object.keys(IMAGE_MIME_TYPES).join(', ')}`);
-    }
-    return mimeType;
-}
-
-function loadImageAsDataUri(imagePath, cwd = process.cwd()) {
-    const resolved = resolveImagePath(imagePath, cwd);
-    if (!fs.existsSync(resolved)) {
-        throw new Error(`Image file not found: ${imagePath}`);
-    }
-
-    const stat = fs.statSync(resolved);
-    if (!stat.isFile()) {
-        throw new Error(`Image path is not a file: ${imagePath}`);
-    }
-
-    const mimeType = getImageMimeType(resolved);
-    const data = fs.readFileSync(resolved).toString('base64');
-    return {
-        path: resolved,
-        mimeType,
-        dataUri: `data:${mimeType};base64,${data}`
-    };
-}
-
-function tryReadClipboardCommand(command, args) {
-    try {
-        return execFileSync(command, args, {
-            encoding: 'buffer',
-            maxBuffer: 1024 * 1024 * 20,
-            stdio: ['ignore', 'pipe', 'ignore']
-        });
-    } catch (_) {
-        return null;
-    }
-}
-
-function loadClipboardImageAsDataUri() {
-    const attempts = [
-        { command: 'wl-paste', args: ['--type', 'image/png', '--no-newline'] },
-        { command: 'xclip', args: ['-selection', 'clipboard', '-t', 'image/png', '-o'] }
-    ];
-
-    for (const attempt of attempts) {
-        const data = tryReadClipboardCommand(attempt.command, attempt.args);
-        if (data && data.length > 0) {
-            return {
-                path: 'clipboard',
-                mimeType: 'image/png',
-                dataUri: `data:image/png;base64,${data.toString('base64')}`
-            };
-        }
-    }
-
-    throw new Error('No clipboard image found. On Linux, install wl-clipboard or xclip, then copy an image and try Ctrl+V again.');
-}
-
-module.exports = {
-    loadImageAsDataUri,
-    loadClipboardImageAsDataUri,
-    _helpers: {
-        getImageMimeType,
-        resolveImagePath,
-        tryReadClipboardCommand
-    }
-};

package/src/CLI/intent_detectors.js

@@ -1,181 +0,0 @@
-'use strict';
-
-// ---------------------------------------------------------------------------
-// Repository Summary
-// ---------------------------------------------------------------------------
-
-/**
- * Returns true when the user's plain-language input is asking for a repo summary.
- * @param {string} text
- * @returns {boolean}
- */
-function isRepoSummaryRequest(text) {
-    const input = (text || '').trim().toLowerCase();
-    if (!input) return false;
-
-    const hasRepoTarget = /\b(repo|repository|project|workspace|codebase)\b|รีโป|โปรเจค|โปรเจ็กต์|โปรเจกต์|โปรเจ็ค/.test(input);
-    const asksSummary   = /\b(summarize|summary|overview)\b|สรุป|ภาพรวม/.test(input);
-    const asksQuestion  = /\b(have|has|มีไหม|มีมั้ย|มีหรือเปล่า)\b/.test(input);
-
-    return hasRepoTarget && asksSummary && !asksQuestion;
-}
-
-/**
- * Parses raw CLI args for the summarize tool.
- * @param {string} rawArgs
- * @returns {{ targetPath: string, json: boolean }}
- */
-function parseRepoSummaryArgs(rawArgs) {
-    const args     = (rawArgs || '').split(/\s+/).filter(Boolean);
-    const json     = args.includes('--json');
-    const pathArgs = args.filter(arg => arg !== '--json');
-    return {
-        targetPath: pathArgs.length > 0 ? pathArgs.join(' ') : process.cwd(),
-        json
-    };
-}
-
-// ---------------------------------------------------------------------------
-// Symbol Index
-// ---------------------------------------------------------------------------
-
-/**
- * Returns true when the user's input is asking for a symbol index.
- * @param {string} text
- * @returns {boolean}
- */
-function isSymbolIndexRequest(text) {
-    const input = (text || '').trim().toLowerCase();
-    if (!input) return false;
-
-    const hasSymbolTarget      = /\b(symbol|symbols|ast|lsp)\b|ซิมโบล|สัญลักษณ์/.test(input);
-    const asksIndex            = /\b(index|list|show|build|scan|overview)\b|ทำ|สร้าง|แสดง|ลิสต์|สแกน/.test(input);
-    const referencesWorkspace  = /\b(repo|repository|project|workspace|codebase|source|code)\b|รีโป|โปรเจค|โปรเจ็กต์|โปรเจกต์|โค้ด/.test(input);
-    const asksQuestion         = /\b(do i|have|has)\b|มีไหม|มีมั้ย|มีหรือเปล่า/.test(input);
-
-    return hasSymbolTarget && (asksIndex || referencesWorkspace) && !asksQuestion;
-}
-
-/**
- * Parses raw CLI args for the symbol index tool.
- * @param {string} rawArgs
- * @returns {{ targetPath: string, json: boolean, limit: number }}
- */
-function parseSymbolIndexArgs(rawArgs) {
-    const args     = (rawArgs || '').split(/\s+/).filter(Boolean);
-    const json     = args.includes('--json');
-    let limit      = 80;
-    const pathArgs = [];
-
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--json') continue;
-        if (arg === '--limit') {
-            const next = Number(args[i + 1]);
-            if (Number.isFinite(next) && next >= 0) { limit = next; i++; }
-            continue;
-        }
-        if (arg.startsWith('--limit=')) {
-            const next = Number(arg.slice('--limit='.length));
-            if (Number.isFinite(next) && next >= 0) limit = next;
-            continue;
-        }
-        pathArgs.push(arg);
-    }
-
-    return {
-        targetPath: pathArgs.length > 0 ? pathArgs.join(' ') : process.cwd(),
-        json,
-        limit
-    };
-}
-
-// ---------------------------------------------------------------------------
-// Semantic Code Search
-// ---------------------------------------------------------------------------
-
-/**
- * Returns true when the user's input is asking for a semantic code search.
- * @param {string} text
- * @returns {boolean}
- */
-function isSemanticCodeSearchRequest(text) {
-    const input = (text || '').trim().toLowerCase();
-    if (!input) return false;
-
-    const hasSemanticSearch   = /\bsemantic\b/.test(input) && /\b(search|find|look for)\b/.test(input);
-    const referencesCode      = /\b(code|repo|repository|project|workspace|codebase|source)\b|โค้ด|รีโป|โปรเจค|โปรเจ็กต์|โปรเจกต์/.test(input);
-    const thaiSemanticSearch  = /ค้นหา/.test(input) && /ความหมาย|semantic/.test(input) && /โค้ด|โปรเจค|รีโป/.test(input);
-    const asksQuestion        = /\b(do i|have|has)\b|มีไหม|มีมั้ย|มีหรือเปล่า/.test(input);
-
-    return (hasSemanticSearch && referencesCode || thaiSemanticSearch) && !asksQuestion;
-}
-
-/**
- * Parses raw CLI args for the semantic code search tool.
- * @param {string} rawArgs
- * @returns {{ mode: string, query: string, targetPath: string, json: boolean, topK: number }}
- */
-function parseSemanticCodeArgs(rawArgs) {
-    const args      = (rawArgs || '').split(/\s+/).filter(Boolean);
-    const json      = args.includes('--json');
-    let topK        = 5;
-    const pathArgs  = [];
-    const queryArgs = [];
-    let mode        = 'search';
-
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === 'index' || arg === 'search') { mode = arg; continue; }
-        if (arg === '--json') continue;
-        if (arg === '--top-k' || arg === '--limit') {
-            const next = Number(args[i + 1]);
-            if (Number.isFinite(next) && next > 0) { topK = next; i++; }
-            continue;
-        }
-        if (arg.startsWith('--top-k=') || arg.startsWith('--limit=')) {
-            const next = Number(arg.slice(arg.indexOf('=') + 1));
-            if (Number.isFinite(next) && next > 0) topK = next;
-            continue;
-        }
-        if (arg === '--path') {
-            if (args[i + 1]) { pathArgs.push(args[i + 1]); i++; }
-            continue;
-        }
-        queryArgs.push(arg);
-    }
-
-    return {
-        mode,
-        query:      queryArgs.join(' ').trim(),
-        targetPath: pathArgs.length > 0 ? pathArgs.join(' ') : process.cwd(),
-        json,
-        topK
-    };
-}
-
-/**
- * Strips intent phrases from text to extract the raw search query.
- * @param {string} text
- * @returns {string}
- */
-function extractSemanticCodeQuery(text) {
-    return String(text || '')
-        .replace(/semantic\s+code\s+search/ig, '')
-        .replace(/semantic\s+search/ig, '')
-        .replace(/search\s+code/ig, '')
-        .replace(/ค้นหาโค้ดแบบความหมาย/g, '')
-        .replace(/ค้นหาแบบ semantic/g, '')
-        .replace(/ใน repo นี้|ในโปรเจคนี้|ในรีโปนี้/g, '')
-        .trim();
-}
-
-module.exports = {
-    isRepoSummaryRequest,
-    parseRepoSummaryArgs,
-    isSymbolIndexRequest,
-    parseSymbolIndexArgs,
-    isSemanticCodeSearchRequest,
-    parseSemanticCodeArgs,
-    extractSemanticCodeQuery
-};