@jshookmcp/jshook 0.2.1 → 0.2.2

package/dist/tests/e2e/phases/browser-phases.js

@@ -1,59 +0,0 @@
-export const browserPhases = [
-    {
-        name: 'Browser Launch & Navigation',
-        setup: ['browser_launch', 'page_navigate'],
-        tools: ['browser_status', 'browser_list_tabs', 'browser_select_tab', 'page_get_performance'],
-    },
-    {
-        name: 'DOM & Page Interaction',
-        setup: [],
-        tools: [
-            'dom_query_selector', 'dom_query_all', 'dom_get_structure',
-            'dom_find_clickable', 'dom_find_by_text', 'dom_get_xpath',
-            'dom_is_in_viewport', 'dom_get_computed_style',
-            'page_click', 'page_type', 'page_hover', 'page_scroll',
-            'page_back', 'page_forward', 'page_reload',
-            'page_press_key', 'page_wait_for_selector',
-            'page_evaluate', 'page_inject_script',
-            'page_get_all_links', 'page_screenshot',
-            'page_set_viewport', 'page_emulate_device',
-        ],
-    },
-    {
-        name: 'Cookies & Storage',
-        setup: [],
-        tools: ['page_get_cookies', 'page_set_cookies', 'page_clear_cookies', 'page_get_local_storage', 'page_set_local_storage'],
-    },
-    { name: 'IndexedDB', setup: [], tools: ['indexeddb_dump'] },
-    {
-        name: 'Page Select (needs injected element)',
-        setup: async (call) => {
-            await call('page_evaluate', { code: `
-        if (!document.querySelector('#test_select_e2e')) {
-          const s = document.createElement('select');
-          s.id = 'test_select_e2e';
-          s.innerHTML = '<option value="a">A</option><option value="b">B</option>';
-          document.body.appendChild(s);
-        }
-        'ok'
-      ` });
-        },
-        tools: ['page_select'],
-    },
-    {
-        name: 'Stealth & Captcha',
-        setup: [],
-        tools: ['stealth_inject', 'stealth_set_user_agent', 'captcha_detect', 'captcha_config'],
-    },
-    { name: 'Camoufox', setup: [], tools: ['camoufox_server_status'] },
-    {
-        name: 'Human Behavior Simulation',
-        setup: [],
-        tools: ['human_mouse', 'human_scroll', 'human_typing'],
-    },
-    {
-        name: 'Captcha Advanced',
-        setup: [],
-        tools: ['captcha_vision_solve', 'widget_challenge_solve'],
-    },
-];

package/dist/tests/e2e/phases/debugger-phases.d.ts

@@ -1,2 +0,0 @@
-import type { Phase } from '../../e2e/helpers/types.js';
-export declare const debuggerPhases: Phase[];

package/dist/tests/e2e/phases/debugger-phases.js

@@ -1,44 +0,0 @@
-export const debuggerPhases = [
-    { name: 'Debugger Enable', setup: ['debugger_enable'], tools: [] },
-    {
-        name: 'Scripts & Source',
-        setup: [],
-        tools: ['get_all_scripts', 'get_script_source', 'get_detailed_data', 'collect_code', 'search_in_scripts'],
-    },
-    {
-        name: 'Breakpoints',
-        setup: [],
-        tools: ['breakpoint_set_on_exception', 'breakpoint_set', 'breakpoint_list', 'breakpoint_remove'],
-    },
-    {
-        name: 'XHR & Event Breakpoints',
-        setup: [],
-        tools: [
-            'xhr_breakpoint_set', 'xhr_breakpoint_list', 'xhr_breakpoint_remove',
-            'event_breakpoint_set', 'event_breakpoint_set_category',
-            'event_breakpoint_list', 'event_breakpoint_remove',
-        ],
-    },
-    {
-        name: 'Watch Expressions',
-        setup: [],
-        tools: ['watch_add', 'watch_list', 'watch_evaluate_all', 'watch_remove', 'watch_clear_all'],
-    },
-    { name: 'Blackbox', setup: [], tools: ['blackbox_add', 'blackbox_add_common', 'blackbox_list'] },
-    {
-        name: 'Debugger Execution (pause/eval/resume)',
-        setup: [],
-        tools: [
-            'debugger_evaluate_global', 'debugger_pause', 'debugger_wait_for_paused',
-            'debugger_get_paused_state', 'debugger_evaluate',
-            'get_call_stack', 'get_scope_variables_enhanced', 'get_object_properties',
-            'debugger_step_over', 'debugger_step_into', 'debugger_step_out',
-            'debugger_resume',
-        ],
-    },
-    {
-        name: 'Debugger Session',
-        setup: [],
-        tools: ['debugger_save_session', 'debugger_list_sessions', 'debugger_export_session'],
-    },
-];

