@houtini/lm 1.0.0

package/dist/prompts/analyze/compare-integration.d.ts

@@ -0,0 +1,130 @@
+/**
+ * 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 { IPromptPlugin } from '../shared/types.js';
+import { PromptStages } from '../../types/prompt-stages.js';
+export declare class IntegrationComparator extends BasePlugin implements IPromptPlugin {
+    name: string;
+    category: "analyze";
+    description: string;
+    parameters: {
+        code: {
+            type: "string";
+            description: string;
+            required: boolean;
+        };
+        filePath: {
+            type: "string";
+            description: string;
+            required: boolean;
+        };
+        projectPath: {
+            type: "string";
+            description: string;
+            required: boolean;
+        };
+        files: {
+            type: "array";
+            description: string;
+            required: boolean;
+            items: {
+                type: "string";
+            };
+        };
+        maxDepth: {
+            type: "number";
+            description: string;
+            required: boolean;
+            default: number;
+        };
+        language: {
+            type: "string";
+            description: string;
+            required: boolean;
+            default: string;
+        };
+        analysisDepth: {
+            type: "string";
+            description: string;
+            enum: string[];
+            default: string;
+            required: boolean;
+        };
+        analysisType: {
+            type: "string";
+            description: string;
+            enum: string[];
+            default: string;
+            required: boolean;
+        };
+        focus: {
+            type: "array";
+            description: string;
+            required: boolean;
+            default: any[];
+            items: {
+                type: "string";
+            };
+        };
+    };
+    private analysisCache;
+    private multiFileAnalysis;
+    constructor();
+    execute(params: any, llmClient: any): Promise<any>;
+    /**
+     * Auto-detect whether this is single-file or multi-file analysis
+     * Integration comparison is primarily a multi-file operation
+     */
+    private detectAnalysisMode;
+    /**
+     * Validate parameters based on detected analysis mode
+     */
+    private validateParameters;
+    /**
+     * Execute single-file analysis for integration patterns
+     */
+    private executeSingleFileAnalysis;
+    /**
+     * Execute multi-file analysis for cross-file integration
+     */
+    private executeMultiFileAnalysis;
+    /**
+     * Single-file integration pattern analysis
+     */
+    private getSingleFilePromptStages;
+    /**
+     * Multi-file cross-integration analysis
+     */
+    private getMultiFilePromptStages;
+    /**
+     * Backwards compatibility method
+     */
+    getPromptStages(params: any): PromptStages;
+    private discoverRelevantFiles;
+    private performMultiFileAnalysis;
+    private analyzeIndividualFile;
+    private countExports;
+    private countImports;
+    private countMethods;
+    private countInterfaces;
+    private identifyIntegrationPatterns;
+    private identifyPotentialIssues;
+    private extractExports;
+    private extractImports;
+    private extractMethods;
+    private extractInterfaces;
+    private extractFileImports;
+    private extractFileExports;
+    private extractFileMethods;
+    private extractFileInterfaces;
+    private getFileExtensions;
+    private generateCacheKey;
+}
+export default IntegrationComparator;
+//# sourceMappingURL=compare-integration.d.ts.map

package/dist/prompts/analyze/compare-integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare-integration.d.ts","sourceRoot":"","sources":["../../../src/prompts/analyze/compare-integration.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAY5D,qBAAa,qBAAsB,SAAQ,UAAW,YAAW,aAAa;IAC5E,IAAI,SAAyB;IAC7B,QAAQ,EAAG,SAAS,CAAU;IAC9B,WAAW,SAA+J;IAG1K,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4DR;IAEF,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,iBAAiB,CAA2B;;IAO9C,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG;IAyBzC;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAe1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAmB1B;;OAEG;YACW,yBAAyB;IA0CvC;;OAEG;YACW,wBAAwB;IA0CtC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAwDjC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAmGhC;;OAEG;IACH,eAAe,CAAC,MAAM,EAAE,GAAG,GAAG,YAAY;YAW5B,qBAAqB;YASrB,wBAAwB;YAsDxB,qBAAqB;IA2BnC,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,2BAA2B;IAenC,OAAO,CAAC,uBAAuB;IAgB/B,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,iBAAiB;IAKzB,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,kBAAkB;IAgB1B,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,gBAAgB;CAKzB;AAED,eAAe,qBAAqB,CAAC"}

