@su-record/vibe 0.1.0

package/mcp/dist/lib/ProjectCache.js

@@ -0,0 +1,126 @@
+// Project caching utility for ts-morph (v1.3)
+// Implements LRU cache to avoid re-parsing on every request
+import { Project } from 'ts-morph';
+import path from 'path';
+export class ProjectCache {
+    static instance = null;
+    cache = new Map();
+    MAX_CACHE_SIZE = 5;
+    CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+    MAX_TOTAL_MEMORY_MB = 200; // Max 200MB total cache
+    MAX_PROJECT_MEMORY_MB = 100; // Max 100MB per project
+    constructor() { }
+    static getInstance() {
+        if (!ProjectCache.instance) {
+            ProjectCache.instance = new ProjectCache();
+        }
+        return ProjectCache.instance;
+    }
+    getOrCreate(projectPath) {
+        // Normalize path and remove trailing slashes
+        let normalizedPath = path.normalize(projectPath);
+        if (normalizedPath.endsWith(path.sep) && normalizedPath.length > 1) {
+            normalizedPath = normalizedPath.slice(0, -1);
+        }
+        const now = Date.now();
+        // Check if cached and not expired
+        const cached = this.cache.get(normalizedPath);
+        if (cached && (now - cached.lastAccess) < this.CACHE_TTL) {
+            cached.lastAccess = now;
+            return cached.project;
+        }
+        // Remove expired entries
+        this.removeExpired();
+        // LRU eviction if cache is full
+        if (this.cache.size >= this.MAX_CACHE_SIZE) {
+            this.evictLRU();
+        }
+        // Create new project
+        const project = new Project({
+            useInMemoryFileSystem: false,
+            compilerOptions: {
+                allowJs: true,
+                skipLibCheck: true,
+                noEmit: true
+            }
+        });
+        // Add source files
+        const pattern = path.join(normalizedPath, '**/*.{ts,tsx,js,jsx}');
+        project.addSourceFilesAtPaths(pattern);
+        const sourceFiles = project.getSourceFiles();
+        const fileCount = sourceFiles.length;
+        // Estimate memory usage (rough: 1MB base + 0.5MB per file)
+        const estimatedMemoryMB = 1 + (fileCount * 0.5);
+        // Skip caching if project is too large
+        if (estimatedMemoryMB > this.MAX_PROJECT_MEMORY_MB) {
+            console.warn(`Project ${normalizedPath} is too large (${estimatedMemoryMB}MB, ${fileCount} files) - not caching`);
+            return project;
+        }
+        // Check total cache memory before adding
+        const totalMemory = this.getTotalMemoryUsage();
+        if (totalMemory + estimatedMemoryMB > this.MAX_TOTAL_MEMORY_MB) {
+            // Evict projects until we have enough space
+            while (this.getTotalMemoryUsage() + estimatedMemoryMB > this.MAX_TOTAL_MEMORY_MB && this.cache.size > 0) {
+                this.evictLRU();
+            }
+        }
+        this.cache.set(normalizedPath, {
+            project,
+            lastAccess: now,
+            fileCount,
+            estimatedMemoryMB
+        });
+        return project;
+    }
+    invalidate(projectPath) {
+        const normalizedPath = path.normalize(projectPath);
+        this.cache.delete(normalizedPath);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    getStats() {
+        const now = Date.now();
+        const projects = Array.from(this.cache.entries()).map(([path, cached]) => ({
+            path,
+            files: cached.fileCount,
+            memoryMB: cached.estimatedMemoryMB,
+            age: Math.floor((now - cached.lastAccess) / 1000) // seconds
+        }));
+        return {
+            size: this.cache.size,
+            totalMemoryMB: this.getTotalMemoryUsage(),
+            projects
+        };
+    }
+    getTotalMemoryUsage() {
+        let total = 0;
+        this.cache.forEach(cached => {
+            total += cached.estimatedMemoryMB;
+        });
+        return total;
+    }
+    removeExpired() {
+        const now = Date.now();
+        const toRemove = [];
+        this.cache.forEach((cached, path) => {
+            if ((now - cached.lastAccess) >= this.CACHE_TTL) {
+                toRemove.push(path);
+            }
+        });
+        toRemove.forEach(path => this.cache.delete(path));
+    }
+    evictLRU() {
+        let oldestPath = null;
+        let oldestTime = Date.now();
+        this.cache.forEach((cached, path) => {
+            if (cached.lastAccess < oldestTime) {
+                oldestTime = cached.lastAccess;
+                oldestPath = path;
+            }
+        });
+        if (oldestPath) {
+            this.cache.delete(oldestPath);
+        }
+    }
+}

package/mcp/dist/lib/PythonParser.js

@@ -0,0 +1,241 @@
+// Python code parser utility for v1.3
+// Uses Python's ast module via child_process
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { writeFile, unlink } from 'fs/promises';
+import path from 'path';
+import os from 'os';
+const execAsync = promisify(exec);
+export class PythonParser {
+    static cleanupRegistered = false;
+    static pythonScript = `
+import ast
+import sys
+import json
+
+def analyze_code(code):
+    try:
+        tree = ast.parse(code)
+        symbols = []
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                symbols.append({
+                    'name': node.name,
+                    'kind': 'function',
+                    'line': node.lineno,
+                    'column': node.col_offset,
+                    'endLine': node.end_lineno,
+                    'docstring': ast.get_docstring(node)
+                })
+            elif isinstance(node, ast.ClassDef):
+                symbols.append({
+                    'name': node.name,
+                    'kind': 'class',
+                    'line': node.lineno,
+                    'column': node.col_offset,
+                    'endLine': node.end_lineno,
+                    'docstring': ast.get_docstring(node)
+                })
+            elif isinstance(node, ast.Assign):
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        symbols.append({
+                            'name': target.id,
+                            'kind': 'variable',
+                            'line': node.lineno,
+                            'column': node.col_offset
+                        })
+            elif isinstance(node, ast.Import) or isinstance(node, ast.ImportFrom):
+                for alias in node.names:
+                    symbols.append({
+                        'name': alias.name,
+                        'kind': 'import',
+                        'line': node.lineno,
+                        'column': node.col_offset
+                    })
+
+        return {'success': True, 'symbols': symbols}
+    except SyntaxError as e:
+        return {'success': False, 'error': str(e)}
+    except Exception as e:
+        return {'success': False, 'error': str(e)}
+
+def calculate_complexity(code):
+    try:
+        tree = ast.parse(code)
+
+        def cyclomatic_complexity(node):
+            complexity = 1
+            for child in ast.walk(node):
+                if isinstance(child, (ast.If, ast.For, ast.While, ast.And, ast.Or, ast.ExceptHandler)):
+                    complexity += 1
+                elif isinstance(child, ast.BoolOp):
+                    complexity += len(child.values) - 1
+            return complexity
+
+        functions = []
+        classes = []
+        total_complexity = 1
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                func_complexity = cyclomatic_complexity(node)
+                functions.append({
+                    'name': node.name,
+                    'complexity': func_complexity,
+                    'line': node.lineno
+                })
+                total_complexity += func_complexity
+            elif isinstance(node, ast.ClassDef):
+                method_count = sum(1 for n in node.body if isinstance(n, ast.FunctionDef))
+                classes.append({
+                    'name': node.name,
+                    'methods': method_count,
+                    'line': node.lineno
+                })
+
+        return {
+            'success': True,
+            'cyclomaticComplexity': total_complexity,
+            'functions': functions,
+            'classes': classes
+        }
+    except Exception as e:
+        return {'success': False, 'error': str(e)}
+
+if __name__ == '__main__':
+    code = sys.stdin.read()
+    action = sys.argv[1] if len(sys.argv) > 1 else 'symbols'
+
+    if action == 'symbols':
+        result = analyze_code(code)
+    elif action == 'complexity':
+        result = calculate_complexity(code)
+    else:
+        result = {'success': False, 'error': 'Unknown action'}
+
+    print(json.dumps(result))
+`;
+    // Singleton Python script path to avoid recreating it
+    static scriptPath = null;
+    /**
+     * Register cleanup handlers on first use
+     */
+    static registerCleanup() {
+        if (this.cleanupRegistered) {
+            return;
+        }
+        this.cleanupRegistered = true;
+        // Cleanup on normal exit
+        process.on('exit', () => {
+            if (this.scriptPath) {
+                try {
+                    const fs = require('fs');
+                    fs.unlinkSync(this.scriptPath);
+                }
+                catch (e) {
+                    // Ignore errors during cleanup
+                }
+            }
+        });
+        // Cleanup on SIGINT (Ctrl+C)
+        process.on('SIGINT', () => {
+            this.cleanup().then(() => process.exit(0));
+        });
+        // Cleanup on SIGTERM
+        process.on('SIGTERM', () => {
+            this.cleanup().then(() => process.exit(0));
+        });
+        // Cleanup on uncaught exception
+        process.on('uncaughtException', (error) => {
+            console.error('Uncaught exception:', error);
+            this.cleanup().then(() => process.exit(1));
+        });
+    }
+    /**
+     * Initialize Python script (singleton pattern)
+     */
+    static async ensureScriptExists() {
+        if (this.scriptPath) {
+            return this.scriptPath;
+        }
+        // Register cleanup handlers on first use
+        this.registerCleanup();
+        this.scriptPath = path.join(os.tmpdir(), `hi-ai-parser-${process.pid}.py`);
+        await writeFile(this.scriptPath, this.pythonScript);
+        return this.scriptPath;
+    }
+    /**
+     * Execute Python code analysis with improved memory management
+     */
+    static async executePython(code, action) {
+        let codePath = null;
+        try {
+            const scriptPath = await this.ensureScriptExists();
+            // Write code to temp file with unique name
+            codePath = path.join(os.tmpdir(), `hi-ai-code-${Date.now()}-${Math.random().toString(36).substr(2, 9)}.py`);
+            await writeFile(codePath, code);
+            // Execute Python script
+            const { stdout, stderr } = await execAsync(`python3 "${scriptPath}" ${action} < "${codePath}"`, {
+                maxBuffer: 10 * 1024 * 1024, // 10MB
+                timeout: 30000 // 30 second timeout
+            });
+            if (stderr && !stderr.includes('DeprecationWarning')) {
+                console.error('Python stderr:', stderr);
+            }
+            const result = JSON.parse(stdout);
+            if (!result.success) {
+                throw new Error(result.error || `Python ${action} analysis failed`);
+            }
+            return result;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error('Python 3 not found. Please install Python 3 to analyze Python code.');
+            }
+            throw error;
+        }
+        finally {
+            // Always cleanup code temp file immediately
+            if (codePath) {
+                await unlink(codePath).catch(() => { });
+            }
+        }
+    }
+    static async findSymbols(code) {
+        const result = await this.executePython(code, 'symbols');
+        return result.symbols || [];
+    }
+    static async analyzeComplexity(code) {
+        const result = await this.executePython(code, 'complexity');
+        return {
+            cyclomaticComplexity: result.cyclomaticComplexity || 1,
+            functions: result.functions || [],
+            classes: result.classes || []
+        };
+    }
+    /**
+     * Cleanup singleton script on process exit
+     */
+    static async cleanup() {
+        if (this.scriptPath) {
+            await unlink(this.scriptPath).catch(() => { });
+            this.scriptPath = null;
+        }
+    }
+    static isPythonFile(filePath) {
+        return filePath.endsWith('.py');
+    }
+    static isPythonCode(code) {
+        // Heuristic: Check for Python-specific patterns
+        const pythonPatterns = [
+            /^import\s+\w+/m,
+            /^from\s+\w+\s+import/m,
+            /^def\s+\w+\s*\(/m,
+            /^class\s+\w+/m,
+            /^if\s+__name__\s*==\s*['"]__main__['"]/m
+        ];
+        return pythonPatterns.some(pattern => pattern.test(code));
+    }
+}

package/mcp/dist/tools/browser/browserPool.js

@@ -0,0 +1,76 @@
+// Browser instance pool for efficient resource management
+import puppeteer from 'puppeteer-core';
+import { getBrowserLaunchOptions } from './browserUtils.js';
+class BrowserPool {
+    browser = null;
+    lastUsed = 0;
+    IDLE_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+    cleanupTimer = null;
+    /**
+     * Get or create browser instance
+     */
+    async getBrowser() {
+        // If browser exists and is connected, return it
+        if (this.browser && this.browser.isConnected()) {
+            this.lastUsed = Date.now();
+            this.scheduleCleanup();
+            return this.browser;
+        }
+        // Create new browser instance
+        const options = getBrowserLaunchOptions();
+        this.browser = await puppeteer.launch(options);
+        this.lastUsed = Date.now();
+        this.scheduleCleanup();
+        return this.browser;
+    }
+    /**
+     * Schedule automatic cleanup of idle browser
+     */
+    scheduleCleanup() {
+        // Clear existing timer
+        if (this.cleanupTimer) {
+            clearTimeout(this.cleanupTimer);
+        }
+        // Set new timer
+        this.cleanupTimer = setTimeout(async () => {
+            const idleTime = Date.now() - this.lastUsed;
+            if (idleTime >= this.IDLE_TIMEOUT) {
+                await this.closeBrowser();
+            }
+        }, this.IDLE_TIMEOUT);
+    }
+    /**
+     * Manually close browser instance
+     */
+    async closeBrowser() {
+        if (this.cleanupTimer) {
+            clearTimeout(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        if (this.browser && this.browser.isConnected()) {
+            await this.browser.close();
+            this.browser = null;
+        }
+    }
+    /**
+     * Get a new page from the browser pool
+     */
+    async getPage() {
+        const browser = await this.getBrowser();
+        return await browser.newPage();
+    }
+}
+// Singleton instance
+export const browserPool = new BrowserPool();
+// Cleanup on process exit
+process.on('exit', () => {
+    browserPool.closeBrowser();
+});
+process.on('SIGINT', async () => {
+    await browserPool.closeBrowser();
+    process.exit(0);
+});
+process.on('SIGTERM', async () => {
+    await browserPool.closeBrowser();
+    process.exit(0);
+});

package/mcp/dist/tools/browser/browserUtils.js

@@ -0,0 +1,135 @@
+// Browser utility functions for finding Chrome/Chromium executables
+import { existsSync } from 'fs';
+import { execSync } from 'child_process';
+import { platform } from 'os';
+/**
+ * Finds Chrome or Chromium executable path on the system
+ */
+export function findChromePath() {
+    const platformName = platform();
+    // Platform-specific paths for Chrome
+    const chromePaths = {
+        win32: [
+            process.env.LOCALAPPDATA + '\\Google\\Chrome\\Application\\chrome.exe',
+            process.env.PROGRAMFILES + '\\Google\\Chrome\\Application\\chrome.exe',
+            process.env['PROGRAMFILES(X86)'] + '\\Google\\Chrome\\Application\\chrome.exe',
+            'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+            'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+        ],
+        darwin: [
+            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+            '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+            '/Applications/Chromium.app/Contents/MacOS/Chromium',
+        ],
+        linux: [
+            '/usr/bin/google-chrome-stable',
+            '/usr/bin/google-chrome',
+            '/usr/bin/chromium-browser',
+            '/usr/bin/chromium',
+            '/snap/bin/chromium',
+        ]
+    };
+    // Platform-specific paths for Edge (as fallback)
+    const edgePaths = {
+        win32: [
+            process.env['PROGRAMFILES(X86)'] + '\\Microsoft\\Edge\\Application\\msedge.exe',
+            process.env.PROGRAMFILES + '\\Microsoft\\Edge\\Application\\msedge.exe',
+            'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
+            'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
+        ],
+        darwin: [
+            '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+        ],
+        linux: [
+            '/usr/bin/microsoft-edge',
+            '/usr/bin/microsoft-edge-stable',
+        ]
+    };
+    // Platform-specific paths for Brave (as fallback)
+    const bravePaths = {
+        win32: [
+            process.env.LOCALAPPDATA + '\\BraveSoftware\\Brave-Browser\\Application\\brave.exe',
+            process.env.PROGRAMFILES + '\\BraveSoftware\\Brave-Browser\\Application\\brave.exe',
+            process.env['PROGRAMFILES(X86)'] + '\\BraveSoftware\\Brave-Browser\\Application\\brave.exe',
+        ],
+        darwin: [
+            '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+        ],
+        linux: [
+            '/usr/bin/brave-browser',
+            '/usr/bin/brave',
+            '/snap/bin/brave',
+        ]
+    };
+    // Check user-specified path first
+    if (process.env.CHROME_PATH && existsSync(process.env.CHROME_PATH)) {
+        return process.env.CHROME_PATH;
+    }
+    // Get paths for current platform
+    const currentPlatform = platformName === 'win32' ? 'win32' :
+        platformName === 'darwin' ? 'darwin' : 'linux';
+    const allPaths = [
+        ...(chromePaths[currentPlatform] || []),
+        ...(edgePaths[currentPlatform] || []),
+        ...(bravePaths[currentPlatform] || [])
+    ];
+    // Find first existing path
+    for (const path of allPaths) {
+        if (path && existsSync(path)) {
+            return path;
+        }
+    }
+    // Try to find Chrome using 'which' command on Unix systems
+    if (platformName !== 'win32') {
+        try {
+            const chromePath = execSync('which google-chrome || which chromium || which chromium-browser', {
+                encoding: 'utf8'
+            }).trim();
+            if (chromePath && existsSync(chromePath)) {
+                return chromePath;
+            }
+        }
+        catch {
+            // Command failed, continue to next method
+        }
+    }
+    // Try to find Chrome using 'where' command on Windows
+    if (platformName === 'win32') {
+        try {
+            const chromePath = execSync('where chrome', { encoding: 'utf8' }).trim().split('\n')[0];
+            if (chromePath && existsSync(chromePath)) {
+                return chromePath;
+            }
+        }
+        catch {
+            // Command failed, continue
+        }
+    }
+    return undefined;
+}
+/**
+ * Get launch options for puppeteer with proper browser configuration
+ */
+export function getBrowserLaunchOptions(additionalOptions = {}) {
+    const executablePath = findChromePath();
+    if (!executablePath) {
+        throw new Error('Chrome/Chromium browser not found. Please install Chrome or set CHROME_PATH environment variable.\n' +
+            'Download Chrome from: https://www.google.com/chrome/\n' +
+            'Or set environment variable: export CHROME_PATH="/path/to/chrome"');
+    }
+    return {
+        headless: true,
+        executablePath,
+        args: [
+            '--no-sandbox',
+            '--disable-setuid-sandbox',
+            '--disable-dev-shm-usage',
+            '--disable-accelerated-2d-canvas',
+            '--no-first-run',
+            '--no-zygote',
+            '--single-process', // For Windows compatibility
+            '--disable-gpu'
+        ],
+        ...additionalOptions
+    };
+}