package/dist/tests/e2e/phases/index.d.ts

@@ -1,2 +0,0 @@
-import type { Phase } from '../../e2e/helpers/types.js';
-export declare const ALL_PHASES: Phase[];

package/dist/tests/e2e/phases/index.js

@@ -1,15 +0,0 @@
-import { maintenancePhases, cleanupPhases } from '../../e2e/phases/maintenance-phases.js';
-import { browserPhases } from '../../e2e/phases/browser-phases.js';
-import { debuggerPhases } from '../../e2e/phases/debugger-phases.js';
-import { monitorPhases } from '../../e2e/phases/monitor-phases.js';
-import { analysisPhases } from '../../e2e/phases/analysis-phases.js';
-import { systemPhases } from '../../e2e/phases/system-phases.js';
-export const ALL_PHASES = [
-    ...maintenancePhases,
-    ...browserPhases,
-    ...debuggerPhases,
-    ...monitorPhases,
-    ...analysisPhases,
-    ...systemPhases,
-    ...cleanupPhases,
-];

package/dist/tests/e2e/phases/maintenance-phases.d.ts

@@ -1,3 +0,0 @@
-import type { Phase } from '../../e2e/helpers/types.js';
-export declare const maintenancePhases: Phase[];
-export declare const cleanupPhases: Phase[];

package/dist/tests/e2e/phases/maintenance-phases.js

@@ -1,19 +0,0 @@
-export const maintenancePhases = [
-    {
-        name: 'Maintenance & Cache',
-        setup: [],
-        tools: [
-            'get_token_budget_stats', 'manual_token_cleanup', 'reset_token_budget',
-            'get_cache_stats', 'smart_cache_cleanup', 'cleanup_artifacts', 'doctor_environment',
-            'boost_profile', 'unboost_profile',
-            'list_extensions', 'reload_extensions', 'browse_extension_registry',
-        ],
-    },
-];
-export const cleanupPhases = [
-    {
-        name: 'Data Cleanup',
-        setup: [],
-        tools: ['clear_collected_data', 'clear_all_caches', 'get_collection_stats', 'browser_close'],
-    },
-];

package/dist/tests/e2e/phases/monitor-phases.d.ts

@@ -1,2 +0,0 @@
-import type { Phase } from '../../e2e/helpers/types.js';
-export declare const monitorPhases: Phase[];

package/dist/tests/e2e/phases/monitor-phases.js

