@pheem49/mint 1.5.0 → 1.5.2

package/tests/gmail.test.js

@@ -1,135 +0,0 @@
-/**
- * Tests: gmail.js plugin
- */
-
-jest.mock('axios', () => ({
-    post: jest.fn(),
-    get: jest.fn()
-}));
-
-jest.mock('../src/System/config_manager', () => ({
-    readConfig: jest.fn()
-}));
-
-const axios = require('axios');
-const { readConfig } = require('../src/System/config_manager');
-const gmail = require('../src/Plugins/gmail');
-
-describe('gmail plugin', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
-    test('has required plugin fields', () => {
-        expect(gmail.name).toBe('gmail');
-        expect(typeof gmail.description).toBe('string');
-        expect(typeof gmail.execute).toBe('function');
-    });
-
-    test('returns configuration message when OAuth config is missing', async () => {
-        readConfig.mockReturnValue({});
-
-        const result = await gmail.execute('inbox');
-
-        expect(result).toContain('Gmail API is not configured');
-        expect(axios.get).not.toHaveBeenCalled();
-    });
-
-    test('searches Gmail and fetches metadata for results', async () => {
-        readConfig.mockReturnValue({
-            gmailClientId: 'client-id',
-            gmailClientSecret: 'client-secret',
-            gmailRefreshToken: 'refresh-token',
-            gmailUserId: 'me'
-        });
-        axios.post.mockResolvedValueOnce({ data: { access_token: 'access-token' } });
-        axios.get
-            .mockResolvedValueOnce({ data: { messages: [{ id: 'msg-1' }] } })
-            .mockResolvedValueOnce({
-                data: {
-                    id: 'msg-1',
-                    snippet: 'Hello snippet',
-                    payload: {
-                        headers: [
-                            { name: 'From', value: 'A <a@example.com>' },
-                            { name: 'Subject', value: 'Hello' },
-                            { name: 'Date', value: 'Fri, 15 May 2026 10:00:00 +0700' }
-                        ]
-                    }
-                }
-            });
-
-        const result = await gmail.execute(JSON.stringify({ action: 'search', query: 'is:unread', limit: 1 }));
-
-        expect(axios.get).toHaveBeenCalledTimes(2);
-        expect(axios.get.mock.calls[0][0]).toBe('https://gmail.googleapis.com/gmail/v1/users/me/messages');
-        expect(result).toContain('Hello');
-        expect(result).toContain('msg-1');
-    });
-
-    test('reads full Gmail message body', async () => {
-        readConfig.mockReturnValue({
-            gmailClientId: 'client-id',
-            gmailClientSecret: 'client-secret',
-            gmailRefreshToken: 'refresh-token',
-            gmailUserId: 'me'
-        });
-        axios.post.mockResolvedValueOnce({ data: { access_token: 'access-token' } });
-        axios.get.mockResolvedValueOnce({
-            data: {
-                id: 'msg-1',
-                payload: {
-                    headers: [
-                        { name: 'From', value: 'A <a@example.com>' },
-                        { name: 'Subject', value: 'Hello' }
-                    ],
-                    mimeType: 'text/plain',
-                    body: { data: gmail._helpers.encodeBase64Url('Full body text') }
-                }
-            }
-        });
-
-        const result = await gmail.execute(JSON.stringify({ action: 'read', id: 'msg-1' }));
-
-        expect(result).toContain('Full body text');
-        expect(result).toContain('Hello');
-    });
-
-    test('creates Gmail draft only', async () => {
-        readConfig.mockReturnValue({
-            gmailClientId: 'client-id',
-            gmailClientSecret: 'client-secret',
-            gmailRefreshToken: 'refresh-token',
-            gmailUserId: 'me'
-        });
-        axios.post
-            .mockResolvedValueOnce({ data: { access_token: 'access-token' } })
-            .mockResolvedValueOnce({ data: { id: 'draft-1' } });
-
-        const result = await gmail.execute(JSON.stringify({
-            action: 'draft',
-            to: 'person@example.com',
-            subject: 'Draft subject',
-            body: 'Draft body'
-        }));
-
-        expect(axios.post).toHaveBeenCalledTimes(2);
-        expect(axios.post.mock.calls[1][0]).toBe('https://gmail.googleapis.com/gmail/v1/users/me/drafts');
-        expect(axios.post.mock.calls[1][1].message.raw).toBeTruthy();
-        expect(result).toContain('Created Gmail draft');
-        expect(result).toContain('Review it in Gmail before sending');
-    });
-
-    test('buildRawEmail removes newline injection from headers', () => {
-        const raw = gmail._helpers.buildRawEmail({
-            to: 'person@example.com\nBcc: attacker@example.com',
-            subject: 'Hello\r\nBad: header',
-            body: 'Body'
-        });
-        const decoded = gmail._helpers.decodeBase64Url(raw);
-
-        expect(decoded).toContain('To: person@example.com Bcc: attacker@example.com');
-        expect(decoded).toContain('Subject: Hello Bad: header');
-        expect(decoded).not.toContain('\nBcc: attacker@example.com');
-    });
-});

