@houtini/lm 1.0.13 → 2.0.1

package/dist/prompts/analyze/diff-signatures.js

@@ -1,708 +0,0 @@
-/**
- * Plugin Template - Modern v4.2 (Single Source of Truth)
- *
- * Universal template that intelligently handles both single-file and multi-file analysis
- * Automatically detects analysis type based on provided parameters
- *
- * Copy this template for creating any new plugin - it adapts to your needs
- */
-import { BasePlugin } from '../../plugins/base-plugin.js';
-import { ThreeStagePromptManager } from '../../core/ThreeStagePromptManager.js';
-import { withSecurity } from '../../security/integration-helpers.js';
-import { readFileContent } from '../shared/helpers.js';
-import { ModelSetup, ResponseProcessor, ParameterValidator, ErrorHandler, MultiFileAnalysis, TokenCalculator } from '../../utils/plugin-utilities.js';
-import { getAnalysisCache } from '../../cache/index.js';
-export class MethodSignatureDiffer extends BasePlugin {
-    constructor() {
-        super();
-        this.name = 'diff_method_signatures';
-        this.category = 'analyze';
-        this.description = 'Compare method signatures between caller and callee to identify parameter mismatches and provide actionable fixes';
-        // Universal parameter set - supports both single and multi-file scenarios
-        this.parameters = {
-            // Single-file parameters
-            code: {
-                type: 'string',
-                description: 'The code to analyze (for single-file analysis)',
-                required: false
-            },
-            filePath: {
-                type: 'string',
-                description: 'Path to single file to analyze',
-                required: false
-            },
-            // Multi-file parameters  
-            projectPath: {
-                type: 'string',
-                description: 'Path to project root (for multi-file analysis)',
-                required: false
-            },
-            files: {
-                type: 'array',
-                description: 'Array of specific file paths (for multi-file analysis)',
-                required: false,
-                items: { type: 'string' }
-            },
-            maxDepth: {
-                type: 'number',
-                description: 'Maximum directory depth for multi-file discovery (1-5)',
-                required: false,
-                default: 3
-            },
-            // Specific parameters for method signature comparison
-            callingFile: {
-                type: 'string',
-                description: 'Absolute path to file containing the method call',
-                required: false
-            },
-            calledClass: {
-                type: 'string',
-                description: 'Class name containing the called method',
-                required: false
-            },
-            methodName: {
-                type: 'string',
-                description: 'Name of the method to check',
-                required: false
-            },
-            // Universal parameters
-            language: {
-                type: 'string',
-                description: 'Programming language',
-                required: false,
-                default: 'javascript'
-            },
-            analysisDepth: {
-                type: 'string',
-                description: 'Level of analysis detail',
-                enum: ['basic', 'detailed', 'comprehensive'],
-                default: 'detailed',
-                required: false
-            },
-            analysisType: {
-                type: 'string',
-                description: 'Type of analysis to perform',
-                enum: ['signature', 'compatibility', 'comprehensive'],
-                default: 'comprehensive',
-                required: false
-            }
-        };
-        this.analysisCache = getAnalysisCache();
-        this.multiFileAnalysis = new MultiFileAnalysis();
-        // Cache and analysis utilities are initialized above
-    }
-    async execute(params, llmClient) {
-        return await withSecurity(this, params, llmClient, async (secureParams) => {
-            try {
-                // 1. Auto-detect analysis mode based on parameters
-                const analysisMode = this.detectAnalysisMode(secureParams);
-                // 2. Validate parameters based on detected mode
-                this.validateParameters(secureParams, analysisMode);
-                // 3. Setup model
-                const { model, contextLength } = await ModelSetup.getReadyModel(llmClient);
-                // 4. Route to appropriate analysis method
-                if (analysisMode === 'single-file') {
-                    return await this.executeSingleFileAnalysis(secureParams, model, contextLength);
-                }
-                else {
-                    return await this.executeMultiFileAnalysis(secureParams, model, contextLength);
-                }
-            }
-            catch (error) {
-                return ErrorHandler.createExecutionError('diff_method_signatures', error);
-            }
-        });
-    }
-    /**
-     * Auto-detect whether this is single-file or multi-file analysis
-     */
-    detectAnalysisMode(params) {
-        // Single-file indicators take priority (avoids default parameter issues)
-        if (params.code || params.filePath) {
-            return 'single-file';
-        }
-        // Multi-file indicators - method signature comparison typically requires multiple files
-        if (params.projectPath || params.files ||
-            (params.callingFile && params.calledClass)) {
-            return 'multi-file';
-        }
-        // Default to multi-file for method signature comparison
-        return 'multi-file';
-    }
-    /**
-     * Validate parameters based on detected analysis mode
-     */
-    validateParameters(params, mode) {
-        if (mode === 'single-file') {
-            ParameterValidator.validateCodeOrFile(params);
-        }
-        else {
-            // For multi-file method signature comparison, we need either:
-            // 1. Specific method signature params (callingFile + calledClass + methodName)
-            // 2. General project analysis params (projectPath)
-            if (params.callingFile && params.calledClass && params.methodName) {
-                // Specific method signature comparison
-                if (!params.callingFile || typeof params.callingFile !== 'string') {
-                    throw new Error('callingFile is required and must be a string for method signature comparison');
-                }
-                if (!params.calledClass || typeof params.calledClass !== 'string') {
-                    throw new Error('calledClass is required and must be a string for method signature comparison');
-                }
-                if (!params.methodName || typeof params.methodName !== 'string') {
-                    throw new Error('methodName is required and must be a string for method signature comparison');
-                }
-            }
-            else {
-                // General project analysis
-                ParameterValidator.validateProjectPath(params);
-                ParameterValidator.validateDepth(params);
-            }
-        }
-        // Universal validations
-        ParameterValidator.validateEnum(params, 'analysisType', ['signature', 'compatibility', 'comprehensive']);
-        ParameterValidator.validateEnum(params, 'analysisDepth', ['basic', 'detailed', 'comprehensive']);
-    }
-    /**
-     * Execute single-file analysis
-     */
-    async executeSingleFileAnalysis(params, model, contextLength) {
-        // Process single file input
-        let codeToAnalyze = params.code;
-        if (params.filePath) {
-            codeToAnalyze = await readFileContent(params.filePath);
-        }
-        // Generate prompt stages for single file
-        const promptStages = this.getSingleFilePromptStages({
-            ...params,
-            code: codeToAnalyze
-        });
-        // Execute with appropriate method
-        const promptManager = new ThreeStagePromptManager();
-        const needsChunking = TokenCalculator.needsChunking(promptStages, contextLength);
-        if (needsChunking) {
-            const chunkSize = TokenCalculator.calculateOptimalChunkSize(promptStages, contextLength);
-            const dataChunks = promptManager.chunkDataPayload(promptStages.dataPayload, chunkSize);
-            const conversation = promptManager.createChunkedConversation(promptStages, dataChunks);
-            const messages = [
-                conversation.systemMessage,
-                ...conversation.dataMessages,
-                conversation.analysisMessage
-            ];
-            return await ResponseProcessor.executeChunked(messages, model, contextLength, 'diff_method_signatures', 'single');
-        }
-        else {
-            return await ResponseProcessor.executeDirect(promptStages, model, contextLength, 'diff_method_signatures');
-        }
-    }
-    /**
-     * Execute multi-file analysis
-     */
-    async executeMultiFileAnalysis(params, model, contextLength) {
-        // For specific method signature comparison
-        if (params.callingFile && params.calledClass && params.methodName) {
-            return await this.executeSpecificMethodComparison(params, model, contextLength);
-        }
-        // For general project analysis
-        let filesToAnalyze = params.files ||
-            await this.discoverRelevantFiles(params.projectPath, params.maxDepth, params.analysisType);
-        // Perform multi-file analysis with caching
-        const analysisResult = await this.performMultiFileAnalysis(filesToAnalyze, params, model, contextLength);
-        // Generate prompt stages for multi-file
-        const promptStages = this.getMultiFilePromptStages({
-            ...params,
-            analysisResult,
-            fileCount: filesToAnalyze.length
-        });
-        // Always use chunking for multi-file
-        const promptManager = new ThreeStagePromptManager();
-        const chunkSize = TokenCalculator.calculateOptimalChunkSize(promptStages, contextLength);
-        const dataChunks = promptManager.chunkDataPayload(promptStages.dataPayload, chunkSize);
-        const conversation = promptManager.createChunkedConversation(promptStages, dataChunks);
-        const messages = [
-            conversation.systemMessage,
-            ...conversation.dataMessages,
-            conversation.analysisMessage
-        ];
-        return await ResponseProcessor.executeChunked(messages, model, contextLength, 'diff_method_signatures', 'multifile');
-    }
-    /**
-     * Execute specific method signature comparison
-     */
-    async executeSpecificMethodComparison(params, model, contextLength) {
-        try {
-            // Read calling file
-            const callingFileContent = await readFileContent(params.callingFile);
-            // Find files that might contain the called class
-            const { dirname } = await import('path');
-            const projectDir = dirname(params.callingFile);
-            const classFiles = await this.findClassFiles(params.calledClass, projectDir);
-            if (classFiles.length === 0) {
-                throw new Error(`Could not find any files containing class: ${params.calledClass}`);
-            }
-            // Read class file contents
-            const classFileContents = {};
-            for (const file of classFiles) {
-                try {
-                    classFileContents[file] = await readFileContent(file);
-                }
-                catch (error) {
-                    // Skip files we can't read
-                }
-            }
-            // Generate prompt stages for specific comparison
-            const promptStages = this.getSpecificComparisonPromptStages({
-                ...params,
-                callingFileContent,
-                classFileContents
-            });
-            // Execute with appropriate method
-            const promptManager = new ThreeStagePromptManager();
-            const needsChunking = TokenCalculator.needsChunking(promptStages, contextLength);
-            if (needsChunking) {
-                const chunkSize = TokenCalculator.calculateOptimalChunkSize(promptStages, contextLength);
-                const dataChunks = promptManager.chunkDataPayload(promptStages.dataPayload, chunkSize);
-                const conversation = promptManager.createChunkedConversation(promptStages, dataChunks);
-                const messages = [
-                    conversation.systemMessage,
-                    ...conversation.dataMessages,
-                    conversation.analysisMessage
-                ];
-                return await ResponseProcessor.executeChunked(messages, model, contextLength, 'diff_method_signatures', 'multifile');
-            }
-            else {
-                return await ResponseProcessor.executeDirect(promptStages, model, contextLength, 'diff_method_signatures');
-            }
-        }
-        catch (error) {
-            return ErrorHandler.createExecutionError('diff_method_signatures', error);
-        }
-    }
-    /**
-     * Single-file prompt stages for method signature analysis within one file
-     */
-    getSingleFilePromptStages(params) {
-        const { code, language, analysisDepth, analysisType } = params;
-        const systemAndContext = `You are a senior software engineer and code review expert specializing in ${analysisDepth} method signature analysis and compatibility assessment.
-
-**Your Expertise:**
-- 15+ years of experience in ${language} development
-- Deep understanding of method signatures, parameter passing, and type systems
-- Expert in identifying compatibility issues that cause runtime errors
-- Skilled at providing actionable, specific fix recommendations
-
-**Analysis Context:**
-- Language: ${language}
-- Analysis Depth: ${analysisDepth}
-- Analysis Type: ${analysisType}
-- Mode: Single File Analysis
-
-**Your Mission:**
-Analyze method signatures within this file to identify potential compatibility issues, parameter mismatches, and provide concrete solutions that prevent runtime errors.`;
-        const dataPayload = `File content to analyze for method signature issues:
-
-\`\`\`${language}
-${code}
-\`\`\``;
-        const outputInstructions = `**COMPREHENSIVE METHOD SIGNATURE ANALYSIS**
-
-Provide your analysis in this structured format:
-
-## Method Signature Issues Found
-
-### Issue 1: [Type of Issue]
-- **Method**: \`methodName()\`
-- **Location**: Line X
-- **Problem**: Clear description of the signature issue
-- **Severity**: Critical/High/Medium/Low
-- **Impact**: What happens at runtime
-- **Fix**: Specific code change needed
-
-### Issue 2: [Type of Issue]
-[Continue for all issues found...]
-
-## Method Compatibility Assessment
-
-### Well-Defined Methods ✅
-- List methods with clear, compatible signatures
-
-### Problematic Methods ⚠️
-- List methods with potential issues
-
-## Recommendations
-
-### Immediate Actions Required
-1. [Most critical fixes needed]
-2. [Second priority fixes]
-
-### Long-term Improvements
-1. [Architectural suggestions]
-2. [Best practice recommendations]
-
-## Code Examples
-
-### Before (Problematic):
-\`\`\`${language}
-// Show problematic signature
-\`\`\`
-
-### After (Fixed):
-\`\`\`${language}
-// Show corrected signature
-\`\`\`
-
-**Analysis Confidence**: X%`;
-        return { systemAndContext, dataPayload, outputInstructions };
-    }
-    /**
-     * Multi-file prompt stages for cross-file method signature analysis
-     */
-    getMultiFilePromptStages(params) {
-        const { analysisResult, analysisType, analysisDepth, fileCount } = params;
-        const systemAndContext = `You are a senior software architect and integration specialist with ${analysisDepth} expertise in cross-file method signature compatibility.
-
-**Your Expertise:**
-- 20+ years of experience in large-scale software architecture
-- Expert in identifying integration issues between modules and classes
-- Deep knowledge of method signature compatibility across file boundaries
-- Proven track record of preventing runtime integration failures
-
-**Analysis Context:**
-- Analysis Type: ${analysisType}
-- Analysis Depth: ${analysisDepth}  
-- Files Analyzed: ${fileCount}
-- Mode: Cross-File Integration Analysis
-
-**Your Mission:**
-Analyze method signatures across multiple files to identify integration risks, compatibility issues, and provide architectural recommendations for bulletproof inter-module communication.`;
-        const dataPayload = `Cross-file method signature analysis results:
-
-${JSON.stringify(analysisResult, null, 2)}`;
-        const outputInstructions = `**CROSS-FILE METHOD SIGNATURE COMPATIBILITY REPORT**
-
-## Executive Summary
-- **Total Integration Points**: [number]
-- **Critical Issues**: [number]
-- **Files at Risk**: [list]
-- **Overall Compatibility**: [percentage]
-
-## Critical Integration Issues
-
-### Issue 1: Method Signature Mismatch
-- **Caller**: \`File A, Line X\`
-- **Callee**: \`File B, Line Y\`
-- **Method**: \`className.methodName()\`
-- **Problem**: Detailed description of signature incompatibility
-- **Runtime Impact**: What breaks when this is called
-- **Severity**: Critical/High/Medium/Low
-- **Fix Strategy**: Step-by-step resolution approach
-
-[Continue for all critical issues...]
-
-## Architecture Assessment
-
-### Stable Integration Points ✅
-- List well-designed, compatible method signatures
-
-### Fragile Integration Points ⚠️
-- List risky method calls requiring attention
-
-### Missing Integration Points ❌
-- Methods called but not found
-
-## Compatibility Matrix
-
-| Caller File | Called Class | Method | Status | Risk Level |
-|-------------|--------------|---------|---------|------------|
-| FileA.js | ClassB | methodX | ⚠️ Mismatch | High |
-| FileC.ts | ClassD | methodY | ✅ Compatible | Low |
-
-## Actionable Remediation Plan
-
-### Phase 1: Critical Fixes (Do Now)
-1. **Fix signature mismatch in ClassB.methodX**
-   - Change: \`methodX(param1)\` → \`methodX(param1, param2)\`
-   - Files to update: [specific files and lines]
-   - Test strategy: [how to verify fix]
-
-### Phase 2: Preventive Measures (Next Sprint)
-1. [Improvements to prevent future issues]
-2. [Tooling or process changes]
-
-### Phase 3: Architecture Improvements (Future)
-1. [Systematic improvements to method design]
-2. [Interface standardization recommendations]
-
-## Code Fixes
-
-### Critical Fix Example:
-**Before (Broken):**
-\`\`\`javascript
-// Caller expects: user.updateProfile(name, email)  
-// Method provides: updateProfile(profileData)
-\`\`\`
-
-**After (Fixed):**
-\`\`\`javascript
-// Updated method signature for compatibility
-\`\`\`
-
-**Risk Assessment**: [Low/Medium/High] risk of regression`;
-        return { systemAndContext, dataPayload, outputInstructions };
-    }
-    /**
-     * Specific comparison prompt stages for targeted method signature analysis
-     */
-    getSpecificComparisonPromptStages(params) {
-        const { callingFile, calledClass, methodName, callingFileContent, classFileContents } = params;
-        const getBasename = (filePath) => {
-            const parts = filePath.replace(/\\/g, '/').split('/');
-            return parts[parts.length - 1];
-        };
-        const systemAndContext = `You are a world-class debugging specialist and method signature expert with forensic-level attention to detail.
-
-**Your Expertise:**
-- 25+ years of experience hunting down method signature bugs
-- Expert in parameter compatibility, type coercion, and runtime behavior
-- Legendary ability to spot subtle signature mismatches that cause production failures
-- Known for providing surgical-precision fixes that solve problems permanently
-
-**Debugging Mission:**
-- **Target Method**: \`${calledClass}.${methodName}()\`
-- **Calling File**: ${getBasename(callingFile)}
-- **Called Class**: ${calledClass}
-
-**Your Task:**
-Perform forensic analysis of this specific method signature issue. Find the exact incompatibility, understand the runtime impact, and provide a bulletproof fix.`;
-        const dataPayload = `**=== CALLING FILE CONTENT ===**
-File: ${callingFile}
-
-${callingFileContent}
-
-**=== CLASS DEFINITION FILES ===**
-${Object.entries(classFileContents).map(([file, content]) => `File: ${file}\n${content}\n${'='.repeat(80)}`).join('\n\n')}`;
-        const outputInstructions = `**FORENSIC METHOD SIGNATURE ANALYSIS**
-
-## Method Call Investigation
-
-### 1. Call Site Analysis
-- **File**: ${require('path').basename(callingFile)}
-- **Line Number**: [exact line]
-- **Call Pattern**: \`${calledClass}.${methodName}(parameters here)\`
-- **Parameters Passed**: 
-  1. \`param1\` - Type: [type], Value: [value/expression]
-  2. \`param2\` - Type: [type], Value: [value/expression]
-  [Continue for all parameters...]
-
-### 2. Method Definition Analysis
-- **File**: [which file contains the class]
-- **Line Number**: [exact line]
-- **Method Signature**: \`${methodName}(expected parameters)\`
-- **Expected Parameters**:
-  1. \`param1\` - Type: [expected type], Required: [yes/no], Default: [if any]
-  2. \`param2\` - Type: [expected type], Required: [yes/no], Default: [if any]
-  [Continue for all parameters...]
-
-### 3. Compatibility Assessment
-
-#### ✅ Compatible Aspects
-- [List what's working correctly]
-
-#### ❌ Incompatibilities Found
-1. **Parameter Count Mismatch**
-   - Passed: X parameters
-   - Expected: Y parameters
-   - Impact: [specific runtime behavior]
-
-2. **Type Mismatches**
-   - Parameter 1: Passing [actualType] but expecting [expectedType]
-   - Parameter 2: [continue analysis...]
-
-3. **Parameter Order Issues**
-   - [If parameters are in wrong order]
-
-## Runtime Impact Analysis
-
-### What Happens When This Runs:
-- **Best Case**: [if it somehow works]
-- **Most Likely**: [typical failure mode]
-- **Worst Case**: [catastrophic failure scenario]
-
-### Error Messages You'll See:
-\`\`\`
-[Likely error messages or unexpected behavior]
-\`\`\`
-
-## Surgical Fix
-
-### Option 1: Update Method Call (Recommended)
-**File**: ${require('path').basename(callingFile)}
-**Change this:**
-\`\`\`javascript
-${calledClass}.${methodName}(current_call_here)
-\`\`\`
-
-**To this:**
-\`\`\`javascript
-${calledClass}.${methodName}(corrected_call_here)
-\`\`\`
-
-### Option 2: Update Method Definition (If Needed)
-**File**: [class definition file]
-**Change the method signature if the call is correct but definition is wrong**
-
-### Option 3: Adapter Pattern (For Complex Cases)
-\`\`\`javascript
-// If both sides have valid reasons to stay as-is
-const adapter = {
-  ${methodName}: (callerParams) => {
-    return ${calledClass}.${methodName}(convertedParams);
-  }
-};
-\`\`\`
-
-## Testing Strategy
-1. **Unit Test**: [specific test to verify fix]
-2. **Integration Test**: [test the full call path]
-3. **Regression Prevention**: [ensure fix doesn't break other callers]
-
-**Confidence Level**: [High/Medium/Low] - with reasoning
-
-**Fix Complexity**: [Simple/Moderate/Complex] - estimated effort required`;
-        return { systemAndContext, dataPayload, outputInstructions };
-    }
-    /**
-     * Implement for backwards compatibility
-     * The system still expects this method, so we intelligently route to the appropriate stages
-     */
-    getPromptStages(params) {
-        const mode = this.detectAnalysisMode(params);
-        // If we have specific method comparison parameters
-        if (params.callingFile && params.calledClass && params.methodName) {
-            return this.getSpecificComparisonPromptStages(params);
-        }
-        if (mode === 'single-file') {
-            return this.getSingleFilePromptStages(params);
-        }
-        else {
-            return this.getMultiFilePromptStages(params);
-        }
-    }
-    // Multi-file helper methods
-    async discoverRelevantFiles(projectPath, maxDepth, analysisType) {
-        const extensions = this.getFileExtensions(analysisType);
-        return await this.multiFileAnalysis.discoverFiles(projectPath, extensions, maxDepth);
-    }
-    async performMultiFileAnalysis(files, params, model, contextLength) {
-        const cacheKey = this.analysisCache.generateKey('diff_method_signatures', params, files);
-        const cached = await this.analysisCache.get(cacheKey);
-        if (cached)
-            return cached;
-        const fileAnalysisResults = await this.multiFileAnalysis.analyzeBatch(files, (file) => this.analyzeIndividualFile(file, params, model), contextLength);
-        // Aggregate results into proper analysis result format
-        const aggregatedResult = {
-            summary: `Method signature analysis of ${files.length} files`,
-            findings: fileAnalysisResults,
-            data: {
-                fileCount: files.length,
-                totalSize: fileAnalysisResults.reduce((sum, result) => sum + (result.size || 0), 0),
-                methodCalls: this.extractMethodCalls(fileAnalysisResults),
-                classDefinitions: this.extractClassDefinitions(fileAnalysisResults)
-            }
-        };
-        await this.analysisCache.cacheAnalysis(cacheKey, aggregatedResult, {
-            modelUsed: model.identifier || 'unknown',
-            executionTime: Date.now() - Date.now(), // TODO: Track actual execution time
-            timestamp: new Date().toISOString()
-        });
-        return aggregatedResult;
-    }
-    async analyzeIndividualFile(file, params, model) {
-        const content = await import('fs/promises').then(fs => fs.readFile(file, 'utf-8'));
-        return {
-            filePath: file,
-            size: content.length,
-            lines: content.split('\n').length,
-            extension: await import('path').then(p => p.extname(file)),
-            // Extract method calls and class definitions for signature analysis
-            methodCalls: this.findMethodCallsInContent(content),
-            classDefinitions: this.findClassDefinitionsInContent(content)
-        };
-    }
-    getFileExtensions(analysisType) {
-        const extensionMap = {
-            'signature': ['.js', '.ts', '.jsx', '.tsx', '.php', '.py', '.java'],
-            'compatibility': ['.js', '.ts', '.jsx', '.tsx', '.php', '.py', '.java'],
-            'comprehensive': ['.js', '.ts', '.jsx', '.tsx', '.php', '.py', '.java', '.cs', '.cpp']
-        };
-        return extensionMap[analysisType] || extensionMap.comprehensive;
-    }
-    extractMethodCalls(results) {
-        return results.flatMap(result => result.methodCalls || []);
-    }
-    extractClassDefinitions(results) {
-        return results.flatMap(result => result.classDefinitions || []);
-    }
-    findMethodCallsInContent(content) {
-        // Simple heuristic to find method calls - can be enhanced
-        const methodCallPattern = /(\w+)\.(\w+)\s*\(/g;
-        const calls = [];
-        let match;
-        while ((match = methodCallPattern.exec(content)) !== null) {
-            calls.push({
-                object: match[1],
-                method: match[2],
-                line: content.substring(0, match.index).split('\n').length
-            });
-        }
-        return calls;
-    }
-    findClassDefinitionsInContent(content) {
-        // Simple heuristic to find class definitions
-        const classPattern = /class\s+(\w+)/g;
-        const classes = [];
-        let match;
-        while ((match = classPattern.exec(content)) !== null) {
-            classes.push({
-                name: match[1],
-                line: content.substring(0, match.index).split('\n').length
-            });
-        }
-        return classes;
-    }
-    /**
-     * Find files that might contain the specified class
-     */
-    async findClassFiles(className, searchDir) {
-        const files = await this.multiFileAnalysis.discoverFiles(searchDir, ['.js', '.ts', '.jsx', '.tsx', '.php', '.py', '.java'], 3);
-        const classFiles = [];
-        for (const file of files) {
-            try {
-                const content = await readFileContent(file);
-                if (this.fileContainsClass(content, className)) {
-                    classFiles.push(file);
-                }
-            }
-            catch (error) {
-                // Skip files we can't read
-            }
-        }
-        return classFiles;
-    }
-    fileContainsClass(content, className) {
-        const classPatterns = [
-            new RegExp(`class\\s+${className}\\s*{`, 'i'),
-            new RegExp(`class\\s+${className}\\s+extends`, 'i'),
-            new RegExp(`class\\s+${className}\\s+implements`, 'i'),
-            new RegExp(`export\\s+class\\s+${className}`, 'i'),
-            new RegExp(`function\\s+${className}\\s*\\(`, 'i'), // Constructor function
-        ];
-        return classPatterns.some(pattern => pattern.test(content));
-    }
-    generateCacheKey(files, params) {
-        const fileHash = files.join('|');
-        const paramHash = JSON.stringify(params);
-        return `${fileHash}_${paramHash}`.substring(0, 64);
-    }
-}
-export default MethodSignatureDiffer;
-//# sourceMappingURL=diff-signatures.js.map