@@ -1,52 +0,0 @@
-export const monitorPhases = [
-    {
-        name: 'Console Monitor',
-        setup: ['console_enable'],
-        tools: [
-            'console_get_logs', 'console_execute', 'console_get_exceptions',
-            'console_inject_script_monitor', 'console_inject_function_tracer',
-            'console_clear_injected_buffers', 'console_reset_injected_interceptors',
-        ],
-    },
-    { name: 'Framework & Extension', setup: [], tools: ['framework_state_extract', 'extension_list_installed'] },
-    {
-        name: 'Network Monitor',
-        setup: ['network_enable'],
-        tools: [
-            'network_get_status', 'network_get_requests', 'network_get_stats',
-            'network_extract_auth', 'network_get_response_body', 'network_replay_request',
-            'console_inject_fetch_interceptor', 'console_inject_xhr_interceptor',
-        ],
-    },
-    {
-        name: 'Streaming (WS/SSE)',
-        setup: [],
-        tools: ['ws_monitor_enable', 'ws_get_frames', 'ws_get_connections', 'sse_monitor_enable', 'sse_get_events', 'ws_monitor_disable'],
-    },
-    {
-        name: 'Performance Start',
-        setup: [],
-        tools: ['performance_get_metrics', 'performance_start_coverage', 'profiler_heap_sampling_start', 'performance_trace_start'],
-    },
-    { name: 'JS Heap', setup: [], tools: ['js_heap_search'] },
-    {
-        name: 'Performance Stop',
-        setup: [],
-        tools: ['performance_stop_coverage', 'performance_take_heap_snapshot'],
-    },
-    {
-        name: 'CPU Profiler (after coverage)',
-        setup: async (call) => {
-            await call('profiler_cpu_start', {});
-            await new Promise((r) => setTimeout(r, 300));
-        },
-        tools: ['profiler_cpu_stop'],
-    },
-    {
-        name: 'Remaining Profiler Stops',
-        setup: [],
-        tools: ['profiler_heap_sampling_stop', 'performance_trace_stop'],
-    },
-    { name: 'Network Teardown', setup: [], tools: ['network_export_har', 'network_disable'] },
-    { name: 'Debugger Teardown', setup: [], tools: ['debugger_disable'] },
-];

package/dist/tests/e2e/phases/system-phases.d.ts

@@ -1,2 +0,0 @@
-import type { Phase } from '../../e2e/helpers/types.js';
-export declare const systemPhases: Phase[];

package/dist/tests/e2e/phases/system-phases.js

@@ -1,47 +0,0 @@
-export const systemPhases = [
-    {
-        name: 'Antidebug',
-        setup: [],
-        tools: [
-            'antidebug_detect_protections', 'antidebug_bypass_all',
-            'antidebug_bypass_debugger_statement', 'antidebug_bypass_console_detect',
-            'antidebug_bypass_stack_trace', 'antidebug_bypass_timing',
-        ],
-    },
-    {
-        name: 'Sourcemap',
-        setup: [],
-        tools: ['sourcemap_discover', 'source_map_extract', 'sourcemap_fetch_and_parse', 'sourcemap_reconstruct_tree'],
-    },
-    {
-        name: 'Workflow',
-        setup: [],
-        tools: [
-            'page_script_register', 'page_script_run',
-            'js_bundle_search', 'webpack_enumerate',
-            'web_api_capture_session', 'api_probe_batch',
-            'tab_workflow', 'script_replace_persist',
-        ],
-    },
-    {
-        name: 'Process',
-        setup: [],
-        tools: ['process_list', 'process_get', 'process_windows', 'process_find', 'process_find_chromium', 'process_check_debug_port', 'process_launch_debug'],
-    },
-    {
-        name: 'Memory (read-only)',
-        setup: [],
-        tools: ['memory_list_regions', 'memory_dump_region', 'memory_read', 'memory_scan', 'memory_scan_filtered', 'memory_check_protection', 'enumerate_modules', 'memory_audit_export'],
-    },
-    {
-        name: 'WASM',
-        setup: [],
-        tools: ['wasm_dump', 'wasm_inspect_sections', 'wasm_decompile', 'wasm_disassemble', 'wasm_optimize', 'wasm_memory_inspect', 'wasm_vmp_trace'],
-    },
-    { name: 'Platform', setup: [], tools: ['asar_extract'] },
-    {
-        name: 'Extension Workflows',
-        setup: [],
-        tools: ['batch_register', 'list_extension_workflows', 'run_extension_workflow'],
-    },
-];

