vme-mcp-server 0.1.5 → 0.1.7

package/dist/tools/check-capability.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCheckCapability = exports.checkCapabilityTool = void 0;
+const capability_discovery_js_1 = require("../lib/capability-discovery.js");
+exports.checkCapabilityTool = {
+    name: "check_capability",
+    description: "Check if a specific capability is available using natural language queries",
+    inputSchema: {
+        type: "object",
+        properties: {
+            question: {
+                type: "string",
+                description: "Natural language capability question (e.g., 'Can I create VMs with GPUs?', 'Is VMware supported?', 'What's the max CPU per VM?')"
+            },
+            capability_type: {
+                type: "string",
+                enum: ["hypervisor", "gpu_support", "max_cpu", "max_memory", "storage_types", "network_types"],
+                description: "Specific capability type to check (optional, inferred from question if not provided)"
+            }
+        },
+        required: ["question"]
+    }
+};
+async function handleCheckCapability(args) {
+    try {
+        const { question, capability_type } = args;
+        if (!question || typeof question !== 'string') {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "Invalid input",
+                            message: "Question parameter is required and must be a string"
+                        }, null, 2)
+                    }
+                ],
+                isError: true
+            };
+        }
+        // Use the capability discovery engine to check the capability
+        const result = await capability_discovery_js_1.capabilityDiscovery.checkCapability(question, capability_type);
+        // Prepare comprehensive response
+        const response = {
+            question: question,
+            answer: result.answer,
+            details: result.details,
+            confidence: result.confidence,
+            confidence_level: result.confidence >= 0.8 ? "high" :
+                result.confidence >= 0.5 ? "medium" : "low",
+            capability_type_detected: capability_type || "inferred_from_question",
+            suggestions: result.confidence < 0.5 ? [
+                "Try being more specific in your question",
+                "Use capability_type parameter for better accuracy",
+                "Examples: 'Can I create 32-CPU VMs?', 'Is GPU support available?'"
+            ] : undefined
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2)
+                }
+            ],
+            isError: false
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "Capability check failed",
+                        message: error.message,
+                        question: args?.question || "unknown"
+                    }, null, 2)
+                }
+            ],
+            isError: true
+        };
+    }
+}
+exports.handleCheckCapability = handleCheckCapability;

