vme-mcp-server 0.1.5 → 0.1.7

package/dist/lib/intent-recognition.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVMIntent = void 0;
+const vm_parsing_js_1 = require("./vm-parsing.js");
+// Intent recognition system for natural language processing
+function parseVMIntent(naturalLanguageInput) {
+    const input = naturalLanguageInput.toLowerCase().trim();
+    const result = {
+        action: 'unknown',
+        confidence: 0,
+        entities: {},
+        originalText: naturalLanguageInput
+    };
+    // Intent Classification with confidence scoring
+    const intentPatterns = {
+        create: [
+            /\b(create|provision|deploy|launch|start|build|make|setup)\b/,
+            /\bneed\s+(\d+\s+)?(vm|server|machine)/,
+            /\bcan\s+you\s+(create|provision|deploy)/
+        ],
+        modify: [
+            /\b(modify|change|update|edit|alter|resize|scale)\b/,
+            /\badd\s+(more\s+)?(cpu|memory|disk|storage)/,
+            /\bchange\s+the\s+(size|plan|configuration)/
+        ],
+        monitor: [
+            /\b(show|list|display|check|status|monitor|view)\b(?!.*\b(available|options|resources|templates|plans)\b)/,
+            /\bwhat\s+(vm|server|machine)/,
+            /\bhow\s+many\s+(vm|server|machine)/
+        ],
+        destroy: [
+            /\b(delete|remove|destroy|terminate|stop|kill)\b/,
+            /\btear\s+down/,
+            /\bshut\s+down/
+        ],
+        discover: [
+            /\b(available|options|resources|templates|plans)\b/,
+            /\bshow\s+me\s+(all|available)/,
+            /\bwhat\s+(are|is)\s+(available|possible)/,
+            /\bwhat\s+can\s+i\s+(create|do)/
+        ]
+    };
+    // Calculate confidence for each intent
+    let maxConfidence = 0;
+    let detectedAction = 'unknown';
+    for (const [action, patterns] of Object.entries(intentPatterns)) {
+        let matches = 0;
+        for (const pattern of patterns) {
+            if (pattern.test(input)) {
+                matches++;
+            }
+        }
+        const confidence = patterns.length > 0 ? matches / patterns.length : 0;
+        if (confidence > maxConfidence) {
+            maxConfidence = confidence;
+            detectedAction = action;
+        }
+    }
+    result.action = detectedAction;
+    result.confidence = maxConfidence;
+    // Entity Extraction for VM creation
+    if (result.action === 'create') {
+        // Extract VM names and count
+        const namePatterns = [
+            /\b(?:vm|server|machine)s?\s+(?:named\s+)?["']?([a-zA-Z0-9\-_]+(?:\s*->\s*[a-zA-Z0-9\-_]+)?)["']?/,
+            /\b(?:named\s+)?["']?([a-zA-Z0-9\-_]+(?:\s*->\s*[a-zA-Z0-9\-_]+)?)["']?\s+(?:vm|server|machine)/,
+            /\bcreate\s+(?:(?:vm|server|machine)s?\s+)?["']?([a-zA-Z0-9\-_]+(?:\s*->\s*[a-zA-Z0-9\-_]+)?)["']?/,
+            /\b(?:vm|server|machine)\s+named\s+["']?([a-zA-Z0-9\-_]+(?:\s*->\s*[a-zA-Z0-9\-_]+)?)["']?/
+        ];
+        for (const pattern of namePatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                const nameInput = match[1] || match[2];
+                result.entities.vmNames = (0, vm_parsing_js_1.parseVMNames)(nameInput);
+                break;
+            }
+        }
+        // Extract count
+        const countMatch = input.match(/\b(\d+)\s+(?:vm|server|machine)/);
+        if (countMatch) {
+            result.entities.count = parseInt(countMatch[1]);
+        }
+        // Extract OS template
+        const osPatterns = [
+            /\b(ubuntu|rocky|centos|debian|rhel|red\s*hat|alma|almalinux)(?:\s+(\d+(?:\.\d+)?))?/,
+            /\busing\s+([a-zA-Z0-9\-_]+)\s+(?:template|os|operating)/,
+            /\b(?:template|os|operating)\s+([a-zA-Z0-9\-_]+)/
+        ];
+        for (const pattern of osPatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                result.entities.osTemplate = match[0];
+                break;
+            }
+        }
+        // Extract size/memory
+        const sizePatterns = [
+            /\b(small|medium|large|tiny)\b/,
+            /\b(\d+)\s*gb\s+(?:memory|ram)\b/,
+            /\b(\d+)\s*cpu[s]?\s*,?\s*(\d+)\s*gb/,
+            /\bwith\s+(\d+(?:gb|cpu))\b/,
+            /\b(\d+gb)\b/
+        ];
+        for (const pattern of sizePatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                result.entities.size = match[0];
+                break;
+            }
+        }
+        // Extract group/environment
+        const groupPatterns = [
+            /\bin\s+(?:the\s+)?([a-zA-Z0-9\-_]+)\s+(?:group|environment|site)/,
+            /\b(?:group|environment|site)\s+([a-zA-Z0-9\-_]+)/,
+            /\bfor\s+([a-zA-Z0-9\-_]+)\s+(?:environment|testing|production)/
+        ];
+        for (const pattern of groupPatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                result.entities.group = match[1];
+                break;
+            }
+        }
+        // Extract zone/cloud
+        const zonePatterns = [
+            /\bon\s+([a-zA-Z0-9\-_]+)\s+(?:zone|cloud)/,
+            /\b(?:zone|cloud)\s+([a-zA-Z0-9\-_]+)/,
+            /\bin\s+([a-zA-Z0-9\-_]+)\s+(?:zone|cloud)/,
+            /\b(?:deploy|launch|create)\s+(?:in\s+)?([a-zA-Z0-9\-_]+)\s+zone/
+        ];
+        for (const pattern of zonePatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                result.entities.zone = match[1];
+                break;
+            }
+        }
+        // Extract distribution strategy
+        if (input.includes('spread') || input.includes('distribute') || input.includes('across')) {
+            result.entities.distribution = 'spread';
+        }
+        else if (input.includes('each node') || input.includes('all nodes')) {
+            result.entities.distribution = 'spread';
+        }
+        else if (input.includes('node') && input.match(/node[s]?\s*[\d,\s]+/)) {
+            const nodeMatch = input.match(/node[s]?\s*([\d,\s]+)/);
+            if (nodeMatch) {
+                result.entities.distribution = nodeMatch[1].replace(/\s+/g, '');
+            }
+        }
+        // Boost confidence if we extracted entities
+        const entityCount = Object.keys(result.entities).length;
+        if (entityCount > 0) {
+            result.confidence = Math.min(0.95, result.confidence + (entityCount * 0.1));
+        }
+    }
+    return result;
+}
+exports.parseVMIntent = parseVMIntent;

