@jshookmcp/jshook 0.1.8 → 0.2.0

package/dist/tests/services/prompts.test.js

@@ -0,0 +1,408 @@
+import { describe, it, expect } from 'vitest';
+import { generateCryptoDetectionPrompt } from '../../src/services/prompts/crypto.js';
+import { generateCodeAnalysisPrompt, generateProjectSummaryMessages, generateFileSummaryMessages, } from '../../src/services/prompts/analysis.js';
+import { generateCodeCleanupMessages, generateVMAnalysisMessages, generateDeobfuscationPrompt, generateVMDeobfuscationMessages, generateControlFlowUnflatteningMessages, } from '../../src/services/prompts/deobfuscation.js';
+import { generateBrowserEnvAnalysisMessages, generateAntiCrawlAnalysisMessages, generateAPIImplementationMessages, generateEnvironmentSuggestionsMessages, generateMissingAPIImplementationsMessages, generateMissingVariablesMessages, } from '../../src/services/prompts/environment.js';
+import { generateRequestAnalysisMessages, generateLogAnalysisMessages, generateKeywordExpansionMessages, } from '../../src/services/prompts/intelligence.js';
+import { generateTaintAnalysisPrompt } from '../../src/services/prompts/taint.js';
+function assertValidMessages(msgs) {
+    expect(Array.isArray(msgs)).toBe(true);
+    expect(msgs.length).toBeGreaterThan(0);
+    for (const msg of msgs) {
+        expect(msg).toHaveProperty('role');
+        expect(msg).toHaveProperty('content');
+        expect(['system', 'user', 'assistant']).toContain(msg.role);
+        expect(typeof msg.content).toBe('string');
+        expect(msg.content.length).toBeGreaterThan(0);
+    }
+}
+const SHORT_CODE = 'const x = 1;';
+const LONG_CODE = 'a'.repeat(10_000);
+const SPECIAL_CHARS_CODE = 'const s = "hello\\nworld"; // <script>alert(1)</script> `${x}` $&';
+describe('generateCryptoDetectionPrompt', () => {
+    it('returns system + user messages with correct roles', () => {
+        const msgs = generateCryptoDetectionPrompt(SHORT_CODE);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[0].role).toBe('system');
+        expect(msgs[1].role).toBe('user');
+    });
+    it('embeds the code in the user message', () => {
+        const msgs = generateCryptoDetectionPrompt(SHORT_CODE);
+        expect(msgs[1].content).toContain(SHORT_CODE);
+    });
+    it('truncates code longer than 4000 chars', () => {
+        const msgs = generateCryptoDetectionPrompt(LONG_CODE);
+        expect(msgs[1].content).toContain('// ... (code truncated)');
+        expect(msgs[1].content).not.toContain('a'.repeat(5000));
+    });
+    it('does not truncate code at exactly 4000 chars', () => {
+        const exact = 'b'.repeat(4000);
+        const msgs = generateCryptoDetectionPrompt(exact);
+        expect(msgs[1].content).not.toContain('truncated');
+        expect(msgs[1].content).toContain(exact);
+    });
+    it('handles special characters in code', () => {
+        const msgs = generateCryptoDetectionPrompt(SPECIAL_CHARS_CODE);
+        expect(msgs[1].content).toContain(SPECIAL_CHARS_CODE);
+    });
+});
+describe('generateCodeAnalysisPrompt', () => {
+    it('returns system + user messages and embeds focus', () => {
+        const msgs = generateCodeAnalysisPrompt(SHORT_CODE, 'security');
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[0].role).toBe('system');
+        expect(msgs[1].role).toBe('user');
+        expect(msgs[1].content).toContain('security');
+    });
+    it('embeds the code in the user message', () => {
+        const msgs = generateCodeAnalysisPrompt('const y = 2;', 'performance');
+        expect(msgs[1].content).toContain('const y = 2;');
+    });
+    it('truncates code longer than 5000 chars', () => {
+        const msgs = generateCodeAnalysisPrompt(LONG_CODE, 'general');
+        expect(msgs[1].content).toContain('// ... (code truncated for analysis)');
+    });
+    it('preserves code at exactly 5000 chars without truncation', () => {
+        const exact = 'c'.repeat(5000);
+        const msgs = generateCodeAnalysisPrompt(exact, 'general');
+        expect(msgs[1].content).not.toContain('truncated');
+        expect(msgs[1].content).toContain(exact);
+    });
+});
+describe('generateProjectSummaryMessages', () => {
+    const files = [
+        { url: 'https://example.com/app.js', size: 1234, type: 'script', content: 'console.log("hi")' },
+        { url: 'https://example.com/util.js', size: 500, type: 'script', content: 'export function util(){}' },
+    ];
+    it('returns system + user messages', () => {
+        const msgs = generateProjectSummaryMessages(files);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[0].role).toBe('system');
+        expect(msgs[1].role).toBe('user');
+    });
+    it('includes file URLs in the user message', () => {
+        const msgs = generateProjectSummaryMessages(files);
+        expect(msgs[1].content).toContain('app.js');
+        expect(msgs[1].content).toContain('util.js');
+    });
+    it('truncates file content previews to 200 chars', () => {
+        const longContent = 'x'.repeat(500);
+        const msgs = generateProjectSummaryMessages([
+            { url: 'https://example.com/big.js', size: 9999, type: 'script', content: longContent },
+        ]);
+        expect(msgs[1].content).not.toContain(longContent);
+        expect(msgs[1].content).toContain('x'.repeat(200));
+    });
+    it('handles empty files array', () => {
+        const msgs = generateProjectSummaryMessages([]);
+        assertValidMessages(msgs);
+    });
+});
+describe('generateFileSummaryMessages', () => {
+    it('returns system + user messages with url and code embedded', () => {
+        const msgs = generateFileSummaryMessages('https://example.com/main.js', SHORT_CODE);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[1].content).toContain('https://example.com/main.js');
+        expect(msgs[1].content).toContain(SHORT_CODE);
+    });
+    it('handles empty code', () => {
+        const msgs = generateFileSummaryMessages('test.js', '');
+        assertValidMessages(msgs);
+        expect(msgs[1].content).toContain('test.js');
+    });
+});
+describe('generateCodeCleanupMessages', () => {
+    it('returns system + user with techniques listed', () => {
+        const msgs = generateCodeCleanupMessages(SHORT_CODE, ['string-array', 'dead-code']);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[0].role).toBe('system');
+        expect(msgs[1].role).toBe('user');
+        expect(msgs[1].content).toContain('- string-array');
+        expect(msgs[1].content).toContain('- dead-code');
+    });
+    it('truncates code longer than 2000 chars', () => {
+        const msgs = generateCodeCleanupMessages('z'.repeat(3000), ['minify']);
+        expect(msgs[1].content).toContain('...(truncated)');
+    });
+    it('does not truncate code at exactly 2000 chars', () => {
+        const exact = 'q'.repeat(2000);
+        const msgs = generateCodeCleanupMessages(exact, []);
+        expect(msgs[1].content).not.toContain('truncated');
+        expect(msgs[1].content).toContain(exact);
+    });
+    it('handles empty techniques array', () => {
+        const msgs = generateCodeCleanupMessages(SHORT_CODE, []);
+        assertValidMessages(msgs);
+    });
+});
+describe('generateVMAnalysisMessages', () => {
+    it('returns only a user message (no system)', () => {
+        const msgs = generateVMAnalysisMessages(SHORT_CODE);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(1);
+        expect(msgs[0].role).toBe('user');
+    });
+    it('embeds code and truncates at 5000 chars', () => {
+        const msgs = generateVMAnalysisMessages(LONG_CODE);
+        expect(msgs[0].content).toContain('a'.repeat(5000));
+        expect(msgs[0].content).not.toContain('a'.repeat(5001));
+    });
+    it('handles special characters', () => {
+        const msgs = generateVMAnalysisMessages(SPECIAL_CHARS_CODE);
+        expect(msgs[0].content).toContain(SPECIAL_CHARS_CODE);
+    });
+});
+describe('generateDeobfuscationPrompt', () => {
+    it('returns system + user messages', () => {
+        const msgs = generateDeobfuscationPrompt(SHORT_CODE);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[0].role).toBe('system');
+        expect(msgs[1].role).toBe('user');
+    });
+    it('truncates code longer than 3000 chars', () => {
+        const msgs = generateDeobfuscationPrompt(LONG_CODE);
+        expect(msgs[1].content).toContain('// ... (code truncated)');
+    });
+    it('does not truncate code at exactly 3000 chars', () => {
+        const exact = 'd'.repeat(3000);
+        const msgs = generateDeobfuscationPrompt(exact);
+        expect(msgs[1].content).not.toContain('truncated');
+        expect(msgs[1].content).toContain(exact);
+    });
+    it('embeds code in the user message', () => {
+        const msgs = generateDeobfuscationPrompt(SHORT_CODE);
+        expect(msgs[1].content).toContain(SHORT_CODE);
+    });
+});
+describe('generateVMDeobfuscationMessages', () => {
+    it('returns system + user messages with the prompt as user content', () => {
+        const msgs = generateVMDeobfuscationMessages('Deobfuscate this VM code');
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[0].role).toBe('system');
+        expect(msgs[1].role).toBe('user');
+        expect(msgs[1].content).toBe('Deobfuscate this VM code');
+    });
+    it('passes the user prompt through unchanged', () => {
+        const prompt = 'Some very specific instructions with special chars: <>&"\'';
+        const msgs = generateVMDeobfuscationMessages(prompt);
+        expect(msgs[1].content).toBe(prompt);
+    });
+});
+describe('generateControlFlowUnflatteningMessages', () => {
+    it('returns system + user messages with code embedded', () => {
+        const msgs = generateControlFlowUnflatteningMessages(SHORT_CODE);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[0].role).toBe('system');
+        expect(msgs[1].role).toBe('user');
+        expect(msgs[1].content).toContain(SHORT_CODE);
+    });
+    it('system prompt mentions control flow flattening', () => {
+        const msgs = generateControlFlowUnflatteningMessages(SHORT_CODE);
+        expect(msgs[0].content).toContain('control flow');
+    });
+});
+describe('generateBrowserEnvAnalysisMessages', () => {
+    const detected = { navigator: ['userAgent', 'platform'] };
+    const missing = [{ path: 'window.chrome', type: 'object' }];
+    it('returns system + user messages with all inputs embedded', () => {
+        const msgs = generateBrowserEnvAnalysisMessages(SHORT_CODE, detected, missing, 'chrome');
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[0].role).toBe('system');
+        expect(msgs[1].role).toBe('user');
+        expect(msgs[1].content).toContain('CHROME');
+        expect(msgs[1].content).toContain('window.chrome');
+        expect(msgs[1].content).toContain('userAgent');
+    });
+    it('truncates code longer than 5000 chars', () => {
+        const msgs = generateBrowserEnvAnalysisMessages(LONG_CODE, detected, missing, 'firefox');
+        expect(msgs[1].content).toContain('...(truncated)');
+    });
+    it('does not truncate code at exactly 5000 chars', () => {
+        const exact = 'e'.repeat(5000);
+        const msgs = generateBrowserEnvAnalysisMessages(exact, detected, missing, 'chrome');
+        expect(msgs[1].content).not.toContain('truncated');
+        expect(msgs[1].content).toContain(exact);
+    });
+});
+describe('generateAntiCrawlAnalysisMessages', () => {
+    it('returns system + user messages with code embedded', () => {
+        const msgs = generateAntiCrawlAnalysisMessages(SHORT_CODE);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[0].role).toBe('system');
+        expect(msgs[1].role).toBe('user');
+        expect(msgs[1].content).toContain(SHORT_CODE);
+    });
+    it('truncates code after 3000 chars and appends marker', () => {
+        const msgs = generateAntiCrawlAnalysisMessages(LONG_CODE);
+        expect(msgs[1].content).toContain('...(truncated)');
+    });
+    it('does not add truncation marker for short code', () => {
+        const msgs = generateAntiCrawlAnalysisMessages('var x = 1;');
+        expect(msgs[1].content).not.toContain('truncated');
+    });
+});
+describe('generateAPIImplementationMessages', () => {
+    it('returns system + user messages with apiPath and context', () => {
+        const msgs = generateAPIImplementationMessages('navigator.getBattery', 'getBattery().then(b => b.level)');
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[1].content).toContain('navigator.getBattery');
+        expect(msgs[1].content).toContain('getBattery().then');
+    });
+    it('truncates context longer than 1000 chars', () => {
+        const longCtx = 'ctx'.repeat(500);
+        const msgs = generateAPIImplementationMessages('window.foo', longCtx);
+        expect(msgs[1].content).toContain('...(truncated)');
+    });
+});
+describe('generateEnvironmentSuggestionsMessages', () => {
+    it('returns system + user messages with stats', () => {
+        const detected = { navigator: ['userAgent'], window: ['innerWidth'] };
+        const missing = [{ path: 'navigator.plugins', type: 'array' }];
+        const msgs = generateEnvironmentSuggestionsMessages(detected, missing, 'chrome');
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[1].content).toContain('CHROME');
+        expect(msgs[1].content).toContain('navigator.plugins');
+        expect(msgs[1].content).toContain('2 environment variables accessed');
+    });
+    it('limits missing API display to 20 entries', () => {
+        const missing = Array.from({ length: 30 }, (_, i) => ({ path: `api.path${i}`, type: 'function' }));
+        const msgs = generateEnvironmentSuggestionsMessages({}, missing, 'firefox');
+        expect(msgs[1].content).toContain('and 10 more');
+    });
+    it('handles empty detected and missing', () => {
+        const msgs = generateEnvironmentSuggestionsMessages({}, [], 'safari');
+        assertValidMessages(msgs);
+        expect(msgs[1].content).toContain('0 environment variables accessed');
+        expect(msgs[1].content).toContain('0 APIs need implementation');
+    });
+});
+describe('generateMissingAPIImplementationsMessages', () => {
+    it('returns system + user messages with APIs and code context', () => {
+        const apis = [{ path: 'window.requestAnimationFrame', type: 'function' }];
+        const msgs = generateMissingAPIImplementationsMessages(apis, SHORT_CODE);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[1].content).toContain('requestAnimationFrame');
+        expect(msgs[1].content).toContain(SHORT_CODE);
+    });
+    it('truncates code context after 1500 chars', () => {
+        const apis = [{ path: 'foo', type: 'function' }];
+        const msgs = generateMissingAPIImplementationsMessages(apis, LONG_CODE);
+        expect(msgs[1].content).toContain('...(truncated)');
+    });
+    it('limits APIs to first 10 entries', () => {
+        const apis = Array.from({ length: 20 }, (_, i) => ({ path: `api${i}`, type: 'function' }));
+        const msgs = generateMissingAPIImplementationsMessages(apis, SHORT_CODE);
+        expect(msgs[1].content).toContain('api9');
+        expect(msgs[1].content).not.toContain('api10');
+    });
+});
+describe('generateMissingVariablesMessages', () => {
+    it('returns system + user messages with all parameters embedded', () => {
+        const msgs = generateMissingVariablesMessages('chrome', ['navigator.userAgent', 'navigator.platform'], SHORT_CODE, { 'window.innerWidth': 1920 });
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[1].content).toContain('CHROME');
+        expect(msgs[1].content).toContain('navigator.userAgent');
+        expect(msgs[1].content).toContain('1920');
+    });
+    it('truncates code after 2000 chars', () => {
+        const msgs = generateMissingVariablesMessages('firefox', ['a'], LONG_CODE, {});
+        expect(msgs[1].content).toContain('...(truncated)');
+    });
+});
+describe('generateRequestAnalysisMessages', () => {
+    const summary = { url: 'https://api.example.com/auth', method: 'POST', headers: { Authorization: 'Bearer xyz' } };
+    it('returns system + user messages', () => {
+        const msgs = generateRequestAnalysisMessages(summary);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[0].role).toBe('system');
+        expect(msgs[1].role).toBe('user');
+    });
+    it('serialises the request summary into user message', () => {
+        const msgs = generateRequestAnalysisMessages(summary);
+        expect(msgs[1].content).toContain('api.example.com');
+        expect(msgs[1].content).toContain('Bearer xyz');
+    });
+    it('handles empty object', () => {
+        const msgs = generateRequestAnalysisMessages({});
+        assertValidMessages(msgs);
+    });
+});
+describe('generateLogAnalysisMessages', () => {
+    const logs = [
+        { type: 'log', text: 'User logged in', url: 'app.js' },
+        { type: 'error', text: 'Token expired', url: 'auth.js' },
+    ];
+    it('returns system + user messages', () => {
+        const msgs = generateLogAnalysisMessages(logs);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+    });
+    it('includes log data in user message', () => {
+        const msgs = generateLogAnalysisMessages(logs);
+        expect(msgs[1].content).toContain('User logged in');
+        expect(msgs[1].content).toContain('Token expired');
+    });
+    it('handles empty log array', () => {
+        const msgs = generateLogAnalysisMessages([]);
+        assertValidMessages(msgs);
+    });
+});
+describe('generateKeywordExpansionMessages', () => {
+    it('returns system + user messages with all params', () => {
+        const msgs = generateKeywordExpansionMessages('example.com', [{ path: '/api/auth', method: 'POST' }], ['CryptoJS', 'token']);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[1].content).toContain('example.com');
+        expect(msgs[1].content).toContain('/api/auth');
+        expect(msgs[1].content).toContain('CryptoJS');
+        expect(msgs[1].content).toContain('token');
+    });
+    it('handles empty url patterns and keywords', () => {
+        const msgs = generateKeywordExpansionMessages('site.com', [], []);
+        assertValidMessages(msgs);
+    });
+});
+describe('generateTaintAnalysisPrompt', () => {
+    it('returns system + user messages with sources and sinks', () => {
+        const msgs = generateTaintAnalysisPrompt(SHORT_CODE, ['document.location'], ['eval']);
+        assertValidMessages(msgs);
+        expect(msgs).toHaveLength(2);
+        expect(msgs[0].role).toBe('system');
+        expect(msgs[1].role).toBe('user');
+        expect(msgs[1].content).toContain('document.location');
+        expect(msgs[1].content).toContain('eval');
+    });
+    it('embeds code in the user message', () => {
+        const msgs = generateTaintAnalysisPrompt('fetch(url)', ['url'], ['fetch']);
+        expect(msgs[1].content).toContain('fetch(url)');
+    });
+    it('truncates code longer than 4000 chars', () => {
+        const msgs = generateTaintAnalysisPrompt(LONG_CODE, ['src'], ['sink']);
+        expect(msgs[1].content).toContain('// ... (truncated)');
+    });
+    it('does not truncate code at exactly 4000 chars', () => {
+        const exact = 'f'.repeat(4000);
+        const msgs = generateTaintAnalysisPrompt(exact, [], []);
+        expect(msgs[1].content).not.toContain('truncated');
+        expect(msgs[1].content).toContain(exact);
+    });
+    it('handles empty sources and sinks', () => {
+        const msgs = generateTaintAnalysisPrompt(SHORT_CODE, [], []);
+        assertValidMessages(msgs);
+    });
+});

