@jshookmcp/jshook 0.2.0 → 0.2.2

package/dist/tests/modules/analyzer/AISummarizer.test.js

@@ -1,133 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const loggerState = vi.hoisted(() => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-}));
-const promptState = vi.hoisted(() => ({
-    generateFileSummaryMessages: vi.fn((url, snippet) => [
-        { role: 'user', content: `${url}:${snippet}` },
-    ]),
-    generateProjectSummaryMessages: vi.fn((files) => [
-        { role: 'user', content: `files:${files.length}` },
-    ]),
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: loggerState,
-}));
-vi.mock('@src/services/prompts/analysis', () => ({
-    generateFileSummaryMessages: promptState.generateFileSummaryMessages,
-    generateProjectSummaryMessages: promptState.generateProjectSummaryMessages,
-}));
-import { AISummarizer } from '../../../src/modules/analyzer/AISummarizer.js';
-function makeFile(overrides = {}) {
-    return {
-        url: 'https://vmoranv.github.io/jshookmcp/cdn/app.js',
-        type: 'inline',
-        size: 120,
-        content: 'function hello(){return 1;}',
-        ...overrides,
-    };
-}
-describe('AISummarizer', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        loggerState.debug.mockReset();
-        loggerState.info.mockReset();
-        loggerState.warn.mockReset();
-        loggerState.error.mockReset();
-        promptState.generateFileSummaryMessages.mockClear();
-        promptState.generateProjectSummaryMessages.mockClear();
-    });
-    it('parses AI JSON summary for a file', async () => {
-        const llm = {
-            chat: vi.fn(async () => ({
-                content: JSON.stringify({
-                    summary: 'ok',
-                    purpose: 'auth',
-                    keyFunctions: ['hello'],
-                    hasAPI: true,
-                    complexity: 'low',
-                }),
-            })),
-        };
-        const result = await new AISummarizer(llm).summarizeFile(makeFile());
-        expect(result.summary).toBe('ok');
-        expect(result.purpose).toBe('auth');
-        expect(result.keyFunctions).toEqual(['hello']);
-        expect(result.hasAPI).toBe(true);
-        expect(result.complexity).toBe('low');
-        expect(result.linesOfCode).toBe(1);
-    });
-    it('truncates long source before sending prompt', async () => {
-        const llm = { chat: vi.fn(async () => ({ content: '{}' })) };
-        const longContent = 'a'.repeat(11050);
-        await new AISummarizer(llm).summarizeFile(makeFile({ content: longContent }));
-        const [, snippet] = promptState.generateFileSummaryMessages.mock.calls[0];
-        expect(snippet.length).toBeGreaterThan(10000);
-        expect(snippet).toContain('... (truncated)');
-    });
-    it('falls back to basic analysis when LLM call throws', async () => {
-        const llm = { chat: vi.fn(async () => Promise.reject(new Error('down'))) };
-        const content = 'function encryptData(){}\nfetch("/api/x")\neval("1")';
-        const result = await new AISummarizer(llm).summarizeFile(makeFile({ content }));
-        expect(result.summary).toContain('Basic analysis');
-        expect(result.hasEncryption).toBe(true);
-        expect(result.hasAPI).toBe(true);
-        expect(result.hasObfuscation).toBe(true);
-        expect(result.keyFunctions).toContain('encryptData');
-    });
-    it('falls back when AI response is not valid JSON', async () => {
-        const llm = { chat: vi.fn(async () => ({ content: 'not-json' })) };
-        const result = await new AISummarizer(llm).summarizeFile(makeFile());
-        expect(result.summary).toContain('Basic analysis');
-        expect(loggerState.warn).toHaveBeenCalled();
-    });
-    it('summarizes files in batches with configured concurrency', async () => {
-        const llm = {
-            chat: vi.fn(async ({ 0: msg }) => ({
-                content: JSON.stringify({
-                    summary: String(msg.content).includes('a.js') ? 'A' : 'B',
-                    purpose: 'x',
-                }),
-            })),
-        };
-        const files = [
-            makeFile({ url: 'a.js', content: 'function a(){}' }),
-            makeFile({ url: 'b.js', content: 'function b(){}' }),
-            makeFile({ url: 'c.js', content: 'function c(){}' }),
-        ];
-        const result = await new AISummarizer(llm).summarizeBatch(files, 2);
-        expect(result).toHaveLength(3);
-        expect(llm.chat).toHaveBeenCalledTimes(3);
-    });
-    it('parses project-level summary and computes totals', async () => {
-        const llm = {
-            chat: vi.fn(async () => ({
-                content: JSON.stringify({
-                    mainPurpose: 'platform',
-                    architecture: 'modular',
-                    technologies: ['ts'],
-                    securityConcerns: ['xss'],
-                    recommendations: ['harden'],
-                }),
-            })),
-        };
-        const result = await new AISummarizer(llm).summarizeProject([
-            makeFile({ size: 10 }),
-            makeFile({ size: 20 }),
-        ]);
-        expect(result.totalFiles).toBe(2);
-        expect(result.totalSize).toBe(30);
-        expect(result.mainPurpose).toBe('platform');
-        expect(result.technologies).toEqual(['ts']);
-    });
-    it('returns safe defaults when project summary fails', async () => {
-        const llm = { chat: vi.fn(async () => ({ content: '{' })) };
-        const result = await new AISummarizer(llm).summarizeProject([makeFile({ size: 7 })]);
-        expect(result.mainPurpose).toBe('Analysis failed');
-        expect(result.totalSize).toBe(7);
-        expect(result.technologies).toEqual([]);
-    });
-});

