vme-mcp-server 0.1.5 → 0.1.6

package/dist/lib/api-utils.js

@@ -0,0 +1,251 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResources = exports.resolveInput = exports.getClusterNodes = exports.api = void 0;
+const axios_1 = __importDefault(require("axios"));
+// Setup axios instance for VME API
+exports.api = axios_1.default.create({
+    baseURL: process.env.VME_API_BASE_URL,
+    headers: {
+        Authorization: `Bearer ${process.env.VME_API_TOKEN}`,
+        "Content-Type": "application/json"
+    }
+});
+// Helper function to get available cluster nodes
+async function getClusterNodes() {
+    try {
+        const clusters = await exports.api.get("/clusters");
+        const prodCluster = clusters.data.clusters.find((cluster) => cluster.name === "prod01");
+        if (prodCluster && prodCluster.servers) {
+            return prodCluster.servers.map((server) => server.id);
+        }
+    }
+    catch (error) {
+        console.error('Error getting cluster nodes:', error);
+    }
+    // Fallback to known nodes if API fails
+    return [1, 2, 3];
+}
+exports.getClusterNodes = getClusterNodes;
+// Resolve user input parameters to VME API resource IDs
+async function resolveInput({ group, cloud, template, size }) {
+    const [groups, zones, instanceTypes, servicePlans] = await Promise.all([
+        exports.api.get("/groups"),
+        exports.api.get("/zones"),
+        exports.api.get("/instance-types"),
+        exports.api.get("/service-plans")
+    ]);
+    // Find group (case-insensitive)
+    const foundGroup = groups.data.groups.find((g) => g.name.toLowerCase() === group.toLowerCase());
+    // Find zone/cloud (case-insensitive, handle both terms)
+    const foundZone = zones.data.zones.find((z) => z.name.toLowerCase() === cloud.toLowerCase());
+    // In HPE VM Essentials, all VMs use "HPE VM" instance type
+    // The actual OS is determined by the image selection
+    const instanceType = instanceTypes.data.instanceTypes.find((t) => t.name === 'HPE VM');
+    // Find appropriate image based on template using osType properties
+    let selectedImage;
+    const templateLower = template.toLowerCase();
+    // Get available images to find the right one
+    const images = await exports.api.get("/virtual-images");
+    if (templateLower.includes('ubuntu')) {
+        // Find Ubuntu images using osType.category and prefer latest version
+        const ubuntuImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'ubuntu').sort((a, b) => {
+            // Sort by version descending (24.04 > 22.04 > 20.04)
+            const aVersion = parseFloat(a.osType.osVersion || '0');
+            const bVersion = parseFloat(b.osType.osVersion || '0');
+            return bVersion - aVersion;
+        });
+        selectedImage = ubuntuImages[0];
+    }
+    else if (templateLower.includes('rocky')) {
+        // Find Rocky Linux images and prefer latest version (Rocky 9 > Rocky 8)
+        const rockyImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'rocky').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = rockyImages[0];
+    }
+    else if (templateLower.includes('centos')) {
+        // Find CentOS images and prefer latest version (CentOS 9 > CentOS 8)
+        const centosImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'centos').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = centosImages[0];
+    }
+    else if (templateLower.includes('debian')) {
+        // Find Debian images and prefer latest version (Debian 12 > Debian 11)
+        const debianImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'debian').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = debianImages[0];
+    }
+    else if (templateLower.includes('alma')) {
+        // Find AlmaLinux images and prefer latest version (AlmaLinux 9 > AlmaLinux 8)
+        const almaImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'almalinux').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = almaImages[0];
+    }
+    else if (templateLower.includes('rhel') || templateLower.includes('red hat')) {
+        // Find RHEL images and prefer latest version
+        const rhelImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'rhel').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = rhelImages[0];
+    }
+    // Default to latest Ubuntu if no specific match
+    if (!selectedImage) {
+        const ubuntuImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'ubuntu').sort((a, b) => {
+            const aVersion = parseFloat(a.osType.osVersion || '0');
+            const bVersion = parseFloat(b.osType.osVersion || '0');
+            return bVersion - aVersion;
+        });
+        selectedImage = ubuntuImages[0] || images.data.virtualImages[0];
+    }
+    // Find service plan based on size (flexible matching)
+    let plan;
+    const sizeLower = size.toLowerCase();
+    if (sizeLower.includes('8gb') || sizeLower.includes('8 gb') || sizeLower.includes('medium')) {
+        plan = servicePlans.data.servicePlans.find((p) => p.name.includes('2 CPU, 8GB Memory'));
+    }
+    else if (sizeLower.includes('4gb') || sizeLower.includes('4 gb') || sizeLower.includes('small')) {
+        plan = servicePlans.data.servicePlans.find((p) => p.name.includes('1 CPU, 4GB Memory'));
+    }
+    // Fallback to any available plan
+    if (!plan) {
+        plan = servicePlans.data.servicePlans.find((p) => p.name.includes('CPU') && p.name.includes('Memory'));
+    }
+    return {
+        groupId: foundGroup?.id || groups.data.groups[0]?.id,
+        cloudId: foundZone?.id || zones.data.zones[0]?.id,
+        instanceTypeId: instanceType?.id,
+        servicePlanId: plan?.id,
+        imageId: selectedImage?.id,
+        // Return resolved names for better error reporting
+        resolvedGroup: foundGroup?.name || groups.data.groups[0]?.name,
+        resolvedCloud: foundZone?.name || zones.data.zones[0]?.name,
+        resolvedInstanceType: instanceType?.name,
+        resolvedPlan: plan?.name,
+        resolvedImage: selectedImage?.osType?.name || selectedImage?.name,
+        // Available options for error messages
+        availableGroups: groups.data.groups.map((g) => g.name),
+        availableZones: zones.data.zones.map((z) => z.name)
+    };
+}
+exports.resolveInput = resolveInput;
+// Unified resource discovery function
+async function getResources(type, intent, role) {
+    try {
+        // Fetch all resource types in parallel for comprehensive discovery
+        const [groups, zones, instanceTypes, servicePlans, virtualImages, clusters] = await Promise.all([
+            exports.api.get("/groups"),
+            exports.api.get("/zones"),
+            exports.api.get("/instance-types"),
+            exports.api.get("/service-plans"),
+            exports.api.get("/virtual-images"),
+            exports.api.get("/clusters")
+        ]);
+        const allResources = {
+            groups: groups.data.groups || [],
+            zones: zones.data.zones || [],
+            instanceTypes: instanceTypes.data.instanceTypes || [],
+            servicePlans: servicePlans.data.servicePlans || [],
+            virtualImages: virtualImages.data.virtualImages || [],
+            clusters: clusters.data.clusters || []
+        };
+        // Apply intelligent filtering based on type
+        if (type) {
+            const typeLower = type.toLowerCase();
+            if (typeLower.includes('compute') || typeLower.includes('vm')) {
+                return {
+                    groups: allResources.groups,
+                    zones: allResources.zones,
+                    servicePlans: allResources.servicePlans,
+                    virtualImages: allResources.virtualImages,
+                    clusters: allResources.clusters,
+                    _filtered_for: 'compute/vm resources'
+                };
+            }
+            else if (typeLower.includes('network')) {
+                return {
+                    zones: allResources.zones,
+                    clusters: allResources.clusters,
+                    _filtered_for: 'network resources'
+                };
+            }
+            else if (typeLower.includes('storage')) {
+                return {
+                    servicePlans: allResources.servicePlans,
+                    zones: allResources.zones,
+                    _filtered_for: 'storage resources'
+                };
+            }
+        }
+        // Apply intent-based filtering
+        if (intent) {
+            const intentLower = intent.toLowerCase();
+            if (intentLower.includes('create') || intentLower.includes('provision')) {
+                // For creation intents, focus on templates and plans
+                return {
+                    groups: allResources.groups,
+                    zones: allResources.zones,
+                    servicePlans: allResources.servicePlans,
+                    virtualImages: allResources.virtualImages.map((img) => ({
+                        id: img.id,
+                        name: img.name,
+                        osType: img.osType,
+                        recommended: img.osType?.category === 'ubuntu' ? true : false
+                    })),
+                    _filtered_for: 'creation/provisioning intent'
+                };
+            }
+            else if (intentLower.includes('list') || intentLower.includes('show') || intentLower.includes('discover')) {
+                // For discovery intents, return comprehensive view
+                return {
+                    summary: {
+                        total_groups: allResources.groups.length,
+                        total_zones: allResources.zones.length,
+                        total_service_plans: allResources.servicePlans.length,
+                        total_os_templates: allResources.virtualImages.length,
+                        total_clusters: allResources.clusters.length
+                    },
+                    ...allResources,
+                    _filtered_for: 'discovery/listing intent'
+                };
+            }
+        }
+        // Default: return all resources with semantic organization
+        return {
+            compute: {
+                groups: allResources.groups,
+                servicePlans: allResources.servicePlans,
+                virtualImages: allResources.virtualImages
+            },
+            infrastructure: {
+                zones: allResources.zones,
+                clusters: allResources.clusters,
+                instanceTypes: allResources.instanceTypes
+            },
+            _organization: 'semantic grouping by function'
+        };
+    }
+    catch (error) {
+        return {
+            error: `Failed to fetch resources: ${error.response?.data?.message || error.message}`,
+            available_endpoints: ['/groups', '/zones', '/service-plans', '/virtual-images', '/clusters'],
+            fallback_suggestion: 'Try checking individual resource types with specific API endpoints'
+        };
+    }
+}
+exports.getResources = getResources;

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/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;