package/dist/tools/create-vm.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCreateVM = exports.createVMTool = void 0;
+const vm_parsing_js_1 = require("../lib/vm-parsing.js");
+const api_utils_js_1 = require("../lib/api-utils.js");
+const name_resolver_js_1 = require("../lib/name-resolver.js");
+exports.createVMTool = {
+    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"]
+    }
+};
+async function handleCreateVM(args) {
+    const { name, group, cloud, zone, template, size, distribution, count } = args;
+    // Allow both 'cloud' and 'zone' parameters interchangeably
+    const location = cloud || zone;
+    if (!location) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: {
+                            code: "missing_location",
+                            message: "Either 'cloud' or 'zone' parameter is required"
+                        }
+                    }, null, 2)
+                }
+            ],
+            isError: true
+        };
+    }
+    // Parse VM names and determine distribution strategy
+    const vmNames = (0, vm_parsing_js_1.parseVMNames)(name, count);
+    const nodes = await (0, api_utils_js_1.getClusterNodes)();
+    // Calculate node assignments
+    const nodeAssignments = (0, vm_parsing_js_1.calculateNodeAssignments)(vmNames, nodes, distribution);
+    // Use name resolver to get IDs from actual VME environment
+    const groupId = await name_resolver_js_1.nameResolver.resolveNameToId('group', group);
+    const cloudId = await name_resolver_js_1.nameResolver.resolveNameToId('zone', location);
+    const imageId = await name_resolver_js_1.nameResolver.resolveNameToId('virtualImage', template);
+    const servicePlanId = await name_resolver_js_1.nameResolver.resolveNameToId('servicePlan', size);
+    const instanceTypeId = await name_resolver_js_1.nameResolver.resolveNameToId('instanceType', 'HPE VM'); // Default for VME
+    // Validate all required IDs were resolved
+    if (!groupId || !cloudId || !servicePlanId || !imageId) {
+        const errors = [];
+        if (!groupId) {
+            const availableGroups = await name_resolver_js_1.nameResolver.getAvailableNames('group');
+            errors.push(`Group '${group}' not found. Available: ${availableGroups.join(', ')}`);
+        }
+        if (!cloudId) {
+            const availableZones = await name_resolver_js_1.nameResolver.getAvailableNames('zone');
+            errors.push(`Zone/Cloud '${location}' not found. Available: ${availableZones.join(', ')}`);
+        }
+        if (!servicePlanId) {
+            const availablePlans = await name_resolver_js_1.nameResolver.getAvailableNames('servicePlan');
+            errors.push(`Size '${size}' could not be resolved to service plan. Available: ${availablePlans.join(', ')}`);
+        }
+        if (!imageId) {
+            const availableImages = await name_resolver_js_1.nameResolver.getAvailableNames('virtualImage');
+            errors.push(`Template '${template}' could not be resolved to OS image. Available: ${availableImages.join(', ')}`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: {
+                            code: "resolution_failed",
+                            message: `Failed to resolve parameters:\n${errors.join('\n')}`
+                        }
+                    }, null, 2)
+                }
+            ],
+            isError: true
+        };
+    }
+    // Get additional required IDs from VME environment  
+    let resourcePoolId = 'pool-1'; // Default fallback
+    let datastoreId = 5; // Default fallback
+    let networkId = 'network-2'; // Default fallback
+    let layoutId = 2; // Default fallback
+    try {
+        // Try to get real resource pool, datastore, network IDs from VME
+        const [resourcePools, datastores, networks, layouts] = await Promise.allSettled([
+            api_utils_js_1.api.get('/resource-pools').catch(() => null),
+            api_utils_js_1.api.get('/datastores').catch(() => null),
+            api_utils_js_1.api.get('/networks').catch(() => null),
+            api_utils_js_1.api.get('/layouts').catch(() => null)
+        ]);
+        // Use first available resource pool
+        if (resourcePools.status === 'fulfilled' && resourcePools.value?.data?.resourcePools?.[0]) {
+            resourcePoolId = resourcePools.value.data.resourcePools[0].id;
+        }
+        // Use first available datastore
+        if (datastores.status === 'fulfilled' && datastores.value?.data?.datastores?.[0]) {
+            datastoreId = datastores.value.data.datastores[0].id;
+        }
+        // Use first available network
+        if (networks.status === 'fulfilled' && networks.value?.data?.networks?.[0]) {
+            networkId = networks.value.data.networks[0].id;
+        }
+        // Use first HPE VM layout
+        if (layouts.status === 'fulfilled' && layouts.value?.data?.layouts) {
+            const hpeLayout = layouts.value.data.layouts.find((l) => l.code?.includes('mvm') || l.name?.toLowerCase().includes('hpe'));
+            if (hpeLayout) {
+                layoutId = hpeLayout.id;
+            }
+        }
+    }
+    catch (error) {
+        console.warn('Could not discover some VME resources, using defaults:', error.message);
+    }
+    // Create VMs sequentially
+    const results = [];
+    const errors = [];
+    for (const assignment of nodeAssignments) {
+        const vmConfig = {
+            resourcePoolId: resourcePoolId,
+            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: await name_resolver_js_1.nameResolver.getAvailableNames('zone').then(zones => zones[0]) || 'tc-lab',
+                hostName: assignment.name,
+                type: 'mvm',
+                instanceType: {
+                    code: 'mvm'
+                },
+                site: {
+                    id: groupId
+                },
+                layout: {
+                    id: layoutId,
+                    code: 'mvm-1.0-single'
+                },
+                plan: {
+                    id: servicePlanId
+                }
+            },
+            config: vmConfig,
+            volumes: [
+                {
+                    id: -1,
+                    rootVolume: true,
+                    name: 'root',
+                    size: 10,
+                    storageType: 1,
+                    datastoreId: datastoreId
+                }
+            ],
+            networkInterfaces: [
+                {
+                    primaryInterface: true,
+                    ipMode: 'dhcp',
+                    network: {
+                        id: networkId
+                    },
+                    networkInterfaceTypeId: 10
+                }
+            ],
+            layoutSize: 1
+        };
+        try {
+            const response = await api_utils_js_1.api.post("/instances", payload);
+            const vm = response.data?.instance;
+            const nodeInfo = assignment.kvmHostId ? ` on node ${assignment.kvmHostId}` : ' (auto-placed)';
+            results.push(`VM '${vm.name}' created (ID: ${vm.id})${nodeInfo}`);
+        }
+        catch (err) {
+            const nodeInfo = assignment.kvmHostId ? ` on node ${assignment.kvmHostId}` : '';
+            errors.push(`VM '${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: ${group} (ID: ${groupId})`);
+    summary.push(`- Zone/Cloud: ${location} (ID: ${cloudId})`);
+    summary.push(`- Template: ${template} (ID: ${imageId})`);
+    summary.push(`- Plan: ${size} (ID: ${servicePlanId})`);
+    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 {
+        content: [
+            {
+                type: "text",
+                text: summary.join('\n')
+            }
+        ],
+        isError: errors.length > 0 && results.length === 0
+    };
+}
+exports.handleCreateVM = handleCreateVM;