package/dist/tests/modules/analyzer/CodeAnalyzer.test.js

@@ -1,125 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const loggerState = vi.hoisted(() => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    success: vi.fn(),
-}));
-const promptState = vi.hoisted(() => ({
-    generateCodeAnalysisPrompt: vi.fn(() => [{ role: 'user', content: 'analyze code' }]),
-    generateTaintAnalysisPrompt: vi.fn(() => [{ role: 'user', content: 'analyze taint' }]),
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: loggerState,
-}));
-vi.mock('@src/services/prompts/analysis', () => ({
-    generateCodeAnalysisPrompt: promptState.generateCodeAnalysisPrompt,
-}));
-vi.mock('@src/services/prompts/taint', () => ({
-    generateTaintAnalysisPrompt: promptState.generateTaintAnalysisPrompt,
-}));
-import { CodeAnalyzer } from '../../../src/modules/analyzer/CodeAnalyzer.js';
-function createLLM(responses) {
-    const queue = [...responses];
-    const chat = vi.fn(async () => {
-        const next = queue.shift() ?? '{}';
-        if (next instanceof Error) {
-            throw next;
-        }
-        return { content: next };
-    });
-    return { llm: { chat }, chat };
-}
-describe('CodeAnalyzer', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        loggerState.debug.mockReset();
-        loggerState.info.mockReset();
-        loggerState.warn.mockReset();
-        loggerState.error.mockReset();
-        loggerState.success.mockReset();
-        promptState.generateCodeAnalysisPrompt.mockReset();
-        promptState.generateCodeAnalysisPrompt.mockReturnValue([
-            { role: 'user', content: 'analyze code' },
-        ]);
-        promptState.generateTaintAnalysisPrompt.mockReset();
-        promptState.generateTaintAnalysisPrompt.mockReturnValue([
-            { role: 'user', content: 'analyze taint' },
-        ]);
-    });
-    it('extracts structure with functions, classes, modules and call graph edges', async () => {
-        const { llm } = createLLM(['{"businessLogic":{"mainFeatures":["auth"]}}']);
-        const analyzer = new CodeAnalyzer(llm);
-        const code = `
-      import helper from './helper';
-      function b() { return 1; }
-      function a() { return b(); }
-      class Box {
-        value = 1;
-        m(p) { return p; }
-      }
-      export default a;
-    `;
-        const result = await analyzer.understand({ code });
-        const functionNames = result.structure.functions.map((fn) => fn.name);
-        expect(functionNames).toContain('a');
-        expect(functionNames).toContain('b');
-        expect(result.structure.classes[0].name).toBe('Box');
-        expect(result.structure.classes[0].methods.some((m) => m.name === 'm')).toBe(true);
-        expect(result.structure.modules[0].imports).toContain('./helper');
-        expect(result.structure.callGraph.edges.some((edge) => edge.from === 'a' && edge.to === 'b')).toBe(true);
-    });
-    it('detects non-empty tech stack heuristics from common code patterns', async () => {
-        const { llm } = createLLM(['{}']);
-        const analyzer = new CodeAnalyzer(llm);
-        const code = `
-      function view() { const [v] = useState(1); return v; }
-      export { view };
-    `;
-        const result = await analyzer.understand({ code });
-        expect(typeof result.techStack.framework).toBe('string');
-        expect((result.techStack.framework ?? '').length).toBeGreaterThan(0);
-    });
-    it('merges AI business logic output with provided context data model', async () => {
-        const { llm } = createLLM([
-            '{"businessLogic":{"mainFeatures":["checkout"],"dataFlow":"calculate totals"}}',
-        ]);
-        const analyzer = new CodeAnalyzer(llm);
-        const result = await analyzer.understand({
-            code: 'function pay(total){ return total; }',
-            context: { tenant: 'acme', region: 'us-east-1' },
-            focus: 'business',
-        });
-        expect(result.businessLogic.mainFeatures).toEqual(['checkout']);
-        expect(result.businessLogic.rules).toContain('calculate totals');
-        expect(result.businessLogic.dataModel).toMatchObject({
-            tenant: 'acme',
-            region: 'us-east-1',
-        });
-    });
-    it('tracks tainted data paths from sources to eval sinks', async () => {
-        const { llm } = createLLM(['{}', '{}']);
-        const analyzer = new CodeAnalyzer(llm);
-        const code = `
-      const payload = location.search;
-      eval(payload);
-    `;
-        const result = await analyzer.understand({ code, focus: 'security' });
-        expect(result.dataFlow.sources.length).toBeGreaterThan(0);
-        expect(result.dataFlow.sinks.some((sink) => sink.type === 'eval')).toBe(true);
-        expect(result.dataFlow.taintPaths.length).toBeGreaterThan(0);
-    });
-    it('falls back gracefully when LLM analysis fails', async () => {
-        const { llm, chat } = createLLM([new Error('LLM unavailable')]);
-        const analyzer = new CodeAnalyzer(llm);
-        const result = await analyzer.understand({
-            code: 'function fallback(x){ return x + 1; }',
-            focus: 'all',
-        });
-        expect(chat).toHaveBeenCalledTimes(1);
-        expect(result.structure.functions.some((fn) => fn.name === 'fallback')).toBe(true);
-        expect(result.qualityScore).toBeGreaterThanOrEqual(0);
-        expect(result.qualityScore).toBeLessThanOrEqual(100);
-    });
-});

