@pheem49/mint 1.2.4 → 1.4.0

package/tests/memory_store.test.js

@@ -0,0 +1,185 @@
+/**
+ * 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');
+    });
+});

package/tests/spotify.test.js

@@ -0,0 +1,201 @@
+/**
+ * Tests: spotify.js plugin
+ * Tests the plugin interface and all action handlers.
+ * Mocks exec/playerctl so no real Spotify needed.
+ */
+
+// ── Mock child_process before requiring the module ─────────────────────────
+jest.mock('child_process', () => ({
+    exec: jest.fn(),
+    execSync: jest.fn(),
+    promisify: undefined, // will use our mock exec
+}));
+
+// Mock promisify to return our mock exec as async
+const { exec: mockExec } = require('child_process');
+jest.mock('util', () => ({
+    ...jest.requireActual('util'),
+    promisify: (fn) => {
+        // Return an async wrapper around mockExec
+        return (...args) => new Promise((resolve, reject) => {
+            mockExec(...args, (err, stdout, stderr) => {
+                if (err) reject(err);
+                else resolve({ stdout: stdout || '', stderr: stderr || '' });
+            });
+        });
+    }
+}));
+
+let spotify;
+
+beforeEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+    spotify = require('../src/Plugins/spotify');
+});
+
+// ── Plugin interface tests ─────────────────────────────────────────────────
+
+describe('Spotify Plugin — interface', () => {
+    test('has required plugin fields', () => {
+        expect(spotify.name).toBe('spotify');
+        expect(typeof spotify.description).toBe('string');
+        expect(typeof spotify.execute).toBe('function');
+    });
+
+    test('description mentions valid commands', () => {
+        expect(spotify.description).toMatch(/play/);
+        expect(spotify.description).toMatch(/pause/);
+        expect(spotify.description).toMatch(/next/);
+    });
+});
+
+// ── Playback control tests ─────────────────────────────────────────────────
+
+describe('Spotify Plugin — playback commands', () => {
+    const playbackCmds = ['play', 'pause', 'stop', 'next', 'previous'];
+
+    playbackCmds.forEach(cmd => {
+        test(`executes "${cmd}" and returns success message`, async () => {
+            mockExec.mockImplementation((command, callback) => {
+                callback(null, '', '');
+            });
+
+            const result = await spotify.execute(cmd);
+            expect(typeof result).toBe('string');
+            expect(result.length).toBeGreaterThan(0);
+            // Should not contain error text
+            expect(result).not.toMatch(/เกิดข้อผิดพลาด/);
+        });
+    });
+
+    test('returns "spotify not running" error when playerctl reports no players', async () => {
+        const err = new Error('No players found');
+        err.stderr = 'No players found';
+        mockExec.mockImplementation((command, callback) => {
+            callback(err, '', 'No players found');
+        });
+
+        const result = await spotify.execute('play');
+        expect(result).toContain('Spotify ยังไม่ได้เปิดอยู่');
+    });
+
+    test('returns playerctl missing error when exit code is 127', async () => {
+        const err = new Error('command not found: playerctl');
+        err.code = 127;
+        mockExec.mockImplementation((command, callback) => {
+            callback(err, '', '');
+        });
+
+        const result = await spotify.execute('play');
+        expect(result).toContain('playerctl');
+    });
+});
+
+// ── Now Playing tests ──────────────────────────────────────────────────────
+
+describe('Spotify Plugin — now_playing', () => {
+    test('returns formatted now playing string', async () => {
+        let callCount = 0;
+        mockExec.mockImplementation((command, callback) => {
+            callCount++;
+            // Mock: title, artist, album, status calls
+            if (command.includes('title'))  callback(null, 'Dynamite\n', '');
+            else if (command.includes('artist')) callback(null, 'BTS\n', '');
+            else if (command.includes('album'))  callback(null, 'BE\n', '');
+            else if (command.includes('status')) callback(null, 'Playing\n', '');
+            else callback(null, '', '');
+        });
+
+        const result = await spotify.execute('now_playing');
+        expect(result).toContain('Dynamite');
+        expect(result).toContain('BTS');
+    });
+
+    test('"status" alias also triggers now_playing', async () => {
+        mockExec.mockImplementation((command, callback) => {
+            if (command.includes('title'))  callback(null, 'Test Song\n', '');
+            else if (command.includes('artist')) callback(null, 'Test Artist\n', '');
+            else if (command.includes('album'))  callback(null, 'Test Album\n', '');
+            else if (command.includes('status')) callback(null, 'Paused\n', '');
+            else callback(null, '', '');
+        });
+
+        const result = await spotify.execute('status');
+        expect(result).toContain('Test Song');
+    });
+});
+
+// ── Volume tests ───────────────────────────────────────────────────────────
+
+describe('Spotify Plugin — volume', () => {
+    test('sets volume to valid level', async () => {
+        mockExec.mockImplementation((command, callback) => {
+            callback(null, '', '');
+        });
+
+        const result = await spotify.execute('volume 70');
+        expect(result).toContain('70%');
+    });
+
+    test('rejects invalid volume level > 100', async () => {
+        const result = await spotify.execute('volume 150');
+        expect(result).toContain('0-100');
+    });
+
+    test('rejects non-numeric volume', async () => {
+        const result = await spotify.execute('volume abc');
+        expect(result).toContain('0-100');
+    });
+});
+
+// ── Shuffle tests ──────────────────────────────────────────────────────────
+
+describe('Spotify Plugin — shuffle', () => {
+    test('enables shuffle with "shuffle on"', async () => {
+        mockExec.mockImplementation((command, callback) => {
+            callback(null, '', '');
+        });
+
+        const result = await spotify.execute('shuffle on');
+        expect(result).toContain('Shuffle');
+    });
+
+    test('disables shuffle with "shuffle off"', async () => {
+        mockExec.mockImplementation((command, callback) => {
+            callback(null, '', '');
+        });
+
+        const result = await spotify.execute('shuffle off');
+        expect(result).toContain('Shuffle');
+    });
+});
+
+// ── Search tests ───────────────────────────────────────────────────────────
+
+describe('Spotify Plugin — search', () => {
+    test('returns message with search query', async () => {
+        // xdg-open will fail in test env, but searchSpotify catches and returns URL
+        const result = await spotify.execute('search BTS Dynamite');
+        expect(result).toContain('BTS Dynamite');
+    });
+
+    test('empty search query returns error message', async () => {
+        const result = await spotify.execute('search ');
+        expect(result).toContain('กรุณาระบุ');
+    });
+});
+
+// ── Unknown command tests ──────────────────────────────────────────────────
+
+describe('Spotify Plugin — unknown command', () => {
+    test('returns helpful error for unknown target', async () => {
+        const result = await spotify.execute('dance');
+        expect(result).toContain('ไม่รู้จักคำสั่ง');
+    });
+
+    test('returns helpful error for empty target', async () => {
+        const result = await spotify.execute('');
+        expect(result).toContain('ไม่รู้จักคำสั่ง');
+    });
+});