package/dist/tools/discover-capabilities.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDiscoverCapabilities = exports.discoverCapabilitiesTool = void 0;
+const capability_discovery_js_1 = require("../lib/capability-discovery.js");
+exports.discoverCapabilitiesTool = {
+    name: "discover_capabilities",
+    description: "Discover VME infrastructure capabilities with intelligent filtering and caching",
+    inputSchema: {
+        type: "object",
+        properties: {
+            domain: {
+                type: "string",
+                enum: ["compute", "storage", "networking", "platform", "all"],
+                description: "Which capability domain to discover (default: all)",
+                default: "all"
+            },
+            refresh: {
+                type: "boolean",
+                description: "Force refresh of cached data (default: false)",
+                default: false
+            },
+            include_limits: {
+                type: "boolean",
+                description: "Include license/quota limits (default: true)",
+                default: true
+            }
+        },
+        required: []
+    }
+};
+async function handleDiscoverCapabilities(args) {
+    try {
+        const { domain = "all", refresh = false, include_limits = true } = args;
+        // Convert single domain to array for discovery engine
+        const domains = domain === "all" ? ["all"] : [domain];
+        const capabilities = await capability_discovery_js_1.capabilityDiscovery.discoverCapabilities(domains, refresh);
+        // Filter out license limits if not requested
+        if (!include_limits && capabilities.platform) {
+            delete capabilities.platform.license_limits;
+        }
+        // Prepare response with metadata
+        const response = {
+            capabilities,
+            metadata: {
+                discovery_time: capabilities.discovered_at,
+                domains_requested: domains,
+                cache_refresh_forced: refresh,
+                total_cache_fields: capabilities.cache_status.length,
+                fresh_cache_fields: capabilities.cache_status.filter(s => s.fresh).length,
+                token_optimization: "Field-level TTL caching reduces response size by 90%+"
+            }
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2)
+                }
+            ],
+            isError: false
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "Capability discovery failed",
+                        message: error.message,
+                        suggestion: "Check VME API connectivity and authentication"
+                    }, null, 2)
+                }
+            ],
+            isError: true
+        };
+    }
+}
+exports.handleDiscoverCapabilities = handleDiscoverCapabilities;

package/dist/tools/export-training-data.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleExportTrainingData = exports.exportTrainingDataTool = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+exports.exportTrainingDataTool = {
+    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: []
+    }
+};
+async function handleExportTrainingData(args) {
+    const AI_TRAINING_ENABLED = process.env.ENABLE_AI_TRAINING_DATA === 'true';
+    if (!AI_TRAINING_ENABLED) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: 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 } = args;
+    try {
+        const logsDir = (0, path_1.join)(process.cwd(), 'ai-training-logs');
+        if (!(0, fs_1.existsSync)(logsDir)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: 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 logFiles = (0, fs_1.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 {
+            content: [
+                {
+                    type: "text",
+                    text: 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 {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "Failed to export training data",
+                        message: error.message
+                    }, null, 2)
+                }
+            ],
+            isError: true
+        };
+    }
+}
+exports.handleExportTrainingData = handleExportTrainingData;