package/dist/lib/name-resolver.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nameResolver = exports.NameResolver = void 0;
+const capability_discovery_js_1 = require("./capability-discovery.js");
+// Generic name->ID resolver using capability discovery data
+class NameResolver {
+    constructor() {
+        this.capabilitiesCache = null;
+        this.cacheTimestamp = 0;
+        this.CACHE_TTL = 300000; // 5 minutes
+    }
+    async getCapabilities() {
+        const now = Date.now();
+        if (!this.capabilitiesCache || (now - this.cacheTimestamp) > this.CACHE_TTL) {
+            this.capabilitiesCache = await capability_discovery_js_1.capabilityDiscovery.discoverCapabilities(['all']);
+            this.cacheTimestamp = now;
+        }
+        return this.capabilitiesCache;
+    }
+    async resolveNameToId(resourceType, name) {
+        if (!name)
+            return null;
+        const capabilities = await this.getCapabilities();
+        const nameLower = name.toLowerCase();
+        switch (resourceType) {
+            case 'virtualImage':
+            case 'image':
+                return this.resolveImageName(capabilities, nameLower);
+            case 'group':
+            case 'site':
+                return this.resolveGroupName(capabilities, nameLower);
+            case 'servicePlan':
+            case 'plan':
+                return this.resolvePlanName(capabilities, nameLower);
+            case 'zone':
+            case 'cloud':
+                return this.resolveZoneName(capabilities, nameLower);
+            case 'instanceType':
+                return this.resolveInstanceTypeName(capabilities, nameLower);
+            default:
+                return null;
+        }
+    }
+    resolveImageName(capabilities, nameLower) {
+        const images = capabilities.compute?.available_images || [];
+        // Try exact name match first
+        let found = images.find((img) => img.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try partial name match
+        found = images.find((img) => img.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        // Try category + version matching (e.g., "ubuntu 20.04" -> ubuntu-2004)
+        for (const img of images) {
+            const imgName = img.name?.toLowerCase() || '';
+            const category = img.category?.toLowerCase() || '';
+            const version = img.version?.toString() || '';
+            // Match patterns like "ubuntu 20.04" to "ubuntu-2004"
+            if (nameLower.includes(category) && nameLower.includes(version)) {
+                return img.id;
+            }
+            // Match patterns like "ubuntu" to first ubuntu image
+            if (nameLower === category) {
+                return img.id;
+            }
+        }
+        return null;
+    }
+    resolveGroupName(capabilities, nameLower) {
+        const groups = capabilities.platform?.groups || [];
+        // Try exact match
+        let found = groups.find((g) => g.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try partial match
+        found = groups.find((g) => g.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        return null;
+    }
+    resolvePlanName(capabilities, nameLower) {
+        const plans = capabilities.compute?.service_plans || [];
+        // Try exact match
+        let found = plans.find((p) => p.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try size-based matching
+        if (nameLower.includes('small') || nameLower.includes('1 cpu') || nameLower.includes('4gb')) {
+            found = plans.find((p) => p.name?.toLowerCase().includes('1 cpu') ||
+                p.name?.toLowerCase().includes('4gb') ||
+                p.max_cpu === 1);
+            if (found)
+                return found.id;
+        }
+        if (nameLower.includes('medium') || nameLower.includes('2 cpu') || nameLower.includes('8gb')) {
+            found = plans.find((p) => p.name?.toLowerCase().includes('2 cpu') ||
+                p.name?.toLowerCase().includes('8gb') ||
+                p.max_cpu === 2);
+            if (found)
+                return found.id;
+        }
+        if (nameLower.includes('large') || nameLower.includes('4 cpu') || nameLower.includes('16gb')) {
+            found = plans.find((p) => p.name?.toLowerCase().includes('4 cpu') ||
+                p.name?.toLowerCase().includes('16gb') ||
+                p.max_cpu === 4);
+            if (found)
+                return found.id;
+        }
+        // Try partial match
+        found = plans.find((p) => p.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        return null;
+    }
+    resolveZoneName(capabilities, nameLower) {
+        const zones = capabilities.networking?.zones || [];
+        // Try exact match
+        let found = zones.find((z) => z.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try partial match
+        found = zones.find((z) => z.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        return null;
+    }
+    resolveInstanceTypeName(capabilities, nameLower) {
+        const instanceTypes = capabilities.compute?.instance_types || [];
+        // Try exact match
+        let found = instanceTypes.find((t) => t.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try code match
+        found = instanceTypes.find((t) => t.code?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try partial match
+        found = instanceTypes.find((t) => t.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        return null;
+    }
+    // Helper method to get available names for a resource type
+    async getAvailableNames(resourceType) {
+        const capabilities = await this.getCapabilities();
+        switch (resourceType) {
+            case 'virtualImage':
+                return capabilities.compute?.available_images?.map((img) => img.name) || [];
+            case 'group':
+                return capabilities.platform?.groups?.map((g) => g.name) || [];
+            case 'servicePlan':
+                return capabilities.compute?.service_plans?.map((p) => p.name) || [];
+            case 'zone':
+                return capabilities.networking?.zones?.map((z) => z.name) || [];
+            case 'instanceType':
+                return capabilities.compute?.instance_types?.map((t) => t.name) || [];
+            default:
+                return [];
+        }
+    }
+    // Helper to resolve multiple resources at once
+    async resolveMultiple(resources) {
+        const results = {};
+        for (const resource of resources) {
+            const key = `${resource.type}_${resource.name}`;
+            results[key] = await this.resolveNameToId(resource.type, resource.name);
+        }
+        return results;
+    }
+}
+exports.NameResolver = NameResolver;
+// Global resolver instance
+exports.nameResolver = new NameResolver();

package/dist/lib/session.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logInteraction = exports.generateSessionId = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+// AI Training Data Collection Configuration
+const AI_TRAINING_ENABLED = process.env.ENABLE_AI_TRAINING_DATA === 'true';
+const AI_TRAINING_FIELDS = (process.env.AI_TRAINING_DATA_FIELDS || 'user_input,parsed_output,success_metrics').split(',');
+const AI_TRAINING_RETENTION_DAYS = parseInt(process.env.AI_TRAINING_DATA_RETENTION_DAYS || '30');
+// Generate session ID for interaction tracking
+function generateSessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+exports.generateSessionId = generateSessionId;
+// Privacy-aware interaction logging
+function logInteraction(interaction) {
+    if (!AI_TRAINING_ENABLED) {
+        return; // Respect user privacy choice
+    }
+    try {
+        // Ensure logs directory exists
+        const logsDir = (0, path_1.join)(process.cwd(), 'ai-training-logs');
+        if (!(0, fs_1.existsSync)(logsDir)) {
+            (0, fs_1.mkdirSync)(logsDir, { recursive: true });
+        }
+        // Filter fields based on user preferences
+        const filteredInteraction = {
+            id: interaction.id || `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: new Date().toISOString(),
+            session_id: interaction.session_id || 'unknown',
+            tool_name: interaction.tool_name || 'unknown'
+        };
+        // Only include fields user has opted into
+        if (AI_TRAINING_FIELDS.includes('user_input') && interaction.user_input) {
+            filteredInteraction.user_input = interaction.user_input;
+        }
+        if (AI_TRAINING_FIELDS.includes('parsed_output') && interaction.parsed_output) {
+            filteredInteraction.parsed_output = interaction.parsed_output;
+        }
+        if (AI_TRAINING_FIELDS.includes('api_calls') && interaction.api_calls) {
+            filteredInteraction.api_calls = interaction.api_calls;
+        }
+        if (AI_TRAINING_FIELDS.includes('success_metrics') && interaction.success_metrics) {
+            filteredInteraction.success_metrics = interaction.success_metrics;
+        }
+        if (AI_TRAINING_FIELDS.includes('timing') && interaction.timing) {
+            filteredInteraction.timing = interaction.timing;
+        }
+        // Append to daily log file (JSONL format)
+        const logFile = (0, path_1.join)(logsDir, `interactions-${new Date().toISOString().split('T')[0]}.jsonl`);
+        const logEntry = JSON.stringify(filteredInteraction) + '\n';
+        (0, fs_1.writeFileSync)(logFile, logEntry, { flag: 'a' });
+    }
+    catch (error) {
+        // Fail silently to not disrupt user experience
+        console.warn('AI training data logging failed:', error);
+    }
+}
+exports.logInteraction = logInteraction;

package/dist/lib/vm-parsing.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateNodeAssignments = exports.parseVMNames = void 0;
+// Helper function to parse VM name patterns
+function parseVMNames(nameInput, count) {
+    // Handle range patterns like "web01->web03" or "web01 -> web03"
+    const rangeMatch = nameInput.match(/^(.+?)(\d+)\s*->\s*(.+?)(\d+)$/);
+    if (rangeMatch) {
+        const [, prefix1, start, prefix2, end] = rangeMatch;
+        if (prefix1.trim() === prefix2.trim()) {
+            const basePrefix = prefix1.trim();
+            const startNum = parseInt(start);
+            const endNum = parseInt(end);
+            const names = [];
+            for (let i = startNum; i <= endNum; i++) {
+                const paddedNum = i.toString().padStart(start.length, '0');
+                names.push(`${basePrefix}${paddedNum}`);
+            }
+            return names;
+        }
+    }
+    // Handle count-based generation
+    if (count && count > 1) {
+        const names = [];
+        // Extract base name and number pattern
+        const match = nameInput.match(/^(.+?)(\d+)$/);
+        if (match) {
+            const [, prefix, startStr] = match;
+            const startNum = parseInt(startStr);
+            for (let i = 0; i < count; i++) {
+                const num = startNum + i;
+                const paddedNum = num.toString().padStart(startStr.length, '0');
+                names.push(`${prefix}${paddedNum}`);
+            }
+            return names;
+        }
+        else {
+            // If no number pattern, append numbers
+            for (let i = 1; i <= count; i++) {
+                const paddedNum = i.toString().padStart(2, '0');
+                names.push(`${nameInput}${paddedNum}`);
+            }
+            return names;
+        }
+    }
+    // Single VM
+    return [nameInput];
+}
+exports.parseVMNames = parseVMNames;
+// Determine node assignment strategy for VMs
+function calculateNodeAssignments(vmNames, nodes, distribution) {
+    let nodeAssignments = [];
+    if (distribution === 'spread' || (vmNames.length > 1 && !distribution)) {
+        // Distribute VMs across all available nodes
+        vmNames.forEach((vmName, index) => {
+            const nodeId = nodes[index % nodes.length];
+            nodeAssignments.push({ name: vmName, kvmHostId: nodeId });
+        });
+    }
+    else if (distribution && distribution !== 'auto') {
+        // Parse specific node assignments like "1,2,3" or "node1,node2,node3"
+        const specifiedNodes = distribution.split(',').map((n) => {
+            const trimmed = n.trim();
+            return trimmed.startsWith('node') ? parseInt(trimmed.replace('node', '')) : parseInt(trimmed);
+        }).filter((n) => !isNaN(n));
+        if (specifiedNodes.length > 0) {
+            vmNames.forEach((vmName, index) => {
+                const nodeId = specifiedNodes[index % specifiedNodes.length];
+                nodeAssignments.push({ name: vmName, kvmHostId: nodeId });
+            });
+        }
+        else {
+            nodeAssignments = vmNames.map(vmName => ({ name: vmName }));
+        }
+    }
+    else {
+        // Auto-placement (no kvmHostId specified)
+        nodeAssignments = vmNames.map(vmName => ({ name: vmName }));
+    }
+    return nodeAssignments;
+}
+exports.calculateNodeAssignments = calculateNodeAssignments;