package/tests/system_monitor.test.js

@@ -0,0 +1,37 @@
+/**
+ * Tests: system_monitor.js plugin
+ */
+
+const systemMonitor = require('../src/Plugins/system_monitor');
+const os = require('os');
+
+describe('System Monitor Plugin', () => {
+    test('has required plugin fields', () => {
+        expect(systemMonitor.name).toBe('system_monitor');
+        expect(typeof systemMonitor.description).toBe('string');
+        expect(typeof systemMonitor.execute).toBe('function');
+    });
+
+    test('returns stats for "stats" target', async () => {
+        const result = await systemMonitor.execute('stats');
+        expect(result).toContain('System Health Report');
+        expect(result).toContain('CPU Load');
+        expect(result).toContain('Memory');
+    });
+
+    test('returns cpu info for "cpu" target', async () => {
+        const result = await systemMonitor.execute('cpu');
+        expect(result).toContain('CPU Load');
+        expect(result).toContain('Cores');
+    });
+
+    test('returns memory info for "memory" target', async () => {
+        const result = await systemMonitor.execute('memory');
+        expect(result).toContain('Memory Status');
+    });
+
+    test('returns disk info for "disk" target', async () => {
+        const result = await systemMonitor.execute('disk');
+        expect(result).toContain('Disk Status');
+    });
+});

package/tests/workspace_manager.test.js

@@ -0,0 +1,41 @@
+/**
+ * Tests: workspace_manager.js
+ */
+
+const wsManager = require('../src/CLI/workspace_manager');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('Workspace Manager', () => {
+    let tempDir;
+
+    beforeEach(() => {
+        // Create a temp workspace directory
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-ws-test-'));
+    });
+
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    test('adds and lists workspaces', () => {
+        wsManager.addWorkspace('test-ws', tempDir, 'Be careful with files');
+        const list = wsManager.listWorkspaces();
+        expect(list['test-ws']).toBeDefined();
+        expect(list['test-ws'].path).toBe(path.resolve(tempDir));
+    });
+
+    test('detects workspace by path', () => {
+        wsManager.addWorkspace('test-ws', tempDir);
+        const ws = wsManager.getWorkspaceByPath(tempDir);
+        expect(ws.name).toBe('test-ws');
+    });
+
+    test('removes workspaces', () => {
+        wsManager.addWorkspace('test-ws', tempDir);
+        wsManager.removeWorkspace('test-ws');
+        const list = wsManager.listWorkspaces();
+        expect(list['test-ws']).toBeUndefined();
+    });
+});