package/dist/tests/modules/analyzer/IntelligentAnalyzer.test.js

@@ -1,177 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const loggerState = vi.hoisted(() => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    success: vi.fn(),
-}));
-const patternState = vi.hoisted(() => ({
-    filterCriticalRequests: vi.fn((input) => input.slice(0, 1)),
-    filterCriticalResponses: vi.fn((input) => input.slice(0, 1)),
-    filterCriticalLogs: vi.fn((input) => input.slice(0, 1)),
-    detectEncryptionPatterns: vi.fn(() => []),
-    detectSignaturePatterns: vi.fn(() => []),
-    detectTokenPatterns: vi.fn(() => []),
-    detectAntiDebugPatterns: vi.fn(() => []),
-    extractSuspiciousAPIs: vi.fn(() => ['api.sign']),
-    extractKeyFunctions: vi.fn(() => ['fnA']),
-}));
-const promptState = vi.hoisted(() => ({
-    generateRequestAnalysisMessages: vi.fn(() => [{ role: 'user', content: 'req' }]),
-    generateLogAnalysisMessages: vi.fn(() => [{ role: 'user', content: 'log' }]),
-    generateKeywordExpansionMessages: vi.fn(() => [{ role: 'user', content: 'kw' }]),
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: loggerState,
-}));
-vi.mock('@src/modules/analyzer/PatternDetector', () => ({
-    filterCriticalRequests: patternState.filterCriticalRequests,
-    filterCriticalResponses: patternState.filterCriticalResponses,
-    filterCriticalLogs: patternState.filterCriticalLogs,
-    detectEncryptionPatterns: patternState.detectEncryptionPatterns,
-    detectSignaturePatterns: patternState.detectSignaturePatterns,
-    detectTokenPatterns: patternState.detectTokenPatterns,
-    detectAntiDebugPatterns: patternState.detectAntiDebugPatterns,
-    extractSuspiciousAPIs: patternState.extractSuspiciousAPIs,
-    extractKeyFunctions: patternState.extractKeyFunctions,
-}));
-vi.mock('@src/services/prompts/intelligence', () => ({
-    generateRequestAnalysisMessages: promptState.generateRequestAnalysisMessages,
-    generateLogAnalysisMessages: promptState.generateLogAnalysisMessages,
-    generateKeywordExpansionMessages: promptState.generateKeywordExpansionMessages,
-}));
-import { IntelligentAnalyzer } from '../../../src/modules/analyzer/IntelligentAnalyzer.js';
-function makeData() {
-    return {
-        requests: [
-            { url: 'https://vmoranv.github.io/jshookmcp/a/api/x?sig=1', method: 'GET', headers: {}, timestamp: 1 },
-            { url: 'https://vmoranv.github.io/jshookmcp/a/api/x?sig=2', method: 'GET', headers: {}, timestamp: 2 },
-        ],
-        responses: [{ url: 'https://vmoranv.github.io/jshookmcp/a/api/x', status: 200, timestamp: 3 }],
-        logs: [{ type: 'log', text: 'fnA', timestamp: 4 }],
-        exceptions: [{ message: 'boom' }],
-    };
-}
-describe('IntelligentAnalyzer', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        Object.values(patternState).forEach((fn) => fn.mockClear?.());
-        Object.values(promptState).forEach((fn) => fn.mockClear?.());
-        Object.values(loggerState).forEach((fn) => fn.mockReset?.());
-    });
-    it('builds analysis result from rule-based detector outputs', () => {
-        patternState.detectEncryptionPatterns.mockReturnValue([
-            { type: 'AES', location: 'req', confidence: 0.9, evidence: ['aes'] },
-        ]);
-        const analyzer = new IntelligentAnalyzer();
-        const result = analyzer.analyze(makeData());
-        expect(result.criticalRequests).toHaveLength(1);
-        expect(result.criticalResponses).toHaveLength(1);
-        expect(result.summary.totalRequests).toBe(2);
-        expect(result.summary.suspiciousAPIs).toEqual(['api.sign']);
-        expect(result.patterns.encryption).toHaveLength(1);
-    });
-    it('aggregates similar requests by origin+pathname and skips invalid URLs', () => {
-        const analyzer = new IntelligentAnalyzer();
-        const grouped = analyzer.aggregateSimilarRequests([
-            { url: 'https://vmoranv.github.io/jshookmcp/a/path?a=1' },
-            { url: 'https://vmoranv.github.io/jshookmcp/a/path?a=2' },
-            { url: 'invalid-url' },
-        ]);
-        expect(grouped.size).toBe(1);
-        expect(grouped.get('https://vmoranv.github.io/jshookmcp/a/path')).toHaveLength(2);
-    });
-    it('generates readable summary text with key sections', () => {
-        const analyzer = new IntelligentAnalyzer();
-        const result = analyzer.analyze(makeData());
-        const text = analyzer.generateAIFriendlySummary(result);
-        expect(text).toContain('Requests: 2');
-        expect(text).toContain('api.sign');
-        expect(text).toContain('fnA');
-    });
-    it('returns empty request-analysis result when LLM is unavailable', async () => {
-        const analyzer = new IntelligentAnalyzer();
-        const result = await analyzer.analyzeCriticalRequestsWithLLM(makeData().requests);
-        expect(result).toEqual({ encryption: [], signature: [], token: [], customPatterns: [] });
-        expect(loggerState.warn).toHaveBeenCalled();
-    });
-    it('parses request-analysis JSON from LLM response', async () => {
-        const llm = {
-            chat: vi.fn(async () => ({
-                content: JSON.stringify({
-                    encryption: [{ type: 'AES', location: 'u', confidence: 0.8, evidence: ['k'] }],
-                    signature: [],
-                    token: [],
-                    customPatterns: [],
-                }),
-            })),
-        };
-        const analyzer = new IntelligentAnalyzer(llm);
-        const result = await analyzer.analyzeCriticalRequestsWithLLM(makeData().requests);
-        expect(result.encryption[0].type).toBe('AES');
-        expect(promptState.generateRequestAnalysisMessages).toHaveBeenCalledTimes(1);
-        expect(llm.chat).toHaveBeenCalledTimes(1);
-    });
-    it('falls back when log-analysis LLM response is invalid JSON', async () => {
-        const llm = { chat: vi.fn(async () => ({ content: 'oops' })) };
-        const analyzer = new IntelligentAnalyzer(llm);
-        const result = await analyzer.analyzeCriticalLogsWithLLM(makeData().logs);
-        expect(result).toEqual({ keyFunctions: [], dataFlow: '', suspiciousPatterns: [] });
-        expect(loggerState.error).toHaveBeenCalled();
-    });
-    it('merges LLM enhancements into rule-based result', async () => {
-        const analyzer = new IntelligentAnalyzer({ chat: vi.fn() });
-        vi.spyOn(analyzer, 'analyzeCriticalRequestsWithLLM').mockResolvedValue({
-            encryption: [{ type: 'AES', location: 'x', confidence: 1, evidence: ['e'] }],
-            signature: [{ type: 'JWT', location: 'y', confidence: 1, parameters: ['p'] }],
-            token: [{ type: 'JWT', location: 'z', confidence: 1, format: 'jwt' }],
-            customPatterns: [],
-        });
-        vi.spyOn(analyzer, 'analyzeCriticalLogsWithLLM').mockResolvedValue({
-            keyFunctions: [{ name: 'llmFunc', purpose: 'x', confidence: 0.9 }],
-            dataFlow: 'df',
-            suspiciousPatterns: [],
-        });
-        const result = await analyzer.analyzeWithLLM(makeData());
-        expect(result.patterns.encryption?.some((p) => p.type === 'AES')).toBe(true);
-        expect(result.patterns.signature?.some((p) => p.type === 'JWT')).toBe(true);
-        expect(result.summary.keyFunctions).toContain('llmFunc');
-    });
-    it('generateAIFriendlySummary handles non-array evidence gracefully', () => {
-        const analyzer = new IntelligentAnalyzer();
-        const result = analyzer.analyze(makeData());
-        result.patterns.encryption = [
-            { type: 'AES', location: 'test', confidence: 0.9, evidence: 'not-an-array' },
-        ];
-        expect(() => analyzer.generateAIFriendlySummary(result)).not.toThrow();
-        const summary = analyzer.generateAIFriendlySummary(result);
-        expect(summary).toContain('AES');
-        expect(summary).toContain('not-an-array');
-    });
-    it('generateAIFriendlySummary handles non-array parameters gracefully', () => {
-        const analyzer = new IntelligentAnalyzer();
-        const result = analyzer.analyze(makeData());
-        result.patterns.signature = [
-            { type: 'HMAC', location: 'test', confidence: 0.9, parameters: 'not-an-array' },
-        ];
-        expect(() => analyzer.generateAIFriendlySummary(result)).not.toThrow();
-        const summary = analyzer.generateAIFriendlySummary(result);
-        expect(summary).toContain('HMAC');
-        expect(summary).toContain('not-an-array');
-    });
-    it('generateAIFriendlySummary handles undefined evidence/parameters gracefully', () => {
-        const analyzer = new IntelligentAnalyzer();
-        const result = analyzer.analyze(makeData());
-        result.patterns.encryption = [
-            { type: 'AES', location: 'test', confidence: 0.9, evidence: undefined },
-        ];
-        result.patterns.signature = [
-            { type: 'HMAC', location: 'test', confidence: 0.9, parameters: undefined },
-        ];
-        expect(() => analyzer.generateAIFriendlySummary(result)).not.toThrow();
-        const summary = analyzer.generateAIFriendlySummary(result);
-        expect(summary).toContain('AES');
-        expect(summary).toContain('HMAC');
-    });
-});