package/tests/gmail_auth.test.js

@@ -1,129 +0,0 @@
-/**
- * Tests: gmail_auth.js OAuth helper
- */
-
-jest.mock('axios', () => ({
-    post: jest.fn()
-}));
-
-jest.mock('../src/System/config_manager', () => ({
-    readConfig: jest.fn(),
-    writeConfig: jest.fn()
-}));
-
-const axios = require('axios');
-const gmailAuth = require('../src/CLI/gmail_auth');
-
-describe('gmail_auth helper', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
-    test('buildAuthUrl includes offline access and consent prompt', () => {
-        const url = gmailAuth.buildAuthUrl({
-            clientId: 'client-id',
-            redirectUri: 'http://127.0.0.1:3333/oauth2callback',
-            state: 'state-1'
-        });
-
-        const parsed = new URL(url);
-        expect(parsed.origin + parsed.pathname).toBe('https://accounts.google.com/o/oauth2/v2/auth');
-        expect(parsed.searchParams.get('client_id')).toBe('client-id');
-        expect(parsed.searchParams.get('access_type')).toBe('offline');
-        expect(parsed.searchParams.get('prompt')).toBe('consent');
-        expect(parsed.searchParams.get('scope')).toContain('gmail.readonly');
-        expect(parsed.searchParams.get('scope')).toContain('gmail.compose');
-    });
-
-    test('exchanges authorization code for token', async () => {
-        axios.post.mockResolvedValueOnce({
-            data: {
-                refresh_token: 'refresh-token'
-            }
-        });
-
-        const token = await gmailAuth.exchangeCodeForToken({
-            clientId: 'client-id',
-            clientSecret: 'client-secret',
-            code: 'code-1',
-            redirectUri: 'http://127.0.0.1:3333/oauth2callback'
-        });
-
-        expect(token.refresh_token).toBe('refresh-token');
-        expect(axios.post).toHaveBeenCalledWith(
-            'https://oauth2.googleapis.com/token',
-            expect.stringContaining('grant_type=authorization_code'),
-            expect.any(Object)
-        );
-    });
-
-    test('runGmailAuth opens browser, accepts callback, and saves refresh token', async () => {
-        axios.post.mockResolvedValueOnce({
-            data: {
-                refresh_token: 'new-refresh-token'
-            }
-        });
-
-        const writeConfig = jest.fn(() => ({ success: true }));
-        const result = await gmailAuth.runGmailAuth({
-            readConfig: () => ({
-                gmailClientId: 'client-id',
-                gmailClientSecret: 'client-secret',
-                gmailUserId: 'me'
-            }),
-            writeConfig,
-            logger: { log: jest.fn() },
-            openBrowser: jest.fn(),
-            getAuthorizationCode: async ({ authUrl, state, redirectUri }) => {
-                expect(authUrl).toContain(encodeURIComponent(redirectUri));
-                expect(state).toBeTruthy();
-                return 'auth-code';
-            },
-            timeoutMs: 5000
-        });
-
-        expect(result.success).toBe(true);
-        expect(writeConfig).toHaveBeenCalledWith(expect.objectContaining({
-            gmailRefreshToken: 'new-refresh-token',
-            gmailUserId: 'me',
-            pluginGmailEnabled: true
-        }));
-    });
-
-    test('runGmailAuth can print link without opening browser', async () => {
-        axios.post.mockResolvedValueOnce({
-            data: {
-                refresh_token: 'manual-refresh-token'
-            }
-        });
-
-        const openBrowser = jest.fn();
-        const writeConfig = jest.fn(() => ({ success: true }));
-
-        const result = await gmailAuth.runGmailAuth({
-            readConfig: () => ({
-                gmailClientId: 'client-id',
-                gmailClientSecret: 'client-secret',
-                gmailUserId: 'me'
-            }),
-            writeConfig,
-            logger: { log: jest.fn() },
-            openBrowser: false,
-            getAuthorizationCode: async () => 'manual-code'
-        });
-
-        expect(result.success).toBe(true);
-        expect(openBrowser).not.toHaveBeenCalled();
-        expect(writeConfig).toHaveBeenCalledWith(expect.objectContaining({
-            gmailRefreshToken: 'manual-refresh-token'
-        }));
-    });
-
-    test('runGmailAuth requires saved client credentials', async () => {
-        await expect(gmailAuth.runGmailAuth({
-            readConfig: () => ({}),
-            openBrowser: jest.fn(),
-            logger: { log: jest.fn() }
-        })).rejects.toThrow('Missing Gmail OAuth Client ID');
-    });
-});

