@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/services/prompts/deobfuscation.js

@@ -1,300 +0,0 @@
-export function generateCodeCleanupMessages(code, techniques) {
-    const codeSnippet = code.length > 2000 ? code.slice(0, 2000) + '\n...(truncated)' : code;
-    const systemPrompt = `# Role
-You are an expert JavaScript code reviewer and refactoring specialist with expertise in:
-- Code readability and maintainability improvement
-- Semantic variable naming based on usage context
-- Code smell detection and refactoring
-- JavaScript best practices (ES6+, clean code principles)
-- Preserving exact program functionality during refactoring
-
-# Task
-Clean up and improve deobfuscated JavaScript code while preserving 100% of its functionality.
-
-# Refactoring Principles
-1. **Semantic Naming**: Infer variable purpose from usage patterns
-   - API calls -> apiClient, fetchData, apiResponse
-   - DOM elements -> userInput, submitButton, errorMessage
-   - Crypto operations -> encryptedData, decryptionKey, hashValue
-   - Loops/counters -> index, itemCount, currentPage
-
-2. **Code Simplification**: Remove obfuscation artifacts
-   - Unnecessary IIFEs and closures
-   - Redundant variable assignments
-   - Complex ternary chains -> if-else
-   - Magic numbers -> named constants
-
-3. **Structure Improvement**: Enhance readability
-   - Extract repeated code to functions
-   - Group related operations
-   - Consistent indentation and spacing
-   - Logical code organization
-
-# Critical Constraints
-- **NEVER** change program logic or behavior
-- **NEVER** remove functional code (even if it looks redundant)
-- **NEVER** add new functionality
-- **ONLY** improve naming, structure, and readability
-- Output must be syntactically valid JavaScript
-- Preserve all side effects and edge cases
-
-# Output Format
-Return ONLY the cleaned JavaScript code (no markdown, no explanations).`;
-    const userPrompt = `# Code Cleanup Task
-
-## Detected Obfuscation Techniques
-${techniques.map((t) => `- ${t}`).join('\n')}
-
-## Deobfuscated Code (needs cleanup)
-\`\`\`javascript
-${codeSnippet}
-\`\`\`
-
-## Your Task
-Clean up and improve this deobfuscated JavaScript code:
-
-1. **Variable Naming**: Rename variables to meaningful names based on their usage
-   - Avoid generic names like 'a', 'b', 'temp'
-   - Use descriptive names like 'userConfig', 'apiEndpoint', 'responseData'
-
-2. **Code Structure**: Improve readability
-   - Remove unnecessary parentheses and brackets
-   - Simplify complex expressions
-   - Extract magic numbers to named constants
-
-3. **Comments**: Add brief comments for:
-   - Complex logic or algorithms
-   - Non-obvious functionality
-   - Important data structures
-
-4. **Consistency**: Ensure consistent code style
-   - Use consistent indentation
-   - Follow JavaScript best practices
-
-## Important Rules
-- Preserve ALL original functionality
-- Do NOT remove any functional code
-- Do NOT change the program logic
-- Output ONLY valid JavaScript code
-- Do NOT add explanations outside the code
-
-## Output Format
-Return only the cleaned JavaScript code without markdown formatting.`;
-    return [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt },
-    ];
-}
-export function generateVMAnalysisMessages(code) {
-    const codeSnippet = code.substring(0, 5000);
-    const userPrompt = `Analyze this JavaScript code protected by JSVMP (JavaScript Virtual Machine Protection).
-
-JSVMP-protected JavaScript code:
-
-\`\`\`javascript
-${codeSnippet}
-\`\`\`
-
-Please analyze:
-
-1. **VM Type**: What type of VM protection is this? (obfuscator.io / custom VM / other)
-
-2. **VM Structure**:
-   - Is there a Program Counter (PC)?
-   - Is there a Stack?
-   - Are there Registers?
-   - What is the bytecode format?
-
-3. **Key Components**:
-   - VM interpreter function (main loop)
-   - Dispatcher (switch statement)
-   - Bytecode array
-
-4. **Restoration Strategy**:
-   - How to extract bytecode?
-   - How to map opcodes?
-   - Recommended restoration steps?
-
-Return JSON:
-{
-  "vmType": "VM type description",
-  "programCounter": "PC variable description",
-  "stack": "stack description",
-  "registers": "registers description",
-  "bytecodeArray": "bytecode array description",
-  "interpreterFunction": "interpreter function description",
-  "restorationSteps": ["step 1", "step 2", ...],
-  "warnings": ["warning 1", "warning 2", ...]
-}`;
-    return [{ role: 'user', content: userPrompt }];
-}
-export function generateDeobfuscationPrompt(code) {
-    const systemPrompt = `# Role
-You are an expert JavaScript analyst specializing in:
-- Code deobfuscation and obfuscation pattern recognition
-- Obfuscator tool identification (javascript-obfuscator, UglifyJS, Terser, Webpack, etc.)
-- Control flow analysis and simplification
-- Semantic code understanding and variable naming
-- AST manipulation and code transformation
-
-# Known Obfuscation Techniques
-1. String Array Obfuscation: Strings stored in arrays with index-based access
-2. Control Flow Flattening: Switch-case state machines replacing normal control flow
-3. Dead Code Injection: Unreachable code blocks
-4. Opaque Predicates: Always-true/false conditions
-5. Variable Name Mangling: _0x1234, _0xabcd style names
-6. Encoding: Hex, Unicode, Base64 encoded strings
-7. VM Protection: Custom virtual machine interpreters
-
-# Task
-Analyze the obfuscated code to:
-1. Identify the obfuscation type and tool used
-2. Understand the actual program logic
-3. Suggest meaningful variable and function names
-4. Provide deobfuscated code if possible
-5. Explain the deobfuscation process step-by-step`;
-    const userPrompt = `# Obfuscated Code
-\`\`\`javascript
-${code.length > 3000 ? code.substring(0, 3000) + '\n\n// ... (code truncated)' : code}
-\`\`\`
-
-# Required Output Schema
-Return ONLY valid JSON:
-
-\`\`\`json
-{
-  "obfuscationType": {
-    "primary": "string-array | control-flow-flattening | vm-protection | mixed | unknown",
-    "techniques": ["technique 1"],
-    "tool": "javascript-obfuscator | webpack | uglify | terser | custom | unknown",
-    "toolVersion": "string or null",
-    "confidence": 0.85
-  },
-  "analysis": {
-    "codeStructure": "description of overall structure",
-    "mainLogic": "what the code actually does",
-    "keyFunctions": [
-      {
-        "obfuscatedName": "_0x1234",
-        "purpose": "what it does",
-        "confidence": 0.9
-      }
-    ],
-    "dataFlow": "how data flows through the code"
-  },
-  "suggestions": {
-    "variableRenames": {
-      "_0x1234": {"suggested": "userId", "reason": "stores user ID from API", "confidence": 0.95}
-    },
-    "functionRenames": {
-      "_0xabcd": {"suggested": "encryptPassword", "reason": "calls CryptoJS.AES.encrypt", "confidence": 0.92}
-    },
-    "simplifications": [
-      {
-        "type": "remove dead code | unflatten control flow | decode strings",
-        "description": "what to simplify",
-        "impact": "high | medium | low"
-      }
-    ]
-  },
-  "deobfuscationSteps": [
-    "Step 1: Extract string array at line 1-5"
-  ],
-  "deobfuscatedCode": "string or null",
-  "limitations": ["what couldn't be deobfuscated and why"],
-  "summary": "Brief summary of obfuscation and deobfuscation results"
-}
-\`\`\`
-
-Return ONLY the JSON output.`;
-    return [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt },
-    ];
-}
-export function generateVMDeobfuscationMessages(userPrompt) {
-    const systemPrompt = `# Role
-You are a world-class expert in JavaScript VM deobfuscation and program analysis with expertise in:
-- Virtual machine architecture and instruction set design
-- Bytecode interpretation and JIT compilation
-- Control flow reconstruction from VM instructions
-- Stack-based and register-based VM analysis
-- Obfuscation techniques used by TikTok, Shopee, and commercial protectors
-
-# Task
-Analyze VM-protected JavaScript code and reconstruct the original, readable JavaScript.
-
-# Methodology
-1. **Identify VM Components**: Locate instruction array, interpreter loop, stack/registers
-2. **Decode Instructions**: Map VM opcodes to JavaScript operations
-3. **Reconstruct Control Flow**: Convert VM jumps/branches to if/while/for
-4. **Simplify**: Remove VM overhead and restore natural code structure
-5. **Validate**: Ensure output is syntactically valid and functionally equivalent
-
-# Critical Requirements
-- Output ONLY valid, executable JavaScript (no markdown, no explanations)
-- Preserve exact program logic and side effects
-- Use meaningful variable names based on context
-- Add brief comments for complex patterns
-- Do NOT hallucinate or guess functionality
-- If uncertain, preserve original code structure
-
-# Output Format
-Return clean JavaScript code without any wrapper or formatting.`;
-    return [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt },
-    ];
-}
-export function generateControlFlowUnflatteningMessages(codeSnippet) {
-    const systemPrompt = `# Role
-You are an expert in JavaScript control flow deobfuscation specializing in:
-- Control flow flattening detection and removal
-- Switch-case state machine analysis
-- Dispatcher loop identification
-- Control flow graph (CFG) reconstruction
-
-# Task
-Analyze control flow flattened JavaScript and reconstruct the original, natural control flow.
-
-# Control Flow Flattening Pattern
-Obfuscators replace normal if/while/for with a dispatcher loop:
-\`\`\`javascript
-var state = '0';
-while (true) {
-  switch (state) {
-    case '0': console.log('a'); state = '1'; break;
-    case '1': console.log('b'); state = '2'; break;
-    case '2': return;
-  }
-}
-
-console.log('a');
-console.log('b');
-return;
-\`\`\`
-
-# Requirements
-- Output ONLY valid JavaScript code
-- Preserve exact program logic
-- Remove dispatcher loops and state variables
-- Restore natural if/while/for structures
-- Use meaningful variable names`;
-    const userPrompt = `# Control Flow Flattened Code
-\`\`\`javascript
-${codeSnippet}
-\`\`\`
-
-# Instructions
-1. Identify the dispatcher loop (while/for with switch-case)
-2. Trace state transitions to determine execution order
-3. Reconstruct original control flow (if/while/for)
-4. Remove state variables and dispatcher overhead
-5. Return ONLY the deobfuscated code (no explanations)
-
-Output the deobfuscated JavaScript code:`;
-    return [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt },
-    ];
-}

