@su-record/vibe 0.1.2 → 0.1.4

package/mcp/dist/lib/MemoryManager.js

@@ -1,334 +0,0 @@
-// SQLite-based memory management system
-// Replaces JSON file storage with proper database
-import Database from 'better-sqlite3';
-import path from 'path';
-export class MemoryManager {
-    db;
-    static instance = null;
-    dbPath;
-    recallStmt = null;
-    saveStmt = null;
-    recallSelectStmt = null;
-    recallUpdateStmt = null;
-    constructor(customDbPath) {
-        if (customDbPath) {
-            this.dbPath = customDbPath;
-        }
-        else {
-            const memoryDir = path.join(process.cwd(), 'memories');
-            this.dbPath = path.join(memoryDir, 'memories.db');
-            // Ensure directory exists synchronously (needed for DB init)
-            try {
-                require('fs').mkdirSync(memoryDir, { recursive: true });
-            }
-            catch (error) {
-                const nodeError = error;
-                if (nodeError.code !== 'EEXIST') {
-                    throw new Error(`Failed to create memory directory: ${nodeError.message}`);
-                }
-            }
-        }
-        this.db = new Database(this.dbPath);
-        this.initializeDatabase();
-        // Only migrate if using default path (not for tests)
-        if (!customDbPath) {
-            this.migrateFromJSON();
-        }
-    }
-    static cleanupRegistered = false;
-    static getInstance(customDbPath) {
-        if (!MemoryManager.instance) {
-            MemoryManager.instance = new MemoryManager(customDbPath);
-            // Register cleanup handlers only once
-            if (!MemoryManager.cleanupRegistered) {
-                MemoryManager.cleanupRegistered = true;
-                // Increase max listeners to avoid warnings in test environments
-                process.setMaxListeners(Math.max(process.getMaxListeners(), 15));
-                // Register cleanup on process exit to prevent memory leaks
-                const cleanup = () => {
-                    if (MemoryManager.instance) {
-                        MemoryManager.instance.close();
-                    }
-                };
-                process.on('exit', cleanup);
-                process.on('SIGINT', () => {
-                    cleanup();
-                    process.exit(0);
-                });
-                process.on('SIGTERM', () => {
-                    cleanup();
-                    process.exit(0);
-                });
-            }
-        }
-        return MemoryManager.instance;
-    }
-    initializeDatabase() {
-        // Create memories table
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS memories (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        category TEXT NOT NULL DEFAULT 'general',
-        timestamp TEXT NOT NULL,
-        lastAccessed TEXT NOT NULL,
-        priority INTEGER DEFAULT 0
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_category ON memories(category);
-      CREATE INDEX IF NOT EXISTS idx_timestamp ON memories(timestamp);
-      CREATE INDEX IF NOT EXISTS idx_priority ON memories(priority);
-      CREATE INDEX IF NOT EXISTS idx_lastAccessed ON memories(lastAccessed);
-    `);
-        // Enable WAL mode for better concurrency
-        this.db.pragma('journal_mode = WAL');
-        // Pre-compile frequently used statements for performance
-        this.initializePreparedStatements();
-    }
-    initializePreparedStatements() {
-        // Pre-compile recall statement
-        try {
-            this.recallStmt = this.db.prepare(`
-        UPDATE memories SET lastAccessed = ?
-        WHERE key = ?
-        RETURNING *
-      `);
-        }
-        catch (error) {
-            // RETURNING not supported, pre-compile fallback statements
-            this.recallStmt = null;
-            this.recallSelectStmt = this.db.prepare(`SELECT * FROM memories WHERE key = ?`);
-            this.recallUpdateStmt = this.db.prepare(`UPDATE memories SET lastAccessed = ? WHERE key = ?`);
-        }
-        // Pre-compile save statement
-        this.saveStmt = this.db.prepare(`
-      INSERT OR REPLACE INTO memories (key, value, category, timestamp, lastAccessed, priority)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-    }
-    /**
-     * Auto-migrate from JSON to SQLite database
-     */
-    migrateFromJSON() {
-        const jsonPath = this.getJSONPath();
-        const memories = this.loadJSONMemories(jsonPath);
-        if (memories.length === 0)
-            return;
-        this.importMemories(memories);
-        this.backupAndCleanup(jsonPath, memories.length);
-    }
-    /**
-     * Get JSON file path
-     */
-    getJSONPath() {
-        return path.join(path.dirname(this.dbPath), 'memories.json');
-    }
-    /**
-     * Load memories from JSON file
-     */
-    loadJSONMemories(jsonPath) {
-        try {
-            const jsonData = require('fs').readFileSync(jsonPath, 'utf-8');
-            return JSON.parse(jsonData);
-        }
-        catch (error) {
-            return [];
-        }
-    }
-    /**
-     * Import memories into SQLite database
-     */
-    importMemories(memories) {
-        const insert = this.db.prepare(`
-      INSERT OR REPLACE INTO memories (key, value, category, timestamp, lastAccessed, priority)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-        const insertMany = this.db.transaction((items) => {
-            for (const item of items) {
-                insert.run(item.key, item.value, item.category || 'general', item.timestamp, item.lastAccessed, item.priority || 0);
-            }
-        });
-        insertMany(memories);
-    }
-    /**
-     * Backup JSON file and log migration
-     */
-    backupAndCleanup(jsonPath, count) {
-        try {
-            require('fs').renameSync(jsonPath, `${jsonPath}.backup`);
-            // Migration successful - could add logger here
-        }
-        catch (error) {
-            // Backup failed but migration completed
-        }
-    }
-    /**
-     * Save or update a memory item
-     * @param key - Unique identifier for the memory
-     * @param value - Content to store
-     * @param category - Category for organization (default: 'general')
-     * @param priority - Priority level (default: 0)
-     */
-    save(key, value, category = 'general', priority = 0) {
-        const timestamp = new Date().toISOString();
-        if (this.saveStmt) {
-            this.saveStmt.run(key, value, category, timestamp, timestamp, priority);
-        }
-        else {
-            // Fallback if prepared statement not available
-            const stmt = this.db.prepare(`
-        INSERT OR REPLACE INTO memories (key, value, category, timestamp, lastAccessed, priority)
-        VALUES (?, ?, ?, ?, ?, ?)
-      `);
-            stmt.run(key, value, category, timestamp, timestamp, priority);
-        }
-    }
-    /**
-     * Recall a memory item by key
-     * @param key - Memory key to recall
-     * @returns Memory item or null if not found
-     */
-    recall(key) {
-        const timestamp = new Date().toISOString();
-        // Use pre-compiled statement if available
-        if (this.recallStmt) {
-            const result = this.recallStmt.get(timestamp, key);
-            return result || null;
-        }
-        // Fallback for older SQLite versions (using pre-compiled statements)
-        if (!this.recallSelectStmt || !this.recallUpdateStmt) {
-            throw new Error('Fallback recall statements not initialized');
-        }
-        const result = this.recallSelectStmt.get(key);
-        if (result) {
-            this.recallUpdateStmt.run(timestamp, key);
-        }
-        return result || null;
-    }
-    /**
-     * Delete a memory item
-     * @param key - Memory key to delete
-     * @returns True if deleted successfully
-     */
-    delete(key) {
-        const stmt = this.db.prepare(`
-      DELETE FROM memories WHERE key = ?
-    `);
-        const result = stmt.run(key);
-        return result.changes > 0;
-    }
-    /**
-     * Update a memory item's value
-     * @param key - Memory key to update
-     * @param value - New value
-     * @returns True if updated successfully
-     */
-    update(key, value) {
-        const timestamp = new Date().toISOString();
-        const stmt = this.db.prepare(`
-      UPDATE memories
-      SET value = ?, timestamp = ?, lastAccessed = ?
-      WHERE key = ?
-    `);
-        const result = stmt.run(value, timestamp, timestamp, key);
-        return result.changes > 0;
-    }
-    /**
-     * List all memories or filter by category
-     * @param category - Optional category filter
-     * @returns Array of memory items
-     */
-    list(category) {
-        let stmt;
-        if (category) {
-            stmt = this.db.prepare(`
-        SELECT * FROM memories WHERE category = ?
-        ORDER BY priority DESC, timestamp DESC
-      `);
-            return stmt.all(category);
-        }
-        else {
-            stmt = this.db.prepare(`
-        SELECT * FROM memories
-        ORDER BY priority DESC, timestamp DESC
-      `);
-            return stmt.all();
-        }
-    }
-    /**
-     * Search memories by keyword
-     * @param query - Search query string
-     * @returns Array of matching memory items
-     */
-    search(query) {
-        const stmt = this.db.prepare(`
-      SELECT * FROM memories
-      WHERE key LIKE ? OR value LIKE ?
-      ORDER BY priority DESC, timestamp DESC
-    `);
-        const pattern = `%${query}%`;
-        return stmt.all(pattern, pattern);
-    }
-    /**
-     * Get memories by priority level
-     * @param priority - Priority level to filter
-     * @returns Array of memory items with specified priority
-     */
-    getByPriority(priority) {
-        const stmt = this.db.prepare(`
-      SELECT * FROM memories
-      WHERE priority = ?
-      ORDER BY timestamp DESC
-    `);
-        return stmt.all(priority);
-    }
-    /**
-     * Update priority of a memory item
-     * @param key - Memory key
-     * @param priority - New priority level
-     * @returns True if updated successfully
-     */
-    setPriority(key, priority) {
-        const stmt = this.db.prepare(`
-      UPDATE memories SET priority = ? WHERE key = ?
-    `);
-        const result = stmt.run(priority, key);
-        return result.changes > 0;
-    }
-    /**
-     * Get memory statistics (optimized to single query)
-     * @returns Total count and count by category
-     */
-    getStats() {
-        // Single query with ROLLUP or combined approach
-        const categories = this.db.prepare(`
-      SELECT category, COUNT(*) as count
-      FROM memories
-      GROUP BY category
-    `).all();
-        const byCategory = {};
-        let total = 0;
-        categories.forEach(cat => {
-            byCategory[cat.category] = cat.count;
-            total += cat.count;
-        });
-        return { total, byCategory };
-    }
-    /**
-     * Close database connection
-     */
-    close() {
-        if (this.db) {
-            this.db.close();
-            MemoryManager.instance = null;
-        }
-    }
-    /**
-     * Reset singleton instance (useful for testing and cleanup)
-     */
-    static resetInstance() {
-        if (MemoryManager.instance) {
-            MemoryManager.instance.close();
-        }
-    }
-}

package/mcp/dist/lib/ProjectCache.js

@@ -1,126 +0,0 @@
-// 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

@@ -1,241 +0,0 @@
-// 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));
-    }
-}