package/dist/tests/setup.d.ts

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

package/dist/tests/setup.js

@@ -0,0 +1,12 @@
+import { beforeAll, afterEach } from 'vitest';
+import { initRegistry } from '../src/server/registry/index.js';
+process.env.ENABLE_INJECTION_TOOLS = 'true';
+process.env.NODE_ENV = 'test';
+beforeAll(async () => {
+    await initRegistry();
+});
+afterEach(async () => {
+    if (global.gc) {
+        global.gc();
+    }
+});

package/dist/tests/utils/AdaptiveDataSerializer.test.d.ts

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

package/dist/tests/utils/AdaptiveDataSerializer.test.js

@@ -0,0 +1,67 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { DetailedDataManager } from '../../src/utils/DetailedDataManager.js';
+import { AdaptiveDataSerializer } from '../../src/utils/AdaptiveDataSerializer.js';
+describe('AdaptiveDataSerializer', () => {
+    let serializer;
+    let storeMock;
+    beforeEach(() => {
+        serializer = new AdaptiveDataSerializer();
+        storeMock = vi.fn(() => 'detail_test_123');
+        vi.spyOn(DetailedDataManager, 'getInstance').mockReturnValue({
+            store: storeMock,
+        });
+    });
+    it('serializes primitive values directly', () => {
+        expect(serializer.serialize(42)).toBe('42');
+        expect(serializer.serialize(true)).toBe('true');
+    });
+    it('serializes large arrays with summary and detailId', () => {
+        const data = Array.from({ length: 120 }, (_, i) => i);
+        const output = JSON.parse(serializer.serialize(data));
+        expect(output.type).toBe('large-array');
+        expect(output.length).toBe(120);
+        expect(output.detailId).toBe('detail_test_123');
+        expect(output.sample).toHaveLength(10);
+    });
+    it('serializes long code strings with preview', () => {
+        const code = `function foo() {\n${Array.from({ length: 120 }, (_, i) => `const x${i} = ${i};`).join('\n')}\n}`;
+        const output = JSON.parse(serializer.serialize(code));
+        expect(output.type).toBe('code-string');
+        expect(output.totalLines).toBeGreaterThan(100);
+        expect(output.preview).toContain('function foo');
+        expect(output.detailId).toBe('detail_test_123');
+    });
+    it('summarizes network request arrays when exceeding max length', () => {
+        const requests = Array.from({ length: 12 }, (_, i) => ({
+            requestId: `r${i}`,
+            url: `https://vmoranv.github.io/jshookmcp/${i}`,
+            method: 'GET',
+            type: 'xhr',
+            timestamp: i,
+            body: 'large-body',
+        }));
+        const output = JSON.parse(serializer.serialize(requests));
+        expect(output.type).toBe('network-requests');
+        expect(output.count).toBe(12);
+        expect(output.summary).toHaveLength(10);
+        expect(output.summary[0]).toEqual({
+            requestId: 'r0',
+            url: 'https://vmoranv.github.io/jshookmcp/0',
+            method: 'GET',
+            type: 'xhr',
+            timestamp: 0,
+        });
+    });
+    it('limits depth for deep objects', () => {
+        const deep = { a: { b: { c: { d: { e: 'value' } } } } };
+        const output = JSON.parse(serializer.serialize(deep, { maxDepth: 3 }));
+        expect(output.a.b.c).toBe('[Max depth reached]');
+    });
+    it('falls back to large-data summary for oversized unknown objects', () => {
+        const payload = { text: 'x'.repeat(5000) };
+        const output = JSON.parse(serializer.serialize(payload, { threshold: 100 }));
+        expect(output.type).toBe('large-data');
+        expect(output.detailId).toBe('detail_test_123');
+        expect(output.size).toBeGreaterThan(100);
+    });
+});

