@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/utils/UnifiedCacheManager.additional.test.js

@@ -0,0 +1,262 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { UnifiedCacheManager } from '../../src/utils/UnifiedCacheManager.js';
+function mb(value) {
+    return value * 1024 * 1024;
+}
+describe('UnifiedCacheManager – additional coverage', () => {
+    afterEach(() => {
+        UnifiedCacheManager.instance = undefined;
+        vi.restoreAllMocks();
+    });
+    describe('preheat (lines 258-262)', () => {
+        it('completes without error for a list of URLs', async () => {
+            const manager = new UnifiedCacheManager();
+            await expect(manager.preheat(['https://a.com', 'https://b.com'])).resolves.toBeUndefined();
+        });
+        it('completes for an empty URL list', async () => {
+            const manager = new UnifiedCacheManager();
+            await expect(manager.preheat([])).resolves.toBeUndefined();
+        });
+    });
+    describe('generateRecommendations – 50% size threshold (line 277)', () => {
+        it('generates INFO recommendation when cache is at 50% size', async () => {
+            const manager = new UnifiedCacheManager();
+            manager.registerCache({
+                name: 'half-cache',
+                getStats: vi.fn(async () => ({
+                    entries: 10,
+                    size: mb(260),
+                    hits: 50,
+                    misses: 50,
+                    hitRate: 0.5,
+                })),
+            });
+            const stats = await manager.getGlobalStats();
+            expect(stats.recommendations.some((r) => r.includes('INFO'))).toBe(true);
+        });
+    });
+    describe('generateRecommendations – no issues (line 302)', () => {
+        it('returns "Cache health is good" recommendation when no issues are detected', async () => {
+            const manager = new UnifiedCacheManager();
+            manager.registerCache({
+                name: 'cache-a',
+                getStats: vi.fn(async () => ({
+                    entries: 5,
+                    size: mb(10),
+                    hits: 50,
+                    misses: 50,
+                    hitRate: 0.5,
+                })),
+            });
+            manager.registerCache({
+                name: 'cache-b',
+                getStats: vi.fn(async () => ({
+                    entries: 5,
+                    size: mb(10),
+                    hits: 50,
+                    misses: 50,
+                    hitRate: 0.5,
+                })),
+            });
+            const stats = await manager.getGlobalStats();
+            expect(stats.recommendations.some((r) => r.includes('Cache health is good'))).toBe(true);
+        });
+        it('returns "Good cache hit rate" recommendation when hitRate > 0.7', async () => {
+            const manager = new UnifiedCacheManager();
+            manager.registerCache({
+                name: 'healthy-cache',
+                getStats: vi.fn(async () => ({
+                    entries: 5,
+                    size: mb(10),
+                    hits: 80,
+                    misses: 20,
+                    hitRate: 0.8,
+                })),
+            });
+            const stats = await manager.getGlobalStats();
+            expect(stats.recommendations.some((r) => r.includes('Good cache hit rate'))).toBe(true);
+        });
+    });
+    describe('generateRecommendations – per-cache size dominance', () => {
+        it('warns when a single cache uses >50% of total size', async () => {
+            const manager = new UnifiedCacheManager();
+            manager.registerCache({
+                name: 'dominant-cache',
+                getStats: vi.fn(async () => ({
+                    entries: 100,
+                    size: mb(300),
+                    hits: 80,
+                    misses: 20,
+                    hitRate: 0.8,
+                })),
+            });
+            manager.registerCache({
+                name: 'small-cache',
+                getStats: vi.fn(async () => ({
+                    entries: 5,
+                    size: mb(10),
+                    hits: 80,
+                    misses: 20,
+                    hitRate: 0.8,
+                })),
+            });
+            const stats = await manager.getGlobalStats();
+            expect(stats.recommendations.some((r) => r.includes('dominant-cache') && r.includes('%'))).toBe(true);
+        });
+        it('warns about low per-cache hit rate (<20%)', async () => {
+            const manager = new UnifiedCacheManager();
+            manager.registerCache({
+                name: 'low-rate-cache',
+                getStats: vi.fn(async () => ({
+                    entries: 50,
+                    size: mb(50),
+                    hits: 2,
+                    misses: 98,
+                    hitRate: 0.02,
+                })),
+            });
+            const stats = await manager.getGlobalStats();
+            expect(stats.recommendations.some((r) => r.includes('low-rate-cache') && r.includes('low hit rate'))).toBe(true);
+        });
+    });
+    describe('smartCleanup – cleanupExpired path', () => {
+        it('calls cleanup on caches with cleanup method', async () => {
+            const manager = new UnifiedCacheManager();
+            const cacheState = { size: mb(400), entries: 100 };
+            const cleanupFn = vi.fn(async () => {
+                cacheState.size = mb(100);
+                cacheState.entries = 10;
+            });
+            manager.registerCache({
+                name: 'expirable-cache',
+                getStats: vi.fn(async () => ({
+                    entries: cacheState.entries,
+                    size: cacheState.size,
+                    hits: 50,
+                    misses: 50,
+                    hitRate: 0.5,
+                })),
+                cleanup: cleanupFn,
+            });
+            const result = await manager.smartCleanup(mb(200));
+            expect(cleanupFn).toHaveBeenCalled();
+            expect(result.after).toBeLessThanOrEqual(mb(200));
+        });
+        it('tolerates cleanup errors gracefully', async () => {
+            const manager = new UnifiedCacheManager();
+            manager.registerCache({
+                name: 'err-cleanup-cache',
+                getStats: vi.fn(async () => ({
+                    entries: 100,
+                    size: mb(400),
+                    hits: 50,
+                    misses: 50,
+                    hitRate: 0.5,
+                })),
+                cleanup: vi.fn(async () => {
+                    throw new Error('cleanup boom');
+                }),
+                clear: vi.fn(async () => undefined),
+            });
+            await expect(manager.smartCleanup(mb(200))).resolves.toBeDefined();
+        });
+    });
+    describe('smartCleanup – cleanupLargeItems path', () => {
+        it('clears the largest caches when other strategies are insufficient', async () => {
+            const manager = new UnifiedCacheManager();
+            const largeCacheState = { size: mb(300), entries: 50 };
+            const smallCacheState = { size: mb(200), entries: 20 };
+            const largeClear = vi.fn(async () => {
+                largeCacheState.size = 0;
+                largeCacheState.entries = 0;
+            });
+            manager.registerCache({
+                name: 'large-cache',
+                getStats: vi.fn(async () => ({
+                    ...largeCacheState,
+                    hits: 70,
+                    misses: 30,
+                    hitRate: 0.7,
+                })),
+                clear: largeClear,
+                cleanup: vi.fn(async () => undefined),
+            });
+            manager.registerCache({
+                name: 'small-cache',
+                getStats: vi.fn(async () => ({
+                    ...smallCacheState,
+                    hits: 70,
+                    misses: 30,
+                    hitRate: 0.7,
+                })),
+                cleanup: vi.fn(async () => undefined),
+                clear: vi.fn(async () => undefined),
+            });
+            await manager.smartCleanup(mb(100));
+            expect(largeClear).toHaveBeenCalled();
+        });
+        it('tolerates clear errors in large cache cleanup', async () => {
+            const manager = new UnifiedCacheManager();
+            manager.registerCache({
+                name: 'fail-clear-cache',
+                getStats: vi.fn(async () => ({
+                    entries: 50,
+                    size: mb(400),
+                    hits: 70,
+                    misses: 30,
+                    hitRate: 0.7,
+                })),
+                cleanup: vi.fn(async () => undefined),
+                clear: vi.fn(async () => {
+                    throw new Error('clear failed');
+                }),
+            });
+            await expect(manager.smartCleanup(mb(100))).resolves.toBeDefined();
+        });
+    });
+    describe('cleanupLowHitRate – clear error tolerance', () => {
+        it('tolerates errors when clearing low hit rate caches', async () => {
+            const manager = new UnifiedCacheManager();
+            const highState = { size: mb(200), entries: 10, hits: 90, misses: 10, hitRate: 0.9 };
+            const lowState = { size: mb(200), entries: 10, hits: 1, misses: 99, hitRate: 0.01 };
+            manager.registerCache({
+                name: 'high-rate',
+                getStats: vi.fn(async () => ({ ...highState })),
+            });
+            manager.registerCache({
+                name: 'low-rate',
+                getStats: vi.fn(async () => ({ ...lowState })),
+                clear: vi.fn(async () => {
+                    throw new Error('nope');
+                }),
+            });
+            await expect(manager.smartCleanup(mb(100))).resolves.toBeDefined();
+        });
+    });
+    describe('unregisterCache', () => {
+        it('removes a registered cache', async () => {
+            const manager = new UnifiedCacheManager();
+            const cache = {
+                name: 'removable',
+                getStats: vi.fn(async () => ({ entries: 5, size: 500 })),
+            };
+            manager.registerCache(cache);
+            let stats = await manager.getGlobalStats();
+            expect(stats.caches).toHaveLength(1);
+            manager.unregisterCache('removable');
+            stats = await manager.getGlobalStats();
+            expect(stats.caches).toHaveLength(0);
+        });
+    });
+    describe('getGlobalStats with zero total', () => {
+        it('returns 0 hitRate when no hits or misses', async () => {
+            const manager = new UnifiedCacheManager();
+            manager.registerCache({
+                name: 'empty-cache',
+                getStats: vi.fn(async () => ({ entries: 0, size: 0, hits: 0, misses: 0 })),
+            });
+            const stats = await manager.getGlobalStats();
+            expect(stats.hitRate).toBe(0);
+        });
+    });
+});

