@jshookmcp/jshook 0.2.3 → 0.2.6

package/dist/packages/extension-sdk/src/workflow.js

@@ -0,0 +1,272 @@
+export class WorkflowNodeBuilder {
+    id;
+    constructor(id) {
+        this.id = id;
+    }
+}
+export class ToolNodeBuilder extends WorkflowNodeBuilder {
+    toolName;
+    _input;
+    _retry;
+    _timeoutMs;
+    constructor(id, toolName) {
+        super(id);
+        this.toolName = toolName;
+    }
+    input(input) {
+        this._input = input;
+        return this;
+    }
+    retry(policy) {
+        this._retry = policy;
+        return this;
+    }
+    timeout(ms) {
+        this._timeoutMs = ms;
+        return this;
+    }
+    build() {
+        return {
+            kind: 'tool',
+            id: this.id,
+            toolName: this.toolName,
+            input: this._input,
+            retry: this._retry,
+            timeoutMs: this._timeoutMs,
+        };
+    }
+}
+class CompositeNodeBuilder extends WorkflowNodeBuilder {
+    _steps = [];
+    step(nodeBuilder) {
+        this._steps.push(nodeBuilder);
+        return this;
+    }
+    tool(id, toolName, config) {
+        const builder = new ToolNodeBuilder(id, toolName);
+        if (config) {
+            if (typeof config === 'function') {
+                config(builder);
+            }
+            else {
+                if (config.input)
+                    builder.input(config.input);
+                if (config.retry)
+                    builder.retry(config.retry);
+                if (config.timeoutMs !== undefined)
+                    builder.timeout(config.timeoutMs);
+            }
+        }
+        this._steps.push(builder);
+        return this;
+    }
+    sequence(id, config) {
+        const builder = new SequenceNodeBuilder(id);
+        if (config)
+            config(builder);
+        this._steps.push(builder);
+        return this;
+    }
+    parallel(id, config) {
+        const builder = new ParallelNodeBuilder(id);
+        if (config)
+            config(builder);
+        this._steps.push(builder);
+        return this;
+    }
+    branch(id, predicateId, config) {
+        const builder = new BranchNodeBuilder(id, predicateId);
+        if (config)
+            config(builder);
+        this._steps.push(builder);
+        return this;
+    }
+    fallback(id, config) {
+        const builder = new FallbackNodeBuilder(id);
+        if (config)
+            config(builder);
+        this._steps.push(builder);
+        return this;
+    }
+}
+export class SequenceNodeBuilder extends CompositeNodeBuilder {
+    build() {
+        return {
+            kind: 'sequence',
+            id: this.id,
+            steps: this._steps.map((b) => b.build()),
+        };
+    }
+}
+export class ParallelNodeBuilder extends CompositeNodeBuilder {
+    _maxConcurrency = 4;
+    _failFast = false;
+    maxConcurrency(concurrency) {
+        this._maxConcurrency = concurrency;
+        return this;
+    }
+    failFast(ff) {
+        this._failFast = ff;
+        return this;
+    }
+    build() {
+        return {
+            kind: 'parallel',
+            id: this.id,
+            steps: this._steps.map((b) => b.build()),
+            maxConcurrency: this._maxConcurrency,
+            failFast: this._failFast,
+        };
+    }
+}
+export class BranchNodeBuilder extends WorkflowNodeBuilder {
+    predicateId;
+    _predicateFn;
+    _whenTrue;
+    _whenFalse;
+    constructor(id, predicateId) {
+        super(id);
+        this.predicateId = predicateId;
+    }
+    predicateFn(fn) {
+        this._predicateFn = fn;
+        return this;
+    }
+    whenTrue(nodeBuilder) {
+        this._whenTrue = nodeBuilder;
+        return this;
+    }
+    whenFalse(nodeBuilder) {
+        this._whenFalse = nodeBuilder;
+        return this;
+    }
+    build() {
+        if (!this._whenTrue) {
+            throw new Error(`BranchNode '${this.id}' requires a whenTrue step`);
+        }
+        return {
+            kind: 'branch',
+            id: this.id,
+            predicateId: this.predicateId,
+            predicateFn: this._predicateFn,
+            whenTrue: this._whenTrue.build(),
+            whenFalse: this._whenFalse ? this._whenFalse.build() : undefined,
+        };
+    }
+}
+export class FallbackNodeBuilder extends WorkflowNodeBuilder {
+    _primary;
+    _fallback;
+    primary(nodeBuilder) {
+        this._primary = nodeBuilder;
+        return this;
+    }
+    fallback(nodeBuilder) {
+        this._fallback = nodeBuilder;
+        return this;
+    }
+    build() {
+        if (!this._primary) {
+            throw new Error(`FallbackNode '${this.id}' requires a primary step`);
+        }
+        if (!this._fallback) {
+            throw new Error(`FallbackNode '${this.id}' requires a fallback step`);
+        }
+        return {
+            kind: 'fallback',
+            id: this.id,
+            primary: this._primary.build(),
+            fallback: this._fallback.build(),
+        };
+    }
+}
+export class WorkflowBuilder {
+    _id;
+    _displayName;
+    _description;
+    _tags;
+    _timeoutMs;
+    _defaultMaxConcurrency;
+    _route;
+    _buildFn;
+    _onStart;
+    _onFinish;
+    _onError;
+    constructor(id, displayName) {
+        this._id = id;
+        this._displayName = displayName;
+    }
+    description(desc) {
+        this._description = desc;
+        return this;
+    }
+    tags(tags) {
+        this._tags = tags;
+        return this;
+    }
+    timeoutMs(timeout) {
+        this._timeoutMs = timeout;
+        return this;
+    }
+    defaultMaxConcurrency(max) {
+        this._defaultMaxConcurrency = max;
+        return this;
+    }
+    route(route) {
+        this._route = route;
+        return this;
+    }
+    buildGraph(fn) {
+        this._buildFn = (ctx) => fn(ctx).build();
+        return this;
+    }
+    onStart(fn) {
+        this._onStart = fn;
+        return this;
+    }
+    onFinish(fn) {
+        this._onFinish = fn;
+        return this;
+    }
+    onError(fn) {
+        this._onError = fn;
+        return this;
+    }
+    build() {
+        if (!this._buildFn)
+            throw new Error(`WorkflowBuilder '${this._id}' needs a buildGraph() function.`);
+        return {
+            kind: 'workflow-contract',
+            version: 1,
+            id: this._id,
+            displayName: this._displayName,
+            description: this._description,
+            tags: this._tags,
+            timeoutMs: this._timeoutMs,
+            defaultMaxConcurrency: this._defaultMaxConcurrency,
+            route: this._route,
+            build: this._buildFn,
+            onStart: this._onStart,
+            onFinish: this._onFinish,
+            onError: this._onError,
+        };
+    }
+}
+export function createWorkflow(id, displayName) {
+    return new WorkflowBuilder(id, displayName);
+}
+export function toolNode(id, toolName) {
+    return new ToolNodeBuilder(id, toolName);
+}
+export function sequenceNode(id) {
+    return new SequenceNodeBuilder(id);
+}
+export function parallelNode(id) {
+    return new ParallelNodeBuilder(id);
+}
+export function branchNode(id, predicateId) {
+    return new BranchNodeBuilder(id, predicateId);
+}
+export function fallbackNode(id) {
+    return new FallbackNodeBuilder(id);
+}

