@su-record/vibe 0.1.2 → 0.1.4

package/mcp/dist/tools/convention/suggestImprovements.js

@@ -1,257 +0,0 @@
-// Convention management tool - completely independent
-export const suggestImprovementsDefinition = {
-    name: 'suggest_improvements',
-    description: '개선|더 좋게|리팩토링|improve|make better|refactor|optimize|enhance code - Suggest improvements',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            code: { type: 'string', description: 'Code to analyze' },
-            focus: { type: 'string', description: 'Focus area', enum: ['performance', 'readability', 'maintainability', 'accessibility', 'type-safety'] },
-            priority: { type: 'string', description: 'Priority level', enum: ['critical', 'high', 'medium', 'low'] }
-        },
-        required: ['code']
-    },
-    annotations: {
-        title: 'Suggest Improvements',
-        audience: ['user', 'assistant']
-    }
-};
-export async function suggestImprovements(args) {
-    const { code, focus = 'maintainability', priority = 'medium' } = args;
-    const suggestions = [];
-    const codeLines = code.split('\n');
-    const codeLength = codeLines.length;
-    // Performance improvements
-    if (focus === 'performance' || focus === 'all') {
-        // Check for inefficient loops
-        if (code.includes('for') && code.includes('length')) {
-            suggestions.push({
-                category: 'performance',
-                priority: 'high',
-                issue: 'Potential inefficient loop accessing .length property',
-                suggestion: 'Cache array length in a variable before the loop',
-                example: 'const len = array.length; for (let i = 0; i < len; i++)'
-            });
-        }
-        // Check for React performance issues
-        if (code.includes('React') || code.includes('jsx') || code.includes('tsx')) {
-            if (!code.includes('memo') && !code.includes('useMemo') && !code.includes('useCallback')) {
-                suggestions.push({
-                    category: 'performance',
-                    priority: 'medium',
-                    issue: 'Missing React performance optimizations',
-                    suggestion: 'Consider using React.memo, useMemo, or useCallback',
-                    example: 'const Component = React.memo(() => { ... })'
-                });
-            }
-            if (code.includes('map') && code.includes('return')) {
-                suggestions.push({
-                    category: 'performance',
-                    priority: 'medium',
-                    issue: 'Ensure unique keys in map functions',
-                    suggestion: 'Use unique and stable keys for list items',
-                    example: 'items.map(item => <div key={item.id}>{item.name}</div>)'
-                });
-            }
-        }
-        // Check for expensive operations
-        if (code.includes('JSON.parse') || code.includes('JSON.stringify')) {
-            suggestions.push({
-                category: 'performance',
-                priority: 'medium',
-                issue: 'JSON operations can be expensive',
-                suggestion: 'Consider memoizing JSON operations or using alternatives',
-                example: 'const memoizedParse = useMemo(() => JSON.parse(data), [data])'
-            });
-        }
-    }
-    // Readability improvements
-    if (focus === 'readability' || focus === 'all') {
-        // Check for long functions
-        if (codeLength > 20) {
-            suggestions.push({
-                category: 'readability',
-                priority: 'high',
-                issue: `Function is too long (${codeLength} lines)`,
-                suggestion: 'Break down into smaller, focused functions',
-                example: 'Extract logical groups into separate functions'
-            });
-        }
-        // Check for deep nesting
-        let maxNesting = 0;
-        let currentNesting = 0;
-        for (const line of codeLines) {
-            const braceCount = (line.match(/\{/g) || []).length - (line.match(/\}/g) || []).length;
-            currentNesting += braceCount;
-            maxNesting = Math.max(maxNesting, currentNesting);
-        }
-        if (maxNesting > 3) {
-            suggestions.push({
-                category: 'readability',
-                priority: 'high',
-                issue: `Deep nesting detected (${maxNesting} levels)`,
-                suggestion: 'Use early returns or guard clauses to reduce nesting',
-                example: 'if (!condition) return; // instead of wrapping in else'
-            });
-        }
-        // Check for magic numbers
-        const magicNumbers = code.match(/\b\d{2,}\b/g) || [];
-        if (magicNumbers.length > 0) {
-            suggestions.push({
-                category: 'readability',
-                priority: 'medium',
-                issue: 'Magic numbers found in code',
-                suggestion: 'Extract numbers into named constants',
-                example: 'const MAX_RETRY_COUNT = 3; // instead of using 3 directly'
-            });
-        }
-        // Check for unclear variable names
-        const shortVars = code.match(/\b[a-z]\b/g) || [];
-        if (shortVars.length > 2) {
-            suggestions.push({
-                category: 'readability',
-                priority: 'medium',
-                issue: 'Single letter variable names detected',
-                suggestion: 'Use descriptive variable names',
-                example: 'const userIndex = 0; // instead of i = 0'
-            });
-        }
-    }
-    // Maintainability improvements
-    if (focus === 'maintainability' || focus === 'all') {
-        // Check for error handling
-        const hasAsyncCode = code.includes('async') || code.includes('await') || code.includes('Promise');
-        const hasErrorHandling = code.includes('try') || code.includes('catch') || code.includes('throw');
-        if (hasAsyncCode && !hasErrorHandling) {
-            suggestions.push({
-                category: 'maintainability',
-                priority: 'high',
-                issue: 'Async code without error handling',
-                suggestion: 'Add try-catch blocks for async operations',
-                example: 'try { await asyncOperation(); } catch (error) { handleError(error); }'
-            });
-        }
-        // Check for code duplication
-        const lines = codeLines.map(line => line.trim()).filter(line => line.length > 5);
-        const duplicateLines = lines.filter((line, index) => lines.indexOf(line) !== index);
-        if (duplicateLines.length > 0) {
-            suggestions.push({
-                category: 'maintainability',
-                priority: 'medium',
-                issue: 'Potential code duplication detected',
-                suggestion: 'Extract common code into reusable functions',
-                example: 'Create utility functions for repeated logic'
-            });
-        }
-        // Check for comments
-        const commentLines = code.match(/\/\*[\s\S]*?\*\/|\/\/.*$/gm) || [];
-        const commentRatio = commentLines.length / codeLines.length;
-        if (commentRatio < 0.1 && codeLength > 10) {
-            suggestions.push({
-                category: 'maintainability',
-                priority: 'low',
-                issue: 'Low comment-to-code ratio',
-                suggestion: 'Add comments explaining complex logic',
-                example: '// Validate user input before processing'
-            });
-        }
-    }
-    // Type safety improvements
-    if (focus === 'type-safety' || focus === 'all') {
-        // Check for any types
-        if (code.includes('any')) {
-            suggestions.push({
-                category: 'type-safety',
-                priority: 'high',
-                issue: 'Using "any" type reduces type safety',
-                suggestion: 'Use specific types or interfaces',
-                example: 'interface User { id: string; name: string; }'
-            });
-        }
-        // Check for loose equality
-        if (code.includes('== ') || code.includes('!= ')) {
-            suggestions.push({
-                category: 'type-safety',
-                priority: 'medium',
-                issue: 'Loose equality operators found',
-                suggestion: 'Use strict equality operators',
-                example: 'Use === and !== instead of == and !='
-            });
-        }
-        // Check for missing return types
-        const functions = code.match(/function\s+\w+\([^)]*\)/g) || [];
-        const functionsWithReturnType = code.match(/function\s+\w+\([^)]*\):\s*\w+/g) || [];
-        if (functions.length > functionsWithReturnType.length) {
-            suggestions.push({
-                category: 'type-safety',
-                priority: 'medium',
-                issue: 'Functions missing explicit return types',
-                suggestion: 'Add return type annotations',
-                example: 'function getName(): string { return "name"; }'
-            });
-        }
-    }
-    // Accessibility improvements
-    if (focus === 'accessibility' || focus === 'all') {
-        // Check for missing alt text
-        if (code.includes('<img') && !code.includes('alt=')) {
-            suggestions.push({
-                category: 'accessibility',
-                priority: 'high',
-                issue: 'Images without alt text',
-                suggestion: 'Add descriptive alt text to images',
-                example: '<img src="..." alt="Description of image" />'
-            });
-        }
-        // Check for missing ARIA labels
-        if (code.includes('button') && !code.includes('aria-label') && !code.includes('aria-describedby')) {
-            suggestions.push({
-                category: 'accessibility',
-                priority: 'medium',
-                issue: 'Interactive elements may need ARIA labels',
-                suggestion: 'Add ARIA labels for screen readers',
-                example: '<button aria-label="Close dialog">×</button>'
-            });
-        }
-        // Check for form labels
-        if (code.includes('<input') && !code.includes('label')) {
-            suggestions.push({
-                category: 'accessibility',
-                priority: 'high',
-                issue: 'Form inputs without labels',
-                suggestion: 'Associate labels with form controls',
-                example: '<label htmlFor="name">Name:</label><input id="name" />'
-            });
-        }
-    }
-    // Filter suggestions by priority if specified
-    const filteredSuggestions = priority === 'all' ? suggestions :
-        suggestions.filter(s => s.priority === priority || s.priority === 'critical');
-    // Sort by priority
-    const priorityOrder = { 'critical': 4, 'high': 3, 'medium': 2, 'low': 1 };
-    filteredSuggestions.sort((a, b) => (priorityOrder[b.priority] || 0) - (priorityOrder[a.priority] || 0));
-    const improvementResult = {
-        action: 'suggest_improvements',
-        focus,
-        priority,
-        codeStats: {
-            lines: codeLength,
-            functions: (code.match(/function\s+\w+|\w+\s*=\s*\(/g) || []).length,
-            comments: (code.match(/\/\*[\s\S]*?\*\/|\/\/.*$/gm) || []).length
-        },
-        suggestions: filteredSuggestions,
-        summary: {
-            total: filteredSuggestions.length,
-            critical: filteredSuggestions.filter(s => s.priority === 'critical').length,
-            high: filteredSuggestions.filter(s => s.priority === 'high').length,
-            medium: filteredSuggestions.filter(s => s.priority === 'medium').length,
-            low: filteredSuggestions.filter(s => s.priority === 'low').length
-        },
-        overallScore: Math.max(0, 100 - (filteredSuggestions.length * 10)),
-        status: 'success'
-    };
-    const topSuggestions = filteredSuggestions.slice(0, 8);
-    return {
-        content: [{ type: 'text', text: `Focus: ${focus}\nScore: ${improvementResult.overallScore}/100\nSuggestions: ${improvementResult.summary.total} (${improvementResult.summary.critical}C ${improvementResult.summary.high}H ${improvementResult.summary.medium}M ${improvementResult.summary.low}L)\n\n${topSuggestions.map(s => `[${s.priority.toUpperCase()}] ${s.category}\n  Issue: ${s.issue}\n  Fix: ${s.suggestion}`).join('\n\n')}${filteredSuggestions.length > 8 ? `\n\n... ${filteredSuggestions.length - 8} more suggestions` : ''}` }]
-    };
-}