package/dist/tests/utils/WorkerPool.additional.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/utils/WorkerPool.additional.test.js

@@ -0,0 +1,361 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+const workerState = vi.hoisted(() => {
+    class WorkerMock {
+        script;
+        options;
+        listeners = new Map();
+        postMessage = vi.fn();
+        terminate = vi.fn(async () => 0);
+        removeAllListeners = vi.fn((event) => {
+            if (event) {
+                this.listeners.delete(event);
+            }
+            else {
+                this.listeners.clear();
+            }
+            return this;
+        });
+        constructor(script, options) {
+            this.script = script;
+            this.options = options;
+        }
+        on(event, callback) {
+            const callbacks = this.listeners.get(event) ?? [];
+            callbacks.push(callback);
+            this.listeners.set(event, callbacks);
+            return this;
+        }
+        emit(event, payload) {
+            const callbacks = this.listeners.get(event) ?? [];
+            callbacks.forEach((callback) => callback(payload));
+        }
+    }
+    return {
+        instances: [],
+        WorkerMock,
+    };
+});
+vi.mock('node:worker_threads', () => {
+    class WorkerCtor {
+        inner;
+        postMessage;
+        terminate;
+        removeAllListeners;
+        constructor(script, options) {
+            this.inner = new workerState.WorkerMock(script, options);
+            workerState.instances.push(this.inner);
+            this.postMessage = this.inner.postMessage;
+            this.terminate = this.inner.terminate;
+            this.removeAllListeners = this.inner.removeAllListeners;
+        }
+        on(event, callback) {
+            this.inner.on(event, callback);
+            return this;
+        }
+    }
+    return {
+        Worker: WorkerCtor,
+    };
+});
+import { WorkerPool } from '../../src/utils/WorkerPool.js';
+describe('WorkerPool – additional coverage', () => {
+    beforeEach(() => {
+        workerState.instances.length = 0;
+        vi.useFakeTimers();
+    });
+    afterEach(async () => {
+        vi.useRealTimers();
+        vi.restoreAllMocks();
+    });
+    describe('handleWorkerFailure (lines 258-274)', () => {
+        it('rejects active job and respawns worker on worker error event', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 1,
+                maxWorkers: 2,
+            });
+            const worker = workerState.instances[0];
+            const task = pool.submit({ v: 1 });
+            expect(worker.postMessage).toHaveBeenCalledWith({ jobId: 1, payload: { v: 1 } });
+            worker.emit('error', new Error('segfault'));
+            await expect(task).rejects.toThrow('segfault');
+            expect(worker.terminate).toHaveBeenCalled();
+            await pool.close();
+        });
+        it('ignores error for unknown worker id', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 1,
+                maxWorkers: 1,
+            });
+            const worker = workerState.instances[0];
+            await pool.close();
+            expect(() => worker.emit('error', new Error('late error'))).not.toThrow();
+        });
+        it('handles worker failure with no active job', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 2,
+                maxWorkers: 4,
+            });
+            expect(workerState.instances).toHaveLength(2);
+            const worker = workerState.instances[0];
+            worker.emit('error', new Error('random crash'));
+            expect(worker.terminate).toHaveBeenCalled();
+            await vi.advanceTimersByTimeAsync(0);
+            expect(workerState.instances.length).toBeGreaterThanOrEqual(3);
+            await pool.close();
+        });
+    });
+    describe('handleWorkerExit (lines 277-296)', () => {
+        it('rejects active job when worker exits unexpectedly with non-zero code', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 1,
+                maxWorkers: 2,
+            });
+            const worker = workerState.instances[0];
+            const task = pool.submit({ v: 42 });
+            worker.emit('exit', 1);
+            await expect(task).rejects.toThrow('worker exited unexpectedly with code 1');
+            await pool.close();
+        });
+        it('cleans up idle timer on worker exit', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 0,
+                maxWorkers: 2,
+                idleTimeoutMs: 5000,
+            });
+            const task = pool.submit({ v: 1 });
+            const worker = workerState.instances[0];
+            worker.emit('message', { jobId: 1, ok: true, result: 10 });
+            await expect(task).resolves.toBe(10);
+            worker.emit('exit', 0);
+            await pool.close();
+        });
+        it('ignores exit for unknown worker id', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 1,
+                maxWorkers: 1,
+            });
+            await pool.close();
+            const worker = workerState.instances[0];
+            expect(() => worker.emit('exit', 0)).not.toThrow();
+        });
+        it('re-ensures min workers after unexpected exit', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 2,
+                maxWorkers: 4,
+            });
+            expect(workerState.instances).toHaveLength(2);
+            const firstWorker = workerState.instances[0];
+            firstWorker.emit('exit', 1);
+            expect(workerState.instances.length).toBeGreaterThanOrEqual(3);
+            await pool.close();
+        });
+        it('pumps queued jobs after worker exit spawns replacement', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 0,
+                maxWorkers: 1,
+            });
+            const task1 = pool.submit({ v: 1 });
+            const task2 = pool.submit({ v: 2 });
+            const worker1 = workerState.instances[0];
+            worker1.emit('exit', 1);
+            await expect(task1).rejects.toThrow('worker exited unexpectedly');
+            const worker2 = workerState.instances[1];
+            expect(worker2).toBeDefined();
+            worker2.emit('message', { jobId: 2, ok: true, result: 200 });
+            await expect(task2).resolves.toBe(200);
+            await pool.close();
+        });
+    });
+    describe('armIdleTimer (lines 309-317)', () => {
+        it('terminates idle worker after timeout when above minWorkers', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 0,
+                maxWorkers: 2,
+                idleTimeoutMs: 1000,
+            });
+            const task = pool.submit({ v: 1 });
+            const worker = workerState.instances[0];
+            worker.emit('message', { jobId: 1, ok: true, result: 42 });
+            await expect(task).resolves.toBe(42);
+            vi.advanceTimersByTime(1001);
+            expect(worker.terminate).toHaveBeenCalled();
+            await pool.close();
+        });
+        it('does not terminate idle worker when at minWorkers', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 1,
+                maxWorkers: 2,
+                idleTimeoutMs: 1000,
+            });
+            const worker = workerState.instances[0];
+            const task = pool.submit({ v: 1 });
+            worker.emit('message', { jobId: 1, ok: true, result: 42 });
+            await expect(task).resolves.toBe(42);
+            vi.advanceTimersByTime(1001);
+            expect(worker.terminate).not.toHaveBeenCalled();
+            await pool.close();
+        });
+        it('clears previous idle timer when re-arming', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 0,
+                maxWorkers: 2,
+                idleTimeoutMs: 2000,
+            });
+            const task1 = pool.submit({ v: 1 });
+            const worker = workerState.instances[0];
+            worker.emit('message', { jobId: 1, ok: true, result: 10 });
+            await expect(task1).resolves.toBe(10);
+            vi.advanceTimersByTime(1500);
+            const task2 = pool.submit({ v: 2 });
+            worker.emit('message', { jobId: 2, ok: true, result: 20 });
+            await expect(task2).resolves.toBe(20);
+            vi.advanceTimersByTime(1000);
+            expect(worker.terminate).not.toHaveBeenCalled();
+            vi.advanceTimersByTime(1001);
+            expect(worker.terminate).toHaveBeenCalled();
+            await pool.close();
+        });
+        it('does not arm idle timer when idleTimeoutMs is 0', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 0,
+                maxWorkers: 2,
+                idleTimeoutMs: 0,
+            });
+            const task = pool.submit({ v: 1 });
+            const worker = workerState.instances[0];
+            worker.emit('message', { jobId: 1, ok: true, result: 99 });
+            await expect(task).resolves.toBe(99);
+            vi.advanceTimersByTime(60000);
+            expect(worker.terminate).not.toHaveBeenCalled();
+            await pool.close();
+        });
+    });
+    describe('handleWorkerMessage edge cases', () => {
+        it('rejects when worker returns ok:false', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 1,
+                maxWorkers: 1,
+            });
+            const worker = workerState.instances[0];
+            const task = pool.submit({ v: 1 });
+            worker.emit('message', { jobId: 1, ok: false, error: 'computation failed' });
+            await expect(task).rejects.toThrow('computation failed');
+            await pool.close();
+        });
+        it('rejects when worker returns ok:true but no result', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 1,
+                maxWorkers: 1,
+            });
+            const worker = workerState.instances[0];
+            const task = pool.submit({ v: 1 });
+            worker.emit('message', { jobId: 1, ok: true });
+            await expect(task).rejects.toThrow('worker returned empty result');
+            await pool.close();
+        });
+        it('ignores messages with no jobId', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 1,
+                maxWorkers: 1,
+            });
+            const worker = workerState.instances[0];
+            const task = pool.submit({ v: 1 });
+            worker.emit('message', { something: 'random' });
+            worker.emit('message', null);
+            worker.emit('message', 42);
+            worker.emit('message', { jobId: 1, ok: true, result: 7 });
+            await expect(task).resolves.toBe(7);
+            await pool.close();
+        });
+        it('ignores messages for unknown jobId', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 1,
+                maxWorkers: 1,
+            });
+            const worker = workerState.instances[0];
+            const task = pool.submit({ v: 1 });
+            worker.emit('message', { jobId: 999, ok: true, result: 0 });
+            worker.emit('message', { jobId: 1, ok: true, result: 5 });
+            await expect(task).resolves.toBe(5);
+            await pool.close();
+        });
+    });
+    describe('dispatchJob postMessage failure', () => {
+        it('rejects job and terminates worker when postMessage throws', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 1,
+                maxWorkers: 2,
+            });
+            const worker = workerState.instances[0];
+            worker.postMessage.mockImplementation(() => {
+                throw new Error('serialization failed');
+            });
+            const task = pool.submit({ v: 1 });
+            await expect(task).rejects.toThrow('serialization failed');
+            expect(worker.terminate).toHaveBeenCalled();
+            await pool.close();
+        });
+    });
+    describe('submit after close', () => {
+        it('rejects submissions after pool is closed', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 1,
+                maxWorkers: 1,
+            });
+            await pool.close();
+            await expect(pool.submit({ v: 1 })).rejects.toThrow('pool is closed');
+        });
+        it('close is idempotent', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 1,
+                maxWorkers: 1,
+            });
+            await pool.close();
+            await expect(pool.close()).resolves.toBeUndefined();
+        });
+    });
+    describe('pool exhaustion', () => {
+        it('queues jobs beyond maxWorkers and processes them as workers free up', async () => {
+            const pool = new WorkerPool({
+                workerScript: 'mock-script',
+                minWorkers: 0,
+                maxWorkers: 2,
+            });
+            const tasks = [
+                pool.submit({ v: 1 }),
+                pool.submit({ v: 2 }),
+                pool.submit({ v: 3 }),
+                pool.submit({ v: 4 }),
+            ];
+            expect(workerState.instances).toHaveLength(2);
+            workerState.instances[0].emit('message', { jobId: 1, ok: true, result: 10 });
+            workerState.instances[1].emit('message', { jobId: 2, ok: true, result: 20 });
+            await expect(tasks[0]).resolves.toBe(10);
+            await expect(tasks[1]).resolves.toBe(20);
+            workerState.instances[0].emit('message', { jobId: 3, ok: true, result: 30 });
+            workerState.instances[1].emit('message', { jobId: 4, ok: true, result: 40 });
+            await expect(tasks[2]).resolves.toBe(30);
+            await expect(tasks[3]).resolves.toBe(40);
+            await pool.close();
+        });
+    });
+});

package/dist/tests/utils/cache.additional.test.d.ts

@@ -0,0 +1 @@
+export {};