package/dist/src/config/search-defaults.js

@@ -58,6 +58,14 @@ export const DEFAULT_QUERY_CATEGORY_PROFILE_CONFIGS = [
             { domain: 'browser', weight: 1.1 },
         ],
     },
+    {
+        pattern: '(?:reverse|mission|signature|hook|crypto|encrypt|websocket|\\bws\\b|protocol|bundle|webpack|deobfusc|stealth|fingerprint|evidence|\\bhar\\b|逆向|签名|加签|协议|反混淆|反检测|指纹|证据|报告)',
+        flags: 'i',
+        domainBoosts: [
+            { domain: 'workflow', weight: 1.8 },
+            { domain: 'analysis', weight: 1.1 },
+        ],
+    },
 ];
 export const DEFAULT_CJK_QUERY_ALIAS_CONFIGS = [
     { pattern: '工作流|流程编排|流程自动化|编排', tokens: ['workflow', 'flow', 'orchestration'] },
@@ -74,6 +82,14 @@ export const DEFAULT_CJK_QUERY_ALIAS_CONFIGS = [
     { pattern: '批量|并发', tokens: ['batch', 'parallel'] },
     { pattern: '令牌|凭证|鉴权|认证', tokens: ['token', 'auth', 'credential'] },
     { pattern: '提取|抽取|解析', tokens: ['extract', 'parse'] },
+    { pattern: '签名|加签|加密|hook', tokens: ['signature', 'crypto', 'hook', 'sign'] },
+    { pattern: '协议|消息|帧|handler', tokens: ['websocket', 'protocol', 'ws', 'handler'] },
+    { pattern: '打包|webpack|混淆|反混淆', tokens: ['bundle', 'webpack', 'deobfuscate', 'unpack'] },
+    {
+        pattern: '反爬|反检测|指纹|stealth',
+        tokens: ['antibot', 'stealth', 'fingerprint', 'detection'],
+    },
+    { pattern: '证据|取证|导出|报告|快照', tokens: ['evidence', 'export', 'report', 'forensic'] },
     { pattern: '多标签页|多标签|标签页', tokens: ['tab', 'multi'] },
     { pattern: '脚本库|脚本仓库', tokens: ['script', 'library'] },
     { pattern: '脚本', tokens: ['script'] },
@@ -81,6 +97,19 @@ export const DEFAULT_CJK_QUERY_ALIAS_CONFIGS = [
     { pattern: '导出', tokens: ['export'] },
     { pattern: '回放|重放', tokens: ['replay'] },
     { pattern: '请求', tokens: ['request'] },
+    { pattern: '鉴权面|认证面|授权面|凭证枚举', tokens: ['auth', 'surface', 'token', 'credential'] },
+    { pattern: '通道|通信|协议注册|协议枚举', tokens: ['protocol', 'channel', 'registry'] },
+    { pattern: '人机|挑战|风控|拦截页', tokens: ['challenge', 'captcha', 'cloudflare', 'turnstile'] },
+    {
+        pattern: '签名谱系|签名链路|加签链路|签名追踪',
+        tokens: ['signing', 'lineage', 'signature', 'trace'],
+    },
+    { pattern: '复现|重发|篡改|参数篡改', tokens: ['replay', 'tamper', 'request'] },
+    {
+        pattern: '反混淆链|反混淆管道|清洗|还原',
+        tokens: ['deobfuscate', 'pipeline', 'transform', 'ast'],
+    },
+    { pattern: '桌面应用|electron|nwjs|预加载', tokens: ['electron', 'bridge', 'preload', 'ipc'] },
 ];
 export const DEFAULT_INTENT_TOOL_BOOST_RULE_CONFIGS = [
     {
@@ -139,6 +168,138 @@ export const DEFAULT_INTENT_TOOL_BOOST_RULE_CONFIGS = [
             { tool: 'network_extract_auth', bonus: 18 },
         ],
     },
+    {
+        pattern: '(?:signature|crypto|encrypt|hash|hook|签名|加签|加密)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'search_in_scripts', bonus: 12 },
+            { tool: 'detect_crypto', bonus: 10 },
+            { tool: 'manage_hooks', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:websocket|\\bws\\b|protocol|socket|handler|协议|消息|帧)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'ws_monitor_enable', bonus: 12 },
+            { tool: 'ws_get_frames', bonus: 10 },
+            { tool: 'ws_get_connections', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:bundle|webpack|chunk|source.*map|deobfusc|源码|打包|混淆|反混淆)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'js_bundle_search', bonus: 14 },
+            { tool: 'collect_code', bonus: 10 },
+            { tool: 'source_map_extract', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:stealth|fingerprint|webdriver|antibot|bot.*detect|反爬|反检测|指纹)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'stealth_inject', bonus: 10 },
+            { tool: 'stealth_generate_fingerprint', bonus: 10 },
+            { tool: 'stealth_verify', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:evidence|export|har|report|snapshot|证据|导出|报告|快照|取证)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'evidence_query_url', bonus: 14 },
+            { tool: 'evidence_export_markdown', bonus: 12 },
+            { tool: 'evidence_export_json', bonus: 10 },
+        ],
+    },
+    {
+        pattern: '(?:auth.*surface|token.*enum|credential.*map|鉴权面|认证面|凭证枚举|jwt|csrf|api.?key|授权)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'network_extract_auth', bonus: 14 },
+            { tool: 'page_get_cookies', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:protocol.*registry|channel.*enum|通道枚举|协议注册|协议归类|SSE|EventSource|beacon|postMessage)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'ws_monitor_enable', bonus: 10 },
+            { tool: 'sse_monitor_enable', bonus: 10 },
+            { tool: 'network_get_requests', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:challenge|turnstile|cloudflare|hcaptcha|datadome|akamai|perimeterx|kasada|人机|挑战|风控|拦截页)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'captcha_detect', bonus: 14 },
+            { tool: 'stealth_verify', bonus: 10 },
+        ],
+    },
+    {
+        pattern: '(?:signing.*lineage|签名谱系|签名链路|加签链路|签名追踪|plaintext.*cipher|明文.*密文)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'detect_crypto', bonus: 12 },
+            { tool: 'extract_function_tree', bonus: 10 },
+            { tool: 'manage_hooks', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:replay.*lab|request.*replay|复现|重发|篡改|参数篡改|request.*tamper)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'network_replay_request', bonus: 14 },
+            { tool: 'instrumentation_network_replay', bonus: 12 },
+            { tool: 'network_export_har', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:deobfusc.*pipeline|反混淆链|反混淆管道|清洗|还原|ast.*transform|packer|unpack)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'webcrack_unpack', bonus: 14 },
+            { tool: 'ast_transform_apply', bonus: 12 },
+            { tool: 'deobfuscate', bonus: 10 },
+            { tool: 'detect_obfuscation', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:electron|nwjs|preload|ipc|asar|桌面应用|预加载|桥接|electron.*bridge)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'electron_inspect_app', bonus: 14 },
+            { tool: 'electron_ipc_sniff', bonus: 12 },
+            { tool: 'asar_search', bonus: 10 },
+            { tool: 'electron_check_fuses', bonus: 8 },
+        ],
+    },
 ];
 export const DEFAULT_SEARCH_CONFIG = {
     queryCategoryProfiles: DEFAULT_QUERY_CATEGORY_PROFILE_CONFIGS,

package/dist/src/constants.d.ts

@@ -1,3 +1,6 @@
+export declare const SHUTDOWN_TIMEOUT_MS: number;
+export declare const RUNTIME_ERROR_WINDOW_MS: number;
+export declare const RUNTIME_ERROR_THRESHOLD: number;
 export declare const DEBUG_PORT_CANDIDATES: number[];
 export declare const DEFAULT_DEBUG_PORT: number;
 export declare const GHIDRA_BRIDGE_ENDPOINT: string;

package/dist/src/constants.js

@@ -40,6 +40,9 @@ const csv = (key, fallback) => {
         .filter(Boolean);
     return parsed.length > 0 ? parsed : fallback;
 };
+export const SHUTDOWN_TIMEOUT_MS = int('SHUTDOWN_TIMEOUT_MS', 10_000);
+export const RUNTIME_ERROR_WINDOW_MS = int('RUNTIME_ERROR_WINDOW_MS', 60_000);
+export const RUNTIME_ERROR_THRESHOLD = int('RUNTIME_ERROR_THRESHOLD', 5);
 export const DEBUG_PORT_CANDIDATES = list('DEBUG_PORT_CANDIDATES', [9222, 9229, 9333, 2039]);
 export const DEFAULT_DEBUG_PORT = int('DEFAULT_DEBUG_PORT', 9222);
 export const GHIDRA_BRIDGE_ENDPOINT = str('GHIDRA_BRIDGE_URL', 'http://127.0.0.1:18080');
@@ -146,7 +149,7 @@ export const PARALLEL_DEFAULT_TIMEOUT_MS = int('PARALLEL_DEFAULT_TIMEOUT_MS', 60
 export const PARALLEL_DEFAULT_MAX_RETRIES = int('PARALLEL_DEFAULT_MAX_RETRIES', 2);
 export const PARALLEL_RETRY_BACKOFF_BASE_MS = int('PARALLEL_RETRY_BACKOFF_BASE_MS', 1_000);
 export const CACHE_GLOBAL_MAX_SIZE_BYTES = int('CACHE_GLOBAL_MAX_SIZE_BYTES', 500 * 1024 * 1024);
-export const CACHE_LOW_HIT_RATE_THRESHOLD = parseFloat(process.env.CACHE_LOW_HIT_RATE_THRESHOLD || '0.3');
+export const CACHE_LOW_HIT_RATE_THRESHOLD = float('CACHE_LOW_HIT_RATE_THRESHOLD', 0.3);
 export const TOKEN_BUDGET_MAX_TOKENS = int('TOKEN_BUDGET_MAX_TOKENS', 200_000);
 export const DETAILED_DATA_DEFAULT_TTL_MS = int('DETAILED_DATA_DEFAULT_TTL_MS', 30 * 60 * 1000);
 export const DETAILED_DATA_MAX_TTL_MS = int('DETAILED_DATA_MAX_TTL_MS', 60 * 60 * 1000);

package/dist/src/index.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+export declare function main(): Promise<void>;

package/dist/src/index.js

@@ -5,7 +5,7 @@ import { logger } from './utils/logger.js';
 import { initRegistry } from './server/registry/index.js';
 import { resolveCliFastPath } from './utils/cliFastPath.js';
 import { cleanupArtifacts, getArtifactRetentionConfig, startArtifactRetentionScheduler, } from './utils/artifactRetention.js';
-const SHUTDOWN_TIMEOUT_MS = 10_000;
+import { SHUTDOWN_TIMEOUT_MS, RUNTIME_ERROR_WINDOW_MS, RUNTIME_ERROR_THRESHOLD, } from './constants.js';
 const FATAL_ERROR_CODES = new Set([
     'ERR_WORKER_OUT_OF_MEMORY',
     'ERR_MEMORY_ALLOCATION_FAILED',
@@ -41,8 +41,16 @@ function formatUnknownError(input) {
         return String(input);
     }
 }
-async function main() {
+export async function main() {
     try {
+        const cliFastPath = resolveCliFastPath(process.argv.slice(2), import.meta.url);
+        if (cliFastPath.handled) {
+            if (cliFastPath.output) {
+                process.stdout.write(cliFastPath.output);
+            }
+            process.exit(cliFastPath.exitCode);
+            return;
+        }
         const config = getConfig();
         logger.debug('Configuration loaded:', config);
         const validation = validateConfig(config);
@@ -50,12 +58,7 @@ async function main() {
             logger.error('Configuration validation failed:');
             validation.errors.forEach((error) => logger.error(`  - ${error}`));
             process.exit(1);
-        }
-        if (config.llm.provider === 'openai' && !config.llm.openai?.apiKey) {
-            logger.warn('OPENAI_API_KEY is not configured. AI-assisted tools may return configuration errors.');
-        }
-        if (config.llm.provider === 'anthropic' && !config.llm.anthropic?.apiKey) {
-            logger.warn('ANTHROPIC_API_KEY is not configured. AI-assisted tools may return configuration errors.');
+            return;
         }
         const artifactRetention = getArtifactRetentionConfig();
         if (artifactRetention.cleanupOnStart && artifactRetention.enabled) {
@@ -68,8 +71,8 @@ async function main() {
         await initRegistry();
         const server = new MCPServer(config);
         const stopArtifactRetentionScheduler = startArtifactRetentionScheduler();
-        const recoveryWindowMs = Math.max(1000, parseInt(process.env.RUNTIME_ERROR_WINDOW_MS ?? '60000', 10));
-        const maxRecoverableErrors = Math.max(1, parseInt(process.env.RUNTIME_ERROR_THRESHOLD ?? '5', 10));
+        const recoveryWindowMs = Math.max(1000, RUNTIME_ERROR_WINDOW_MS);
+        const maxRecoverableErrors = Math.max(1, RUNTIME_ERROR_THRESHOLD);
         const runtimeRecovery = {
             windowStart: Date.now(),
             errorCount: 0,
@@ -175,11 +178,4 @@ async function main() {
         process.exit(1);
     }
 }
-const cliFastPath = resolveCliFastPath(process.argv.slice(2), import.meta.url);
-if (cliFastPath.handled) {
-    if (cliFastPath.output) {
-        process.stdout.write(cliFastPath.output);
-    }
-    process.exit(cliFastPath.exitCode);
-}
 void main();

package/dist/src/modules/analyzer/CodeAnalyzer.d.ts

@@ -1,8 +1,6 @@
 import type { UnderstandCodeOptions, UnderstandCodeResult } from '../../types/index.js';
-import { type LLMService } from '../../services/LLMService.js';
 export declare class CodeAnalyzer {
-    private llm;
-    constructor(llm: LLMService);
+    constructor(legacyDependency?: unknown);
     understand(options: UnderstandCodeOptions): Promise<UnderstandCodeResult>;
     private analyzeStructure;
     private aiAnalyze;

package/dist/src/modules/analyzer/CodeAnalyzer.js

@@ -1,7 +1,5 @@
 import * as parser from '@babel/parser';
 import traverse from '@babel/traverse';
-import {} from '../../services/LLMService.js';
-import { generateCodeAnalysisPrompt } from '../../services/prompts/analysis.js';
 import { logger } from '../../utils/logger.js';
 import { identifySecurityRisks } from '../analyzer/SecurityCodeAnalyzer.js';
 import { calculateQualityScore, detectCodePatterns, analyzeComplexityMetrics, } from '../analyzer/QualityAnalyzer.js';
@@ -11,9 +9,8 @@ const isTraversablePath = (value) => typeof value === 'object' &&
     'traverse' in value &&
     typeof value.traverse === 'function';
 export class CodeAnalyzer {
-    llm;
-    constructor(llm) {
-        this.llm = llm;
+    constructor(legacyDependency) {
+        void legacyDependency;
     }
     async understand(options) {
         logger.info('Starting code understanding...');
@@ -64,9 +61,8 @@ export class CodeAnalyzer {
                 sourceType: 'module',
                 plugins: ['jsx', 'typescript'],
             });
-            const self = this;
             traverse(ast, {
-                FunctionDeclaration(path) {
+                FunctionDeclaration: (path) => {
                     const node = path.node;
                     functions.push({
                         name: node.id?.name || 'anonymous',
@@ -76,10 +72,10 @@ export class CodeAnalyzer {
                             line: node.loc?.start.line || 0,
                             column: node.loc?.start.column,
                         },
-                        complexity: self.calculateComplexity(path),
+                        complexity: this.calculateComplexity(path),
                     });
                 },
-                FunctionExpression(path) {
+                FunctionExpression: (path) => {
                     const node = path.node;
                     const parent = path.parent;
                     let name = 'anonymous';
@@ -91,16 +87,20 @@ export class CodeAnalyzer {
                     }
                     functions.push({
                         name,
-                        params: node.params.map((p) => (p.type === 'Identifier' ? p.name : 'unknown')),
+                        params: node.params.map((p) => {
+                            if (p.type !== 'Identifier')
+                                return 'unknown';
+                            return p.name;
+                        }),
                         location: {
                             file: 'current',
                             line: node.loc?.start.line || 0,
                             column: node.loc?.start.column,
                         },
-                        complexity: self.calculateComplexity(path),
+                        complexity: this.calculateComplexity(path),
                     });
                 },
-                ArrowFunctionExpression(path) {
+                ArrowFunctionExpression: (path) => {
                     const node = path.node;
                     const parent = path.parent;
                     let name = 'arrow';
@@ -115,7 +115,7 @@ export class CodeAnalyzer {
                             line: node.loc?.start.line || 0,
                             column: node.loc?.start.column,
                         },
-                        complexity: self.calculateComplexity(path),
+                        complexity: this.calculateComplexity(path),
                     });
                 },
                 ClassDeclaration(path) {
@@ -172,20 +172,8 @@ export class CodeAnalyzer {
             callGraph,
         };
     }
-    async aiAnalyze(code, focus) {
-        try {
-            const messages = generateCodeAnalysisPrompt(code, focus);
-            const response = await this.llm.chat(messages, { temperature: 0.3, maxTokens: 2000 });
-            const jsonMatch = response.content.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-                return JSON.parse(jsonMatch[0]);
-            }
-            return { rawAnalysis: response.content };
-        }
-        catch (error) {
-            logger.warn('AI analysis failed, using fallback', error);
-            return {};
-        }
+    async aiAnalyze(_code, _focus) {
+        return {};
     }
     detectTechStack(code, aiAnalysis) {
         const techStack = {
@@ -363,6 +351,6 @@ export class CodeAnalyzer {
         return complexity;
     }
     async analyzeDataFlow(code) {
-        return analyzeDataFlowWithTaint(code, this.llm);
+        return analyzeDataFlowWithTaint(code);
     }
 }

package/dist/src/modules/analyzer/CodeAnalyzerDataFlow.d.ts

@@ -1,3 +1,2 @@
 import type { DataFlow } from '../../types/index.js';
-import type { LLMService } from '../../services/LLMService.js';
-export declare function analyzeDataFlowWithTaint(code: string, llm?: LLMService): Promise<DataFlow>;
+export declare function analyzeDataFlowWithTaint(code: string): Promise<DataFlow>;