@su-record/vibe 0.1.3 → 0.1.7

package/mcp/dist/__tests__/python-dart-complexity.test.js

@@ -1,146 +0,0 @@
-/**
- * Tests for Python and Dart/Flutter code complexity analysis
- */
-import { describe, it, expect } from 'vitest';
-import { detectLanguage } from '../tools/convention/languageDetector.js';
-import { calculatePythonComplexity, calculatePythonCognitiveComplexity } from '../tools/convention/pythonComplexity.js';
-import { calculateDartComplexity, calculateDartCognitiveComplexity } from '../tools/convention/dartComplexity.js';
-import { analyzeComplexity } from '../tools/convention/analyzeComplexity.js';
-describe('Language Detection', () => {
-    it('should detect Python code', () => {
-        const pythonCode = `
-def calculate_sum(numbers):
-    total = 0
-    for num in numbers:
-        total += num
-    return total
-`;
-        expect(detectLanguage(pythonCode)).toBe('python');
-    });
-    it('should detect Dart/Flutter code', () => {
-        const dartCode = `
-class MyWidget extends StatelessWidget {
-  @override
-  Widget build(BuildContext context) {
-    return Container(
-      child: Text('Hello'),
-    );
-  }
-}
-`;
-        expect(detectLanguage(dartCode)).toBe('dart');
-    });
-    it('should detect TypeScript code', () => {
-        const tsCode = `
-interface User {
-  name: string;
-  age: number;
-}
-
-function greet(user: User): void {
-  console.log(\`Hello, \${user.name}\`);
-}
-`;
-        expect(detectLanguage(tsCode)).toBe('typescript');
-    });
-});
-describe('Python Complexity Analysis', () => {
-    it('should calculate Python cyclomatic complexity', () => {
-        const pythonCode = `
-def complex_function(x, y, z):
-    if x > 0:
-        if y > 0:
-            return x + y
-        elif y < 0:
-            return x - y
-    elif z > 0:
-        for i in range(10):
-            if i % 2 == 0:
-                print(i)
-    return 0
-`;
-        const result = calculatePythonComplexity(pythonCode);
-        expect(result.value).toBeGreaterThan(5);
-        expect(result.status).toBeDefined();
-    });
-    it('should calculate Python cognitive complexity', () => {
-        const pythonCode = `
-def nested_function(items):
-    for item in items:
-        if item > 0:
-            if item % 2 == 0:
-                print("Even positive")
-    return items
-`;
-        const result = calculatePythonCognitiveComplexity(pythonCode);
-        expect(result.value).toBeGreaterThan(0);
-    });
-});
-describe('Dart Complexity Analysis', () => {
-    it('should calculate Dart cyclomatic complexity', () => {
-        const dartCode = `
-Widget buildWidget(bool condition) {
-  if (condition) {
-    return Text('Yes');
-  } else {
-    return Text('No');
-  }
-}
-`;
-        const result = calculateDartComplexity(dartCode);
-        expect(result.value).toBeGreaterThan(1);
-    });
-    it('should calculate Dart cognitive complexity', () => {
-        const dartCode = `
-class MyWidget extends StatelessWidget {
-  @override
-  Widget build(BuildContext context) {
-    return condition1
-      ? Text('A')
-      : condition2
-        ? Text('B')
-        : Text('C');
-  }
-}
-`;
-        const result = calculateDartCognitiveComplexity(dartCode);
-        expect(result.value).toBeGreaterThanOrEqual(0); // Ternary operators may not be counted
-    });
-});
-describe('Integrated Complexity Analysis', () => {
-    it('should analyze Python code with auto-detection', async () => {
-        const pythonCode = `
-def fibonacci(n):
-    if n <= 1:
-        return n
-    return fibonacci(n-1) + fibonacci(n-2)
-`;
-        const result = await analyzeComplexity({ code: pythonCode });
-        expect(result.content[0].text).toContain('Python');
-        expect(result.content[0].text).toContain('cyclomaticComplexity');
-    });
-    it('should analyze Dart code with auto-detection', async () => {
-        const dartCode = `
-class Counter extends StatefulWidget {
-  @override
-  _CounterState createState() => _CounterState();
-}
-`;
-        const result = await analyzeComplexity({ code: dartCode });
-        expect(result.content[0].text).toContain('Dart');
-    });
-    it('should analyze TypeScript code', async () => {
-        const tsCode = `
-function complexFunc(a: number, b: number): number {
-  if (a > b) {
-    return a;
-  } else if (a < b) {
-    return b;
-  }
-  return 0;
-}
-`;
-        const result = await analyzeComplexity({ code: tsCode });
-        expect(result.content[0].text).toContain('TypeScript');
-    });
-});

package/mcp/dist/index.js