package/dist/tests/utils/CacheAdapters.test.d.ts

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

package/dist/tests/utils/CacheAdapters.test.js

@@ -0,0 +1,91 @@
+import { describe, expect, it, vi } from 'vitest';
+import { CodeCacheAdapter, CodeCompressorAdapter, DetailedDataManagerAdapter, createCacheAdapters, } from '../../src/utils/CacheAdapters.js';
+describe('CacheAdapters', () => {
+    it('maps DetailedDataManager stats into cache stats format', () => {
+        const manager = {
+            getStats: vi.fn(() => ({
+                cacheSize: 3,
+                defaultTTLSeconds: 60,
+                maxCacheSize: 100,
+            })),
+            clear: vi.fn(),
+        };
+        const adapter = new DetailedDataManagerAdapter(manager);
+        expect(adapter.name).toBe('DetailedDataManager');
+        expect(adapter.getStats()).toEqual({
+            entries: 3,
+            size: 3 * 50 * 1024,
+            hits: 0,
+            misses: 0,
+            ttl: 60_000,
+            maxSize: 100,
+        });
+    });
+    it('delegates clear to DetailedDataManager', () => {
+        const manager = {
+            getStats: vi.fn(() => ({
+                cacheSize: 0,
+                defaultTTLSeconds: 30,
+                maxCacheSize: 10,
+            })),
+            clear: vi.fn(),
+        };
+        const adapter = new DetailedDataManagerAdapter(manager);
+        adapter.clear();
+        expect(manager.clear).toHaveBeenCalledOnce();
+    });
+    it('maps CodeCache stats and delegates clear/cleanup', async () => {
+        const cache = {
+            getStats: vi.fn(async () => ({ memoryEntries: 2, diskEntries: 3, totalSize: 999 })),
+            cleanup: vi.fn(async () => undefined),
+            clear: vi.fn(async () => undefined),
+        };
+        const adapter = new CodeCacheAdapter(cache);
+        await expect(adapter.getStats()).resolves.toEqual({
+            entries: 5,
+            size: 999,
+            hits: 0,
+            misses: 0,
+        });
+        await adapter.cleanup();
+        await adapter.clear();
+        expect(cache.cleanup).toHaveBeenCalledOnce();
+        expect(cache.clear).toHaveBeenCalledOnce();
+    });
+    it('calculates CodeCompressor hit rate and size estimate', () => {
+        const compressor = {
+            getStats: vi.fn(() => ({ cacheHits: 8, cacheMisses: 2, totalCompressedSize: 1000 })),
+            getCacheSize: vi.fn(() => 5),
+            clearCache: vi.fn(),
+        };
+        const adapter = new CodeCompressorAdapter(compressor);
+        expect(adapter.getStats()).toEqual({
+            entries: 5,
+            size: 1000,
+            hits: 8,
+            misses: 2,
+            hitRate: 0.8,
+        });
+    });
+    it('handles zero-entry compressor cache size gracefully', () => {
+        const compressor = {
+            getStats: vi.fn(() => ({ cacheHits: 0, cacheMisses: 0, totalCompressedSize: 1000 })),
+            getCacheSize: vi.fn(() => 0),
+            clearCache: vi.fn(),
+        };
+        const adapter = new CodeCompressorAdapter(compressor);
+        expect(adapter.getStats().size).toBe(0);
+    });
+    it('creates the three expected adapters', () => {
+        const manager = { getStats: vi.fn(), clear: vi.fn() };
+        const cache = { getStats: vi.fn(), cleanup: vi.fn(), clear: vi.fn() };
+        const compressor = { getStats: vi.fn(), getCacheSize: vi.fn(), clearCache: vi.fn() };
+        const adapters = createCacheAdapters(manager, cache, compressor);
+        expect(adapters).toHaveLength(3);
+        expect(adapters.map((a) => a.name)).toEqual([
+            'DetailedDataManager',
+            'CodeCache',
+            'CodeCompressor',
+        ]);
+    });
+});

