code-auditor-mcp 3.4.11 → 3.4.13

package/dist/languages/RuntimeManager.js

@@ -7,7 +7,10 @@ import { promisify } from 'util';
 import * as path from 'path';
 import * as fs from 'fs/promises';
 const execAsync = promisify(exec);
-export class RuntimeManager {
+// ---------------------------------------------------------------------------
+// Detection layer: shared state + runtime discovery (leaf — no cross-layer calls)
+// ---------------------------------------------------------------------------
+class RuntimeManagerDetection {
     runtimes = new Map();
     initialized = false;
     config = new Map();
@@ -35,217 +38,6 @@ export class RuntimeManager {
         console.error('[RuntimeManager] Runtime detection complete');
         this.logRuntimeStatus();
     }
-    /**
-     * Check if a specific runtime is available
-     */
-    hasRuntime(name) {
-        const runtime = this.runtimes.get(name);
-        const config = this.config.get(name);
-        return runtime?.available === true &&
-            (config?.enabled !== false) &&
-            this.checkVersionCompatibility(runtime, config);
-    }
-    /**
-     * Get fallback runtime for a language if the primary is unavailable
-     */
-    getFallbackRuntime(language) {
-        const fallbackMap = {
-            'typescript': ['node', 'deno', 'bun'],
-            'javascript': ['node', 'deno', 'bun'],
-            'go': ['go'],
-            'python': ['python'],
-            'rust': ['rust']
-        };
-        const fallbacks = fallbackMap[language] || [];
-        for (const fallback of fallbacks) {
-            if (this.hasRuntime(fallback)) {
-                const runtime = this.runtimes.get(fallback);
-                if (runtime?.analyzer?.supports.some(ext => this.getLanguageExtensions(language).includes(ext))) {
-                    return runtime;
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Get file extensions for a language
-     */
-    getLanguageExtensions(language) {
-        const extensionMap = {
-            'typescript': ['.ts', '.tsx'],
-            'javascript': ['.js', '.jsx'],
-            'go': ['.go'],
-            'python': ['.py'],
-            'rust': ['.rs']
-        };
-        return extensionMap[language] || [];
-    }
-    /**
-     * Attempt to analyze with fallback runtime if primary fails
-     */
-    async analyzeWithFallback(language, files, options) {
-        // Try primary runtime first
-        let result = await this.spawnAnalyzer(language, files, options);
-        if (result && result.errors?.length === 0) {
-            return result;
-        }
-        // If primary failed, try fallback
-        const fallbackRuntime = this.getFallbackRuntime(language);
-        if (fallbackRuntime) {
-            console.log(`[RuntimeManager] Primary ${language} runtime failed, trying fallback: ${fallbackRuntime.name}`);
-            try {
-                const fallbackResult = await fallbackRuntime.analyzer.analyze(files, {
-                    ...options,
-                    fallbackMode: true,
-                    originalLanguage: language
-                });
-                // Add warning about fallback usage
-                fallbackResult.errors = fallbackResult.errors || [];
-                fallbackResult.errors.push({
-                    message: `Analysis completed using fallback runtime ${fallbackRuntime.name} instead of native ${language} runtime`,
-                    type: 'fallback_warning',
-                    language
-                });
-                return fallbackResult;
-            }
-            catch (fallbackError) {
-                console.error(`[RuntimeManager] Fallback runtime also failed:`, fallbackError);
-            }
-        }
-        // No fallback available or fallback also failed
-        return {
-            violations: [],
-            indexEntries: [],
-            metrics: { filesAnalyzed: 0, executionTime: 0 },
-            errors: [{
-                    message: `No working runtime available for ${language}. Install ${language} runtime or enable fallback options.`,
-                    type: 'no_runtime',
-                    language,
-                    suggestions: this.getRuntimeInstallationSuggestions(language)
-                }]
-        };
-    }
-    /**
-     * Get installation suggestions for missing runtimes
-     */
-    getRuntimeInstallationSuggestions(language) {
-        const suggestions = {
-            'go': [
-                'Install Go: https://golang.org/dl/',
-                'Or use package manager: brew install go (macOS), apt install golang (Ubuntu)'
-            ],
-            'python': [
-                'Install Python: https://python.org/downloads/',
-                'Or use package manager: brew install python (macOS), apt install python3 (Ubuntu)'
-            ],
-            'rust': [
-                'Install Rust: https://rustup.rs/',
-                'Run: curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh'
-            ],
-            'node': [
-                'Install Node.js: https://nodejs.org/',
-                'Or use nvm: nvm install node'
-            ]
-        };
-        return suggestions[language] || ['Check the official documentation for installation instructions'];
-    }
-    /**
-     * Get runtime information
-     */
-    getRuntime(name) {
-        return this.runtimes.get(name);
-    }
-    /**
-     * Get all available runtimes
-     */
-    getAvailableRuntimes() {
-        return Array.from(this.runtimes.values()).filter(r => r.available);
-    }
-    /**
-     * Spawn analyzer for a specific language
-     */
-    async spawnAnalyzer(language, files, options) {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        const runtime = this.runtimes.get(language);
-        if (!runtime?.available || !runtime.analyzer) {
-            console.warn(`[RuntimeManager] No analyzer available for ${language}`);
-            return null;
-        }
-        console.log(`[RuntimeManager] Spawning ${language} analyzer for ${files.length} files`);
-        const startTime = Date.now();
-        const processTimeout = options?.timeout || 300000; // 5 minutes default
-        try {
-            const result = await this.runWithTimeout(() => runtime.analyzer.analyze(files, options), processTimeout);
-            const executionTime = Date.now() - startTime;
-            result.metrics.executionTime = executionTime;
-            console.log(`[RuntimeManager] ${language} analysis complete in ${executionTime}ms: ${result.violations.length} violations`);
-            return result;
-        }
-        catch (error) {
-            const executionTime = Date.now() - startTime;
-            console.error(`[RuntimeManager] Error in ${language} analyzer after ${executionTime}ms:`, error);
-            return {
-                violations: [],
-                indexEntries: [],
-                metrics: { filesAnalyzed: 0, executionTime },
-                errors: [{
-                        message: error instanceof Error ? error.message : String(error),
-                        language,
-                        type: error instanceof Error && error.message.includes('timeout') ? 'timeout' : 'runtime_error'
-                    }]
-            };
-        }
-    }
-    /**
-     * Run a function with timeout
-     */
-    async runWithTimeout(fn, timeoutMs) {
-        return new Promise((resolve, reject) => {
-            const timeoutId = setTimeout(() => {
-                reject(new Error(`Analysis timed out after ${timeoutMs}ms`));
-            }, timeoutMs);
-            fn()
-                .then(result => {
-                clearTimeout(timeoutId);
-                resolve(result);
-            })
-                .catch(error => {
-                clearTimeout(timeoutId);
-                reject(error);
-            });
-        });
-    }
-    /**
-     * Spawn multiple analyzers in parallel with concurrency control
-     */
-    async spawnMultipleAnalyzers(languageFilePairs, options) {
-        const maxConcurrency = options?.maxConcurrency || 3;
-        const results = [];
-        console.log(`[RuntimeManager] Spawning ${languageFilePairs.length} analyzers with max concurrency ${maxConcurrency}`);
-        // Process in batches to control concurrency
-        for (let i = 0; i < languageFilePairs.length; i += maxConcurrency) {
-            const batch = languageFilePairs.slice(i, i + maxConcurrency);
-            const batchPromises = batch.map(async ({ language, files }) => {
-                const result = await this.spawnAnalyzer(language, files, options);
-                return { language, result };
-            });
-            const batchResults = await Promise.all(batchPromises);
-            results.push(...batchResults);
-        }
-        return results;
-    }
-    /**
-     * Kill all running analyzer processes (for cleanup)
-     */
-    async killAllAnalyzers() {
-        console.log('[RuntimeManager] Killing all analyzer processes...');
-        // This is a placeholder for process management
-        // In future implementations, we'll track child processes and kill them here
-        // For now, we just log the action since our analyzers run in-process
-        console.log('[RuntimeManager] All analyzer processes terminated');
-    }
     /**
      * Detect Node.js runtime
      */
@@ -426,6 +218,23 @@ export class RuntimeManager {
             return false;
         }
     }
+    /**
+     * Log runtime status
+     */
+    logRuntimeStatus() {
+        console.log('\n[RuntimeManager] Runtime Status:');
+        for (const [name, runtime] of this.runtimes) {
+            const status = runtime.available ? '✅' : '❌';
+            const analyzer = runtime.analyzer ? '(analyzer available)' : '(no analyzer)';
+            console.log(`  ${status} ${runtime.name} ${runtime.version} ${analyzer}`);
+        }
+        console.log('');
+    }
+}
+// ---------------------------------------------------------------------------
+// Version layer: semantic-version comparison and compatibility reporting
+// ---------------------------------------------------------------------------
+class RuntimeManagerVersion extends RuntimeManagerDetection {
     /**
      * Check version compatibility with detailed reporting
      */
@@ -453,25 +262,14 @@ export class RuntimeManager {
             const config = this.config.get(name);
             const minVersion = config?.minVersion || runtime.minVersion;
             const compatible = this.checkVersionCompatibility(runtime, config);
-            let status;
-            let recommendations = [];
-            if (!runtime.available) {
-                status = 'unknown';
-                recommendations.push(`Install ${runtime.name} runtime`);
-                recommendations.push(...this.getRuntimeInstallationSuggestions(name));
-            }
-            else if (runtime.version === 'unknown') {
-                status = 'unknown';
-                recommendations.push(`Unable to detect ${runtime.name} version`);
-            }
-            else if (!compatible) {
-                status = 'incompatible';
-                recommendations.push(`Update ${runtime.name} to version ${minVersion} or higher`);
-                recommendations.push(`Current: ${runtime.version}, Required: ${minVersion}`);
-            }
-            else {
-                status = 'compatible';
-            }
+            const { status, recommendations } = deriveCompatibilityStatus({
+                name,
+                available: runtime.available,
+                version: runtime.version,
+                compatible,
+                minVersion,
+                installSuggestions: this.getRuntimeInstallationSuggestions(name)
+            });
             report.push({
                 runtime: runtime.name,
                 currentVersion: runtime.version,
@@ -552,16 +350,90 @@ export class RuntimeManager {
         return 0;
     }
     /**
-     * Log runtime status
+     * Get installation suggestions for missing runtimes
      */
-    logRuntimeStatus() {
-        console.log('\n[RuntimeManager] Runtime Status:');
-        for (const [name, runtime] of this.runtimes) {
-            const status = runtime.available ? '✅' : '❌';
-            const analyzer = runtime.analyzer ? '(analyzer available)' : '(no analyzer)';
-            console.log(`  ${status} ${runtime.name} ${runtime.version} ${analyzer}`);
+    getRuntimeInstallationSuggestions(language) {
+        const suggestions = {
+            'go': [
+                'Install Go: https://golang.org/dl/',
+                'Or use package manager: brew install go (macOS), apt install golang (Ubuntu)'
+            ],
+            'python': [
+                'Install Python: https://python.org/downloads/',
+                'Or use package manager: brew install python (macOS), apt install python3 (Ubuntu)'
+            ],
+            'rust': [
+                'Install Rust: https://rustup.rs/',
+                'Run: curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh'
+            ],
+            'node': [
+                'Install Node.js: https://nodejs.org/',
+                'Or use nvm: nvm install node'
+            ]
+        };
+        return suggestions[language] || ['Check the official documentation for installation instructions'];
+    }
+}
+// ---------------------------------------------------------------------------
+// Access layer: runtime lookup, fallback resolution, and statistics
+// ---------------------------------------------------------------------------
+class RuntimeManagerAccess extends RuntimeManagerVersion {
+    /**
+     * Check if a specific runtime is available
+     */
+    hasRuntime(name) {
+        const runtime = this.runtimes.get(name);
+        const config = this.config.get(name);
+        return runtime?.available === true &&
+            (config?.enabled !== false) &&
+            this.checkVersionCompatibility(runtime, config);
+    }
+    /**
+     * Get fallback runtime for a language if the primary is unavailable
+     */
+    getFallbackRuntime(language) {
+        const fallbackMap = {
+            'typescript': ['node', 'deno', 'bun'],
+            'javascript': ['node', 'deno', 'bun'],
+            'go': ['go'],
+            'python': ['python'],
+            'rust': ['rust']
+        };
+        const fallbacks = fallbackMap[language] || [];
+        for (const fallback of fallbacks) {
+            if (this.hasRuntime(fallback)) {
+                const runtime = this.runtimes.get(fallback);
+                if (runtime?.analyzer?.supports.some(ext => this.getLanguageExtensions(language).includes(ext))) {
+                    return runtime;
+                }
+            }
         }
-        console.log('');
+        return null;
+    }
+    /**
+     * Get file extensions for a language
+     */
+    getLanguageExtensions(language) {
+        const extensionMap = {
+            'typescript': ['.ts', '.tsx'],
+            'javascript': ['.js', '.jsx'],
+            'go': ['.go'],
+            'python': ['.py'],
+            'rust': ['.rs']
+        };
+        return extensionMap[language] || [];
+    }
+    /**
+     * Get runtime information
+     */
+    getRuntime(name) {
+        return this.runtimes.get(name);
+    }
+    /**
+     * Get all available runtimes
+     */
+    getAvailableRuntimes() {
+        return Array.from(this.runtimes.values()).filter(r => r.available);
     }
     /**
      * Get runtime statistics
@@ -585,6 +457,156 @@ export class RuntimeManager {
         };
     }
 }
+// ---------------------------------------------------------------------------
+// Spawning layer: analyzer process orchestration (public top layer)
+// ---------------------------------------------------------------------------
+/**
+ * Runtime manager.
+ */
+export class RuntimeManager extends RuntimeManagerAccess {
+    /**
+     * Attempt to analyze with fallback runtime if primary fails
+     * @param files
+     * @param language
+     * @param options
+     * @returns
+     */
+    async analyzeWithFallback(language, files, options) {
+        // Try primary runtime first
+        let result = await this.spawnAnalyzer(language, files, options);
+        if (result && result.errors?.length === 0) {
+            return result;
+        }
+        // If primary failed, try fallback
+        const fallbackRuntime = this.getFallbackRuntime(language);
+        if (fallbackRuntime) {
+            console.log(`[RuntimeManager] Primary ${language} runtime failed, trying fallback: ${fallbackRuntime.name}`);
+            try {
+                const fallbackResult = await fallbackRuntime.analyzer.analyze(files, {
+                    ...options,
+                    fallbackMode: true,
+                    originalLanguage: language
+                });
+                // Add warning about fallback usage
+                fallbackResult.errors = fallbackResult.errors || [];
+                fallbackResult.errors.push({
+                    message: `Analysis completed using fallback runtime ${fallbackRuntime.name} instead of native ${language} runtime`,
+                    type: 'fallback_warning',
+                    language
+                });
+                return fallbackResult;
+            }
+            catch (fallbackError) {
+                console.error(`[RuntimeManager] Fallback runtime also failed:`, fallbackError);
+            }
+        }
+        // No fallback available or fallback also failed
+        return {
+            violations: [],
+            indexEntries: [],
+            metrics: { filesAnalyzed: 0, executionTime: 0 },
+            errors: [{
+                    message: `No working runtime available for ${language}. Install ${language} runtime or enable fallback options.`,
+                    type: 'no_runtime',
+                    language,
+                    suggestions: this.getRuntimeInstallationSuggestions(language)
+                }]
+        };
+    }
+    /**
+     * Spawn analyzer for a specific language
+     * @param files
+     * @param language
+     * @param options
+     * @returns
+     */
+    async spawnAnalyzer(language, files, options) {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        const runtime = this.runtimes.get(language);
+        if (!runtime?.available || !runtime.analyzer) {
+            console.warn(`[RuntimeManager] No analyzer available for ${language}`);
+            return null;
+        }
+        console.log(`[RuntimeManager] Spawning ${language} analyzer for ${files.length} files`);
+        const startTime = Date.now();
+        const processTimeout = options?.timeout || 300000; // 5 minutes default
+        try {
+            const result = await this.runWithTimeout(() => runtime.analyzer.analyze(files, options), processTimeout);
+            const executionTime = Date.now() - startTime;
+            result.metrics.executionTime = executionTime;
+            console.log(`[RuntimeManager] ${language} analysis complete in ${executionTime}ms: ${result.violations.length} violations`);
+            return result;
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            console.error(`[RuntimeManager] Error in ${language} analyzer after ${executionTime}ms:`, error);
+            return {
+                violations: [],
+                indexEntries: [],
+                metrics: { filesAnalyzed: 0, executionTime },
+                errors: [{
+                        message: error instanceof Error ? error.message : String(error),
+                        language,
+                        type: error instanceof Error && error.message.includes('timeout') ? 'timeout' : 'runtime_error'
+                    }]
+            };
+        }
+    }
+    /**
+     * Run a function with timeout
+     */
+    async runWithTimeout(fn, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error(`Analysis timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            fn()
+                .then(result => {
+                clearTimeout(timeoutId);
+                resolve(result);
+            })
+                .catch(error => {
+                clearTimeout(timeoutId);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Spawn multiple analyzers in parallel with concurrency control
+     * @param languageFilePairs
+     * @param options
+     * @returns
+     */
+    async spawnMultipleAnalyzers(languageFilePairs, options) {
+        const maxConcurrency = options?.maxConcurrency || 3;
+        const results = [];
+        console.log(`[RuntimeManager] Spawning ${languageFilePairs.length} analyzers with max concurrency ${maxConcurrency}`);
+        // Process in batches to control concurrency
+        for (let i = 0; i < languageFilePairs.length; i += maxConcurrency) {
+            const batch = languageFilePairs.slice(i, i + maxConcurrency);
+            const batchPromises = batch.map(async ({ language, files }) => {
+                const result = await this.spawnAnalyzer(language, files, options);
+                return { language, result };
+            });
+            const batchResults = await Promise.all(batchPromises);
+            results.push(...batchResults);
+        }
+        return results;
+    }
+    /**
+     * Kill all running analyzer processes (for cleanup)
+     * @returns
+     */
+    async killAllAnalyzers() {
+        console.log('[RuntimeManager] Killing all analyzer processes...');
+        // This is a placeholder for process management
+        // In future implementations, we'll track child processes and kill them here
+        // For now, we just log the action since our analyzers run in-process
+        console.log('[RuntimeManager] All analyzer processes terminated');
+    }
+}
 // Enhanced TypeScript analyzer that integrates with existing infrastructure
 class TypeScriptAnalyzer {
     name = 'typescript';
@@ -605,73 +627,15 @@ class TypeScriptAnalyzer {
                 minSeverity: options?.minSeverity || 'warning',
                 verbose: false
             });
-            // Extract index entries from the audit process
-            const indexEntries = [];
-            // Try to get functions from the audit metadata if available
-            if (auditResult.metadata?.collectedFunctions) {
-                for (const func of auditResult.metadata.collectedFunctions) {
-                    indexEntries.push({
-                        id: `typescript:function:${func.filePath}:${func.name}:${func.lineNumber || 0}`,
-                        name: func.name,
-                        type: 'function',
-                        language: 'typescript',
-                        file: func.filePath,
-                        signature: func.name, // Basic signature
-                        parameters: [],
-                        purpose: func.purpose || '',
-                        context: func.context || '',
-                        startLine: func.startLine,
-                        endLine: func.endLine,
-                        lineNumber: func.lineNumber,
-                        metadata: func.metadata
-                    });
-                }
-            }
-            // Add component information if available
-            if (auditResult.metadata?.fileToFunctionsMap) {
-                for (const [filePath, funcs] of Object.entries(auditResult.metadata.fileToFunctionsMap)) {
-                    for (const func of funcs) {
-                        if (!indexEntries.find(e => e.id === `typescript:function:${func.filePath}:${func.name}:${func.lineNumber || 0}`)) {
-                            indexEntries.push({
-                                id: `typescript:function:${func.filePath}:${func.name}:${func.lineNumber || 0}`,
-                                name: func.name,
-                                type: 'function',
-                                language: 'typescript',
-                                file: func.filePath,
-                                signature: func.name,
-                                parameters: [],
-                                purpose: func.purpose || '',
-                                context: func.context || '',
-                                startLine: func.startLine,
-                                endLine: func.endLine,
-                                lineNumber: func.lineNumber,
-                                metadata: func.metadata
-                            });
-                        }
-                    }
-                }
-            }
             const executionTime = Date.now() - startTime;
-            // Extract violations from all analyzer results
-            const violations = [];
-            for (const [analyzerName, analyzerResult] of Object.entries(auditResult.analyzerResults)) {
-                violations.push(...analyzerResult.violations);
-            }
-            // Extract errors from analyzer results
-            const errors = [];
-            for (const [analyzerName, analyzerResult] of Object.entries(auditResult.analyzerResults)) {
-                if (analyzerResult.errors) {
-                    errors.push(...analyzerResult.errors);
-                }
-            }
             return {
-                violations,
-                indexEntries,
+                violations: extractViolations(auditResult),
+                indexEntries: collectIndexEntries(auditResult.metadata),
                 metrics: {
                     filesAnalyzed: files.length,
                     executionTime
                 },
-                errors
+                errors: extractErrors(auditResult)
             };
         }
         catch (error) {
@@ -692,6 +656,63 @@ class TypeScriptAnalyzer {
         }
     }
 }
+/** Build a single function index entry from a collected-function record. */
+function toFunctionIndexEntry(func) {
+    return {
+        id: `typescript:function:${func.filePath}:${func.name}:${func.lineNumber || 0}`,
+        name: func.name,
+        type: 'function',
+        language: 'typescript',
+        file: func.filePath,
+        signature: func.name,
+        parameters: [],
+        purpose: func.purpose || '',
+        context: func.context || '',
+        startLine: func.startLine,
+        endLine: func.endLine,
+        lineNumber: func.lineNumber,
+        metadata: func.metadata
+    };
+}
+/** Extract function index entries from audit metadata (dedup across both maps). */
+function collectIndexEntries(metadata) {
+    const indexEntries = [];
+    // Try to get functions from the audit metadata if available
+    if (metadata?.collectedFunctions) {
+        for (const func of metadata.collectedFunctions) {
+            indexEntries.push(toFunctionIndexEntry(func));
+        }
+    }
+    // Add component information if available
+    if (metadata?.fileToFunctionsMap) {
+        for (const funcs of Object.values(metadata.fileToFunctionsMap)) {
+            for (const func of funcs) {
+                if (!indexEntries.find(e => e.id === `typescript:function:${func.filePath}:${func.name}:${func.lineNumber || 0}`)) {
+                    indexEntries.push(toFunctionIndexEntry(func));
+                }
+            }
+        }
+    }
+    return indexEntries;
+}
+/** Flatten violations from all analyzer results. */
+function extractViolations(auditResult) {
+    const violations = [];
+    for (const analyzerResult of Object.values(auditResult.analyzerResults ?? {})) {
+        violations.push(...analyzerResult.violations);
+    }
+    return violations;
+}
+/** Flatten errors from all analyzer results. */
+function extractErrors(auditResult) {
+    const errors = [];
+    for (const analyzerResult of Object.values(auditResult.analyzerResults ?? {})) {
+        if (analyzerResult.errors) {
+            errors.push(...analyzerResult.errors);
+        }
+    }
+    return errors;
+}
 class GoAnalyzer {
     analyzerPath;
     name = 'go';
@@ -766,55 +787,7 @@ class GoAnalyzer {
     }
     async runGoAnalyzer(goDir, files, options) {
         const binaryPath = path.join(goDir, 'analyzer');
-        return new Promise((resolve, reject) => {
-            const child = spawn(binaryPath, [], {
-                stdio: ['pipe', 'pipe', 'pipe'],
-                cwd: goDir
-            });
-            let stdout = '';
-            let stderr = '';
-            child.stdout?.on('data', (data) => {
-                stdout += data.toString();
-            });
-            child.stderr?.on('data', (data) => {
-                stderr += data.toString();
-            });
-            child.on('close', (code) => {
-                if (code !== 0) {
-                    reject(new Error(`Go analyzer exited with code ${code}: ${stderr}`));
-                    return;
-                }
-                try {
-                    // Parse the last line as JSON response
-                    const lines = stdout.trim().split('\n');
-                    const lastLine = lines[lines.length - 1];
-                    const response = JSON.parse(lastLine);
-                    if (response.error) {
-                        reject(new Error(`Go analyzer error: ${response.error.message}`));
-                    }
-                    else {
-                        resolve(response.result);
-                    }
-                }
-                catch (parseError) {
-                    reject(new Error(`Failed to parse Go analyzer response: ${parseError}`));
-                }
-            });
-            child.on('error', (error) => {
-                reject(new Error(`Failed to spawn Go analyzer: ${error}`));
-            });
-            // Send JSON-RPC request
-            const request = {
-                method: 'analyze',
-                params: {
-                    files,
-                    options
-                },
-                id: 1
-            };
-            child.stdin?.write(JSON.stringify(request) + '\n');
-            child.stdin?.end();
-        });
+        return spawnGoAnalyzer(binaryPath, goDir, files, options);
     }
 }
 class PythonAnalyzer {
@@ -838,4 +811,86 @@ class PythonAnalyzer {
         };
     }
 }
+/**
+ * Derive compatibility status + recommendations for a single runtime.
+ */
+function deriveCompatibilityStatus(input) {
+    const recommendations = [];
+    if (!input.available) {
+        recommendations.push(`Install ${input.name} runtime`);
+        recommendations.push(...input.installSuggestions);
+        return { status: 'unknown', recommendations };
+    }
+    if (input.version === 'unknown') {
+        recommendations.push(`Unable to detect ${input.name} version`);
+        return { status: 'unknown', recommendations };
+    }
+    if (!input.compatible) {
+        recommendations.push(`Update ${input.name} to version ${input.minVersion} or higher`);
+        recommendations.push(`Current: ${input.version}, Required: ${input.minVersion}`);
+        return { status: 'incompatible', recommendations };
+    }
+    return { status: 'compatible', recommendations };
+}
+/**
+ * Spawn the Go analyzer binary and stream a JSON-RPC analyze request.
+ */
+function spawnGoAnalyzer(binaryPath, goDir, files, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(binaryPath, [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd: goDir
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            handleGoAnalyzerClose(code, { stdout, stderr }, resolve, reject);
+        });
+        child.on('error', (error) => {
+            reject(new Error(`Failed to spawn Go analyzer: ${error}`));
+        });
+        // Send JSON-RPC request
+        const request = {
+            method: 'analyze',
+            params: { files, options },
+            id: 1
+        };
+        child.stdin?.write(JSON.stringify(request) + '\n');
+        child.stdin?.end();
+    });
+}
+/**
+ * Handle the `close` event of the Go analyzer child process: reject on a
+ * non-zero exit code, otherwise resolve with the parsed JSON-RPC result.
+ */
+function handleGoAnalyzerClose(code, streams, resolve, reject) {
+    if (code !== 0) {
+        reject(new Error(`Go analyzer exited with code ${code}: ${streams.stderr}`));
+        return;
+    }
+    try {
+        resolve(parseGoAnalyzerResponse(streams.stdout));
+    }
+    catch (parseError) {
+        reject(new Error(`Failed to parse Go analyzer response: ${parseError}`));
+    }
+}
+/**
+ * Parse the last line of Go analyzer stdout as a JSON-RPC result.
+ */
+function parseGoAnalyzerResponse(stdout) {
+    const lines = stdout.trim().split('\n');
+    const lastLine = lines[lines.length - 1];
+    const response = JSON.parse(lastLine);
+    if (response.error) {
+        throw new Error(`Go analyzer error: ${response.error.message}`);
+    }
+    return response.result;
+}
 //# sourceMappingURL=RuntimeManager.js.map