vme-mcp-server 0.1.5 → 0.1.6

package/dist/tools/create-vm.js

@@ -0,0 +1,205 @@
+"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");
+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);
+    const resolved = await (0, api_utils_js_1.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 {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: {
+                            code: "resolution_failed",
+                            message: `Failed to resolve parameters:\n${errors.join('\n')}`
+                        }
+                    }, null, 2)
+                }
+            ],
+            isError: true
+        };
+    }
+    // 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_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: ${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 {
+        content: [
+            {
+                type: "text",
+                text: summary.join('\n')
+            }
+        ],
+        isError: errors.length > 0 && results.length === 0
+    };
+}
+exports.handleCreateVM = handleCreateVM;

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-resources.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetResources = exports.getResourcesTool = void 0;
+const api_utils_js_1 = require("../lib/api-utils.js");
+exports.getResourcesTool = {
+    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: []
+    }
+};
+async function handleGetResources(args) {
+    const { type, intent, role } = args;
+    const resources = await (0, api_utils_js_1.getResources)(type, intent, role);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(resources, null, 2)
+            }
+        ],
+        isError: !!resources.error
+    };
+}
+exports.handleGetResources = handleGetResources;

package/dist/tools/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolHandlers = exports.allTools = exports.handleProvideFeedback = exports.provideFeedbackTool = exports.handleExportTrainingData = exports.exportTrainingDataTool = exports.handleCreateVM = exports.createVMTool = exports.handleParseIntent = exports.parseIntentTool = exports.handleGetResources = exports.getResourcesTool = void 0;
+// Import and re-export all tools and their handlers
+const get_resources_js_1 = require("./get-resources.js");
+const parse_intent_js_1 = require("./parse-intent.js");
+const create_vm_js_1 = require("./create-vm.js");
+const export_training_data_js_1 = require("./export-training-data.js");
+const provide_feedback_js_1 = require("./provide-feedback.js");
+// Re-export for external use
+var get_resources_js_2 = require("./get-resources.js");
+Object.defineProperty(exports, "getResourcesTool", { enumerable: true, get: function () { return get_resources_js_2.getResourcesTool; } });
+Object.defineProperty(exports, "handleGetResources", { enumerable: true, get: function () { return get_resources_js_2.handleGetResources; } });
+var parse_intent_js_2 = require("./parse-intent.js");
+Object.defineProperty(exports, "parseIntentTool", { enumerable: true, get: function () { return parse_intent_js_2.parseIntentTool; } });
+Object.defineProperty(exports, "handleParseIntent", { enumerable: true, get: function () { return parse_intent_js_2.handleParseIntent; } });
+var create_vm_js_2 = require("./create-vm.js");
+Object.defineProperty(exports, "createVMTool", { enumerable: true, get: function () { return create_vm_js_2.createVMTool; } });
+Object.defineProperty(exports, "handleCreateVM", { enumerable: true, get: function () { return create_vm_js_2.handleCreateVM; } });
+var export_training_data_js_2 = require("./export-training-data.js");
+Object.defineProperty(exports, "exportTrainingDataTool", { enumerable: true, get: function () { return export_training_data_js_2.exportTrainingDataTool; } });
+Object.defineProperty(exports, "handleExportTrainingData", { enumerable: true, get: function () { return export_training_data_js_2.handleExportTrainingData; } });
+var provide_feedback_js_2 = require("./provide-feedback.js");
+Object.defineProperty(exports, "provideFeedbackTool", { enumerable: true, get: function () { return provide_feedback_js_2.provideFeedbackTool; } });
+Object.defineProperty(exports, "handleProvideFeedback", { enumerable: true, get: function () { return provide_feedback_js_2.handleProvideFeedback; } });
+// Collect all tool definitions
+exports.allTools = [
+    get_resources_js_1.getResourcesTool,
+    parse_intent_js_1.parseIntentTool,
+    create_vm_js_1.createVMTool,
+    export_training_data_js_1.exportTrainingDataTool,
+    provide_feedback_js_1.provideFeedbackTool
+];
+// Export tool handlers map for easy lookup
+exports.toolHandlers = {
+    get_resources: get_resources_js_1.handleGetResources,
+    parse_vm_intent: parse_intent_js_1.handleParseIntent,
+    create_vm: create_vm_js_1.handleCreateVM,
+    export_training_data: export_training_data_js_1.handleExportTrainingData,
+    provide_feedback: provide_feedback_js_1.handleProvideFeedback
+};

package/dist/tools/parse-intent.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleParseIntent = exports.parseIntentTool = void 0;
+const intent_recognition_js_1 = require("../lib/intent-recognition.js");
+const session_js_1 = require("../lib/session.js");
+exports.parseIntentTool = {
+    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"]
+    }
+};
+async function handleParseIntent(args) {
+    const startTime = Date.now();
+    const { naturalLanguageInput } = args;
+    const sessionId = (0, session_js_1.generateSessionId)();
+    const parsedIntent = (0, intent_recognition_js_1.parseVMIntent)(naturalLanguageInput);
+    const parseTime = Date.now() - startTime;
+    // Log interaction for AI training (respects privacy settings)
+    (0, session_js_1.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 {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(parsedIntent, null, 2)
+            }
+        ],
+        isError: parsedIntent.action === 'unknown' && parsedIntent.confidence < 0.3
+    };
+}
+exports.handleParseIntent = handleParseIntent;

package/dist/tools/provide-feedback.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleProvideFeedback = exports.provideFeedbackTool = void 0;
+const session_js_1 = require("../lib/session.js");
+exports.provideFeedbackTool = {
+    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"]
+    }
+};
+async function handleProvideFeedback(args) {
+    const { original_input, parsed_result, correct_interpretation, feedback_notes } = args;
+    const sessionId = (0, session_js_1.generateSessionId)();
+    // Log feedback for future model improvements
+    (0, session_js_1.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 {
+        content: [
+            {
+                type: "text",
+                text: 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
+    };
+}
+exports.handleProvideFeedback = handleProvideFeedback;

package/dist/types/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vme-mcp-server",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "VMware vCenter MCP Server - Natural language infrastructure management for Claude",
   "main": "dist/server.js",
   "bin": {