@agentskillkit/agent-skills 1.0.1 → 3.2.2

package/tests/scripts/page-type-detector.test.js

@@ -0,0 +1,141 @@
+/**
+ * Page Type Detection Tests - Studio Design System
+ * =================================================
+ * Unit tests for detectPageType() function
+ */
+
+import { describe, test, expect } from 'vitest';
+import { detectPageType } from '../../.agent/skills/studio/scripts-js/utils/page-type-detector.js';
+
+describe('Page Type Detection', () => {
+    describe('detectPageType - keyword matching', () => {
+        test('detects Dashboard / Data View', () => {
+            expect(detectPageType('dashboard analytics')).toBe('Dashboard / Data View');
+            expect(detectPageType('admin panel')).toBe('Dashboard / Data View');
+            expect(detectPageType('metrics overview')).toBe('Dashboard / Data View');
+            expect(detectPageType('data visualization')).toBe('Dashboard / Data View');
+        });
+
+        test('detects Checkout / Payment', () => {
+            expect(detectPageType('checkout page')).toBe('Checkout / Payment');
+            expect(detectPageType('payment flow')).toBe('Checkout / Payment');
+            expect(detectPageType('shopping cart')).toBe('Checkout / Payment');
+            expect(detectPageType('order summary')).toBe('Checkout / Payment');
+        });
+
+        test('detects Settings / Profile', () => {
+            expect(detectPageType('settings page')).toBe('Settings / Profile');
+            expect(detectPageType('user profile')).toBe('Settings / Profile');
+            expect(detectPageType('account preferences')).toBe('Settings / Profile');
+            expect(detectPageType('config panel')).toBe('Settings / Profile');
+        });
+
+        test('detects Landing / Marketing', () => {
+            expect(detectPageType('landing page')).toBe('Landing / Marketing');
+            expect(detectPageType('marketing site')).toBe('Landing / Marketing');
+            expect(detectPageType('homepage hero')).toBe('Landing / Marketing');
+            expect(detectPageType('promo page')).toBe('Landing / Marketing');
+        });
+
+        test('detects Authentication', () => {
+            expect(detectPageType('login form')).toBe('Authentication');
+            expect(detectPageType('signup page')).toBe('Authentication');
+            expect(detectPageType('register account')).toBe('Authentication');
+            expect(detectPageType('password reset')).toBe('Authentication');
+        });
+
+        test('detects Pricing / Plans', () => {
+            expect(detectPageType('pricing table')).toBe('Pricing / Plans');
+            expect(detectPageType('subscription plans')).toBe('Pricing / Plans');
+            expect(detectPageType('pricing tiers')).toBe('Pricing / Plans');
+            expect(detectPageType('package options')).toBe('Pricing / Plans');
+        });
+
+        test('detects Blog / Article', () => {
+            expect(detectPageType('blog post')).toBe('Blog / Article');
+            expect(detectPageType('article page')).toBe('Blog / Article');
+            expect(detectPageType('news story')).toBe('Blog / Article');
+            expect(detectPageType('content page')).toBe('Blog / Article');
+        });
+
+        test('detects Product Detail', () => {
+            expect(detectPageType('product page')).toBe('Product Detail');
+            expect(detectPageType('item detail')).toBe('Product Detail');
+            expect(detectPageType('pdp layout')).toBe('Product Detail');
+            expect(detectPageType('shop product')).toBe('Product Detail');
+        });
+
+        test('detects Search Results', () => {
+            expect(detectPageType('search results')).toBe('Search Results');
+            expect(detectPageType('browse catalog')).toBe('Search Results');
+            expect(detectPageType('filter list')).toBe('Search Results');
+        });
+
+        test('detects Empty State', () => {
+            expect(detectPageType('404 page')).toBe('Empty State');
+            expect(detectPageType('empty state')).toBe('Empty State');
+            expect(detectPageType('error not found')).toBe('Empty State');
+            expect(detectPageType('zero results')).toBe('Empty State');
+        });
+    });
+
+    describe('detectPageType - case insensitive', () => {
+        test('handles uppercase input', () => {
+            expect(detectPageType('DASHBOARD')).toBe('Dashboard / Data View');
+            expect(detectPageType('CHECKOUT')).toBe('Checkout / Payment');
+        });
+
+        test('handles mixed case input', () => {
+            expect(detectPageType('Dashboard Analytics')).toBe('Dashboard / Data View');
+            expect(detectPageType('Checkout Page')).toBe('Checkout / Payment');
+        });
+    });
+
+    describe('detectPageType - fallback logic', () => {
+        test('uses style results fallback for dashboard', () => {
+            const styleResults = [
+                {
+                    'Style Category': 'Modern Dashboard',
+                    'Best For': 'Dashboard applications, data visualization'
+                }
+            ];
+            expect(detectPageType('unknown page', styleResults)).toBe('Dashboard / Data View');
+        });
+
+        test('uses style results fallback for landing', () => {
+            const styleResults = [
+                {
+                    'Style Category': 'Hero Design',
+                    'Best For': 'Landing pages, marketing sites'
+                }
+            ];
+            expect(detectPageType('unknown page', styleResults)).toBe('Landing / Marketing');
+        });
+
+        test('returns General for unknown context', () => {
+            expect(detectPageType('unknown random page')).toBe('General');
+        });
+
+        test('returns General when no style results', () => {
+            expect(detectPageType('unknown page', [])).toBe('General');
+        });
+
+        test('handles null/undefined context', () => {
+            expect(detectPageType(null)).toBe('General');
+            expect(detectPageType(undefined)).toBe('General');
+            expect(detectPageType('')).toBe('General');
+        });
+    });
+
+    describe('detectPageType - priority matching', () => {
+        test('matches first keyword when multiple patterns possible', () => {
+            // "dashboard" appears before "data" in patterns
+            expect(detectPageType('dashboard data analytics')).toBe('Dashboard / Data View');
+        });
+
+        test('handles partial keyword matches', () => {
+            expect(detectPageType('dashboards')).toBe('Dashboard / Data View'); // plural
+            expect(detectPageType('checkout-page')).toBe('Checkout / Payment'); // hyphenated
+        });
+    });
+});