package/tests/google_calendar.test.js

@@ -1,113 +0,0 @@
-/**
- * Tests: google_calendar.js plugin
- */
-
-jest.mock('axios', () => ({
-    post: jest.fn(),
-    get: jest.fn()
-}));
-
-jest.mock('electron', () => ({
-    shell: {
-        openExternal: jest.fn()
-    }
-}));
-
-jest.mock('../src/System/config_manager', () => ({
-    readConfig: jest.fn()
-}));
-
-const axios = require('axios');
-const { shell } = require('electron');
-const { readConfig } = require('../src/System/config_manager');
-
-describe('google_calendar plugin', () => {
-    let plugin;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        plugin = require('../src/Plugins/google_calendar');
-    });
-
-    test('has required plugin fields', () => {
-        expect(plugin.name).toBe('google_calendar');
-        expect(typeof plugin.description).toBe('string');
-        expect(typeof plugin.execute).toBe('function');
-    });
-
-    test('falls back to opening Google Calendar when API config is missing', async () => {
-        readConfig.mockReturnValue({});
-
-        const result = await plugin.execute('open');
-
-        expect(shell.openExternal).toHaveBeenCalledWith('https://calendar.google.com/');
-        expect(result).toContain('Google Calendar');
-    });
-
-    test('creates event through Google Calendar API', async () => {
-        readConfig.mockReturnValue({
-            googleCalendarClientId: 'client-id',
-            googleCalendarClientSecret: 'client-secret',
-            googleCalendarRefreshToken: 'refresh-token',
-            googleCalendarId: 'primary'
-        });
-        axios.post
-            .mockResolvedValueOnce({ data: { access_token: 'access-token' } })
-            .mockResolvedValueOnce({
-                data: {
-                    summary: 'Demo meeting',
-                    htmlLink: 'https://calendar.google.com/event/demo'
-                }
-            });
-
-        const result = await plugin.execute(JSON.stringify({
-            action: 'create',
-            summary: 'Demo meeting',
-            start: '2026-05-15T10:00:00+07:00',
-            end: '2026-05-15T11:00:00+07:00'
-        }));
-
-        expect(axios.post).toHaveBeenCalledTimes(2);
-        expect(axios.post.mock.calls[1][0]).toContain('/calendars/primary/events');
-        expect(axios.post.mock.calls[1][1].summary).toBe('Demo meeting');
-        expect(result).toContain('Demo meeting');
-        expect(result).toContain('https://calendar.google.com/event/demo');
-    });
-
-    test('lists upcoming events through Google Calendar API', async () => {
-        readConfig.mockReturnValue({
-            googleCalendarClientId: 'client-id',
-            googleCalendarClientSecret: 'client-secret',
-            googleCalendarRefreshToken: 'refresh-token',
-            googleCalendarId: 'primary'
-        });
-        axios.post.mockResolvedValueOnce({ data: { access_token: 'access-token' } });
-        axios.get.mockResolvedValueOnce({
-            data: {
-                items: [
-                    {
-                        summary: 'Planning',
-                        start: { dateTime: '2026-05-15T10:00:00+07:00' },
-                        end: { dateTime: '2026-05-15T11:00:00+07:00' }
-                    }
-                ]
-            }
-        });
-
-        const result = await plugin.execute(JSON.stringify({ action: 'list', days: 3 }));
-
-        expect(axios.get).toHaveBeenCalledTimes(1);
-        expect(axios.get.mock.calls[0][0]).toContain('/calendars/primary/events');
-        expect(result).toContain('Planning');
-    });
-
-    test('builds all-day event payload with exclusive end date', () => {
-        const payload = plugin._helpers.buildEventPayload({
-            summary: 'All day',
-            date: '2026-05-15'
-        });
-
-        expect(payload.start).toEqual({ date: '2026-05-15' });
-        expect(payload.end).toEqual({ date: '2026-05-16' });
-    });
-});

