vme-mcp-server 0.1.5 → 0.1.6

package/dist/server.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+#!/usr/bin/env node
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -6,929 +7,46 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const axios_1 = __importDefault(require("axios"));
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const dotenv_1 = __importDefault(require("dotenv"));
-const fs_1 = require("fs");
-const path_1 = require("path");
+const index_js_2 = require("./tools/index.js");
+// Load environment variables
 dotenv_1.default.config();
+// Disable TLS verification for VME API (if needed)
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
-// 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');
-// 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);
-    }
-}
-// Generate session ID for interaction tracking
-function generateSessionId() {
-    return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-}
-const api = axios_1.default.create({
-    baseURL: process.env.VME_API_BASE_URL,
-    headers: {
-        Authorization: `Bearer ${process.env.VME_API_TOKEN}`,
-        "Content-Type": "application/json"
-    }
+// Create VME MCP server with modular architecture
+const server = new index_js_1.Server({
+    name: "vme-mcp-server",
+    version: "1.5.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
 });
-// 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];
-}
-// Helper function to get available cluster nodes
-async function getClusterNodes() {
-    try {
-        const clusters = await 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];
-}
-async function resolveInput({ group, cloud, template, size }) {
-    const [groups, zones, instanceTypes, servicePlans] = await Promise.all([
-        api.get("/groups"),
-        api.get("/zones"),
-        api.get("/instance-types"),
-        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 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'));
-    }
+// Register all tools using the modular tool definitions
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
     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)
-    };
-}
-function parseVMIntent(naturalLanguageInput) {
-    const input = naturalLanguageInput.toLowerCase().trim();
-    const result = {
-        action: 'unknown',
-        confidence: 0,
-        entities: {},
-        originalText: naturalLanguageInput
+        tools: index_js_2.allTools,
     };
-    // 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 = 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;
-}
-// 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([
-            api.get("/groups"),
-            api.get("/zones"),
-            api.get("/instance-types"),
-            api.get("/service-plans"),
-            api.get("/virtual-images"),
-            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'
-        };
-    }
+});
+// Handle tool calls using the modular tool handlers
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    // Look up the handler for this tool
+    const handler = index_js_2.toolHandlers[name];
+    if (!handler) {
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    // Call the appropriate handler
+    return await handler(args);
+});
+// Start the server
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("VME MCP Server v1.5.0 running on stdio with modular architecture");
 }
