@su-record/vibe 0.1.0

package/mcp/dist/lib/ContextCompressor.js

@@ -0,0 +1,305 @@
+// Context compression utility (v1.3)
+// Intelligently compress context when approaching token limits
+export class ContextCompressor {
+    static MAX_CHUNK_SIZE = 500; // characters
+    static DEFAULT_TARGET_TOKENS = 4000;
+    static TOKENS_PER_CHAR_ESTIMATE = 0.25;
+    static MAX_SCORE = 100;
+    static MIN_SCORE = 0;
+    static CODE_KEYWORDS = [
+        'function', 'class', 'const', 'let', 'var', 'import', 'export',
+        'def', 'async', 'await', 'return', 'if', 'for', 'while'
+    ];
+    static IMPORTANT_KEYWORDS = [
+        'error', 'bug', 'fix', 'issue', 'problem', 'solution',
+        '에러', '버그', '수정', '문제', '해결', 'TODO', 'FIXME'
+    ];
+    /**
+     * Compress context by selecting most important chunks
+     * @param context - Text content to compress
+     * @param targetTokens - Target token count (default: 4000)
+     * @returns Compression result with statistics
+     */
+    static compress(context, targetTokens = ContextCompressor.DEFAULT_TARGET_TOKENS) {
+        // Handle empty or very short context
+        if (!context || context.trim().length === 0) {
+            return {
+                compressed: '',
+                originalSize: 0,
+                compressedSize: 0,
+                compressionRatio: 0,
+                removedSections: [],
+                retainedSections: []
+            };
+        }
+        const chunks = this.splitIntoChunks(context);
+        const scoredChunks = chunks.map(chunk => this.scoreChunk(chunk));
+        // If content is already smaller than target, return as-is
+        // Only skip compression if content is very small (use 1.2x instead of 4x)
+        // This ensures compression activates more aggressively
+        if (context.length <= targetTokens * 1.2) {
+            return {
+                compressed: context,
+                originalSize: context.length,
+                compressedSize: context.length,
+                compressionRatio: 1,
+                removedSections: [],
+                retainedSections: scoredChunks.map(s => s.type),
+                retentionStats: {
+                    codeRetentionPercent: 100,
+                    answerRetentionPercent: 100,
+                    questionRetentionPercent: 100
+                }
+            };
+        }
+        // Sort by score (highest first)
+        scoredChunks.sort((a, b) => b.score - a.score);
+        // Select chunks until target size
+        // TOKENS_PER_CHAR_ESTIMATE = 0.25 means 1 char ≈ 0.25 tokens, so 4 chars ≈ 1 token
+        // Reserve space for headers and formatting (5% overhead, min 50 chars, max 300 chars)
+        const HEADER_OVERHEAD = Math.max(50, Math.min(300, targetTokens * 4 * 0.05));
+        const targetChars = (targetTokens * 4) - HEADER_OVERHEAD;
+        const selected = [];
+        const removed = [];
+        let currentSize = 0;
+        for (const chunk of scoredChunks) {
+            if (currentSize + chunk.text.length <= targetChars) {
+                selected.push(chunk);
+                currentSize += chunk.text.length;
+            }
+            else {
+                removed.push(this.summarizeChunk(chunk));
+            }
+        }
+        // Reconstruct compressed context
+        const compressed = this.reconstructContext(selected, removed);
+        // Calculate retention statistics
+        const retentionStats = this.calculateRetentionStats(scoredChunks, selected);
+        return {
+            compressed,
+            originalSize: context.length,
+            compressedSize: compressed.length,
+            compressionRatio: compressed.length / context.length,
+            removedSections: removed,
+            retainedSections: selected.map(s => s.type),
+            retentionStats
+        };
+    }
+    /**
+     * Calculate retention percentages by type
+     */
+    static calculateRetentionStats(allChunks, selectedChunks) {
+        const countByType = (chunks, type) => {
+            return chunks.filter(c => c.type === type).length;
+        };
+        const totalCode = countByType(allChunks, 'code');
+        const totalAnswer = countByType(allChunks, 'answer');
+        const totalQuestion = countByType(allChunks, 'question');
+        const retainedCode = countByType(selectedChunks, 'code');
+        const retainedAnswer = countByType(selectedChunks, 'answer');
+        const retainedQuestion = countByType(selectedChunks, 'question');
+        return {
+            codeRetentionPercent: totalCode > 0 ? Math.round((retainedCode / totalCode) * 100) : 0,
+            answerRetentionPercent: totalAnswer > 0 ? Math.round((retainedAnswer / totalAnswer) * 100) : 0,
+            questionRetentionPercent: totalQuestion > 0 ? Math.round((retainedQuestion / totalQuestion) * 100) : 0
+        };
+    }
+    /**
+     * Split context into manageable chunks
+     */
+    static splitIntoChunks(context) {
+        const chunks = [];
+        const lines = context.split('\n');
+        let currentChunk = '';
+        for (const line of lines) {
+            if (currentChunk.length + line.length > this.MAX_CHUNK_SIZE) {
+                if (currentChunk.trim()) {
+                    chunks.push(currentChunk.trim());
+                }
+                currentChunk = line;
+            }
+            else {
+                currentChunk += '\n' + line;
+            }
+        }
+        if (currentChunk.trim()) {
+            chunks.push(currentChunk.trim());
+        }
+        return chunks;
+    }
+    /**
+     * Score chunk importance (0-100)
+     * @param text - Text chunk to score
+     * @returns Scored chunk with type and keywords
+     */
+    static scoreChunk(text) {
+        const lowerText = text.toLowerCase();
+        const type = this.detectChunkType(lowerText, text);
+        const keywords = this.extractKeywords(lowerText);
+        const baseScore = this.calculateBaseScore(text, lowerText, type);
+        const finalScore = Math.max(ContextCompressor.MIN_SCORE, Math.min(ContextCompressor.MAX_SCORE, baseScore));
+        return { text, score: finalScore, type, keywords };
+    }
+    /**
+     * Detect chunk type based on content
+     */
+    static detectChunkType(lowerText, text) {
+        if (text.includes('```'))
+            return 'code';
+        if (lowerText.match(/^(answer|solution|결과|답변):/i))
+            return 'answer';
+        if (lowerText.match(/^(timestamp|date|author|file):/i))
+            return 'metadata';
+        if (lowerText.includes('?'))
+            return 'question';
+        if (this.CODE_KEYWORDS.some(kw => lowerText.includes(kw)))
+            return 'code';
+        return 'explanation';
+    }
+    /**
+     * Extract important keywords from text
+     */
+    static extractKeywords(lowerText) {
+        const keywords = [];
+        for (const keyword of this.IMPORTANT_KEYWORDS) {
+            if (lowerText.includes(keyword.toLowerCase())) {
+                keywords.push(keyword);
+            }
+        }
+        return keywords;
+    }
+    /**
+     * Calculate base score for chunk
+     */
+    static calculateBaseScore(text, lowerText, type) {
+        let score = 0;
+        // Type-based scoring
+        score += this.getTypeScore(type, lowerText);
+        // Keyword bonus
+        score += this.getKeywordScore(lowerText);
+        // Structure bonuses
+        score += this.getStructureScore(text);
+        return score;
+    }
+    /**
+     * Get score based on chunk type
+     */
+    static getTypeScore(type, lowerText) {
+        const typeScores = {
+            code: 30,
+            answer: 35,
+            question: 25,
+            explanation: 0,
+            metadata: -20
+        };
+        return typeScores[type];
+    }
+    /**
+     * Get score for important keywords
+     */
+    static getKeywordScore(lowerText) {
+        let score = 0;
+        for (const keyword of this.IMPORTANT_KEYWORDS) {
+            if (lowerText.includes(keyword.toLowerCase())) {
+                score += 15;
+            }
+        }
+        return score;
+    }
+    /**
+     * Get score based on text structure
+     */
+    static getStructureScore(text) {
+        let score = 0;
+        // Penalize very long chunks
+        if (text.length > 1000)
+            score -= 10;
+        // Boost short, concise chunks
+        if (text.length < 200 && text.split('\n').length <= 5)
+            score += 10;
+        // Boost structured content (lists)
+        if (text.match(/^[\d\-\*•]/m))
+            score += 15;
+        // Boost code blocks
+        if (text.includes('```'))
+            score += 20;
+        return score;
+    }
+    /**
+     * Summarize removed chunk (one-liner)
+     */
+    static summarizeChunk(chunk) {
+        const firstLine = chunk.text.split('\n')[0].trim();
+        const summary = firstLine.length > 80
+            ? firstLine.substring(0, 77) + '...'
+            : firstLine;
+        return `[${chunk.type}] ${summary}`;
+    }
+    /**
+     * Reconstruct compressed context
+     */
+    static reconstructContext(selected, removed) {
+        // Group by type for better organization
+        const byType = {
+            code: [],
+            answer: [],
+            question: [],
+            explanation: [],
+            metadata: []
+        };
+        selected.forEach(chunk => {
+            byType[chunk.type].push(chunk);
+        });
+        const sections = [];
+        // Add header
+        sections.push('[Compressed Context - High Priority Information]\n');
+        // Add answers first (most important)
+        if (byType.answer.length > 0) {
+            sections.push('## Key Answers & Solutions');
+            sections.push(byType.answer.map(c => c.text).join('\n\n'));
+            sections.push('');
+        }
+        // Add code blocks
+        if (byType.code.length > 0) {
+            sections.push('## Code Snippets');
+            sections.push(byType.code.map(c => c.text).join('\n\n'));
+            sections.push('');
+        }
+        // Add questions
+        if (byType.question.length > 0) {
+            sections.push('## Questions');
+            sections.push(byType.question.map(c => c.text).join('\n\n'));
+            sections.push('');
+        }
+        // Add explanations
+        if (byType.explanation.length > 0) {
+            sections.push('## Context');
+            sections.push(byType.explanation.map(c => c.text).join('\n\n'));
+            sections.push('');
+        }
+        // Add summary of removed sections
+        if (removed.length > 0) {
+            sections.push('## Removed Sections (Low Priority)');
+            sections.push(removed.join('\n'));
+        }
+        return sections.join('\n');
+    }
+    /**
+     * Extract key entities (names, numbers, dates) from context
+     */
+    static extractKeyEntities(context) {
+        const names = Array.from(new Set(context.match(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b/g) || []));
+        const numbers = Array.from(new Set(context.match(/\b\d+(?:\.\d+)?\b/g) || []));
+        const dates = Array.from(new Set(context.match(/\d{4}-\d{2}-\d{2}|\d{2}\/\d{2}\/\d{4}/g) || []));
+        const files = Array.from(new Set(context.match(/[\w\-]+\.[a-z]{2,4}\b/gi) || []));
+        return { names, numbers, dates, files };
+    }
+    /**
+     * Estimate token count (rough approximation)
+     */
+    static estimateTokens(text) {
+        // GPT-like tokenization: ~1 token per 4 characters
+        // More accurate would require actual tokenizer
+        return Math.ceil(text.length / 4);
+    }
+}

package/mcp/dist/lib/MemoryManager.js

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