package/mcp/dist/tools/convention/validateCodeQuality.js

@@ -1,177 +0,0 @@
-// Convention management tool - completely independent
-// Enhanced Software Engineering Metrics
-const CODE_QUALITY_METRICS = {
-    COMPLEXITY: {
-        maxCyclomaticComplexity: 10,
-        maxCognitiveComplexity: 15,
-        maxFunctionLines: 20,
-        maxNestingDepth: 3,
-        maxParameters: 5
-    },
-    COUPLING: {
-        maxDependencies: 7,
-        maxFanOut: 5,
-        preventCircularDeps: true
-    },
-    COHESION: {
-        singleResponsibility: true,
-        relatedFunctionsOnly: true
-    },
-    MAINTAINABILITY: {
-        noMagicNumbers: true,
-        consistentNaming: true,
-        properErrorHandling: true,
-        typesSafety: true
-    },
-    PERFORMANCE: {
-        memoizeExpensiveCalc: true,
-        lazyLoading: true,
-        batchOperations: true
-    }
-};
-export const validateCodeQualityDefinition = {
-    name: 'validate_code_quality',
-    description: '품질|리뷰|검사|quality|review code|check quality|validate|코드 리뷰 - Validate code quality',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            code: { type: 'string', description: 'Code to validate' },
-            type: { type: 'string', description: 'Code type', enum: ['component', 'function', 'hook', 'utility', 'general'] },
-            strict: { type: 'boolean', description: 'Apply strict validation rules' },
-            metrics: { type: 'string', description: 'Specific metrics to check', enum: ['complexity', 'coupling', 'cohesion', 'maintainability', 'performance', 'all'] }
-        },
-        required: ['code']
-    },
-    annotations: {
-        title: 'Validate Code Quality',
-        audience: ['user', 'assistant']
-    }
-};
-export async function validateCodeQuality(args) {
-    const { code: validateCode, type: validateType = 'general', strict = false, metrics = 'all' } = args;
-    const qualityIssues = [];
-    const qualityScore = { total: 100, deductions: [] };
-    // Basic complexity checks
-    const lines = validateCode.split('\n');
-    const functionLineCount = lines.length;
-    if (functionLineCount > CODE_QUALITY_METRICS.COMPLEXITY.maxFunctionLines) {
-        qualityIssues.push({
-            type: 'complexity',
-            severity: 'high',
-            message: `Function exceeds maximum lines (${functionLineCount}/${CODE_QUALITY_METRICS.COMPLEXITY.maxFunctionLines})`
-        });
-        qualityScore.deductions.push({ reason: 'Function too long', points: 15 });
-    }
-    // Nesting depth check
-    let maxNesting = 0;
-    let currentNesting = 0;
-    for (const line of lines) {
-        const braceCount = (line.match(/\{/g) || []).length - (line.match(/\}/g) || []).length;
-        currentNesting += braceCount;
-        maxNesting = Math.max(maxNesting, currentNesting);
-    }
-    if (maxNesting > CODE_QUALITY_METRICS.COMPLEXITY.maxNestingDepth) {
-        qualityIssues.push({
-            type: 'complexity',
-            severity: 'medium',
-            message: `Nesting depth exceeds maximum (${maxNesting}/${CODE_QUALITY_METRICS.COMPLEXITY.maxNestingDepth})`
-        });
-        qualityScore.deductions.push({ reason: 'Deep nesting', points: 10 });
-    }
-    // Cyclomatic complexity estimation
-    const cyclomaticComplexity = (validateCode.match(/\bif\b|\bfor\b|\bwhile\b|\bcase\b|\b&&\b|\b\|\|\b/g) || []).length + 1;
-    if (cyclomaticComplexity > CODE_QUALITY_METRICS.COMPLEXITY.maxCyclomaticComplexity) {
-        qualityIssues.push({
-            type: 'complexity',
-            severity: 'high',
-            message: `Cyclomatic complexity too high (${cyclomaticComplexity}/${CODE_QUALITY_METRICS.COMPLEXITY.maxCyclomaticComplexity})`
-        });
-        qualityScore.deductions.push({ reason: 'High cyclomatic complexity', points: 20 });
-    }
-    // Anti-pattern checks
-    if (validateCode.includes('any')) {
-        qualityIssues.push({
-            type: 'type-safety',
-            severity: 'medium',
-            message: 'Using "any" type - consider more specific types'
-        });
-        qualityScore.deductions.push({ reason: 'Any type usage', points: 10 });
-    }
-    if (validateCode.includes('== ')) {
-        qualityIssues.push({
-            type: 'best-practices',
-            severity: 'low',
-            message: 'Use strict equality (===) instead of loose equality (==)'
-        });
-        qualityScore.deductions.push({ reason: 'Loose equality', points: 5 });
-    }
-    if (validateCode.includes('var ')) {
-        qualityIssues.push({
-            type: 'best-practices',
-            severity: 'medium',
-            message: 'Use const/let instead of var'
-        });
-        qualityScore.deductions.push({ reason: 'Var usage', points: 8 });
-    }
-    // Magic numbers check
-    const magicNumbers = validateCode.match(/\b\d{2,}\b/g) || [];
-    if (magicNumbers.length > 0) {
-        qualityIssues.push({
-            type: 'maintainability',
-            severity: 'low',
-            message: `Found potential magic numbers: ${magicNumbers.join(', ')}`
-        });
-        qualityScore.deductions.push({ reason: 'Magic numbers', points: 5 });
-    }
-    // Error handling check
-    const hasErrorHandling = validateCode.includes('try') || validateCode.includes('catch') || validateCode.includes('throw');
-    if (!hasErrorHandling && validateCode.includes('async')) {
-        qualityIssues.push({
-            type: 'error-handling',
-            severity: 'medium',
-            message: 'Async functions should include error handling'
-        });
-        qualityScore.deductions.push({ reason: 'Missing error handling', points: 10 });
-    }
-    // Performance checks for React components
-    if (validateType === 'component' && validateCode.includes('React')) {
-        if (!validateCode.includes('memo') && !validateCode.includes('useMemo') && !validateCode.includes('useCallback')) {
-            qualityIssues.push({
-                type: 'performance',
-                severity: 'low',
-                message: 'Consider using React.memo, useMemo, or useCallback for performance optimization'
-            });
-            qualityScore.deductions.push({ reason: 'Missing performance optimization', points: 5 });
-        }
-    }
-    const finalScore = Math.max(0, qualityScore.total - qualityScore.deductions.reduce((sum, d) => sum + d.points, 0));
-    const validationResult = {
-        action: 'validate_code_quality',
-        type: validateType,
-        strict,
-        metricsRequested: metrics,
-        score: finalScore,
-        grade: finalScore >= 90 ? 'A' : finalScore >= 80 ? 'B' : finalScore >= 70 ? 'C' : finalScore >= 60 ? 'D' : 'F',
-        issues: qualityIssues,
-        deductions: qualityScore.deductions,
-        recommendations: qualityIssues.length > 0 ? [
-            'Consider breaking down complex functions',
-            'Reduce nesting depth with early returns',
-            'Use more specific types instead of "any"',
-            'Apply consistent coding standards',
-            'Add proper error handling',
-            'Consider performance optimizations'
-        ] : ['Code quality is excellent!'],
-        metrics: {
-            complexity: cyclomaticComplexity,
-            lines: functionLineCount,
-            nesting: maxNesting,
-            issues: qualityIssues.length
-        },
-        status: 'success'
-    };
-    const topIssues = qualityIssues.slice(0, 8);
-    return {
-        content: [{ type: 'text', text: `Type: ${validateType}\nScore: ${finalScore}/100 (Grade: ${validationResult.grade})\nMetrics: Lines=${validationResult.metrics.lines}, Complexity=${validationResult.metrics.complexity}, Nesting=${validationResult.metrics.nesting}\n\nIssues (${qualityIssues.length}):\n${topIssues.map(i => `[${i.severity.toUpperCase()}] ${i.type}: ${i.message}`).join('\n')}${qualityIssues.length > 8 ? `\n... ${qualityIssues.length - 8} more issues` : ''}\n\nDeductions: -${qualityScore.deductions.reduce((sum, d) => sum + d.points, 0)} pts (${qualityScore.deductions.map(d => `${d.reason}: -${d.points}`).join(', ')})` }]
-    };
-}