package/dist/tests/modules/analyzer/PatternDetector.test.js

@@ -1,149 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { calculateRequestPriority, detectAntiDebugPatterns, detectEncryptionPatterns, detectSignaturePatterns, detectTokenPatterns, extractKeyFunctions, extractSuspiciousAPIs, filterCriticalLogs, filterCriticalRequests, filterCriticalResponses, } from '../../../src/modules/analyzer/PatternDetector.js';
-function request(overrides) {
-    return {
-        requestId: overrides.requestId ?? 'r1',
-        url: overrides.url ?? 'https://vmoranv.github.io/jshookmcp/api/data',
-        method: overrides.method ?? 'GET',
-        headers: overrides.headers ?? {},
-        postData: overrides.postData,
-        timestamp: overrides.timestamp ?? Date.now(),
-        type: overrides.type,
-        initiator: overrides.initiator,
-    };
-}
-function response(overrides) {
-    return {
-        requestId: overrides.requestId ?? 'resp-1',
-        url: overrides.url ?? 'https://vmoranv.github.io/jshookmcp/api/data',
-        status: overrides.status ?? 200,
-        statusText: overrides.statusText ?? 'OK',
-        headers: overrides.headers ?? {},
-        mimeType: overrides.mimeType ?? 'application/json',
-        timestamp: overrides.timestamp ?? Date.now(),
-        fromCache: overrides.fromCache,
-        timing: overrides.timing,
-    };
-}
-function log(overrides) {
-    return {
-        type: overrides.type ?? 'log',
-        text: overrides.text ?? '',
-        timestamp: overrides.timestamp ?? Date.now(),
-        args: overrides.args,
-        stackTrace: overrides.stackTrace,
-        url: overrides.url,
-        lineNumber: overrides.lineNumber,
-        columnNumber: overrides.columnNumber,
-    };
-}
-describe('PatternDetector', () => {
-    it('filters critical requests and sorts by calculated priority', () => {
-        const requests = [
-            request({ requestId: 'r-ignored', url: 'https://vmoranv.github.io/jshookmcp/static/ignored.css' }),
-            request({ requestId: 'r-static', url: 'https://vmoranv.github.io/jshookmcp/logo.png' }),
-            request({ requestId: 'r-post', url: 'https://vmoranv.github.io/jshookmcp/order', method: 'POST' }),
-            request({ requestId: 'r-keyword', url: 'https://vmoranv.github.io/jshookmcp/api/login?token=abc' }),
-        ];
-        const critical = filterCriticalRequests(requests);
-        expect(critical.map((item) => item.requestId)).toEqual(['r-keyword', 'r-post']);
-        expect(calculateRequestPriority(critical[0])).toBeGreaterThan(calculateRequestPriority(critical[1]));
-    });
-    it('filters critical responses by mime type, keyword, and timestamp order', () => {
-        const responses = [
-            response({
-                requestId: 'blacklisted',
-                url: 'https://cdn.jsdelivr.net/x.js',
-                mimeType: 'application/javascript',
-                timestamp: 1,
-            }),
-            response({
-                requestId: 'json',
-                url: 'https://vmoranv.github.io/jshookmcp/plain',
-                mimeType: 'application/json',
-                timestamp: 2,
-            }),
-            response({
-                requestId: 'keyword',
-                url: 'https://vmoranv.github.io/jshookmcp/auth/step',
-                mimeType: 'text/html',
-                timestamp: 3,
-            }),
-        ];
-        const filtered = filterCriticalResponses(responses);
-        expect(filtered.map((item) => item.requestId)).toEqual(['keyword', 'json']);
-    });
-    it('filters console logs and removes framework noise', () => {
-        const logs = [
-            log({ text: '[HMR] connected', type: 'info' }),
-            log({ text: ' ', type: 'log' }),
-            log({ text: 'token refresh failed', type: 'warn' }),
-            log({ text: 'auth success', type: 'log' }),
-        ];
-        const critical = filterCriticalLogs(logs);
-        expect(critical).toHaveLength(2);
-        expect(critical[0].type).toBe('warn');
-        expect(critical[1].text).toContain('auth');
-    });
-    it('detects encryption patterns and deduplicates repeated locations', () => {
-        const patterns = detectEncryptionPatterns([
-            request({
-                url: 'https://vmoranv.github.io/jshookmcp/crypto/aes/endpoint',
-                postData: '{"payload":"encrypt this"}',
-            }),
-        ], [log({ text: 'CryptoJS.AES encrypt invoked', url: 'console://main' })]);
-        const sameLocation = patterns.filter((pattern) => pattern.location.includes('/crypto/aes'));
-        expect(sameLocation).toHaveLength(1);
-        expect(patterns.some((pattern) => pattern.type === 'AES')).toBe(true);
-    });
-    it('detects signature patterns from URL params, headers and request body', () => {
-        const patterns = detectSignaturePatterns([
-            request({
-                url: 'https://vmoranv.github.io/jshookmcp/api?signature=abc&data=1',
-                headers: { 'x-signature': 'a'.repeat(64), 'x-trace-id': 'trace' },
-                postData: JSON.stringify({ sign: 'a'.repeat(64), payload: 'x' }),
-            }),
-        ], []);
-        expect(patterns.length).toBeGreaterThanOrEqual(3);
-        expect(patterns.some((item) => item.type === 'HMAC')).toBe(true);
-        expect(patterns.some((item) => item.location.includes('URL params'))).toBe(true);
-        expect(patterns.some((item) => item.location.includes('POST body'))).toBe(true);
-    });
-    it('detects token patterns across headers, URL params and fallback form data', () => {
-        const jwt = 'aaa.bbb.ccc';
-        const oauthToken = 'oauth_token_value_12345678901234567890';
-        const patterns = detectTokenPatterns([
-            request({
-                url: `https://vmoranv.github.io/jshookmcp/login?access_token=${oauthToken}`,
-                headers: { Authorization: `Bearer ${jwt}` },
-                postData: 'token=abc12345678901234567890',
-            }),
-        ], []);
-        expect(patterns.some((item) => item.type === 'JWT')).toBe(true);
-        expect(patterns.some((item) => item.type === 'OAuth')).toBe(true);
-        expect(patterns.some((item) => item.format.includes('POST body'))).toBe(true);
-    });
-    it('detects anti-debug traces and extracts key APIs/functions', () => {
-        const antiDebug = detectAntiDebugPatterns([
-            log({ text: 'debugger; Date.now(); console.log(x = 1); devtools check', url: 'x.js' }),
-        ]);
-        expect(antiDebug.map((item) => item.type)).toEqual([
-            'debugger',
-            'console.log',
-            'devtools-detect',
-            'timing-check',
-        ]);
-        const apis = extractSuspiciousAPIs([
-            request({ method: 'GET', url: 'https://vmoranv.github.io/jshookmcp/api/user' }),
-            request({ method: 'POST', url: 'https://vmoranv.github.io/jshookmcp/v1/login' }),
-            request({ method: 'GET', url: 'https://vmoranv.github.io/jshookmcp/api/user' }),
-        ]);
-        expect(apis).toEqual(['GET /jshookmcp/api/user', 'POST /jshookmcp/v1/login']);
-        const functions = extractKeyFunctions([
-            log({ text: 'signPayload(data); console.log("x"); verifyToken(token);' }),
-        ]);
-        expect(functions).toContain('signPayload');
-        expect(functions).toContain('verifyToken');
-        expect(functions).not.toContain('console');
-    });
-});