package/dist/prompts/analyze/compare-integration.js

@@ -0,0 +1,543 @@
+/**
+ * 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 } from '../../utils/plugin-utilities.js';
+import { getAnalysisCache } from '../../cache/index.js';
+export class IntegrationComparator extends BasePlugin {
+    constructor() {
+        super();
+        this.name = 'compare_integration';
+        this.category = 'analyze';
+        this.description = 'Compare integration between multiple files to identify mismatches, missing imports, and compatibility issues. Returns actionable fixes with line numbers.';
+        // 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 absolute file paths to analyze',
+                required: false,
+                items: { type: 'string' }
+            },
+            maxDepth: {
+                type: 'number',
+                description: 'Maximum directory depth for multi-file discovery (1-5)',
+                required: false,
+                default: 3
+            },
+            // 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 integration analysis to perform',
+                enum: ['integration', 'compatibility', 'dependencies'],
+                default: 'integration',
+                required: false
+            },
+            focus: {
+                type: 'array',
+                description: 'Specific areas to focus on: method_compatibility, namespace_dependencies, data_flow, missing_connections',
+                required: false,
+                default: [],
+                items: { type: 'string' }
+            }
+        };
+        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('compare_integration', error);
+            }
+        });
+    }
+    /**
+     * Auto-detect whether this is single-file or multi-file analysis
+     * Integration comparison is primarily a multi-file operation
+     */
+    detectAnalysisMode(params) {
+        // Single-file indicators (for analyzing integration patterns within one file)
+        if (params.code || (params.filePath && !params.files && !params.projectPath)) {
+            return 'single-file';
+        }
+        // Multi-file indicators - primary use case
+        if (params.projectPath || params.files) {
+            return 'multi-file';
+        }
+        // Default to multi-file for integration 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, we need either projectPath OR files (at least 2)
+            if (!params.projectPath && (!params.files || params.files.length < 2)) {
+                throw new Error('Multi-file integration analysis requires either projectPath or at least 2 files');
+            }
+            if (params.projectPath) {
+                ParameterValidator.validateProjectPath(params);
+                ParameterValidator.validateDepth(params);
+            }
+        }
+        // Universal validations
+        ParameterValidator.validateEnum(params, 'analysisType', ['integration', 'compatibility', 'dependencies']);
+        ParameterValidator.validateEnum(params, 'analysisDepth', ['basic', 'detailed', 'comprehensive']);
+    }
+    /**
+     * Execute single-file analysis for integration patterns
+     */
+    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(contextLength);
+        const needsChunking = promptManager.needsChunking(promptStages);
+        if (needsChunking) {
+            const conversation = promptManager.createChunkedConversation(promptStages);
+            const messages = [
+                conversation.systemMessage,
+                ...conversation.dataMessages,
+                conversation.analysisMessage
+            ];
+            return await ResponseProcessor.executeChunked(messages, model, contextLength, 'compare_integration', 'single');
+        }
+        else {
+            return await ResponseProcessor.executeDirect(promptStages, model, contextLength, 'compare_integration');
+        }
+    }
+    /**
+     * Execute multi-file analysis for cross-file integration
+     */
+    async executeMultiFileAnalysis(params, model, contextLength) {
+        // Discover files
+        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(contextLength);
+        const conversation = promptManager.createChunkedConversation(promptStages);
+        const messages = [
+            conversation.systemMessage,
+            ...conversation.dataMessages,
+            conversation.analysisMessage
+        ];
+        return await ResponseProcessor.executeChunked(messages, model, contextLength, 'compare_integration', 'multifile');
+    }
+    /**
+     * Single-file integration pattern analysis
+     */
+    getSingleFilePromptStages(params) {
+        const { code, language, analysisDepth, analysisType, focus } = params;
+        const systemAndContext = `You are a senior software architect and integration specialist with 15+ years of experience analyzing ${language} codebases.
+
+**ANALYSIS CONTEXT:**
+- Language: ${language}
+- Analysis Depth: ${analysisDepth}
+- Analysis Type: ${analysisType}
+- Focus Areas: ${focus && focus.length > 0 ? focus.join(', ') : 'General integration patterns'}
+- Mode: Single File Integration Pattern Analysis
+
+**YOUR EXPERTISE:**
+- Deep understanding of integration patterns and anti-patterns
+- Master of API design, interface contracts, and dependency management
+- Expert in identifying potential integration issues before they cause runtime problems
+- Specialist in providing actionable, specific recommendations with code examples
+
+Your task is to analyze this single file for integration readiness, interface design quality, and potential compatibility issues with other components.`;
+        const dataPayload = `**FILE TO ANALYZE FOR INTEGRATION PATTERNS:**
+
+\`\`\`${language}
+${code}
+\`\`\``;
+        const outputInstructions = `**PROVIDE CLEAN MARKDOWN INTEGRATION ANALYSIS:**
+
+# Single File Integration Analysis
+
+## Integration Readiness: [Excellent/Good/Fair/Poor]
+
+## Key Findings
+- **Interface Quality**: [Assessment of exports/public methods]
+- **Dependency Health**: [Import/dependency structure assessment]
+- **Contract Clarity**: [Method signatures and types assessment]
+
+## Integration Issues Found
+
+### Critical Issues
+- [Issue description with line numbers if applicable]
+
+### Recommendations  
+1. [Specific actionable recommendations]
+2. [Interface improvements needed]
+3. [Type safety enhancements]
+
+## Integration Strengths
+- [Good patterns already in use]
+- [Defensive programming practices]
+
+**Analysis Complete** - Focus on actionable insights, not raw code dumps.`;
+        return { systemAndContext, dataPayload, outputInstructions };
+    }
+    /**
+     * Multi-file cross-integration analysis
+     */
+    getMultiFilePromptStages(params) {
+        const { analysisResult, analysisType, analysisDepth, fileCount, focus } = params;
+        const systemAndContext = `You are a senior software architect and integration specialist with 15+ years of experience analyzing complex multi-file systems.
+
+**ANALYSIS CONTEXT:**
+- Analysis Type: ${analysisType}
+- Analysis Depth: ${analysisDepth}  
+- Files Analyzed: ${fileCount}
+- Focus Areas: ${focus && focus.length > 0 ? focus.join(', ') : 'Comprehensive integration analysis'}
+- Mode: Multi-File Integration Comparison
+
+**YOUR EXPERTISE:**
+- Master of cross-file dependency analysis and interface compatibility
+- Expert in identifying integration anti-patterns that cause runtime failures
+- Specialist in API contract validation and method signature compatibility
+- Authority on data flow analysis and architectural integration patterns
+- Expert at providing specific, actionable fixes with line numbers and code examples
+
+**CRITICAL ANALYSIS AREAS:**
+- Method signature mismatches between files
+- Missing imports and unused exports
+- Data type incompatibilities across interfaces  
+- Circular dependency detection
+- Interface contract violations
+- Error handling consistency across file boundaries
+
+Your task is to perform deep cross-file integration analysis, identifying ALL compatibility issues with specific fixes.`;
+        const dataPayload = `**MULTI-FILE INTEGRATION ANALYSIS DATA:**
+
+${JSON.stringify(analysisResult, null, 2)}`;
+        const outputInstructions = `**PROVIDE CLEAN MARKDOWN MULTI-FILE INTEGRATION ANALYSIS:**
+
+# Multi-File Integration Analysis Report
+
+## Executive Summary
+- **Overall Integration Health**: [Excellent/Good/Fair/Poor/Critical]
+- **Files Analyzed**: ${fileCount}
+- **Critical Issues**: [Count]
+- **Integration Risk**: [Low/Medium/High/Critical]
+
+## Key Integration Issues Found
+
+### 🚨 Critical Issues (Fix Immediately)
+1. **[Issue Type]** in [filename.ts:123]
+   - **Problem**: [Brief description]
+   - **Impact**: [What breaks]
+   - **Fix**: [Specific solution]
+
+### ⚠️ High Priority Issues
+1. **[Issue Type]** between [file1.ts] and [file2.ts]  
+   - **Problem**: [Description]
+   - **Fix**: [Solution]
+
+### 📋 Medium Priority Issues
+- [List of less critical but important issues]
+
+## Method Compatibility Analysis
+- **Compatible Calls**: [Count] ✅
+- **Signature Mismatches**: [Count] ❌
+- **Missing Implementations**: [Count] ⚠️
+
+## Import/Export Health
+- **Clean Dependencies**: [Count] ✅
+- **Unused Exports**: [Count] 🧹
+- **Missing Imports**: [Count] ❌
+- **Circular Dependencies**: [Count] 🔄
+
+## Architecture Assessment
+- **Design Patterns**: [Good patterns found]
+- **Anti-Patterns**: [Problematic patterns]
+- **Coupling**: [Tight/Loose assessment]
+
+## Priority Action Plan
+
+### Phase 1: Critical Fixes (Do First)
+1. [Fix critical integration breakages]
+2. [Resolve method signature mismatches]
+
+### Phase 2: Improvements (Do Next)
+1. [Clean up unused exports]
+2. [Improve interface consistency]
+
+### Phase 3: Long-term (Do Later)  
+1. [Architectural improvements]
+2. [Enhanced error handling]
+
+## Integration Testing Recommendations
+- [Specific integration tests to write]
+- [Mock strategies to use]
+- [Error scenarios to test]
+
+**Analysis Complete** - Focused on actionable insights, not data dumps.`;
+        return { systemAndContext, dataPayload, outputInstructions };
+    }
+    /**
+     * Backwards compatibility method
+     */
+    getPromptStages(params) {
+        const mode = this.detectAnalysisMode(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('compare_integration', 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 for integration analysis (focus on insights, not raw content)
+        const aggregatedResult = {
+            summary: `Integration analysis of ${files.length} files`,
+            integrationInsights: {
+                fileCount: files.length,
+                totalSize: fileAnalysisResults.reduce((sum, result) => sum + (result.size || 0), 0),
+                exportCount: this.countExports(fileAnalysisResults),
+                importCount: this.countImports(fileAnalysisResults),
+                methodCount: this.countMethods(fileAnalysisResults),
+                interfaceCount: this.countInterfaces(fileAnalysisResults),
+                integrationPatterns: this.identifyIntegrationPatterns(fileAnalysisResults),
+                potentialIssues: this.identifyPotentialIssues(fileAnalysisResults)
+            },
+            fileList: fileAnalysisResults.map(f => ({
+                fileName: f.fileName,
+                filePath: f.filePath,
+                size: f.size,
+                lines: f.lines,
+                hasExports: f.integrationInfo?.exports?.length > 0,
+                hasImports: f.integrationInfo?.imports?.length > 0,
+                methodCount: f.integrationInfo?.methods?.length || 0
+            }))
+        };
+        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'));
+        const stats = await import('fs/promises').then(fs => fs.stat(file));
+        // Extract integration-relevant information
+        const imports = this.extractFileImports(content);
+        const exports = this.extractFileExports(content);
+        const methods = this.extractFileMethods(content);
+        const interfaces = this.extractFileInterfaces(content);
+        return {
+            filePath: file,
+            fileName: file.split(/[/\\]/).pop(),
+            size: content.length,
+            lines: content.split('\n').length,
+            extension: file.split('.').pop() || '',
+            modified: stats.mtime,
+            content: content.length < 2000 ? content : `[${content.length} characters] - Content available for analysis`, // Minimal content for context
+            integrationInfo: {
+                imports,
+                exports,
+                methods,
+                interfaces
+            }
+        };
+    }
+    countExports(fileResults) {
+        return fileResults.reduce((sum, file) => sum + (file.integrationInfo?.exports?.length || 0), 0);
+    }
+    countImports(fileResults) {
+        return fileResults.reduce((sum, file) => sum + (file.integrationInfo?.imports?.length || 0), 0);
+    }
+    countMethods(fileResults) {
+        return fileResults.reduce((sum, file) => sum + (file.integrationInfo?.methods?.length || 0), 0);
+    }
+    countInterfaces(fileResults) {
+        return fileResults.reduce((sum, file) => sum + (file.integrationInfo?.interfaces?.length || 0), 0);
+    }
+    identifyIntegrationPatterns(fileResults) {
+        const patterns = [];
+        // Simple pattern detection based on file analysis
+        if (fileResults.some(f => f.fileName?.includes('base-') || f.fileName?.includes('Base'))) {
+            patterns.push('Inheritance Pattern');
+        }
+        if (fileResults.some(f => f.fileName?.includes('interface') || f.fileName?.includes('Interface'))) {
+            patterns.push('Interface Segregation');
+        }
+        if (fileResults.some(f => f.fileName?.includes('factory') || f.fileName?.includes('Factory'))) {
+            patterns.push('Factory Pattern');
+        }
+        return patterns;
+    }
+    identifyPotentialIssues(fileResults) {
+        const issues = [];
+        // Simple issue detection
+        const largeFiles = fileResults.filter(f => f.size > 50000);
+        if (largeFiles.length > 0) {
+            issues.push(`Large files detected: ${largeFiles.length} files > 50KB`);
+        }
+        const filesWithManyMethods = fileResults.filter(f => (f.integrationInfo?.methods?.length || 0) > 20);
+        if (filesWithManyMethods.length > 0) {
+            issues.push(`High method count: ${filesWithManyMethods.length} files with >20 methods`);
+        }
+        return issues;
+    }
+    extractExports(fileResults) {
+        return fileResults.flatMap(file => file.integrationInfo?.exports || []);
+    }
+    extractImports(fileResults) {
+        return fileResults.flatMap(file => file.integrationInfo?.imports || []);
+    }
+    extractMethods(fileResults) {
+        return fileResults.flatMap(file => file.integrationInfo?.methods || []);
+    }
+    extractInterfaces(fileResults) {
+        return fileResults.flatMap(file => file.integrationInfo?.interfaces || []);
+    }
+    // Simple pattern matching for integration elements (can be enhanced)
+    extractFileImports(content) {
+        const importRegex = /import\s+.*\s+from\s+['"`]([^'"`]+)['"`]/g;
+        const imports = [];
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+            imports.push({
+                module: match[1],
+                line: content.substring(0, match.index).split('\n').length
+            });
+        }
+        return imports;
+    }
+    extractFileExports(content) {
+        const exportRegex = /export\s+(function|class|const|let|var|interface|type)\s+(\w+)/g;
+        const exports = [];
+        let match;
+        while ((match = exportRegex.exec(content)) !== null) {
+            exports.push({
+                type: match[1],
+                name: match[2],
+                line: content.substring(0, match.index).split('\n').length
+            });
+        }
+        return exports;
+    }
+    extractFileMethods(content) {
+        const methodRegex = /(function\s+(\w+)|(\w+)\s*\(.*?\)\s*[{:])/g;
+        const methods = [];
+        let match;
+        while ((match = methodRegex.exec(content)) !== null) {
+            methods.push({
+                name: match[2] || match[3],
+                line: content.substring(0, match.index).split('\n').length
+            });
+        }
+        return methods;
+    }
+    extractFileInterfaces(content) {
+        const interfaceRegex = /interface\s+(\w+)/g;
+        const interfaces = [];
+        let match;
+        while ((match = interfaceRegex.exec(content)) !== null) {
+            interfaces.push({
+                name: match[1],
+                line: content.substring(0, match.index).split('\n').length
+            });
+        }
+        return interfaces;
+    }
+    getFileExtensions(analysisType) {
+        const extensionMap = {
+            'integration': ['.js', '.ts', '.jsx', '.tsx', '.py', '.php', '.java', '.cs'],
+            'compatibility': ['.js', '.ts', '.jsx', '.tsx', '.d.ts'],
+            'dependencies': ['.js', '.ts', '.jsx', '.tsx', '.json', '.package.json']
+        };
+        return extensionMap[analysisType] || extensionMap.integration;
+    }
+    generateCacheKey(files, params) {
+        const fileHash = files.join('|');
+        const paramHash = JSON.stringify(params);
+        return `${fileHash}_${paramHash}`.substring(0, 64);
+    }
+}
+export default IntegrationComparator;
+//# sourceMappingURL=compare-integration.js.map