package/dist/tests/e2e/skip-list.d.ts

@@ -1,6 +0,0 @@
-export interface SkipListConfig {
-    electronPath: string;
-    miniappPath: string;
-    asarPath: string;
-}
-export declare function buildSkipSet(config: SkipListConfig): Set<string>;

package/dist/tests/e2e/skip-list.js

@@ -1,19 +0,0 @@
-export function buildSkipSet(config) {
-    return new Set([
-        'captcha_wait', 'register_account_flow',
-        'inject_dll', 'module_inject_dll', 'inject_shellcode', 'module_inject_shellcode',
-        'memory_write', 'memory_batch_write', 'memory_protect',
-        'process_kill',
-        'frida_bridge', 'jadx_bridge',
-        'camoufox_server_launch', 'camoufox_server_close',
-        'browser_attach', 'extension_execute_in_context', 'wasm_offline_run',
-        'module_list', 'check_debug_port',
-        'debugger_load_session',
-        'install_extension',
-        'captcha_vision_solve', 'widget_challenge_solve',
-        'run_extension_workflow',
-        ...(!config.electronPath ? ['electron_attach', 'electron_inspect_app'] : []),
-        ...(!config.miniappPath ? ['miniapp_pkg_analyze', 'miniapp_pkg_scan', 'miniapp_pkg_unpack'] : []),
-        ...(!config.asarPath ? ['asar_extract'] : []),
-    ]);
-}

package/dist/tests/errors/PrerequisiteError.test.js

@@ -1,19 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ToolError } from '../../src/errors/ToolError.js';
-import { PrerequisiteError } from '../../src/errors/PrerequisiteError.js';
-describe('PrerequisiteError', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('extends ToolError with the PREREQUISITE code and preserved message', () => {
-        const error = new PrerequisiteError('debugger must be enabled first');
-        expect(error).toBeInstanceOf(PrerequisiteError);
-        expect(error).toBeInstanceOf(ToolError);
-        expect(error).toBeInstanceOf(Error);
-        expect(error.name).toBe('PrerequisiteError');
-        expect(error.message).toBe('debugger must be enabled first');
-        expect(error.code).toBe('PREREQUISITE');
-        expect(error.toolName).toBeUndefined();
-        expect(error.details).toBeUndefined();
-    });
-});

package/dist/tests/errors/ToolError.test.js

@@ -1,30 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ToolError, USER_CORRECTABLE_CODES } from '../../src/errors/ToolError.js';
-describe('ToolError', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('captures code, message, tool metadata, and cause', () => {
-        const cause = new Error('root-cause');
-        const error = new ToolError('RUNTIME', 'tool failed', {
-            toolName: 'page_evaluate',
-            details: { url: 'https://example.com' },
-            cause,
-        });
-        expect(error).toBeInstanceOf(ToolError);
-        expect(error).toBeInstanceOf(Error);
-        expect(error.name).toBe('ToolError');
-        expect(error.message).toBe('tool failed');
-        expect(error.code).toBe('RUNTIME');
-        expect(error.toolName).toBe('page_evaluate');
-        expect(error.details).toEqual({ url: 'https://example.com' });
-        expect(error.cause).toBe(cause);
-    });
-    it('tracks user-correctable error codes separately from fatal ones', () => {
-        expect(USER_CORRECTABLE_CODES.has('PREREQUISITE')).toBe(true);
-        expect(USER_CORRECTABLE_CODES.has('VALIDATION')).toBe(true);
-        expect(USER_CORRECTABLE_CODES.has('NOT_FOUND')).toBe(true);
-        expect(USER_CORRECTABLE_CODES.has('TIMEOUT')).toBe(false);
-        expect(USER_CORRECTABLE_CODES.has('RUNTIME')).toBe(false);
-    });
-});

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);
-    });
-});