package/mcp/dist/tools/memory/autoSaveContext.js

@@ -1,79 +0,0 @@
-// Memory management tool - SQLite based with context compression (v1.3)
-import { MemoryManager } from '../../lib/MemoryManager.js';
-import { ContextCompressor } from '../../lib/ContextCompressor.js';
-export const autoSaveContextDefinition = {
-    name: 'auto_save_context',
-    description: 'commit|save|checkpoint|backup|커밋|저장|compress - Auto-save and compress context',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            urgency: { type: 'string', description: 'Urgency level', enum: ['low', 'medium', 'high', 'critical'] },
-            contextType: { type: 'string', description: 'Type of context to save', enum: ['progress', 'decisions', 'code-snippets', 'debugging', 'planning'] },
-            sessionId: { type: 'string', description: 'Current session identifier' },
-            summary: { type: 'string', description: 'Brief summary of current context' },
-            fullContext: { type: 'string', description: 'Full context to compress and save' },
-            compress: { type: 'boolean', description: 'Enable smart compression (default: true)' }
-        },
-        required: ['urgency', 'contextType']
-    },
-    annotations: {
-        title: 'Auto-Save Context',
-        audience: ['user', 'assistant']
-    }
-};
-export async function autoSaveContext(args) {
-    const { urgency, contextType, sessionId, summary, fullContext, compress = true } = args;
-    try {
-        const memoryManager = MemoryManager.getInstance();
-        let contextToSave = summary || '';
-        let compressionStats = null;
-        // Apply smart compression if full context provided and compression enabled
-        if (fullContext && compress) {
-            const targetTokens = urgency === 'critical' ? 6000 : urgency === 'high' ? 4000 : 2000;
-            const compressionResult = ContextCompressor.compress(fullContext, targetTokens);
-            contextToSave = compressionResult.compressed;
-            compressionStats = {
-                originalTokens: ContextCompressor.estimateTokens(fullContext),
-                compressedTokens: ContextCompressor.estimateTokens(compressionResult.compressed),
-                ratio: Math.round(compressionResult.compressionRatio * 100),
-                removed: compressionResult.removedSections.length
-            };
-        }
-        else if (fullContext) {
-            contextToSave = fullContext;
-        }
-        const contextData = {
-            timestamp: new Date().toISOString(),
-            urgency,
-            contextType,
-            sessionId,
-            summary,
-            context: contextToSave,
-            compressed: compress && !!fullContext,
-            compressionStats
-        };
-        const priority = urgency === 'high' || urgency === 'critical' ? 2 : urgency === 'medium' ? 1 : 0;
-        const contextKey = sessionId ? `context:session_${sessionId}_${Date.now()}` : `context:${Date.now()}`;
-        memoryManager.save(contextKey, JSON.stringify(contextData), 'context', priority);
-        let resultText = `✓ Context saved: ${contextType} (${urgency})`;
-        if (sessionId)
-            resultText += `\nSession: ${sessionId}`;
-        if (compressionStats) {
-            resultText += `\nCompressed: ${compressionStats.originalTokens} → ${compressionStats.compressedTokens} tokens (${compressionStats.ratio}%)`;
-            resultText += `\nRemoved: ${compressionStats.removed} low-priority sections`;
-        }
-        if (summary)
-            resultText += `\n${summary}`;
-        return {
-            content: [{
-                    type: 'text',
-                    text: resultText
-                }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
-        };
-    }
-}

package/mcp/dist/tools/memory/database.js

@@ -1,123 +0,0 @@
-// SQLite database connection and schema management
-import Database from 'better-sqlite3';
-import path from 'path';
-import { getMemoryDir } from './memoryConfig.js';
-import { existsSync, mkdirSync } from 'fs';
-class MemoryDatabase {
-    db = null;
-    dbPath;
-    constructor() {
-        const memoryDir = getMemoryDir();
-        // Ensure directory exists
-        if (!existsSync(memoryDir)) {
-            mkdirSync(memoryDir, { recursive: true });
-        }
-        this.dbPath = path.join(memoryDir, 'memories.db');
-    }
-    /**
-     * Get database connection (lazy initialization)
-     */
-    getConnection() {
-        if (!this.db) {
-            // Ensure directory exists before opening database
-            const memoryDir = getMemoryDir();
-            if (!existsSync(memoryDir)) {
-                mkdirSync(memoryDir, { recursive: true });
-            }
-            this.db = new Database(this.dbPath);
-            // Enable WAL mode for better concurrency
-            this.db.pragma('journal_mode = WAL');
-            // Initialize schema
-            this.initSchema();
-        }
-        return this.db;
-    }
-    /**
-     * Initialize database schema
-     */
-    initSchema() {
-        const db = this.db;
-        // Memories table
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS memories (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        key TEXT UNIQUE NOT NULL,
-        value TEXT NOT NULL,
-        category TEXT NOT NULL DEFAULT 'general',
-        timestamp TEXT NOT NULL,
-        lastAccessed TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_memories_key ON memories(key);
-      CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(category);
-      CREATE INDEX IF NOT EXISTS idx_memories_lastAccessed ON memories(lastAccessed);
-    `);
-        // Sessions table
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS sessions (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        sessionId TEXT NOT NULL,
-        contextType TEXT NOT NULL,
-        summary TEXT NOT NULL,
-        urgency TEXT NOT NULL,
-        currentTask TEXT,
-        codeChanges TEXT,
-        decisions TEXT,
-        blockers TEXT,
-        nextSteps TEXT,
-        timestamp TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_sessions_sessionId ON sessions(sessionId);
-      CREATE INDEX IF NOT EXISTS idx_sessions_timestamp ON sessions(timestamp);
-      CREATE INDEX IF NOT EXISTS idx_sessions_urgency ON sessions(urgency);
-    `);
-        // Guides table (for coding guides)
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS guides (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT UNIQUE NOT NULL,
-        category TEXT NOT NULL,
-        content TEXT NOT NULL,
-        timestamp TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_guides_name ON guides(name);
-      CREATE INDEX IF NOT EXISTS idx_guides_category ON guides(category);
-    `);
-    }
-    /**
-     * Close database connection
-     */
-    close() {
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-        }
-    }
-    /**
-     * Run a checkpoint to merge WAL file
-     */
-    checkpoint() {
-        if (this.db) {
-            this.db.pragma('wal_checkpoint(TRUNCATE)');
-        }
-    }
-}
-// Singleton instance
-export const memoryDB = new MemoryDatabase();
-// Cleanup on process exit
-process.on('exit', () => {
-    memoryDB.checkpoint();
-    memoryDB.close();
-});
-process.on('SIGINT', () => {
-    memoryDB.checkpoint();
-    memoryDB.close();
-    process.exit(0);
-});
-process.on('SIGTERM', () => {
-    memoryDB.checkpoint();
-    memoryDB.close();
-    process.exit(0);
-});

package/mcp/dist/tools/memory/deleteMemory.js

@@ -1,39 +0,0 @@
-// Memory management tool - completely independent
-import { MemoryManager } from '../../lib/MemoryManager.js';
-export const deleteMemoryDefinition = {
-    name: 'delete_memory',
-    description: '잊어|삭제해|지워|forget|delete|remove|erase - Delete specific memory',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            key: { type: 'string', description: 'Memory key to delete' }
-        },
-        required: ['key']
-    },
-    annotations: {
-        title: 'Delete Memory',
-        audience: ['user', 'assistant']
-    }
-};
-export async function deleteMemory(args) {
-    const { key: deleteKey } = args;
-    try {
-        const mm = MemoryManager.getInstance();
-        const deleted = mm.delete(deleteKey);
-        if (deleted) {
-            return {
-                content: [{ type: 'text', text: `✓ Deleted memory: "${deleteKey}"` }]
-            };
-        }
-        else {
-            return {
-                content: [{ type: 'text', text: `✗ Memory not found: "${deleteKey}"` }]
-            };
-        }
-    }
-    catch (error) {
-        return {
-            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
-        };
-    }
-}