package/tests/google_tts_urls.test.js

@@ -1,24 +0,0 @@
-const { getGoogleTtsUrls, splitTextForTts } = require('../src/System/google_tts_urls');
-
-describe('google_tts_urls', () => {
-    test('returns no URLs for empty text', () => {
-        expect(getGoogleTtsUrls('')).toEqual([]);
-    });
-
-    test('builds Google Translate TTS URLs with encoded text', () => {
-        const urls = getGoogleTtsUrls('hello world', { lang: 'en' });
-
-        expect(urls).toHaveLength(1);
-        expect(urls[0].shortText).toBe('hello world');
-        expect(urls[0].url).toContain('translate_tts?');
-        expect(urls[0].url).toContain('q=hello+world');
-        expect(urls[0].url).toContain('tl=en');
-    });
-
-    test('splits long text into bounded chunks', () => {
-        const chunks = splitTextForTts('a '.repeat(150), 50);
-
-        expect(chunks.length).toBeGreaterThan(1);
-        expect(chunks.every(chunk => chunk.length <= 50)).toBe(true);
-    });
-});

package/tests/memory_store.test.js

@@ -1,185 +0,0 @@
-/**
- * Tests: memory_store.js
- * Tests profile CRUD, usage pattern recording, and getUserContext output.
- * Uses an isolated in-memory DB path via MINT_TEST_DB env var.
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// ── Isolate DB per test run ─────────────────────────────────────────────────
-let tempDir;
-let memStore;
-
-beforeEach(() => {
-    jest.resetModules();
-
-    // Create isolated temp directory
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-mem-test-'));
-
-    // Patch os.homedir so memory_store uses our temp .mint dir
-    jest.spyOn(os, 'homedir').mockReturnValue(tempDir);
-
-    // Require fresh instance (no cache)
-    memStore = require('../src/AI_Brain/memory_store');
-});
-
-afterEach(() => {
-    jest.restoreAllMocks();
-    jest.resetModules();
-    fs.rmSync(tempDir, { recursive: true, force: true });
-});
-
-// ── Profile tests ──────────────────────────────────────────────────────────
-
-describe('memory_store — setProfile / getProfile', () => {
-    test('stores and retrieves a string value', () => {
-        memStore.setProfile('test_key', 'hello');
-        expect(memStore.getProfile('test_key')).toBe('hello');
-    });
-
-    test('returns defaultValue when key does not exist', () => {
-        expect(memStore.getProfile('nonexistent', 'default_val')).toBe('default_val');
-    });
-
-    test('overwrites existing key', () => {
-        memStore.setProfile('key', 'first');
-        memStore.setProfile('key', 'second');
-        expect(memStore.getProfile('key')).toBe('second');
-    });
-
-    test('stores numeric value as string', () => {
-        memStore.setProfile('count', 42);
-        expect(memStore.getProfile('count')).toBe('42');
-    });
-});
-
-// ── recordInteraction tests ────────────────────────────────────────────────
-
-describe('memory_store — recordInteraction', () => {
-    test('records preferred language as thai for thai text', () => {
-        memStore.recordInteraction('ช่วยเขียนโค้ดให้หน่อยนะคะ', 'โค้ดค่ะ');
-        expect(memStore.getProfile('preferred_language')).toBe('thai');
-    });
-
-    test('records preferred language as english for english text', () => {
-        memStore.recordInteraction('please help me write a function', 'sure!');
-        expect(memStore.getProfile('preferred_language')).toBe('english');
-    });
-
-    test('increments total_interactions counter', () => {
-        memStore.recordInteraction('msg 1', 'reply 1');
-        memStore.recordInteraction('msg 2', 'reply 2');
-        expect(memStore.getProfile('total_interactions')).toBe('2');
-    });
-
-    test('records coding keywords as patterns', () => {
-        memStore.recordInteraction('fix the Python script bug', 'sure!');
-        const patterns = memStore.getTopPatterns(10).map(p => p.pattern);
-        // 'python' and 'script' are keywords extracted (stop words removed)
-        expect(patterns.some(p => ['python', 'script', 'fix'].includes(p))).toBe(true);
-    });
-
-    test('does not throw on empty message', () => {
-        expect(() => memStore.recordInteraction('', '')).not.toThrow();
-    });
-});
-
-// ── getTopPatterns tests ───────────────────────────────────────────────────
-
-describe('memory_store — getTopPatterns', () => {
-    test('returns patterns sorted by count descending', () => {
-        memStore.recordInteraction('python python python', 'ok');
-        memStore.recordInteraction('python javascript', 'ok');
-        const patterns = memStore.getTopPatterns(5);
-        const patternNames = patterns.map(p => p.pattern);
-        expect(patternNames[0]).toBe('python'); // python used most
-    });
-
-    test('returns empty array when no interactions recorded', () => {
-        expect(memStore.getTopPatterns(5)).toEqual([]);
-    });
-});
-
-// ── getUserContext tests ───────────────────────────────────────────────────
-
-describe('memory_store — getUserContext', () => {
-    test('returns empty string when no data', () => {
-        expect(memStore.getUserContext()).toBe('');
-    });
-
-    test('includes preferred_language in context output', () => {
-        memStore.recordInteraction('สวัสดีครับ', 'สวัสดีค่ะ');
-        const ctx = memStore.getUserContext();
-        expect(ctx).toContain('thai');
-    });
-
-    test('includes total_interactions in context', () => {
-        memStore.recordInteraction('hello', 'hi');
-        const ctx = memStore.getUserContext();
-        expect(ctx).toContain('1');
-    });
-
-    test('context starts with the user context header', () => {
-        memStore.setProfile('preferred_language', 'english');
-        const ctx = memStore.getUserContext();
-        expect(ctx).toContain('[LONG-TERM USER CONTEXT');
-    });
-
-    test('context ends with END marker', () => {
-        memStore.setProfile('preferred_language', 'thai');
-        const ctx = memStore.getUserContext();
-        expect(ctx).toContain('[END USER CONTEXT]');
-    });
-});
-
-// ── Response Cache tests ──────────────────────────────────────────────────
-
-describe('memory_store — response cache', () => {
-    test('stores and retrieves a response', () => {
-        const query = 'What is 2+2?';
-        const response = { response: '4', action: { type: 'none' } };
-        memStore.cacheResponse(query, response);
-        
-        const cached = memStore.getCachedResponse(query);
-        expect(cached.response).toBe('4');
-    });
-
-    test('returns null for missing query', () => {
-        expect(memStore.getCachedResponse('where is my cat?')).toBe(null);
-    });
-
-    test('is case-insensitive and ignores whitespace', () => {
-        const query = '  Hello World  ';
-        const response = { response: 'Hi!', action: { type: 'none' } };
-        memStore.cacheResponse(query, response);
-        
-        const cached = memStore.getCachedResponse('hello world');
-        expect(cached.response).toBe('Hi!');
-    });
-});
-
-// ── saveSessionSummary / getRecentMemories tests ───────────────────────────
-
-describe('memory_store — session summaries', () => {
-    test('saves and retrieves a summary', () => {
-        memStore.saveSessionSummary('User asked about Python scripting', ['python', 'coding']);
-        const memories = memStore.getRecentMemories(5);
-        expect(memories.length).toBe(1);
-        expect(memories[0].summary).toBe('User asked about Python scripting');
-    });
-
-    test('ignores too-short summaries', () => {
-        memStore.saveSessionSummary('ok', []);
-        const memories = memStore.getRecentMemories(5);
-        expect(memories.length).toBe(0);
-    });
-
-    test('returns most recent summaries first', () => {
-        memStore.saveSessionSummary('First session about web development', []);
-        memStore.saveSessionSummary('Second session about machine learning', []);
-        const memories = memStore.getRecentMemories(5);
-        expect(memories[0].summary).toContain('Second');
-    });
-});