package/dist/src/services/prompts/environment.d.ts

@@ -1,16 +0,0 @@
-import type { LLMMessage } from '../LLMService.js';
-export declare function generateBrowserEnvAnalysisMessages(code: string, detected: object, missing: Array<{
-    path: string;
-    type: string;
-}>, browserType: string): LLMMessage[];
-export declare function generateAntiCrawlAnalysisMessages(code: string): LLMMessage[];
-export declare function generateAPIImplementationMessages(apiPath: string, context: string): LLMMessage[];
-export declare function generateEnvironmentSuggestionsMessages(detected: Record<string, string[]>, missing: Array<{
-    path: string;
-    type: string;
-}>, browserType: string): LLMMessage[];
-export declare function generateMissingAPIImplementationsMessages(missingAPIs: Array<{
-    path: string;
-    type: string;
-}>, code: string): LLMMessage[];
-export declare function generateMissingVariablesMessages(browserType: string, missingPaths: string[], code: string, existingManifest: Record<string, unknown>): LLMMessage[];

package/dist/src/services/prompts/environment.js

@@ -1,372 +0,0 @@
-export function generateBrowserEnvAnalysisMessages(code, detected, missing, browserType) {
-    const codeSnippet = code.length > 5000 ? code.substring(0, 5000) + '\n\n...(truncated)' : code;
-    const systemPrompt = `# Role
-You are an expert JavaScript analyst and anti-detection specialist with 10+ years of experience in:
-- Browser environment emulation and fingerprinting
-- Anti-bot and anti-scraping technique analysis
-- JavaScript obfuscation and deobfuscation
-- Browser API implementation and polyfills
-- Web security and privacy technologies
-
-# Expertise Areas
-- **Browser Fingerprinting**: Canvas, WebGL, Audio, Font, CSS fingerprinting
-- **Environment Detection**: WebDriver, Headless Chrome, Puppeteer detection
-- **API Emulation**: DOM, BOM, Web APIs (Crypto, Storage, Performance, etc.)
-- **Anti-Detection**: Stealth techniques, environment consistency checks
-- **Browser Internals**: Chrome, Firefox, Safari implementation differences
-
-# Task
-Analyze the provided JavaScript code to:
-1. Identify ALL browser environment variables and APIs being accessed
-2. Detect anti-bot and fingerprinting techniques
-3. Recommend realistic values for missing environment variables
-4. Provide working JavaScript implementations for missing APIs
-5. Assess detection risks and provide mitigation strategies
-
-# Analysis Standards
-- Follow W3C Web API specifications
-- Use real browser behavior patterns (not placeholder values)
-- Ensure environment consistency (e.g., userAgent matches platform)
-- Detect common anti-bot libraries (Cloudflare, PerimeterX, DataDome, etc.)
-- Identify fingerprinting scripts (FingerprintJS, CreepJS, etc.)`;
-    const userPrompt = `# Target Browser
-${browserType.toUpperCase()} (Latest stable version)
-
-# Detected Environment Variable Access
-\`\`\`json
-${JSON.stringify(detected, null, 2)}
-\`\`\`
-
-# Missing APIs (Need Implementation)
-\`\`\`json
-${JSON.stringify(missing, null, 2)}
-\`\`\`
-
-# Code to Analyze
-\`\`\`javascript
-${codeSnippet}
-\`\`\`
-
-# Required Output Schema
-Return ONLY valid JSON with this EXACT structure (all fields required):
-
-\`\`\`json
-{
-  "recommendedVariables": {
-    "navigator.userAgent": "string - realistic UA matching target browser",
-    "navigator.platform": "string - must match UA (Win32, MacIntel, Linux x86_64)",
-    "navigator.vendor": "string - Google Inc. for Chrome, empty for Firefox",
-    "window.chrome": "object | undefined - Chrome-specific object",
-    "navigator.webdriver": "boolean - MUST be false or undefined for stealth",
-    "navigator.plugins": "PluginArray - realistic plugin list, not empty array",
-    "...": "other detected variables with realistic values"
-  },
-  "recommendedAPIs": [
-    {
-      "path": "string - full API path (e.g., 'window.requestAnimationFrame')",
-      "implementation": "string - complete working JavaScript code",
-      "reason": "string - why this API is needed and how it's used in the code",
-      "priority": "critical | high | medium | low",
-      "complexity": "simple | moderate | complex"
-    }
-  ],
-  "antiCrawlFeatures": [
-    {
-      "feature": "string - specific technique name",
-      "type": "fingerprinting | detection | obfuscation | challenge",
-      "severity": "critical | high | medium | low",
-      "description": "string - detailed technical description",
-      "location": "string - line number or function name if identifiable",
-      "mitigation": "string - specific bypass technique with code example",
-      "confidence": 0.95
-    }
-  ],
-  "environmentConsistency": {
-    "issues": [
-      {
-        "variable1": "navigator.userAgent",
-        "variable2": "navigator.platform",
-        "issue": "UA indicates Windows but platform is MacIntel",
-        "fix": "Ensure platform matches UA OS"
-      }
-    ],
-    "score": 85
-  },
-  "suggestions": [
-    "string - actionable recommendation 1",
-    "string - actionable recommendation 2",
-    "string - actionable recommendation 3"
-  ],
-  "confidence": 0.85,
-  "summary": "2-3 sentence summary of findings and main risks"
-}
-\`\`\`
-
-Now analyze the code and return ONLY the JSON output (no markdown, no explanations).`;
-    return [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt },
-    ];
-}
-export function generateAntiCrawlAnalysisMessages(code) {
-    const systemPrompt = `# Role
-You are an expert in web anti-bot and anti-scraping technologies with deep knowledge of:
-- Commercial anti-bot solutions (Cloudflare, PerimeterX, DataDome, Akamai, etc.)
-- Browser fingerprinting techniques (Canvas, WebGL, Audio, Font, CSS, etc.)
-- Bot detection methods (behavioral analysis, TLS fingerprinting, etc.)
-- Stealth and evasion techniques
-
-# Known Anti-Bot Techniques
-1. **Browser Fingerprinting**
-   - Canvas fingerprinting (toDataURL, getImageData)
-   - WebGL fingerprinting (renderer, vendor, extensions)
-   - Audio fingerprinting (AudioContext, OscillatorNode)
-   - Font fingerprinting (measureText, font enumeration)
-   - CSS fingerprinting (getComputedStyle)
-
-2. **Environment Detection**
-   - WebDriver detection (navigator.webdriver)
-   - Headless detection (chrome.runtime, permissions)
-   - Automation tool detection (window.cdc_, $cdc_, __webdriver_)
-   - Plugin detection (navigator.plugins length check)
-
-3. **Behavioral Analysis**
-   - Mouse movement patterns (entropy, velocity, acceleration)
-   - Keyboard timing analysis
-   - Scroll behavior patterns
-   - Touch event simulation detection
-
-4. **Advanced Techniques**
-   - TLS/SSL fingerprinting (JA3, JA3S)
-   - HTTP/2 fingerprinting
-   - Timing attacks (performance.now() precision)
-   - Memory/CPU profiling
-   - Stack trace analysis
-
-# Task
-Analyze the code and identify ALL anti-bot and fingerprinting techniques with high precision.`;
-    const userPrompt = `# Code to Analyze
-\`\`\`javascript
-${code.substring(0, 3000)}${code.length > 3000 ? '\n\n...(truncated)' : ''}
-\`\`\`
-
-# Required Output Schema
-Return ONLY valid JSON array with this structure:
-
-\`\`\`json
-[
-  {
-    "feature": "string - specific technique name (e.g., 'Canvas Fingerprinting via toDataURL')",
-    "type": "fingerprinting | detection | behavioral | challenge | obfuscation",
-    "severity": "critical | high | medium | low",
-    "description": "string - detailed technical description of what the code does",
-    "location": "string - line number, function name, or code pattern",
-    "mitigation": "string - specific bypass code or technique",
-    "confidence": 0.95,
-    "vendor": "string | null - if identifiable (Cloudflare, PerimeterX, etc.)"
-  }
-]
-\`\`\`
-
-# Analysis Guidelines
-- Be specific: "Canvas toDataURL fingerprinting" not just "Canvas detection"
-- Provide working mitigation code when possible
-- Identify vendor if signature matches known products
-- Only report techniques you actually see in the code
-- Use confidence scores honestly (0.7-0.8 for uncertain, 0.9+ for definite)
-
-Now analyze and return ONLY the JSON array.`;
-    return [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt },
-    ];
-}
-export function generateAPIImplementationMessages(apiPath, context) {
-    const systemPrompt = `# Role
-You are a browser API implementation expert with deep knowledge of:
-- W3C Web API specifications
-- Browser internals (V8, SpiderMonkey, JavaScriptCore)
-- DOM, BOM, and Web APIs implementation details
-- Cross-browser compatibility
-- Anti-detection and stealth techniques
-
-# Task
-Provide a realistic, working JavaScript implementation for the requested browser API that:
-1. Follows W3C specifications
-2. Matches real browser behavior
-3. Passes anti-detection checks
-4. Is production-ready (handles edge cases)
-5. Is concise but complete
-
-# Implementation Standards
-- Return realistic values (not null/undefined unless spec requires)
-- Handle all parameter variations
-- Include proper error handling
-- Match browser-specific behavior when needed
-- Consider performance implications`;
-    const userPrompt = `# API to Implement
-\`${apiPath}\`
-
-# Usage Context
-\`\`\`javascript
-${context.substring(0, 1000)}${context.length > 1000 ? '\n...(truncated)' : ''}
-\`\`\`
-
-# Requirements
-1. Provide ONLY the JavaScript implementation code
-2. Code must be production-ready and handle edge cases
-3. Match real browser behavior (not a mock/stub)
-4. Include JSDoc comment explaining the implementation
-5. Consider anti-detection (e.g., function.toString() should look native)
-
-# Output Format
-Return ONLY JavaScript code in a code block, no explanations outside the code.
-
-Now provide the implementation for \`${apiPath}\`:`;
-    return [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt },
-    ];
-}
-export function generateEnvironmentSuggestionsMessages(detected, missing, browserType) {
-    const totalVars = Object.values(detected).flat().length;
-    const systemPrompt = `# Role
-You are a browser automation and anti-detection expert providing actionable recommendations.
-
-# Task
-Generate 3-5 specific, prioritized recommendations for browser environment emulation.
-
-# Recommendation Criteria
-1. **Actionable**: Provide specific steps or code snippets
-2. **Prioritized**: Most critical issues first
-3. **Realistic**: Based on real-world anti-bot scenarios
-4. **Concise**: One clear sentence per recommendation
-5. **Technical**: Include specific API names or techniques`;
-    const userPrompt = `# Environment Analysis
-- **Target Browser**: ${browserType.toUpperCase()}
-- **Detected Variables**: ${totalVars} environment variables accessed
-- **Missing APIs**: ${missing.length} APIs need implementation
-
-# Missing API Details
-${missing
-        .slice(0, 20)
-        .map((m) => `- \`${m.path}\` (${m.type})`)
-        .join('\n')}${missing.length > 20 ? `\n... and ${missing.length - 20} more` : ''}
-
-# Key Patterns Detected
-- Navigator access: ${(detected.navigator || []).length} properties
-- Window access: ${(detected.window || []).length} properties
-- Document access: ${(detected.document || []).length} properties
-- Screen access: ${(detected.screen || []).length} properties
-
-# Required Output
-Return ONLY a JSON array of 3-5 actionable recommendations:
-
-\`\`\`json
-[
-  "Recommendation 1 with specific action",
-  "Recommendation 2 with specific action",
-  "Recommendation 3 with specific action"
-]
-\`\`\`
-
-# Guidelines
-- Focus on high-impact, easy-to-implement fixes first
-- Mention specific tools (Puppeteer Stealth, undetected-chromedriver) when relevant
-- Include code snippets in recommendations when helpful
-- Prioritize anti-detection over completeness
-
-Now generate recommendations:`;
-    return [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt },
-    ];
-}
-export function generateMissingAPIImplementationsMessages(missingAPIs, code) {
-    const systemPrompt = `# Role
-You are a browser API implementation expert.
-
-# Task
-Generate realistic JavaScript implementations for missing browser APIs.
-
-# Requirements
-1. Follow W3C specifications
-2. Match real browser behavior
-3. Handle edge cases
-4. Include proper error handling
-5. Make functions look native (toString returns "[native code]")`;
-    const userPrompt = `# Missing APIs
-${JSON.stringify(missingAPIs.slice(0, 10), null, 2)}
-
-# Code Context
-\`\`\`javascript
-${code.substring(0, 1500)}${code.length > 1500 ? '\n...(truncated)' : ''}
-\`\`\`
-
-# Required Output
-Return ONLY valid JSON object mapping API paths to implementations:
-
-\`\`\`json
-{
-  "window.requestAnimationFrame": "function(callback) { return setTimeout(callback, 16); }",
-  "navigator.getBattery": "function() { return Promise.resolve({ level: 1, charging: true }); }",
-  "...": "other implementations"
-}
-\`\`\`
-
-Return ONLY the JSON object:`;
-    return [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt },
-    ];
-}
-export function generateMissingVariablesMessages(browserType, missingPaths, code, existingManifest) {
-    const systemPrompt = `# Role
-You are a browser environment expert specializing in realistic browser API value generation.
-
-# Task
-Generate realistic values for missing browser environment variables based on code analysis.
-
-# Requirements
-1. Values must be realistic and match real browser behavior
-2. Ensure consistency across related variables (e.g., UA matches platform)
-3. Consider anti-detection (avoid obvious fake values)
-4. Follow W3C specifications for API return types`;
-    const userPrompt = `# Target Browser
-${browserType.toUpperCase()}
-
-# Missing Variables (need values)
-${JSON.stringify(missingPaths, null, 2)}
-
-# Code Context (for understanding usage)
-\`\`\`javascript
-${code.substring(0, 2000)}${code.length > 2000 ? '\n...(truncated)' : ''}
-\`\`\`
-
-# Existing Variables (for consistency)
-${JSON.stringify(existingManifest, null, 2)}
-
-# Required Output
-Return ONLY valid JSON object with missing variable paths as keys and realistic values:
-
-\`\`\`json
-{
-  "navigator.userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36...",
-  "navigator.platform": "Win32",
-  "window.innerWidth": 1920,
-  "...": "other missing variables"
-}
-\`\`\`
-
-# Guidelines
-- Use realistic values matching target browser
-- Ensure cross-variable consistency
-- Consider code usage patterns
-- Avoid placeholder values like "test" or "example"
-
-Return ONLY the JSON object:`;
-    return [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt },
-    ];
-}

package/dist/src/services/prompts/intelligence.d.ts

@@ -1,4 +0,0 @@
-import type { LLMMessage } from '../LLMService.js';
-export declare function generateRequestAnalysisMessages(requestSummary: object): LLMMessage[];
-export declare function generateLogAnalysisMessages(logSummary: object[]): LLMMessage[];
-export declare function generateKeywordExpansionMessages(domain: string, urlPatterns: object[], logKeywords: string[]): LLMMessage[];