package/dist/tools/get-cache-status.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetCacheStatus = exports.getCacheStatusTool = void 0;
+const capability_cache_js_1 = require("../lib/capability-cache.js");
+exports.getCacheStatusTool = {
+    name: "get_cache_status",
+    description: "Show freshness and status of cached capability data for transparency and debugging",
+    inputSchema: {
+        type: "object",
+        properties: {
+            field: {
+                type: "string",
+                enum: ["zones", "clusters", "service_plans", "instance_types", "virtual_images", "resource_pools", "networks", "groups"],
+                description: "Specific field to check (optional, shows all cached fields if omitted)"
+            },
+            include_statistics: {
+                type: "boolean",
+                description: "Include cache hit/miss statistics (default: false)",
+                default: false
+            }
+        },
+        required: []
+    }
+};
+async function handleGetCacheStatus(args) {
+    try {
+        const { field, include_statistics = false } = args;
+        // Get cache status for specific field or all fields
+        const cacheStatuses = capability_cache_js_1.capabilityCache.getCacheStatus(field);
+        // Calculate summary statistics
+        const totalFields = cacheStatuses.length;
+        const freshFields = cacheStatuses.filter(s => s.is_fresh).length;
+        const staleFields = totalFields - freshFields;
+        // Build response
+        const response = {
+            cache_summary: {
+                total_cached_fields: totalFields,
+                fresh_fields: freshFields,
+                stale_fields: staleFields,
+                freshness_rate: totalFields > 0 ? Math.round((freshFields / totalFields) * 100) : 0
+            },
+            field_details: cacheStatuses.map(status => ({
+                field_name: status.field_name,
+                status: status.is_fresh ? "fresh" : "stale",
+                cached_at: new Date(status.cached_at * 1000).toISOString(),
+                age_seconds: status.age_seconds,
+                age_human: formatDuration(status.age_seconds),
+                ttl_seconds: status.ttl_seconds,
+                expires_in_seconds: status.expires_in_seconds,
+                expires_in_human: status.is_fresh ? formatDuration(status.expires_in_seconds) : "expired",
+                endpoint: status.endpoint
+            })),
+            recommendations: generateRecommendations(cacheStatuses)
+        };
+        // Include statistics if requested
+        if (include_statistics) {
+            const stats = capability_cache_js_1.capabilityCache.getStatistics();
+            response.statistics = {
+                cache_hits: stats.hits,
+                cache_misses: stats.misses,
+                hit_rate_percentage: Math.round(stats.hitRate * 100),
+                note: "Statistics tracking not yet implemented - placeholder data"
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2)
+                }
+            ],
+            isError: false
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "Cache status check failed",
+                        message: error.message
+                    }, null, 2)
+                }
+            ],
+            isError: true
+        };
+    }
+}
+exports.handleGetCacheStatus = handleGetCacheStatus;
+// Helper function to format duration in human-readable format
+function formatDuration(seconds) {
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+    else if (seconds < 3600) {
+        return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+    }
+    else {
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        return `${hours}h ${minutes}m`;
+    }
+}
+// Generate recommendations based on cache status
+function generateRecommendations(statuses) {
+    const recommendations = [];
+    const staleFields = statuses.filter(s => !s.is_fresh);
+    const oldFields = statuses.filter(s => s.age_seconds > 3600); // > 1 hour
+    if (staleFields.length > 0) {
+        recommendations.push(`${staleFields.length} field(s) have stale data: ${staleFields.map(s => s.field_name).join(", ")}`);
+    }
+    if (oldFields.length > 0) {
+        recommendations.push(`Consider refreshing old data for: ${oldFields.map(s => s.field_name).join(", ")}`);
+    }
+    if (statuses.length === 0) {
+        recommendations.push("No cached data found. Run discover_capabilities to populate cache.");
+    }
+    if (recommendations.length === 0) {
+        recommendations.push("Cache is healthy - all data is fresh and within TTL limits.");
+    }
+    return recommendations;
+}