package/dist/tests/modules/analyzer/QualityAnalyzer.test.js

@@ -1,85 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import * as parser from '@babel/parser';
-const loggerState = vi.hoisted(() => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: loggerState,
-}));
-import { analyzeComplexityMetrics, calculateCodeSimilarity, calculateQualityScore, detectCodePatterns, detectDuplicateCode, } from '../../../src/modules/analyzer/QualityAnalyzer.js';
-describe('QualityAnalyzer helpers', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        Object.values(loggerState).forEach((fn) => fn.mockReset?.());
-    });
-    it('calculates weighted quality score with security/complexity penalties', () => {
-        const score = calculateQualityScore({ functions: [{ complexity: 12 }], classes: [], modules: [], callGraph: { nodes: [], edges: [] } }, [
-            { severity: 'critical' },
-            { severity: 'high' },
-        ], { qualityScore: 80 }, { cyclomaticComplexity: 15, cognitiveComplexity: 12, maintainabilityIndex: 60 }, [{ severity: 'high' }]);
-        expect(score).toBeGreaterThanOrEqual(0);
-        expect(score).toBeLessThan(80);
-    });
-    it('clamps quality score to valid range', () => {
-        const score = calculateQualityScore({ functions: [], classes: [], modules: [], callGraph: { nodes: [], edges: [] } }, Array.from({ length: 30 }, () => ({ severity: 'critical' })), { qualityScore: -50 }, { cyclomaticComplexity: 100, cognitiveComplexity: 100, maintainabilityIndex: -10 }, Array.from({ length: 20 }, () => ({ severity: 'high' })));
-        expect(score).toBeGreaterThanOrEqual(0);
-        expect(score).toBeLessThanOrEqual(100);
-    });
-    it('detects design patterns and anti-patterns from code', () => {
-        const code = `
-      class Subject {
-        subscribe() {}
-        unsubscribe() {}
-        notify() {}
-      }
-      var magic = 42;
-      try { throw new Error('x'); } catch (e) {}
-    `;
-        const result = detectCodePatterns(code);
-        expect(result.patterns.some((p) => p.name === 'Observer Pattern')).toBe(true);
-        expect(result.antiPatterns.some((p) => p.name === 'Use of var')).toBe(true);
-        expect(result.antiPatterns.some((p) => p.name === 'Magic Number')).toBe(true);
-        expect(result.antiPatterns.some((p) => p.name === 'Empty Catch Block')).toBe(true);
-    });
-    it('computes complexity and halstead metrics for nested code', () => {
-        const code = `
-      function x(a, b) {
-        if (a > 1 && b > 2) {
-          for (let i = 0; i < 3; i++) {
-            if (i % 2 === 0) return i + a;
-          }
-        }
-        return 0;
-      }
-    `;
-        const metrics = analyzeComplexityMetrics(code);
-        expect(metrics.cyclomaticComplexity).toBeGreaterThan(1);
-        expect(metrics.cognitiveComplexity).toBeGreaterThan(0);
-        expect(metrics.halsteadMetrics.vocabulary).toBeGreaterThan(0);
-    });
-    it('detects duplicate functions from AST', () => {
-        const code = `
-      function alpha(x){ return x + 1; }
-      function beta(y){ return y + 1; }
-    `;
-        const ast = parser.parse(code, { sourceType: 'module' });
-        const duplicates = detectDuplicateCode(ast);
-        expect(duplicates.length).toBeGreaterThan(0);
-        expect(duplicates[0].similarity).toBeGreaterThanOrEqual(0.85);
-    });
-    it('measures similarity and rejects drastically different lengths', () => {
-        const close = calculateCodeSimilarity('abc123', 'abc124');
-        const far = calculateCodeSimilarity('short', 'x'.repeat(200));
-        expect(close).toBeGreaterThan(0.7);
-        expect(far).toBe(0);
-    });
-    it('returns empty pattern sets for invalid source code', () => {
-        const result = detectCodePatterns('function broken( {');
-        expect(result.patterns).toEqual([]);
-        expect(result.antiPatterns).toEqual([]);
-        expect(loggerState.warn).toHaveBeenCalled();
-    });
-});