@su-record/vibe 0.1.0

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

@@ -0,0 +1,109 @@
+/**
+ * Python-specific complexity analysis
+ */
+import { THRESHOLDS } from './complexityMetrics.js';
+/**
+ * Calculate cyclomatic complexity for Python code
+ */
+export function calculatePythonComplexity(code) {
+    // Python control flow keywords
+    const patterns = [
+        /\bif\b/g, // if statements
+        /\belif\b/g, // elif statements
+        /\bfor\b/g, // for loops
+        /\bwhile\b/g, // while loops
+        /\btry\b/g, // try blocks
+        /\bexcept\b/g, // except blocks
+        /\band\b/g, // logical and
+        /\bor\b/g, // logical or
+        /\bwith\b/g, // with statements
+        /\blambda\b/g // lambda expressions
+    ];
+    let complexity = 1; // Base complexity
+    for (const pattern of patterns) {
+        const matches = code.match(pattern);
+        if (matches) {
+            complexity += matches.length;
+        }
+    }
+    return {
+        value: complexity,
+        threshold: THRESHOLDS.maxCyclomatic,
+        status: complexity <= THRESHOLDS.maxCyclomatic ? 'pass' : 'fail',
+        description: 'Python cyclomatic complexity (control flow branches)'
+    };
+}
+/**
+ * Calculate cognitive complexity for Python
+ */
+export function calculatePythonCognitiveComplexity(code) {
+    let complexity = 0;
+    let nestingLevel = 0;
+    const lines = code.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Detect indentation level (Python uses indentation for nesting)
+        const indent = line.match(/^(\s*)/)?.[1].length || 0;
+        const currentNesting = Math.floor(indent / 4); // Assuming 4-space indents
+        // Control flow that increases cognitive load
+        if (/\b(if|elif|for|while|try|except|with)\b/.test(trimmed)) {
+            complexity += 1 + currentNesting;
+        }
+        // Logical operators increase complexity
+        const logicalOps = trimmed.match(/\b(and|or)\b/g);
+        if (logicalOps) {
+            complexity += logicalOps.length;
+        }
+        // List comprehensions add cognitive load
+        if (/\[.*for.*in.*\]/.test(trimmed)) {
+            complexity += 1;
+        }
+        // Nested functions
+        if (/^\s+def\s+/.test(line)) {
+            complexity += currentNesting;
+        }
+    }
+    return {
+        value: complexity,
+        threshold: THRESHOLDS.maxCognitive,
+        status: complexity <= THRESHOLDS.maxCognitive ? 'pass' : 'fail',
+        description: 'Python cognitive complexity (mental load to understand)'
+    };
+}
+/**
+ * Analyze Python code quality
+ */
+export function analyzePythonQuality(code) {
+    const issues = [];
+    const recommendations = [];
+    // Check for common Python anti-patterns
+    if (code.includes('eval(') || code.includes('exec(')) {
+        issues.push('Use of eval() or exec() detected - security risk');
+        recommendations.push('Avoid eval() and exec(), use safer alternatives');
+    }
+    if (/except:\s*$/.test(code)) {
+        issues.push('Bare except clause detected');
+        recommendations.push('Specify exception types: except ValueError:');
+    }
+    if (/import \*/.test(code)) {
+        issues.push('Wildcard import detected');
+        recommendations.push('Import specific names instead of using wildcard');
+    }
+    // Check for long functions
+    const functionMatches = code.match(/def\s+\w+\([^)]*\):/g) || [];
+    if (functionMatches.length > 0) {
+        const avgFunctionLength = code.split('\n').length / functionMatches.length;
+        if (avgFunctionLength > 50) {
+            issues.push('Functions are too long (avg > 50 lines)');
+            recommendations.push('Break down large functions into smaller ones');
+        }
+    }
+    // Check for PEP 8 violations (basic)
+    const lines = code.split('\n');
+    const longLines = lines.filter(line => line.length > 79);
+    if (longLines.length > lines.length * 0.2) {
+        issues.push('Many lines exceed 79 characters (PEP 8)');
+        recommendations.push('Keep lines under 79 characters for better readability');
+    }
+    return { issues, recommendations };
+}

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

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

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

@@ -0,0 +1,79 @@
+// 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'}` }]
+        };
+    }
+}