@@ -1,230 +0,0 @@
-#!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-// Import all tool definitions and handlers
-import { getCurrentTimeDefinition, getCurrentTime } from './tools/time/getCurrentTime.js';
-// Semantic code analysis tools (Serena-inspired)
-import { findSymbolDefinition, findSymbol } from './tools/semantic/findSymbol.js';
-import { findReferencesDefinition, findReferences } from './tools/semantic/findReferences.js';
-import { createThinkingChainDefinition, createThinkingChain } from './tools/thinking/createThinkingChain.js';
-import { analyzeProblemDefinition, analyzeProblem } from './tools/thinking/analyzeProblem.js';
-import { stepByStepAnalysisDefinition, stepByStepAnalysis } from './tools/thinking/stepByStepAnalysis.js';
-import { breakDownProblemDefinition, breakDownProblem } from './tools/thinking/breakDownProblem.js';
-import { thinkAloudProcessDefinition, thinkAloudProcess } from './tools/thinking/thinkAloudProcess.js';
-import { formatAsPlanDefinition, formatAsPlan } from './tools/thinking/formatAsPlan.js';
-import { monitorConsoleLogsDefinition, monitorConsoleLogs } from './tools/browser/monitorConsoleLogs.js';
-import { inspectNetworkRequestsDefinition, inspectNetworkRequests } from './tools/browser/inspectNetworkRequests.js';
-import { saveMemoryDefinition, saveMemory } from './tools/memory/saveMemory.js';
-import { recallMemoryDefinition, recallMemory } from './tools/memory/recallMemory.js';
-import { listMemoriesDefinition, listMemories } from './tools/memory/listMemories.js';
-import { deleteMemoryDefinition, deleteMemory } from './tools/memory/deleteMemory.js';
-import { searchMemoriesDefinition, searchMemoriesHandler } from './tools/memory/searchMemories.js';
-import { updateMemoryDefinition, updateMemory } from './tools/memory/updateMemory.js';
-import { autoSaveContextDefinition, autoSaveContext } from './tools/memory/autoSaveContext.js';
-import { restoreSessionContextDefinition, restoreSessionContext } from './tools/memory/restoreSessionContext.js';
-import { prioritizeMemoryDefinition, prioritizeMemory } from './tools/memory/prioritizeMemory.js';
-import { startSessionDefinition, startSession } from './tools/memory/startSession.js';
-import { getCodingGuideDefinition, getCodingGuide } from './tools/convention/getCodingGuide.js';
-import { applyQualityRulesDefinition, applyQualityRules } from './tools/convention/applyQualityRules.js';
-import { validateCodeQualityDefinition, validateCodeQuality } from './tools/convention/validateCodeQuality.js';
-import { analyzeComplexityDefinition, analyzeComplexity } from './tools/convention/analyzeComplexity.js';
-import { checkCouplingCohesionDefinition, checkCouplingCohesion } from './tools/convention/checkCouplingCohesion.js';
-import { suggestImprovementsDefinition, suggestImprovements } from './tools/convention/suggestImprovements.js';
-import { generatePrdDefinition, generatePrd } from './tools/planning/generatePrd.js';
-import { createUserStoriesDefinition, createUserStories } from './tools/planning/createUserStories.js';
-import { analyzeRequirementsDefinition, analyzeRequirements } from './tools/planning/analyzeRequirements.js';
-import { featureRoadmapDefinition, featureRoadmap } from './tools/planning/featureRoadmap.js';
-import { enhancePromptDefinition, enhancePrompt } from './tools/prompt/enhancePrompt.js';
-import { analyzePromptDefinition, analyzePrompt } from './tools/prompt/analyzePrompt.js';
-import { previewUiAsciiDefinition, previewUiAscii } from './tools/ui/previewUiAscii.js';
-// Collect all tool definitions
-const tools = [
-    // Time Utility Tools
-    getCurrentTimeDefinition,
-    // Semantic Code Analysis Tools (Serena-inspired)
-    findSymbolDefinition,
-    findReferencesDefinition,
-    // Sequential Thinking Tools  
-    createThinkingChainDefinition,
-    analyzeProblemDefinition,
-    stepByStepAnalysisDefinition,
-    breakDownProblemDefinition,
-    thinkAloudProcessDefinition,
-    formatAsPlanDefinition,
-    // Browser Development Tools
-    monitorConsoleLogsDefinition,
-    inspectNetworkRequestsDefinition,
-    // Memory Management Tools
-    saveMemoryDefinition,
-    recallMemoryDefinition,
-    listMemoriesDefinition,
-    deleteMemoryDefinition,
-    searchMemoriesDefinition,
-    updateMemoryDefinition,
-    autoSaveContextDefinition,
-    restoreSessionContextDefinition,
-    prioritizeMemoryDefinition,
-    startSessionDefinition,
-    // Convention Tools
-    getCodingGuideDefinition,
-    applyQualityRulesDefinition,
-    validateCodeQualityDefinition,
-    analyzeComplexityDefinition,
-    checkCouplingCohesionDefinition,
-    suggestImprovementsDefinition,
-    // Planning Tools
-    generatePrdDefinition,
-    createUserStoriesDefinition,
-    analyzeRequirementsDefinition,
-    featureRoadmapDefinition,
-    // Prompt Enhancement Tools
-    enhancePromptDefinition,
-    analyzePromptDefinition,
-    // UI Preview Tools
-    previewUiAsciiDefinition
-];
-function createServer() {
-    const server = new Server({
-        name: 'Hi-AI',
-        version: '1.3.0',
-    }, {
-        capabilities: {
-            tools: {},
-            prompts: {},
-            resources: {},
-        },
-    });
-    server.setRequestHandler(ListToolsRequestSchema, async () => {
-        return { tools };
-    });
-    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-        const { name, arguments: args } = request.params;
-        try {
-            switch (name) {
-                // Time Utility Tools
-                case 'get_current_time':
-                    return await getCurrentTime(args);
-                // Semantic Code Analysis Tools
-                case 'find_symbol':
-                    return await findSymbol(args);
-                case 'find_references':
-                    return await findReferences(args);
-                // Sequential Thinking Tools
-                case 'create_thinking_chain':
-                    return await createThinkingChain(args);
-                case 'analyze_problem':
-                    return await analyzeProblem(args);
-                case 'step_by_step_analysis':
-                    return await stepByStepAnalysis(args);
-                case 'break_down_problem':
-                    return await breakDownProblem(args);
-                case 'think_aloud_process':
-                    return await thinkAloudProcess(args);
-                case 'format_as_plan':
-                    return await formatAsPlan(args);
-                // Browser Development Tools
-                case 'monitor_console_logs':
-                    return await monitorConsoleLogs(args);
-                case 'inspect_network_requests':
-                    return await inspectNetworkRequests(args);
-                // Memory Management Tools
-                case 'save_memory':
-                    return await saveMemory(args);
-                case 'recall_memory':
-                    return await recallMemory(args);
-                case 'list_memories':
-                    return await listMemories(args);
-                case 'delete_memory':
-                    return await deleteMemory(args);
-                case 'search_memories':
-                    return await searchMemoriesHandler(args);
-                case 'update_memory':
-                    return await updateMemory(args);
-                case 'auto_save_context':
-                    return await autoSaveContext(args);
-                case 'restore_session_context':
-                    return await restoreSessionContext(args);
-                case 'prioritize_memory':
-                    return await prioritizeMemory(args);
-                case 'start_session':
-                    return await startSession(args);
-                // Convention Tools
-                case 'get_coding_guide':
-                    return await getCodingGuide(args);
-                case 'apply_quality_rules':
-                    return await applyQualityRules(args);
-                case 'validate_code_quality':
-                    return await validateCodeQuality(args);
-                case 'analyze_complexity':
-                    return await analyzeComplexity(args);
-                case 'check_coupling_cohesion':
-                    return await checkCouplingCohesion(args);
-                case 'suggest_improvements':
-                    return await suggestImprovements(args);
-                // Planning Tools
-                case 'generate_prd':
-                    return await generatePrd(args);
-                case 'create_user_stories':
-                    return await createUserStories(args);
-                case 'analyze_requirements':
-                    return await analyzeRequirements(args);
-                case 'feature_roadmap':
-                    return await featureRoadmap(args);
-                // Prompt Enhancement Tools
-                case 'enhance_prompt':
-                    return await enhancePrompt(args);
-                case 'analyze_prompt':
-                    return await analyzePrompt(args);
-                // UI Preview Tools
-                case 'preview_ui_ascii':
-                    return await previewUiAscii(args);
-                default:
-                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-            }
-        }
-        catch (error) {
-            throw new McpError(ErrorCode.InternalError, `Error executing tool: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    });
-    return server;
-}
-// Default export for Smithery platform
-export default function ({ sessionId, config }) {
-    // Return the configured server instance
-    return createServer();
-}
-async function main() {
-    const server = createServer();
-    const transport = new StdioServerTransport();
-    // Handle process termination gracefully
-    process.on('SIGINT', async () => {
-        await server.close();
-        process.exit(0);
-    });
-    process.on('SIGTERM', async () => {
-        await server.close();
-        process.exit(0);
-    });
-    // Handle EPIPE errors that occur with sidecar proxy
-    process.on('uncaughtException', (error) => {
-        if (error.message && error.message.includes('EPIPE')) {
-            // Gracefully handle EPIPE errors
-            console.error('Connection closed by client');
-            return;
-        }
-        console.error('Uncaught exception:', error);
-        process.exit(1);
-    });
-    process.on('unhandledRejection', (reason, promise) => {
-        console.error('Unhandled Rejection at:', promise, 'reason:', reason);
-    });
-    await server.connect(transport);
-}
-// Only run main when not being imported by Smithery
-if (process.argv[1]?.includes('hi-ai') || process.argv[1]?.endsWith('index.js')) {
-    main().catch((error) => {
-        console.error('Server initialization failed:', error);
-        process.exit(1);
-    });
-}

package/mcp/dist/lib/ContextCompressor.js

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