@wundr.io/cli 1.0.10 → 1.0.12

package/dist/nlp/intent-parser.js

@@ -1,744 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntentParser = void 0;
-const events_1 = require("events");
-const logger_1 = require("../utils/logger");
-/**
- * Advanced NLP Intent Parser for converting natural language to CLI commands
- */
-class IntentParser extends events_1.EventEmitter {
-    claudeClient;
-    config;
-    commandPatterns;
-    intentCache;
-    entityPatterns;
-    constructor(claudeClient, config = {}) {
-        super();
-        this.claudeClient = claudeClient;
-        this.config = {
-            confidenceThreshold: 0.7,
-            maxAlternatives: 3,
-            enableNER: true,
-            enableContextAwareness: true,
-            cacheDuration: 5 * 60 * 1000, // 5 minutes
-            ...config,
-        };
-        this.commandPatterns = new Map();
-        this.intentCache = new Map();
-        this.entityPatterns = new Map();
-        this.initializePatterns();
-        this.initializeEntityRecognition();
-    }
-    /**
-     * Parse natural language input and extract intent
-     */
-    async parseIntent(input, availableCommands, context = {}) {
-        const normalizedInput = this.normalizeInput(input);
-        const cacheKey = this.getCacheKey(normalizedInput, availableCommands, context);
-        // Check cache first
-        const cached = this.intentCache.get(cacheKey);
-        if (cached && Date.now() - cached.timestamp < this.config.cacheDuration) {
-            logger_1.logger.debug('Returning cached intent result');
-            return cached.result;
-        }
-        try {
-            // Step 1: Quick pattern matching for common commands
-            const patternResult = await this.patternMatching(normalizedInput, availableCommands);
-            if (patternResult.confidence >= 0.9) {
-                this.cacheResult(cacheKey, patternResult);
-                return patternResult;
-            }
-            // Step 2: Named Entity Recognition
-            const entities = this.config.enableNER
-                ? await this.extractEntities(normalizedInput)
-                : [];
-            // Step 3: AI-powered intent analysis
-            const aiResult = await this.aiIntentAnalysis(normalizedInput, availableCommands, context, entities);
-            // Step 4: Combine results and validate
-            const finalResult = this.combineResults(patternResult, aiResult, entities);
-            // Step 5: Post-processing and validation
-            const validatedResult = await this.validateAndEnrich(finalResult, availableCommands, context);
-            this.cacheResult(cacheKey, validatedResult);
-            this.emit('intent_parsed', {
-                input: normalizedInput,
-                result: validatedResult,
-            });
-            return validatedResult;
-        }
-        catch (error) {
-            logger_1.logger.error('Intent parsing failed:', error);
-            return this.fallbackIntentParsing(normalizedInput, availableCommands, context);
-        }
-    }
-    /**
-     * Extract command parameters from natural language
-     */
-    async extractParameters(input, command, commandPattern) {
-        const parameters = {};
-        if (!commandPattern) {
-            commandPattern = this.commandPatterns.get(command);
-        }
-        if (!commandPattern) {
-            logger_1.logger.debug(`No pattern found for command: ${command}`);
-            return parameters;
-        }
-        // Extract using AI
-        const systemPrompt = `You are a parameter extraction system. Extract parameters from user input for the command "${command}".
-
-Command parameters:
-${commandPattern.parameters.map(p => `- ${p.name} (${p.type}${p.required ? ', required' : ', optional'}): ${p.aliases?.join(', ') || ''}`).join('\n')}
-
-Extract parameters from the user input and respond with JSON only:
-{
-  "parameters": {
-    "paramName": "value"
-  },
-  "confidence": 0.9
-}`;
-        try {
-            const response = await this.claudeClient.sendMessage(input, systemPrompt, {
-                temperature: 0.1,
-                maxTokens: 1024,
-            });
-            const result = JSON.parse(response.trim());
-            // Validate extracted parameters
-            for (const param of commandPattern.parameters) {
-                if (param.required && !result.parameters[param.name]) {
-                    logger_1.logger.warn(`Missing required parameter: ${param.name}`);
-                }
-                if (result.parameters[param.name] && param.validation) {
-                    if (!param.validation.test(result.parameters[param.name])) {
-                        logger_1.logger.warn(`Parameter validation failed for ${param.name}: ${result.parameters[param.name]}`);
-                        delete result.parameters[param.name];
-                    }
-                }
-                // Apply default values
-                if (!result.parameters[param.name] &&
-                    param.defaultValue !== undefined) {
-                    result.parameters[param.name] = param.defaultValue;
-                }
-            }
-            return result.parameters;
-        }
-        catch (error) {
-            logger_1.logger.error('Parameter extraction failed:', error);
-            return this.fallbackParameterExtraction(input, commandPattern);
-        }
-    }
-    /**
-     * Suggest commands based on partial input
-     */
-    async suggestCommands(partialInput, availableCommands, context = {}, limit = 5) {
-        const suggestions = [];
-        // Pattern-based suggestions
-        const patternSuggestions = this.getPatternSuggestions(partialInput, availableCommands);
-        suggestions.push(...patternSuggestions);
-        // AI-powered suggestions if we need more
-        if (suggestions.length < limit) {
-            try {
-                const aiSuggestions = await this.getAISuggestions(partialInput, availableCommands, context, limit - suggestions.length);
-                suggestions.push(...aiSuggestions);
-            }
-            catch (error) {
-                logger_1.logger.error('AI suggestions failed:', error);
-            }
-        }
-        // Sort by confidence and limit results
-        suggestions.sort((a, b) => b.confidence - a.confidence);
-        return suggestions.slice(0, limit);
-    }
-    /**
-     * Register a custom command pattern
-     */
-    registerCommandPattern(pattern) {
-        this.commandPatterns.set(pattern.intent, pattern);
-        logger_1.logger.debug(`Registered command pattern: ${pattern.intent}`);
-    }
-    /**
-     * Batch register multiple command patterns
-     */
-    registerCommandPatterns(patterns) {
-        patterns.forEach(pattern => this.registerCommandPattern(pattern));
-    }
-    /**
-     * Get registered command patterns
-     */
-    getCommandPatterns() {
-        return Array.from(this.commandPatterns.values());
-    }
-    /**
-     * Clear intent cache
-     */
-    clearCache() {
-        this.intentCache.clear();
-        this.emit('cache_cleared');
-    }
-    /**
-     * Get cache statistics
-     */
-    getCacheStats() {
-        const now = Date.now();
-        const validEntries = Array.from(this.intentCache.values()).filter(entry => now - entry.timestamp < this.config.cacheDuration);
-        const oldestEntry = validEntries.length > 0
-            ? new Date(Math.min(...validEntries.map(e => e.timestamp)))
-            : null;
-        return {
-            size: validEntries.length,
-            hitRate: this.intentCache.size > 0
-                ? validEntries.length / this.intentCache.size
-                : 0,
-            oldestEntry,
-        };
-    }
-    // Private methods
-    initializePatterns() {
-        const defaultPatterns = [
-            {
-                intent: 'analyze',
-                patterns: [
-                    'analyze {path?}',
-                    'check {path?}',
-                    'scan {path?}',
-                    'examine {path?}',
-                    'review {path?}',
-                ],
-                parameters: [
-                    { name: 'path', type: 'path', required: false, defaultValue: '.' },
-                    {
-                        name: 'focus',
-                        type: 'enum',
-                        required: false,
-                        enumValues: ['dependencies', 'quality', 'security', 'performance'],
-                    },
-                    {
-                        name: 'format',
-                        type: 'enum',
-                        required: false,
-                        enumValues: ['json', 'table', 'csv'],
-                    },
-                ],
-                examples: [
-                    'analyze the project',
-                    'check dependencies in src folder',
-                    'scan for security issues',
-                ],
-                category: 'analysis',
-            },
-            {
-                intent: 'create',
-                patterns: [
-                    'create {type} {name}',
-                    'new {type} {name}',
-                    'generate {type} {name}',
-                    'make {type} {name}',
-                ],
-                parameters: [
-                    {
-                        name: 'type',
-                        type: 'enum',
-                        required: true,
-                        enumValues: ['component', 'service', 'test', 'config'],
-                    },
-                    { name: 'name', type: 'string', required: true },
-                    { name: 'template', type: 'string', required: false },
-                ],
-                examples: [
-                    'create component UserProfile',
-                    'new service AuthService',
-                    'generate test for UserService',
-                ],
-                category: 'generation',
-            },
-            {
-                intent: 'init',
-                patterns: [
-                    'init {project?}',
-                    'initialize {project?}',
-                    'setup {project?}',
-                    'configure {project?}',
-                ],
-                parameters: [
-                    { name: 'project', type: 'string', required: false },
-                    { name: 'template', type: 'string', required: false },
-                    { name: 'force', type: 'boolean', required: false },
-                ],
-                examples: [
-                    'init new project',
-                    'initialize with React template',
-                    'setup the workspace',
-                ],
-                category: 'setup',
-            },
-            {
-                intent: 'help',
-                patterns: [
-                    'help {command?}',
-                    'how {action?}',
-                    'what {question?}',
-                    'explain {topic?}',
-                ],
-                parameters: [
-                    { name: 'command', type: 'string', required: false },
-                    { name: 'topic', type: 'string', required: false },
-                ],
-                examples: [
-                    'help with analyze command',
-                    'how to create components',
-                    'what does this do',
-                ],
-                category: 'help',
-            },
-            {
-                intent: 'dashboard',
-                patterns: [
-                    'dashboard',
-                    'ui',
-                    'interface',
-                    'show {view?}',
-                    'open {view?}',
-                ],
-                parameters: [
-                    {
-                        name: 'view',
-                        type: 'enum',
-                        required: false,
-                        enumValues: ['overview', 'metrics', 'reports'],
-                    },
-                    { name: 'port', type: 'number', required: false, defaultValue: 3000 },
-                ],
-                examples: ['open dashboard', 'show metrics view', 'start ui'],
-                category: 'interface',
-            },
-        ];
-        defaultPatterns.forEach(pattern => this.registerCommandPattern(pattern));
-    }
-    initializeEntityRecognition() {
-        this.entityPatterns.set('file_path', /(?:\.\/|\/|~\/)[^\s]+/g);
-        this.entityPatterns.set('package_name', /(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*/g);
-        this.entityPatterns.set('command', /(?:wundr\s+)?(?:analyze|create|init|help|dashboard|batch|watch)\b/g);
-        this.entityPatterns.set('option', /--?[a-zA-Z][a-zA-Z0-9-]*/g);
-        this.entityPatterns.set('technology', /\b(?:react|angular|vue|nodejs|typescript|javascript|python|java|docker|kubernetes)\b/gi);
-    }
-    normalizeInput(input) {
-        return input
-            .trim()
-            .toLowerCase()
-            .replace(/[^\w\s\-\.\/]/g, ' ')
-            .replace(/\s+/g, ' ');
-    }
-    getCacheKey(input, commands, context) {
-        const contextKey = JSON.stringify({
-            projectType: context.projectType,
-            workingDirectory: context.workingDirectory,
-            recentCommands: context.recentCommands?.slice(0, 3), // Only recent commands for cache key
-        });
-        return `${input}:${commands.sort().join(',')}:${contextKey}`;
-    }
-    async patternMatching(input, availableCommands) {
-        let bestMatch = {
-            intent: 'unknown',
-            confidence: 0,
-            context: { entities: [], keywords: [], sentiment: 'neutral' },
-        };
-        for (const [intent, pattern] of this.commandPatterns) {
-            if (!availableCommands.includes(intent)) {
-                continue;
-            }
-            const confidence = this.calculatePatternScore(input, pattern);
-            if (confidence > bestMatch.confidence) {
-                bestMatch = {
-                    intent,
-                    confidence,
-                    command: `wundr ${intent}`,
-                    parameters: {},
-                    reasoning: `Pattern match for "${intent}" command`,
-                    context: { entities: [], keywords: [], sentiment: 'neutral' },
-                };
-            }
-        }
-        return bestMatch;
-    }
-    calculatePatternScore(input, pattern) {
-        let score = 0;
-        let totalWeight = 0;
-        // Check pattern matches
-        for (const patternStr of pattern.patterns) {
-            const patternWords = patternStr.toLowerCase().split(/\s+/);
-            const inputWords = input.split(/\s+/);
-            let matchCount = 0;
-            for (const word of patternWords) {
-                if (word.startsWith('{') && word.endsWith('}')) {
-                    continue;
-                } // Skip parameters
-                if (inputWords.includes(word)) {
-                    matchCount++;
-                }
-            }
-            const patternScore = matchCount / patternWords.filter(w => !w.startsWith('{')).length;
-            score = Math.max(score, patternScore);
-        }
-        totalWeight += 0.6;
-        // Check examples
-        let exampleScore = 0;
-        for (const example of pattern.examples) {
-            const similarity = this.calculateStringSimilarity(input, example.toLowerCase());
-            exampleScore = Math.max(exampleScore, similarity);
-        }
-        score += exampleScore * 0.4;
-        totalWeight += 0.4;
-        return score / totalWeight;
-    }
-    calculateStringSimilarity(str1, str2) {
-        const words1 = str1.split(/\s+/);
-        const words2 = str2.split(/\s+/);
-        let matches = 0;
-        for (const word1 of words1) {
-            if (words2.includes(word1)) {
-                matches++;
-            }
-        }
-        return matches / Math.max(words1.length, words2.length);
-    }
-    async extractEntities(input) {
-        const entities = [];
-        for (const [type, pattern] of this.entityPatterns) {
-            const matches = Array.from(input.matchAll(pattern));
-            for (const match of matches) {
-                if (match.index !== undefined) {
-                    entities.push({
-                        text: match[0],
-                        type: type,
-                        confidence: 0.8, // Static confidence for regex patterns
-                        startIndex: match.index,
-                        endIndex: match.index + match[0].length,
-                    });
-                }
-            }
-        }
-        return entities;
-    }
-    async aiIntentAnalysis(input, availableCommands, context, entities) {
-        const contextInfo = this.buildContextInfo(context);
-        const entityInfo = entities.length > 0
-            ? `\nDetected entities: ${entities.map(e => `${e.text} (${e.type})`).join(', ')}`
-            : '';
-        const systemPrompt = `You are an expert CLI intent analyzer. Analyze user input and map it to appropriate commands.
-
-Available commands: ${availableCommands.join(', ')}
-${contextInfo}${entityInfo}
-
-User input: "${input}"
-
-Analyze and respond with JSON only:
-{
-  "intent": "command_name",
-  "confidence": 0.95,
-  "command": "wundr analyze --path ./src",
-  "parameters": {"path": "./src"},
-  "alternatives": [
-    {"command": "wundr scan", "confidence": 0.7, "description": "Alternative interpretation"}
-  ],
-  "reasoning": "User wants to analyze source code based on path mention",
-  "clarification": null
-}`;
-        try {
-            const response = await this.claudeClient.sendMessage(input, systemPrompt, {
-                temperature: 0.1,
-                maxTokens: 1536,
-            });
-            const cleanResponse = response.trim();
-            const jsonMatch = cleanResponse.match(/\{[\s\S]*\}/);
-            if (!jsonMatch) {
-                throw new Error('No valid JSON in AI response');
-            }
-            const result = JSON.parse(jsonMatch[0]);
-            // Add context information
-            result.context = {
-                entities,
-                keywords: this.extractKeywords(input),
-                sentiment: this.analyzeSentiment(input),
-            };
-            return result;
-        }
-        catch (error) {
-            logger_1.logger.error('AI intent analysis failed:', error);
-            throw error;
-        }
-    }
-    buildContextInfo(context) {
-        const parts = [];
-        if (context.projectType) {
-            parts.push(`Project type: ${context.projectType}`);
-        }
-        if (context.recentCommands?.length) {
-            parts.push(`Recent commands: ${context.recentCommands.slice(0, 3).join(', ')}`);
-        }
-        if (context.workingDirectory) {
-            parts.push(`Working directory: ${context.workingDirectory}`);
-        }
-        return parts.length > 0 ? `\nContext: ${parts.join(', ')}` : '';
-    }
-    combineResults(patternResult, aiResult, entities) {
-        // Use AI result as base, but boost confidence if pattern matching agrees
-        let finalResult = { ...aiResult };
-        if (patternResult.intent === aiResult.intent) {
-            finalResult.confidence = Math.min(0.98, aiResult.confidence + 0.1);
-            finalResult.reasoning += ' (confirmed by pattern matching)';
-        }
-        else if (patternResult.confidence > 0.8) {
-            // High-confidence pattern match might override AI
-            if (patternResult.confidence > aiResult.confidence) {
-                finalResult = patternResult;
-                finalResult.reasoning += ' (overridden by high-confidence pattern match)';
-            }
-        }
-        // Ensure entities are included
-        if (finalResult.context) {
-            finalResult.context.entities = entities;
-        }
-        return finalResult;
-    }
-    async validateAndEnrich(result, availableCommands, context) {
-        // Validate that the intent command is available
-        if (!availableCommands.includes(result.intent)) {
-            logger_1.logger.warn(`Intent "${result.intent}" not in available commands`);
-            result.confidence *= 0.5;
-            result.clarification = `The command "${result.intent}" is not available. Did you mean one of: ${availableCommands.join(', ')}?`;
-        }
-        // Add safety warnings for destructive commands
-        const commandPattern = this.commandPatterns.get(result.intent);
-        if (commandPattern?.destructive) {
-            result.clarification = 'This is a destructive operation. Are you sure you want to proceed?';
-        }
-        // Enrich with context-aware suggestions
-        if (result.confidence < this.config.confidenceThreshold) {
-            result.alternatives = await this.getContextualAlternatives(result, availableCommands, context);
-        }
-        return result;
-    }
-    async getContextualAlternatives(result, availableCommands, context) {
-        const alternatives = [];
-        // Add pattern-based alternatives
-        for (const command of availableCommands) {
-            if (command !== result.intent) {
-                const pattern = this.commandPatterns.get(command);
-                if (pattern) {
-                    const confidence = this.calculatePatternScore(result.command || '', pattern);
-                    if (confidence > 0.3) {
-                        alternatives.push({
-                            command: `wundr ${command}`,
-                            confidence,
-                            description: `Alternative: ${pattern.examples[0] || command}`,
-                        });
-                    }
-                }
-            }
-        }
-        // Sort and limit alternatives
-        alternatives.sort((a, b) => b.confidence - a.confidence);
-        return alternatives.slice(0, this.config.maxAlternatives);
-    }
-    fallbackIntentParsing(input, availableCommands, context) {
-        // Simple keyword matching as last resort
-        const keywords = input.split(/\s+/);
-        const bestMatch = 'help';
-        const bestScore = 0;
-        for (const command of availableCommands) {
-            if (keywords.includes(command)) {
-                return {
-                    intent: command,
-                    confidence: 0.6,
-                    command: `wundr ${command}`,
-                    parameters: {},
-                    reasoning: 'Fallback keyword matching',
-                    context: { entities: [], keywords, sentiment: 'neutral' },
-                };
-            }
-        }
-        return {
-            intent: bestMatch,
-            confidence: 0.3,
-            command: `wundr ${bestMatch}`,
-            parameters: {},
-            clarification: `I couldn't understand "${input}". Type "help" to see available commands.`,
-            reasoning: 'Fallback to help command',
-            context: { entities: [], keywords, sentiment: 'neutral' },
-        };
-    }
-    fallbackParameterExtraction(input, pattern) {
-        const parameters = {};
-        const words = input.split(/\s+/);
-        // Simple heuristic parameter extraction
-        for (const param of pattern.parameters) {
-            if (param.type === 'path') {
-                const pathMatch = input.match(/(?:\.\/|\/|~\/)[^\s]+/);
-                if (pathMatch) {
-                    parameters[param.name] = pathMatch[0];
-                }
-            }
-            else if (param.type === 'boolean') {
-                if (words.some(word => ['yes', 'true', 'on', 'enable'].includes(word.toLowerCase()))) {
-                    parameters[param.name] = true;
-                }
-                else if (words.some(word => ['no', 'false', 'off', 'disable'].includes(word.toLowerCase()))) {
-                    parameters[param.name] = false;
-                }
-            }
-            // Apply default values
-            if (!parameters[param.name] && param.defaultValue !== undefined) {
-                parameters[param.name] = param.defaultValue;
-            }
-        }
-        return parameters;
-    }
-    getPatternSuggestions(partialInput, availableCommands) {
-        const suggestions = [];
-        for (const command of availableCommands) {
-            const pattern = this.commandPatterns.get(command);
-            if (!pattern) {
-                continue;
-            }
-            // Check if partial input matches command or examples
-            const confidence = Math.max(this.calculateStringSimilarity(partialInput, command), ...pattern.examples.map(ex => this.calculateStringSimilarity(partialInput, ex)));
-            if (confidence > 0.3) {
-                suggestions.push({
-                    command: `wundr ${command}`,
-                    description: pattern.examples[0] || `Run ${command} command`,
-                    confidence,
-                    completion: pattern.examples[0] || `wundr ${command}`,
-                });
-            }
-        }
-        return suggestions;
-    }
-    async getAISuggestions(partialInput, availableCommands, context, limit) {
-        const systemPrompt = `You are a CLI auto-completion assistant. Based on partial user input, suggest the most likely command completions.
-
-Available commands: ${availableCommands.join(', ')}
-Partial input: "${partialInput}"
-
-Provide ${limit} suggestions in JSON format:
-{
-  "suggestions": [
-    {
-      "command": "wundr analyze",
-      "description": "Analyze the project for issues",
-      "confidence": 0.9,
-      "completion": "wundr analyze --path ."
-    }
-  ]
-}`;
-        try {
-            const response = await this.claudeClient.sendMessage('', systemPrompt, {
-                temperature: 0.3,
-                maxTokens: 1024,
-            });
-            const result = JSON.parse(response.trim());
-            return result.suggestions || [];
-        }
-        catch (error) {
-            logger_1.logger.error('AI suggestions failed:', error);
-            return [];
-        }
-    }
-    extractKeywords(input) {
-        // Simple keyword extraction
-        const stopWords = [
-            'the',
-            'and',
-            'or',
-            'but',
-            'in',
-            'on',
-            'at',
-            'to',
-            'for',
-            'of',
-            'with',
-            'by',
-            'is',
-            'are',
-            'was',
-            'were',
-            'be',
-            'been',
-            'have',
-            'has',
-            'had',
-            'do',
-            'does',
-            'did',
-            'will',
-            'would',
-            'could',
-            'should',
-        ];
-        return input
-            .toLowerCase()
-            .split(/\s+/)
-            .filter(word => word.length > 2 && !stopWords.includes(word))
-            .slice(0, 10); // Limit to 10 keywords
-    }
-    analyzeSentiment(input) {
-        const positiveWords = [
-            'good',
-            'great',
-            'excellent',
-            'awesome',
-            'perfect',
-            'love',
-            'like',
-            'thanks',
-            'help',
-            'please',
-        ];
-        const negativeWords = [
-            'bad',
-            'terrible',
-            'awful',
-            'hate',
-            'problem',
-            'error',
-            'issue',
-            'broken',
-            'fail',
-            'wrong',
-        ];
-        const words = input.toLowerCase().split(/\s+/);
-        const positiveCount = words.filter(word => positiveWords.includes(word)).length;
-        const negativeCount = words.filter(word => negativeWords.includes(word)).length;
-        if (positiveCount > negativeCount) {
-            return 'positive';
-        }
-        if (negativeCount > positiveCount) {
-            return 'negative';
-        }
-        return 'neutral';
-    }
-    cacheResult(key, result) {
-        this.intentCache.set(key, {
-            result,
-            timestamp: Date.now(),
-        });
-        // Clean old entries periodically
-        if (this.intentCache.size % 100 === 0) {
-            this.cleanCache();
-        }
-    }
-    cleanCache() {
-        const now = Date.now();
-        const expiredKeys = [];
-        for (const [key, entry] of this.intentCache) {
-            if (now - entry.timestamp > this.config.cacheDuration) {
-                expiredKeys.push(key);
-            }
-        }
-        expiredKeys.forEach(key => this.intentCache.delete(key));
-        if (expiredKeys.length > 0) {
-            logger_1.logger.debug(`Cleaned ${expiredKeys.length} expired cache entries`);
-        }
-    }
-}
-exports.IntentParser = IntentParser;
-exports.default = IntentParser;
-//# sourceMappingURL=intent-parser.js.map