package/dist/tests/utils/DetailedDataManager.test.d.ts

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

package/dist/tests/utils/DetailedDataManager.test.js

@@ -0,0 +1,67 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { DetailedDataManager } from '../../src/utils/DetailedDataManager.js';
+describe('DetailedDataManager', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-01-01T00:00:00.000Z'));
+    });
+    afterEach(() => {
+        DetailedDataManager.getInstance().shutdown();
+        vi.useRealTimers();
+        vi.restoreAllMocks();
+    });
+    it('returns singleton instance and recreates after shutdown', () => {
+        const first = DetailedDataManager.getInstance();
+        const second = DetailedDataManager.getInstance();
+        expect(first).toBe(second);
+        first.shutdown();
+        const third = DetailedDataManager.getInstance();
+        expect(third).not.toBe(first);
+    });
+    it('stores and retrieves data with path and updates access stats', () => {
+        const manager = DetailedDataManager.getInstance();
+        const detailId = manager.store({ nested: { value: 42 } });
+        expect(manager.retrieve(detailId)).toEqual({ nested: { value: 42 } });
+        expect(manager.retrieve(detailId, 'nested.value')).toBe(42);
+        const detailed = manager.getDetailedStats().find((entry) => entry.detailId === detailId);
+        expect(detailed?.accessCount).toBe(2);
+    });
+    it('throws for missing and expired detail ids', () => {
+        const manager = DetailedDataManager.getInstance();
+        expect(() => manager.retrieve('detail_missing')).toThrow('not found or expired');
+        const detailId = manager.store({ hello: 'world' }, 10);
+        vi.advanceTimersByTime(11);
+        expect(() => manager.retrieve(detailId)).toThrow('expired');
+    });
+    it('cleans up expired entries via cleanup routine', () => {
+        const manager = DetailedDataManager.getInstance();
+        manager.store({ a: 1 }, 5);
+        manager.store({ b: 2 }, 30_000);
+        vi.advanceTimersByTime(6);
+        manager.cleanup();
+        expect(manager.getStats().cacheSize).toBe(1);
+    });
+    it('evicts least-recently-used entry when cache reaches limit', () => {
+        const manager = DetailedDataManager.getInstance();
+        const ids = [];
+        for (let index = 0; index < 100; index++) {
+            ids.push(manager.store({ index }));
+            vi.advanceTimersByTime(1);
+        }
+        manager.retrieve(ids[99]);
+        vi.advanceTimersByTime(1);
+        const overflowId = manager.store({ overflow: true });
+        expect(manager.getStats().cacheSize).toBe(100);
+        expect(() => manager.retrieve(ids[0])).toThrow('not found or expired');
+        expect(manager.retrieve(overflowId)).toEqual({ overflow: true });
+    });
+    it('returns detailed response for oversized payload in smartHandle', () => {
+        const manager = DetailedDataManager.getInstance();
+        const large = { payload: 'x'.repeat(5000) };
+        const result = manager.smartHandle(large, 100);
+        expect(result.detailId).toMatch(/^detail_/);
+        expect(result.summary.type).toBe('object');
+        expect(result.summary.size).toBeGreaterThan(100);
+        expect(manager.retrieve(result.detailId)).toEqual(large);
+    });
+});

package/dist/tests/utils/RingBuffer.test.d.ts

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