@jshookmcp/jshook 0.1.7 → 0.1.9

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

@@ -0,0 +1,133 @@
+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.d.ts

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

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

@@ -0,0 +1,125 @@
+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.d.ts

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

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

@@ -0,0 +1,177 @@
+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.d.ts

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

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

@@ -0,0 +1,149 @@
+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.d.ts

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