package/tests/scripts/process-manager.test.js

@@ -0,0 +1,79 @@
+/**
+ * Unit Tests - Process Manager Utility
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { savePid, loadPid, deletePidFile, isRunning } from '../../../.agent/scripts-js/utils/process-manager.js';
+import { spawn } from 'child_process';
+import { join } from 'path';
+import { unlink } from 'fs/promises';
+
+const TEST_PID_FILE = join(process.cwd(), 'tests', 'scripts', '.tmp', 'test.pid');
+
+describe('Process Manager', () => {
+    afterEach(async () => {
+        try {
+            await unlink(TEST_PID_FILE);
+        } catch {
+            // File may not exist
+        }
+    });
+
+    it('should save PID to file', async () => {
+        await savePid(TEST_PID_FILE, 12345);
+
+        const loaded = await loadPid(TEST_PID_FILE);
+        expect(loaded).toBe(12345);
+    });
+
+    it('should load PID from file', async () => {
+        await savePid(TEST_PID_FILE, 99999);
+
+        const pid = await loadPid(TEST_PID_FILE);
+        expect(pid).toBe(99999);
+    });
+
+    it('should return null for missing PID file', async () => {
+        const pid = await loadPid(join(process.cwd(), 'nonexistent.pid'));
+        expect(pid).toBeNull();
+    });
+
+    it('should return null for invalid PID content', async () => {
+        const { writeFile } = await import('fs/promises');
+        await writeFile(TEST_PID_FILE, 'not-a-number', 'utf-8');
+
+        const pid = await loadPid(TEST_PID_FILE);
+        expect(pid).toBeNull();
+    });
+
+    it('should delete PID file', async () => {
+        await savePid(TEST_PID_FILE, 11111);
+        await deletePidFile(TEST_PID_FILE);
+
+        const pid = await loadPid(TEST_PID_FILE);
+        expect(pid).toBeNull();
+    });
+
+    it('should detect running process (current process)', () => {
+        const running = isRunning(process.pid);
+        expect(running).toBe(true);
+    });
+
+    it('should detect non-existent process', () => {
+        // PID 999999 should not exist
+        const running = isRunning(999999);
+        expect(running).toBe(false);
+    });
+
+    it('should detect spawned child process', () => {
+        const child = spawn('node', ['-e', 'setTimeout(() => {}, 5000)'], {
+            detached: true,
+            stdio: 'ignore'
+        });
+
+        const running = isRunning(child.pid);
+        expect(running).toBe(true);
+
+        // Clean up
+        child.kill('SIGTERM');
+    });
+});

package/tests/scripts/reporter.test.js

@@ -0,0 +1,96 @@
+/**
+ * Unit Tests - Reporter Utility
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { formatJsonOutput, printSummary, printFinalReport } from '../../../.agent/scripts-js/utils/reporter.js';
+
+describe('Reporter', () => {
+    const mockResults = [
+        { name: 'Test 1', passed: true, skipped: false, duration: 1.5 },
+        { name: 'Test 2', passed: false, skipped: false, duration: 2.0, error: 'Failed' },
+        { name: 'Test 3', passed: true, skipped: true }
+    ];
+
+    it('should format JSON output with correct structure', () => {
+        const startTime = new Date(Date.now() - 5000);
+        const json = formatJsonOutput(mockResults, '/project/path', 'http://localhost:3000', startTime);
+        const parsed = JSON.parse(json);
+
+        expect(parsed.version).toBe('3.2.0');
+        expect(parsed.project_path).toBe('/project/path');
+        expect(parsed.url).toBe('http://localhost:3000');
+        expect(parsed.summary.total).toBe(3);
+        expect(parsed.summary.passed).toBe(1);
+        expect(parsed.summary.failed).toBe(1);
+        expect(parsed.summary.skipped).toBe(1);
+        expect(parsed.results).toHaveLength(3);
+    });
+
+    it('should handle null URL in JSON output', () => {
+        const json = formatJsonOutput(mockResults, '/path', null, new Date());
+        const parsed = JSON.parse(json);
+
+        expect(parsed.url).toBeNull();
+    });
+
+    it('printSummary should return false when checks fail', () => {
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+
+        const result = printSummary(mockResults);
+
+        expect(result).toBe(false);
+        expect(consoleSpy).toHaveBeenCalledWith(
+            expect.stringContaining('❌ Failed: 1')
+        );
+
+        consoleSpy.mockRestore();
+    });
+
+    it('printSummary should return true when all checks pass', () => {
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+
+        const passingResults = [
+            { name: 'Test 1', passed: true, skipped: false },
+            { name: 'Test 2', passed: true, skipped: false }
+        ];
+
+        const result = printSummary(passingResults);
+
+        expect(result).toBe(true);
+        expect(consoleSpy).toHaveBeenCalledWith(
+            expect.stringContaining('All checks PASSED')
+        );
+
+        consoleSpy.mockRestore();
+    });
+
+    it('printFinalReport should include category breakdown', () => {
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+
+        const categorizedResults = [
+            { name: 'Security', passed: true, skipped: false, category: 'Security', duration: 1.0 },
+            { name: 'Lint', passed: true, skipped: false, category: 'Code Quality', duration: 0.5 }
+        ];
+
+        printFinalReport(categorizedResults, new Date(Date.now() - 3000));
+
+        expect(consoleSpy).toHaveBeenCalledWith(
+            expect.stringContaining('Security:')
+        );
+        expect(consoleSpy).toHaveBeenCalledWith(
+            expect.stringContaining('Code Quality:')
+        );
+
+        consoleSpy.mockRestore();
+    });
+
+    it('printFinalReport should return false on failures', () => {
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+
+        const result = printFinalReport(mockResults, new Date());
+
+        expect(result).toBe(false);
+
+        consoleSpy.mockRestore();
+    });
+});

package/tests/scripts/runner.test.js

@@ -0,0 +1,82 @@
+/**
+ * Unit Tests - Script Runner Utility
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { runScript, scriptExists } from '../../../.agent/scripts-js/utils/runner.js';
+import { writeFile, unlink, mkdir } from 'fs/promises';
+import { join } from 'path';
+
+const TEST_DIR = join(process.cwd(), 'tests', 'scripts', '.tmp');
+
+describe('Script Runner', () => {
+    beforeEach(async () => {
+        try {
+            await mkdir(TEST_DIR, { recursive: true });
+        } catch {
+            // Directory exists
+        }
+    });
+
+    it('should execute a simple script and capture output', async () => {
+        const testScript = join(TEST_DIR, 'test-echo.js');
+        await writeFile(testScript, `console.log('Hello World');`, 'utf-8');
+
+        const result = await runScript(testScript, []);
+
+        expect(result.code).toBe(0);
+        expect(result.passed).toBe(true);
+        expect(result.stdout).toContain('Hello World');
+
+        await unlink(testScript);
+    }, 10000);
+
+    it('should capture stderr on error', async () => {
+        const testScript = join(TEST_DIR, 'test-error.js');
+        await writeFile(testScript, `console.error('Error message'); process.exit(1);`, 'utf-8');
+
+        const result = await runScript(testScript, []);
+
+        expect(result.code).toBe(1);
+        expect(result.passed).toBe(false);
+        expect(result.stderr).toContain('Error message');
+
+        await unlink(testScript);
+    }, 10000);
+
+    it('should timeout long-running scripts', async () => {
+        const testScript = join(TEST_DIR, 'test-timeout.js');
+        await writeFile(testScript, `setTimeout(() => {}, 10000);`, 'utf-8');
+
+        await expect(
+            runScript(testScript, [], { timeout: 500 })
+        ).rejects.toThrow('Timeout');
+
+        await unlink(testScript);
+    }, 15000);
+
+    it('should pass arguments to script', async () => {
+        const testScript = join(TEST_DIR, 'test-args.js');
+        await writeFile(testScript, `console.log(process.argv.slice(2).join(' '));`, 'utf-8');
+
+        const result = await runScript(testScript, ['arg1', 'arg2']);
+
+        expect(result.stdout).toContain('arg1 arg2');
+
+        await unlink(testScript);
+    }, 10000);
+
+    it('scriptExists should detect existing files', async () => {
+        const testFile = join(TEST_DIR, 'exists.js');
+        await writeFile(testFile, '', 'utf-8');
+
+        const exists = await scriptExists(testFile);
+        expect(exists).toBe(true);
+
+        await unlink(testFile);
+    });
+
+    it('scriptExists should return false for missing files', async () => {
+        const exists = await scriptExists(join(TEST_DIR, 'nonexistent.js'));
+        expect(exists).toBe(false);
+    });
+});

package/tests/scripts/search-cache.test.js

@@ -0,0 +1,210 @@
+/**
+ * Search Cache Tests - Studio Design System
+ * ==========================================
+ * Unit tests for LRU cache and search caching
+ */
+
+import { describe, test, expect, beforeEach } from 'vitest';
+import {
+    LRUCache,
+    withCache,
+    clearSearchCache,
+    getCacheStats,
+    searchCache
+} from '../../.agent/skills/studio/scripts-js/utils/search-cache.js';
+
+describe('Search Cache', () => {
+    beforeEach(() => {
+        clearSearchCache();
+    });
+
+    describe('LRUCache', () => {
+        test('stores and retrieves values', () => {
+            const cache = new LRUCache(10);
+            
+            cache.set('key1', { data: 'value1' });
+            
+            expect(cache.get('key1')).toEqual({ data: 'value1' });
+        });
+
+        test('returns undefined for missing keys', () => {
+            const cache = new LRUCache(10);
+            
+            expect(cache.get('nonexistent')).toBeUndefined();
+        });
+
+        test('evicts oldest entry when at capacity', () => {
+            const cache = new LRUCache(3);
+            
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.set('key3', 'value3');
+            cache.set('key4', 'value4'); // Should evict key1
+            
+            expect(cache.get('key1')).toBeUndefined();
+            expect(cache.get('key2')).toBe('value2');
+            expect(cache.get('key4')).toBe('value4');
+        });
+
+        test('updates LRU order on get', () => {
+            const cache = new LRUCache(3);
+            
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.set('key3', 'value3');
+            
+            // Access key1, making it most recently used
+            cache.get('key1');
+            
+            // Add key4, should evict key2 (oldest unused)
+            cache.set('key4', 'value4');
+            
+            expect(cache.get('key1')).toBe('value1');
+            expect(cache.get('key2')).toBeUndefined();
+        });
+
+        test('expires entries after TTL', async () => {
+            const cache = new LRUCache(10, 50); // 50ms TTL
+            
+            cache.set('key1', 'value1');
+            expect(cache.get('key1')).toBe('value1');
+            
+            // Wait for expiration
+            await new Promise(resolve => setTimeout(resolve, 60));
+            
+            expect(cache.get('key1')).toBeUndefined();
+        });
+
+        test('has() returns correct boolean', () => {
+            const cache = new LRUCache(10);
+            
+            cache.set('key1', 'value1');
+            
+            expect(cache.has('key1')).toBe(true);
+            expect(cache.has('key2')).toBe(false);
+        });
+
+        test('clear() removes all entries', () => {
+            const cache = new LRUCache(10);
+            
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.clear();
+            
+            expect(cache.size).toBe(0);
+            expect(cache.get('key1')).toBeUndefined();
+        });
+
+        test('getStats() returns cache statistics', () => {
+            const cache = new LRUCache(50, 300000);
+            
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            
+            const stats = cache.getStats();
+            
+            expect(stats.size).toBe(2);
+            expect(stats.maxSize).toBe(50);
+            expect(stats.ttlMs).toBe(300000);
+        });
+    });
+
+    describe('LRUCache.generateKey', () => {
+        test('generates consistent keys', () => {
+            const key1 = LRUCache.generateKey('dashboard', 'style', 5);
+            const key2 = LRUCache.generateKey('dashboard', 'style', 5);
+            
+            expect(key1).toBe(key2);
+        });
+
+        test('normalizes query to lowercase', () => {
+            const key1 = LRUCache.generateKey('DASHBOARD', 'style', 5);
+            const key2 = LRUCache.generateKey('dashboard', 'style', 5);
+            
+            expect(key1).toBe(key2);
+        });
+
+        test('creates different keys for different domains', () => {
+            const key1 = LRUCache.generateKey('test', 'style', 5);
+            const key2 = LRUCache.generateKey('test', 'ux', 5);
+            
+            expect(key1).not.toBe(key2);
+        });
+
+        test('creates different keys for different maxResults', () => {
+            const key1 = LRUCache.generateKey('test', 'style', 5);
+            const key2 = LRUCache.generateKey('test', 'style', 10);
+            
+            expect(key1).not.toBe(key2);
+        });
+
+        test('handles null/undefined query', () => {
+            const key1 = LRUCache.generateKey(null, 'style', 5);
+            const key2 = LRUCache.generateKey(undefined, 'style', 5);
+            
+            expect(key1).toBe(key2);
+            expect(key1).toBe(':style:5');
+        });
+    });
+
+    describe('withCache wrapper', () => {
+        test('caches search results', async () => {
+            let callCount = 0;
+            const mockSearch = async (query, domain, maxResults) => {
+                callCount++;
+                return { results: [`result for ${query}`] };
+            };
+            
+            const cachedSearch = withCache(mockSearch, 'style');
+            
+            // First call - cache miss
+            await cachedSearch('test query', 5);
+            expect(callCount).toBe(1);
+            
+            // Second call - cache hit
+            await cachedSearch('test query', 5);
+            expect(callCount).toBe(1); // Still 1, used cache
+        });
+
+        test('tracks hit/miss statistics', async () => {
+            clearSearchCache();
+            
+            const mockSearch = async () => ({ results: [] });
+            const cachedSearch = withCache(mockSearch, 'style');
+            
+            await cachedSearch('query1', 5); // miss
+            await cachedSearch('query1', 5); // hit
+            await cachedSearch('query2', 5); // miss
+            
+            const stats = getCacheStats();
+            expect(stats.hits).toBe(1);
+            expect(stats.misses).toBe(2);
+        });
+    });
+
+    describe('getCacheStats', () => {
+        test('returns cache statistics with hit rate', async () => {
+            clearSearchCache();
+            
+            const mockSearch = async () => ({ results: [] });
+            const cachedSearch = withCache(mockSearch, 'style');
+            
+            await cachedSearch('q1', 5); // miss
+            await cachedSearch('q1', 5); // hit
+            await cachedSearch('q1', 5); // hit
+            await cachedSearch('q1', 5); // hit
+            
+            const stats = getCacheStats();
+            expect(stats.hits).toBe(3);
+            expect(stats.misses).toBe(1);
+            expect(stats.hitRate).toBe('75.0%');
+        });
+
+        test('returns 0% hit rate when no requests', () => {
+            clearSearchCache();
+            
+            const stats = getCacheStats();
+            expect(stats.hitRate).toBe('0%');
+        });
+    });
+});