-const server = new index_js_1.Server({
-    name: "vm-create-server",
-    version: "1.0.0"
-}, {
-    capabilities: {
-        tools: {
-            list: async () => ([
-                {
-                    name: "get_resources",
-                    description: "Discover and explore available VME infrastructure resources with intelligent filtering",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            type: {
-                                type: "string",
-                                description: "Resource type filter: 'compute', 'network', 'storage', 'vm', or leave empty for all"
-                            },
-                            intent: {
-                                type: "string",
-                                description: "Intent-based filtering: 'create', 'provision', 'list', 'discover', or natural language description"
-                            },
-                            role: {
-                                type: "string",
-                                description: "User role for permission-aware filtering (future enhancement)"
-                            }
-                        },
-                        required: []
-                    }
-                },
-                {
-                    name: "parse_vm_intent",
-                    description: "Parse natural language VM requests into structured parameters with confidence scoring",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            naturalLanguageInput: {
-                                type: "string",
-                                description: "Natural language description of VM provisioning request"
-                            }
-                        },
-                        required: ["naturalLanguageInput"]
-                    }
-                },
-                {
-                    name: "export_training_data",
-                    description: "Export AI training data for model improvement (requires ENABLE_AI_TRAINING_DATA=true)",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            format: {
-                                type: "string",
-                                description: "Export format: 'jsonl' or 'csv'",
-                                enum: ["jsonl", "csv"]
-                            },
-                            days: {
-                                type: "number",
-                                description: "Number of days of data to export (default: 7)"
-                            }
-                        },
-                        required: []
-                    }
-                },
-                {
-                    name: "provide_feedback",
-                    description: "Provide feedback on intent parsing accuracy to improve future predictions",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            original_input: {
-                                type: "string",
-                                description: "Original natural language input"
-                            },
-                            parsed_result: {
-                                type: "object",
-                                description: "The parsed result that was incorrect"
-                            },
-                            correct_interpretation: {
-                                type: "object",
-                                description: "What the correct interpretation should have been"
-                            },
-                            feedback_notes: {
-                                type: "string",
-                                description: "Additional notes about what went wrong"
-                            }
-                        },
-                        required: ["original_input", "feedback_notes"]
-                    }
-                },
-                {
-                    name: "create_vm",
-                    description: "Provision a new virtual machine",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            name: {
-                                type: "string",
-                                description: "Name for VM(s). Supports patterns like 'web01' or 'web01->web03' for multiple VMs"
-                            },
-                            group: {
-                                type: "string",
-                                description: "Group/site where VM will be created"
-                            },
-                            cloud: {
-                                type: "string",
-                                description: "Cloud/zone where VM will be provisioned (also accepts 'zone')"
-                            },
-                            zone: {
-                                type: "string",
-                                description: "Zone/cloud where VM will be provisioned (alias for 'cloud')"
-                            },
-                            template: {
-                                type: "string",
-                                description: "VM template or operating system"
-                            },
-                            size: {
-                                type: "string",
-                                description: "VM size (small, medium, 4GB, 8GB, etc.)"
-                            },
-                            distribution: {
-                                type: "string",
-                                description: "VM distribution strategy: 'auto' (default), 'spread' (across all nodes), or 'node1,node2,node3' (specific nodes)"
-                            },
-                            count: {
-                                type: "number",
-                                description: "Number of VMs to create (alternative to name patterns)"
-                            }
-                        },
-                        required: ["name", "group", "template", "size"]
-                    }
-                }
-            ]),
-            call: async (req) => {
-                if (req.tool === "get_resources") {
-                    const { type, intent, role } = req.arguments;
-                    const resources = await getResources(type, intent, role);
-                    return {
-                        toolResult: JSON.stringify(resources, null, 2),
-                        isError: !!resources.error
-                    };
-                }
-                if (req.tool === "parse_vm_intent") {
-                    const startTime = Date.now();
-                    const { naturalLanguageInput } = req.arguments;
-                    const sessionId = generateSessionId();
-                    const parsedIntent = parseVMIntent(naturalLanguageInput);
-                    const parseTime = Date.now() - startTime;
-                    // Log interaction for AI training (respects privacy settings)
-                    logInteraction({
-                        session_id: sessionId,
-                        tool_name: 'parse_vm_intent',
-                        user_input: { naturalLanguageInput },
-                        parsed_output: parsedIntent,
-                        success_metrics: {
-                            operation_success: parsedIntent.action !== 'unknown',
-                            confidence_score: parsedIntent.confidence,
-                            entities_extracted: Object.keys(parsedIntent.entities).length
-                        },
-                        timing: {
-                            parse_duration_ms: parseTime,
-                            total_duration_ms: parseTime
-                        }
-                    });
-                    return {
-                        toolResult: JSON.stringify(parsedIntent, null, 2),
-                        isError: parsedIntent.action === 'unknown' && parsedIntent.confidence < 0.3
-                    };
-                }
-                if (req.tool === "export_training_data") {
-                    if (!AI_TRAINING_ENABLED) {
-                        return {
-                            toolResult: JSON.stringify({
-                                error: "Training data collection is disabled",
-                                message: "Set ENABLE_AI_TRAINING_DATA=true in .env to enable data collection and export"
-                            }, null, 2),
-                            isError: true
-                        };
-                    }
-                    const { format = "jsonl", days = 7 } = req.arguments;
-                    try {
-                        const logsDir = (0, path_1.join)(process.cwd(), 'ai-training-logs');
-                        if (!(0, fs_1.existsSync)(logsDir)) {
-                            return {
-                                toolResult: JSON.stringify({
-                                    message: "No training data found",
-                                    data_count: 0
-                                }, null, 2),
-                                isError: false
-                            };
-                        }
-                        // Collect data from last N days
-                        const cutoffDate = new Date(Date.now() - (days * 24 * 60 * 60 * 1000));
-                        const allData = [];
-                        // Read log files and aggregate data
-                        const { readdirSync } = require('fs');
-                        const logFiles = readdirSync(logsDir).filter((file) => file.startsWith('interactions-') && file.endsWith('.jsonl'));
-                        for (const file of logFiles) {
-                            const fileDate = new Date(file.replace('interactions-', '').replace('.jsonl', ''));
-                            if (fileDate >= cutoffDate) {
-                                const content = (0, fs_1.readFileSync)((0, path_1.join)(logsDir, file), 'utf-8');
-                                const lines = content.trim().split('\n').filter(line => line.trim());
-                                for (const line of lines) {
-                                    try {
-                                        allData.push(JSON.parse(line));
-                                    }
-                                    catch (e) {
-                                        // Skip malformed lines
-                                    }
-                                }
-                            }
-                        }
-                        return {
-                            toolResult: JSON.stringify({
-                                message: `Exported ${allData.length} training data records from last ${days} days`,
-                                format: format,
-                                data_count: allData.length,
-                                data: format === 'jsonl' ? allData : allData.map(item => ({
-                                    timestamp: item.timestamp,
-                                    tool: item.tool_name,
-                                    user_input: JSON.stringify(item.user_input),
-                                    parsed_output: JSON.stringify(item.parsed_output),
-                                    success: item.success_metrics?.operation_success,
-                                    confidence: item.success_metrics?.confidence_score
-                                }))
-                            }, null, 2),
-                            isError: false
-                        };
-                    }
-                    catch (error) {
-                        return {
-                            toolResult: JSON.stringify({
-                                error: "Failed to export training data",
-                                message: error.message
-                            }, null, 2),
-                            isError: true
-                        };
-                    }
-                }
-                if (req.tool === "provide_feedback") {
-                    const { original_input, parsed_result, correct_interpretation, feedback_notes } = req.arguments;
-                    const sessionId = generateSessionId();
-                    // Log feedback for future model improvements
-                    logInteraction({
-                        session_id: sessionId,
-                        tool_name: 'provide_feedback',
-                        user_input: { original_input, feedback_notes },
-                        parsed_output: { parsed_result, correct_interpretation },
-                        user_feedback: feedback_notes,
-                        success_metrics: {
-                            operation_success: false, // This indicates the original parsing was wrong
-                            user_satisfaction: 0 // User had to provide feedback = dissatisfied
-                        }
-                    });
-                    return {
-                        toolResult: JSON.stringify({
-                            message: "Thank you for the feedback! This will help improve future intent recognition.",
-                            feedback_recorded: true,
-                            original_input: original_input,
-                            feedback_notes: feedback_notes
-                        }, null, 2),
-                        isError: false
-                    };
-                }
-                if (req.tool !== "create_vm")
-                    return;
-                const { name, group, cloud, zone, template, size, distribution, count } = req.arguments;
-                // Allow both 'cloud' and 'zone' parameters interchangeably
-                const location = cloud || zone;
-                if (!location) {
-                    return {
-                        error: {
-                            code: "missing_location",
-                            message: "Either 'cloud' or 'zone' parameter is required"
-                        }
-                    };
-                }
-                // Parse VM names and determine distribution strategy
-                const vmNames = parseVMNames(name, count);
-                const nodes = await getClusterNodes();
-                // Determine node assignment strategy
-                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 }));
-                }
-                const resolved = await resolveInput({ group, cloud: location, template, size });
-                const { groupId, cloudId, instanceTypeId, servicePlanId, imageId } = resolved;
-                if (!groupId || !cloudId || !instanceTypeId || !servicePlanId || !imageId) {
-                    const errors = [];
-                    if (!groupId)
-                        errors.push(`Group '${group}' not found. Available: ${resolved.availableGroups.join(', ')}`);
-                    if (!cloudId)
-                        errors.push(`Zone/Cloud '${location}' not found. Available: ${resolved.availableZones.join(', ')}`);
-                    if (!instanceTypeId)
-                        errors.push(`Instance type could not be resolved`);
-                    if (!servicePlanId)
-                        errors.push(`Size '${size}' could not be resolved to service plan`);
-                    if (!imageId)
-                        errors.push(`Template '${template}' could not be resolved to OS image`);
-                    return {
-                        error: {
-                            code: "resolution_failed",
-                            message: `Failed to resolve parameters:\n${errors.join('\n')}`
-                        }
-                    };
-                }
-                // Create VMs sequentially
-                const results = [];
-                const errors = [];
-                for (const assignment of nodeAssignments) {
-                    const vmConfig = {
-                        resourcePoolId: 'pool-1',
-                        poolProviderType: 'mvm',
-                        imageId: imageId,
-                        createUser: true
-                    };
-                    // Add kvmHostId only if explicitly specified
-                    if (assignment.kvmHostId) {
-                        vmConfig.kvmHostId = assignment.kvmHostId;
-                    }
-                    const payload = {
-                        zoneId: cloudId,
-                        instance: {
-                            name: assignment.name,
-                            cloud: 'tc-lab',
-                            hostName: assignment.name,
-                            type: 'mvm',
-                            instanceType: {
-                                code: 'mvm'
-                            },
-                            site: {
-                                id: groupId
-                            },
-                            layout: {
-                                id: 2, // Single HPE VM
-                                code: 'mvm-1.0-single'
-                            },
-                            plan: {
-                                id: servicePlanId
-                            }
-                        },
-                        config: vmConfig,
-                        volumes: [
-                            {
-                                id: -1,
-                                rootVolume: true,
-                                name: 'root',
-                                size: 10,
-                                storageType: 1,
-                                datastoreId: 5
-                            }
-                        ],
-                        networkInterfaces: [
-                            {
-                                primaryInterface: true,
-                                ipMode: 'dhcp',
-                                network: {
-                                    id: 'network-2'
-                                },
-                                networkInterfaceTypeId: 10
-                            }
-                        ],
-                        layoutSize: 1
-                    };
-                    try {
-                        const response = await api.post("/instances", payload);
-                        const vm = response.data?.instance;
-                        const nodeInfo = assignment.kvmHostId ? ` on node ${assignment.kvmHostId}` : ' (auto-placed)';
-                        results.push(`✅ '${vm.name}' created (ID: ${vm.id})${nodeInfo}`);
-                    }
-                    catch (err) {
-                        const nodeInfo = assignment.kvmHostId ? ` on node ${assignment.kvmHostId}` : '';
-                        errors.push(`❌ '${assignment.name}' failed${nodeInfo}: ${err.response?.data?.message || err.message}`);
-                    }
-                }
-                // Prepare response
-                const summary = [];
-                if (results.length > 0) {
-                    summary.push(`Successfully created ${results.length} VM(s):`);
-                    summary.push(...results);
-                }
-                if (errors.length > 0) {
-                    summary.push(`\nFailed to create ${errors.length} VM(s):`);
-                    summary.push(...errors);
-                }
-                summary.push(`\nResolved parameters:`);
-                summary.push(`- Group: ${resolved.resolvedGroup}`);
-                summary.push(`- Zone/Cloud: ${resolved.resolvedCloud}`);
-                summary.push(`- Template: ${resolved.resolvedImage}`);
-                summary.push(`- Plan: ${resolved.resolvedPlan}`);
-                if (distribution === 'spread' || (vmNames.length > 1 && !distribution)) {
-                    summary.push(`- Distribution: Spread across nodes ${nodes.join(', ')}`);
-                }
-                else if (nodeAssignments.some(a => a.kvmHostId)) {
-                    summary.push(`- Distribution: Specific node placement`);
-                }
-                else {
-                    summary.push(`- Distribution: Auto-placement`);
-                }
-                return {
-                    toolResult: summary.join('\n'),
-                    isError: errors.length > 0 && results.length === 0
-                };
-            }
-        }
-    }
+main().catch((error) => {
+    console.error("Failed to start server:", error);
+    process.exit(1);
 });
-const transport = new stdio_js_1.StdioServerTransport();
-server.connect(transport);