vme-mcp-server 0.1.5 → 0.1.7

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,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolHandlers = exports.allTools = exports.handleQueryResources = exports.queryResourcesTool = exports.handleGetCacheStatus = exports.getCacheStatusTool = exports.handleCheckCapability = exports.checkCapabilityTool = exports.handleDiscoverCapabilities = exports.discoverCapabilitiesTool = exports.handleProvideFeedback = exports.provideFeedbackTool = exports.handleExportTrainingData = exports.exportTrainingDataTool = exports.handleCreateVM = exports.createVMTool = exports.handleParseIntent = exports.parseIntentTool = exports.handleGetResources = exports.getResourcesTool = void 0;
+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");
+// Sprint 2: Capability Discovery Tools
+const discover_capabilities_js_1 = require("./discover-capabilities.js");
+const check_capability_js_1 = require("./check-capability.js");
+const get_cache_status_js_1 = require("./get-cache-status.js");
+const query_resources_js_1 = require("./query-resources.js");
+// Re-export for external use
+var get_resources_js_1 = require("./get-resources.js");
+Object.defineProperty(exports, "getResourcesTool", { enumerable: true, get: function () { return get_resources_js_1.getResourcesTool; } });
+Object.defineProperty(exports, "handleGetResources", { enumerable: true, get: function () { return get_resources_js_1.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; } });
+var discover_capabilities_js_2 = require("./discover-capabilities.js");
+Object.defineProperty(exports, "discoverCapabilitiesTool", { enumerable: true, get: function () { return discover_capabilities_js_2.discoverCapabilitiesTool; } });
+Object.defineProperty(exports, "handleDiscoverCapabilities", { enumerable: true, get: function () { return discover_capabilities_js_2.handleDiscoverCapabilities; } });
+var check_capability_js_2 = require("./check-capability.js");
+Object.defineProperty(exports, "checkCapabilityTool", { enumerable: true, get: function () { return check_capability_js_2.checkCapabilityTool; } });
+Object.defineProperty(exports, "handleCheckCapability", { enumerable: true, get: function () { return check_capability_js_2.handleCheckCapability; } });
+var get_cache_status_js_2 = require("./get-cache-status.js");
+Object.defineProperty(exports, "getCacheStatusTool", { enumerable: true, get: function () { return get_cache_status_js_2.getCacheStatusTool; } });
+Object.defineProperty(exports, "handleGetCacheStatus", { enumerable: true, get: function () { return get_cache_status_js_2.handleGetCacheStatus; } });
+var query_resources_js_2 = require("./query-resources.js");
+Object.defineProperty(exports, "queryResourcesTool", { enumerable: true, get: function () { return query_resources_js_2.queryResourcesTool; } });
+Object.defineProperty(exports, "handleQueryResources", { enumerable: true, get: function () { return query_resources_js_2.handleQueryResources; } });
+// Collect all tool definitions
+exports.allTools = [
+    // Sprint 1.5 tools
+    // getResourcesTool, // DISABLED - caused 37K+ token responses, replaced by Sprint 2 capability discovery
+    parse_intent_js_1.parseIntentTool,
+    create_vm_js_1.createVMTool,
+    export_training_data_js_1.exportTrainingDataTool,
+    provide_feedback_js_1.provideFeedbackTool,
+    // Sprint 2 capability discovery tools
+    discover_capabilities_js_1.discoverCapabilitiesTool,
+    check_capability_js_1.checkCapabilityTool,
+    get_cache_status_js_1.getCacheStatusTool,
+    query_resources_js_1.queryResourcesTool
+];
+// Export tool handlers map for easy lookup
+exports.toolHandlers = {
+    // Sprint 1.5 handlers
+    // get_resources: handleGetResources, // DISABLED - caused 37K+ token responses
+    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,
+    // Sprint 2 capability discovery handlers
+    discover_capabilities: discover_capabilities_js_1.handleDiscoverCapabilities,
+    check_capability: check_capability_js_1.handleCheckCapability,
+    get_cache_status: get_cache_status_js_1.handleGetCacheStatus,
+    query_resources: query_resources_js_1.handleQueryResources
+};

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/tools/query-resources.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleQueryResources = exports.queryResourcesTool = void 0;
+const api_utils_js_1 = require("../lib/api-utils.js");
+exports.queryResourcesTool = {
+    name: "query_resources",
+    description: "Query actual infrastructure resources (VMs, hosts, networks) with natural language. Use discover_capabilities first to learn available OS types, groups, and statuses in your environment.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            natural_query: {
+                type: "string",
+                description: "Natural language query like 'Windows VMs', 'stopped VMs in production', 'any VMs?', 'Ubuntu hosts', 'VMs in development group'"
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of results to return (default: 10, max: 100)",
+                default: 10
+            }
+        },
+        required: ["natural_query"]
+    }
+};
+function parseResourceQuery(query, limit = 10) {
+    const q = query.toLowerCase().trim();
+    // Determine resource type
+    let resource = 'instances'; // default
+    if (q.includes('host') || q.includes('server') || q.includes('node')) {
+        resource = 'hosts';
+    }
+    else if (q.includes('network')) {
+        resource = 'networks';
+    }
+    // Determine action
+    let action = 'list';
+    if (q.includes('how many') || q.includes('count')) {
+        action = 'count';
+    }
+    else if (q.includes('any ') || q.includes('summary')) {
+        action = 'summary';
+    }
+    // Extract filters
+    const filters = {};
+    // OS Type patterns
+    if (q.includes('windows'))
+        filters.osType = 'windows';
+    if (q.includes('linux'))
+        filters.osType = 'linux';
+    if (q.includes('ubuntu'))
+        filters.osType = 'ubuntu';
+    if (q.includes('centos'))
+        filters.osType = 'centos';
+    if (q.includes('rocky'))
+        filters.osType = 'rocky';
+    if (q.includes('debian'))
+        filters.osType = 'debian';
+    if (q.includes('rhel'))
+        filters.osType = 'rhel';
+    // Status patterns
+    if (q.includes('running'))
+        filters.status = 'running';
+    if (q.includes('stopped'))
+        filters.status = 'stopped';
+    if (q.includes('failed') || q.includes('error'))
+        filters.status = 'failed';
+    if (q.includes('provisioning'))
+        filters.status = 'provisioning';
+    // Group patterns
+    if (q.includes('production') || q.includes('prod'))
+        filters.group = 'production';
+    if (q.includes('development') || q.includes('dev'))
+        filters.group = 'development';
+    if (q.includes('test') || q.includes('testing'))
+        filters.group = 'test';
+    // Name patterns (exact matches)
+    const nameMatch = q.match(/named?\s+["']?([a-zA-Z0-9\-_]+)["']?/);
+    if (nameMatch) {
+        filters.name = nameMatch[1];
+    }
+    return { resource, action, filters, limit };
+}
+function filterResults(data, filters) {
+    return data.filter(item => {
+        // OS Type filtering
+        if (filters.osType) {
+            const itemOS = item.osType?.toLowerCase() || '';
+            const filterOS = filters.osType.toLowerCase();
+            if (filterOS === 'windows' && !itemOS.includes('windows'))
+                return false;
+            if (filterOS === 'linux' && !itemOS.includes('linux') && !itemOS.includes('ubuntu') && !itemOS.includes('centos') && !itemOS.includes('rocky') && !itemOS.includes('debian') && !itemOS.includes('rhel'))
+                return false;
+            if (filterOS !== 'windows' && filterOS !== 'linux' && !itemOS.includes(filterOS))
+                return false;
+        }
+        // Status filtering
+        if (filters.status) {
+            const itemStatus = item.status?.toLowerCase() || '';
+            if (!itemStatus.includes(filters.status.toLowerCase()))
+                return false;
+        }
+        // Group filtering
+        if (filters.group) {
+            const itemGroup = item.group?.name?.toLowerCase() || item.site?.name?.toLowerCase() || '';
+            if (!itemGroup.includes(filters.group.toLowerCase()))
+                return false;
+        }
+        // Name filtering
+        if (filters.name) {
+            const itemName = item.name?.toLowerCase() || '';
+            if (!itemName.includes(filters.name.toLowerCase()))
+                return false;
+        }
+        return true;
+    });
+}
+function formatResponse(parsedQuery, results, totalCount) {
+    const { action, resource, filters } = parsedQuery;
+    if (action === 'count') {
+        return {
+            action: 'count',
+            resource: resource,
+            filters_applied: filters,
+            total_count: results.length,
+            query_summary: `Found ${results.length} ${resource} matching criteria`
+        };
+    }
+    if (action === 'summary') {
+        const statusCounts = {};
+        const osCounts = {};
+        results.forEach(item => {
+            const status = item.status || 'unknown';
+            const os = item.osType || 'unknown';
+            statusCounts[status] = (statusCounts[status] || 0) + 1;
+            osCounts[os] = (osCounts[os] || 0) + 1;
+        });
+        return {
+            action: 'summary',
+            resource: resource,
+            filters_applied: filters,
+            total_count: results.length,
+            summary: {
+                by_status: statusCounts,
+                by_os_type: osCounts
+            },
+            query_summary: `Found ${results.length} ${resource} matching criteria`
+        };
+    }
+    // Default: list action
+    const limitedResults = results.slice(0, parsedQuery.limit);
+    return {
+        action: 'list',
+        resource: resource,
+        filters_applied: filters,
+        total_count: results.length,
+        returned_count: limitedResults.length,
+        items: limitedResults.map(item => ({
+            id: item.id,
+            name: item.name,
+            status: item.status,
+            osType: item.osType,
+            group: item.group?.name || item.site?.name || 'unknown',
+            ...(resource === 'instances' && {
+                plan: item.plan?.name,
+                powerState: item.powerState,
+                ipAddress: item.externalIp || item.internalIp
+            })
+        })),
+        query_summary: `Showing ${limitedResults.length} of ${results.length} ${resource} matching criteria`
+    };
+}
+async function handleQueryResources(args) {
+    try {
+        const { natural_query, limit = 10 } = args;
+        if (!natural_query || typeof natural_query !== 'string') {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "Invalid input",
+                            message: "natural_query parameter is required and must be a string",
+                            examples: ["any VMs?", "Windows VMs", "stopped VMs in production", "Ubuntu hosts"]
+                        }, null, 2)
+                    }
+                ],
+                isError: true
+            };
+        }
+        const parsedQuery = parseResourceQuery(natural_query, Math.min(limit, 100));
+        // Map resource type to API endpoint
+        const endpointMap = {
+            'instances': '/instances',
+            'hosts': '/servers',
+            'networks': '/networks'
+        };
+        const endpoint = endpointMap[parsedQuery.resource];
+        // Query the VME API
+        const response = await api_utils_js_1.api.get(endpoint);
+        // Extract data array from response
+        let rawData = [];
+        if (parsedQuery.resource === 'instances' && response.data.instances) {
+            rawData = response.data.instances;
+        }
+        else if (parsedQuery.resource === 'hosts' && response.data.servers) {
+            rawData = response.data.servers;
+        }
+        else if (parsedQuery.resource === 'networks' && response.data.networks) {
+            rawData = response.data.networks;
+        }
+        else {
+            // Fallback: try to find array in response
+            const possibleArrays = Object.values(response.data).filter(Array.isArray);
+            if (possibleArrays.length > 0) {
+                rawData = possibleArrays[0];
+            }
+        }
+        // Apply filters
+        const filteredResults = filterResults(rawData, parsedQuery.filters);
+        // Format response based on action
+        const formattedResponse = formatResponse(parsedQuery, filteredResults, rawData.length);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(formattedResponse, null, 2)
+                }
+            ],
+            isError: false
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "Resource query failed",
+                        message: error.message,
+                        natural_query: args?.natural_query || "unknown",
+                        suggestion: "Check VME API connectivity or try discover_capabilities first to see available resources"
+                    }, null, 2)
+                }
+            ],
+            isError: true
+        };
+    }
+}
+exports.handleQueryResources = handleQueryResources;

package/dist/types/interfaces.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vme-mcp-server",
-  "version": "0.1.5",
-  "description": "VMware vCenter MCP Server - Natural language infrastructure management for Claude",
+  "version": "0.1.7",
+  "description": "",
   "main": "dist/server.js",
   "bin": {
     "vme-mcp-server": "./dist/server.js"
@@ -47,8 +47,8 @@
   },
   "devDependencies": {
     "@types/node": "^22.15.29",
+    "chai": "^5.2.0",
     "mocha": "^10.2.0",
     "nyc": "^15.1.0"
-  },
-  "description": ""
+  }
 }