package/tests/scripts/text-utils.test.js

@@ -0,0 +1,63 @@
+/**
+ * Unit Tests - CSV Loader Utility
+ */
+import { describe, it, expect } from 'vitest';
+import { tokenize, buildDocument, extractColumns } from '../../.agent/skills/studio/scripts-js/utils/text-utils.js';
+
+describe('Text Utils - Tokenization', () => {
+    describe('tokenize()', () => {
+        it('should lowercase and split text', () => {
+            const result = tokenize('Hello World');
+            expect(result).toEqual(['hello', 'world']);
+        });
+
+        it('should remove punctuation', () => {
+            const result = tokenize('Hello, World! How are you?');
+            expect(result).toEqual(['hello', 'world', 'how', 'are', 'you']);
+        });
+
+        it('should filter words <= 2 characters', () => {
+            const result = tokenize('I am ok to go');
+            expect(result).toEqual([]); // 'I', 'am', 'ok', 'to', 'go' all <=2 chars
+        });
+
+        it('should handle empty/null input', () => {
+            expect(tokenize('')).toEqual([]);
+            expect(tokenize(null)).toEqual([]);
+            expect(tokenize(undefined)).toEqual([]);
+        });
+
+        it('should convert numbers to string', () => {
+            const result = tokenize(12345);
+            expect(result).toEqual(['12345']);
+        });
+    });
+
+    describe('buildDocument()', () => {
+        it('should join column values with space', () => {
+            const row = { name: 'Alice', city: 'NYC', age: '30' };
+            const result = buildDocument(row, ['name', 'city']);
+            expect(result).toBe('Alice NYC');
+        });
+
+        it('should handle missing columns', () => {
+            const row = { name: 'Bob' };
+            const result = buildDocument(row, ['name', 'city', 'country']);
+            expect(result).toBe('Bob  ');
+        });
+    });
+
+    describe('extractColumns()', () => {
+        it('should extract only specified columns', () => {
+            const row = { a: '1', b: '2', c: '3' };
+            const result = extractColumns(row, ['a', 'c']);
+            expect(result).toEqual({ a: '1', c: '3' });
+        });
+
+        it('should skip non-existent columns', () => {
+            const row = { a: '1' };
+            const result = extractColumns(row, ['a', 'b', 'c']);
+            expect(result).toEqual({ a: '1' });
+        });
+    });
+});