vme-mcp-server 0.1.5 → 0.1.7

package/dist/lib/api-utils.js

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

package/dist/lib/capability-cache.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capabilityCache = exports.SmartCapabilityCache = void 0;
+const api_utils_js_1 = require("./api-utils.js");
+// Smart capability cache with field-level TTL
+class SmartCapabilityCache {
+    constructor() {
+        this.cache = new Map();
+        // TTL configuration based on VME resource change patterns
+        this.ttlConfig = {
+            zones: 3600, // Zones rarely change (1 hour)
+            clusters: 1800, // Cluster topology changes occasionally (30 min)
+            service_plans: 1800, // Plans change occasionally (30 min)
+            instance_types: 7200, // Instance types very stable (2 hours)
+            virtual_images: 900, // Images updated more frequently (15 min)
+            cluster_status: 300, // Node status changes often (5 min)
+            resource_pools: 1800, // Pool config changes occasionally (30 min)
+            networks: 3600, // Network config rarely changes (1 hour)
+            groups: 3600, // Groups rarely change (1 hour)
+        };
+        // Default TTL for unknown fields
+        this.defaultTTL = 600; // 10 minutes
+    }
+    /**
+     * Get data for a specific field, using cache if fresh or fetching if stale
+     */
+    async getField(fieldName, forceRefresh = false) {
+        const cached = this.cache.get(fieldName);
+        const now = Math.floor(Date.now() / 1000);
+        // Check if cache is fresh and not forcing refresh
+        if (!forceRefresh && cached && this.isFresh(cached, now)) {
+            return cached.data;
+        }
+        // Fetch fresh data from VME API
+        const endpoint = this.getEndpointForField(fieldName);
+        try {
+            const response = await api_utils_js_1.api.get(endpoint);
+            // Store in cache with appropriate TTL
+            const cacheEntry = {
+                data: response.data,
+                cached_at: now,
+                ttl_seconds: this.ttlConfig[fieldName] || this.defaultTTL,
+                endpoint: endpoint,
+                field_name: fieldName
+            };
+            this.cache.set(fieldName, cacheEntry);
+            return response.data;
+        }
+        catch (error) {
+            // If API fails and we have stale cache, return it with warning
+            if (cached) {
+                console.warn(`VME API failed for ${fieldName}, returning stale cache data`);
+                return cached.data;
+            }
+            // No cache and API failed - propagate error
+            throw new Error(`Failed to fetch ${fieldName}: ${error.message}`);
+        }
+    }
+    /**
+     * Get cache status for a specific field or all fields
+     */
+    getCacheStatus(fieldName) {
+        const now = Math.floor(Date.now() / 1000);
+        const statuses = [];
+        if (fieldName) {
+            const cached = this.cache.get(fieldName);
+            if (cached) {
+                statuses.push(this.buildCacheStatus(cached, now));
+            }
+        }
+        else {
+            // Return status for all cached fields
+            for (const cached of this.cache.values()) {
+                statuses.push(this.buildCacheStatus(cached, now));
+            }
+        }
+        return statuses;
+    }
+    /**
+     * Invalidate cache for specific field or all fields
+     */
+    invalidate(fieldName) {
+        if (fieldName) {
+            this.cache.delete(fieldName);
+        }
+        else {
+            this.cache.clear();
+        }
+    }
+    /**
+     * Get cache hit rate statistics
+     */
+    getStatistics() {
+        // This would need hit/miss tracking - placeholder for now
+        return { hits: 0, misses: 0, hitRate: 0 };
+    }
+    // Private helper methods
+    isFresh(cached, now) {
+        return (now - cached.cached_at) < cached.ttl_seconds;
+    }
+    buildCacheStatus(cached, now) {
+        const age = now - cached.cached_at;
+        const expiresIn = cached.ttl_seconds - age;
+        return {
+            field_name: cached.field_name,
+            cached_at: cached.cached_at,
+            ttl_seconds: cached.ttl_seconds,
+            age_seconds: age,
+            is_fresh: this.isFresh(cached, now),
+            expires_in_seconds: Math.max(0, expiresIn),
+            endpoint: cached.endpoint
+        };
+    }
+    getEndpointForField(fieldName) {
+        // Map field names to VME API endpoints
+        const endpointMap = {
+            zones: "/zones",
+            clusters: "/clusters",
+            service_plans: "/service-plans",
+            instance_types: "/instance-types",
+            virtual_images: "/virtual-images",
+            resource_pools: "/resource-pools",
+            networks: "/networks",
+            groups: "/groups"
+        };
+        return endpointMap[fieldName] || `/${fieldName}`;
+    }
+}
+exports.SmartCapabilityCache = SmartCapabilityCache;
+// Global cache instance
+exports.capabilityCache = new SmartCapabilityCache();

package/dist/lib/capability-discovery.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capabilityDiscovery = exports.CapabilityDiscoveryEngine = void 0;
+const capability_cache_js_1 = require("./capability-cache.js");
+// Capability discovery engine
+class CapabilityDiscoveryEngine {
+    /**
+     * Discover capabilities for specified domains
+     */
+    async discoverCapabilities(domains = ["all"], forceRefresh = false) {
+        const result = {
+            discovered_at: new Date().toISOString(),
+            cache_status: []
+        };
+        // Determine which domains to discover
+        const shouldDiscover = (domain) => domains.includes("all") || domains.includes(domain);
+        try {
+            // Discover capabilities in parallel for efficiency
+            const discoveries = await Promise.allSettled([
+                shouldDiscover("compute") ? this.discoverComputeCapabilities(forceRefresh) : Promise.resolve(null),
+                shouldDiscover("networking") ? this.discoverNetworkingCapabilities(forceRefresh) : Promise.resolve(null),
+                shouldDiscover("storage") ? this.discoverStorageCapabilities(forceRefresh) : Promise.resolve(null),
+                shouldDiscover("platform") ? this.discoverPlatformCapabilities(forceRefresh) : Promise.resolve(null),
+            ]);
+            // Process results
+            if (discoveries[0]?.status === "fulfilled" && discoveries[0].value) {
+                result.compute = discoveries[0].value;
+            }
+            if (discoveries[1]?.status === "fulfilled" && discoveries[1].value) {
+                result.networking = discoveries[1].value;
+            }
+            if (discoveries[2]?.status === "fulfilled" && discoveries[2].value) {
+                result.storage = discoveries[2].value;
+            }
+            if (discoveries[3]?.status === "fulfilled" && discoveries[3].value) {
+                result.platform = discoveries[3].value;
+            }
+            // Add cache status summary
+            result.cache_status = this.getCacheStatusSummary();
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Capability discovery failed: ${error.message}`);
+        }
+    }
+    /**
+     * Check if a specific capability is available
+     */
+    async checkCapability(question, capabilityType) {
+        // Simple natural language processing for capability questions
+        const questionLower = question.toLowerCase();
+        try {
+            // GPU support check
+            if (questionLower.includes("gpu") || capabilityType === "gpu_support") {
+                const compute = await this.discoverComputeCapabilities();
+                return {
+                    answer: compute.gpu_support,
+                    details: compute.gpu_support
+                        ? "GPU support is available in this VME environment"
+                        : "No GPU support detected in cluster nodes",
+                    confidence: 0.95
+                };
+            }
+            // Hypervisor checks
+            if (questionLower.includes("vmware") || questionLower.includes("kvm") || questionLower.includes("hypervisor")) {
+                const compute = await this.discoverComputeCapabilities();
+                const hypervisor = questionLower.includes("vmware") ? "VMware" :
+                    questionLower.includes("kvm") ? "KVM" : null;
+                if (hypervisor) {
+                    const available = compute.hypervisors.includes(hypervisor);
+                    return {
+                        answer: available,
+                        details: available
+                            ? `${hypervisor} hypervisor is available`
+                            : `${hypervisor} hypervisor not found. Available: ${compute.hypervisors.join(", ")}`,
+                        confidence: 0.9
+                    };
+                }
+            }
+            // CPU/Memory limit checks
+            if (questionLower.match(/\b(\d+)\s*(cpu|core|vcpu)/)) {
+                const compute = await this.discoverComputeCapabilities();
+                const requestedCPU = parseInt(questionLower.match(/\b(\d+)\s*(cpu|core|vcpu)/)?.[1] || "0");
+                const canSupport = requestedCPU <= compute.max_cpu_per_vm;
+                return {
+                    answer: canSupport,
+                    details: canSupport
+                        ? `${requestedCPU} CPU configuration is supported (max: ${compute.max_cpu_per_vm})`
+                        : `${requestedCPU} CPU exceeds maximum of ${compute.max_cpu_per_vm} per VM`,
+                    confidence: 0.85
+                };
+            }
+            // Generic fallback
+            return {
+                answer: false,
+                details: "Unable to determine capability from question. Try being more specific.",
+                confidence: 0.1
+            };
+        }
+        catch (error) {
+            return {
+                answer: false,
+                details: `Error checking capability: ${error.message}`,
+                confidence: 0.0
+            };
+        }
+    }
+    // Private discovery methods for each domain
+    async discoverComputeCapabilities(forceRefresh = false) {
+        const [clusters, servicePlans, instanceTypes, virtualImages] = await Promise.all([
+            capability_cache_js_1.capabilityCache.getField("clusters", forceRefresh),
+            capability_cache_js_1.capabilityCache.getField("service_plans", forceRefresh),
+            capability_cache_js_1.capabilityCache.getField("instance_types", forceRefresh),
+            capability_cache_js_1.capabilityCache.getField("virtual_images", forceRefresh),
+        ]);
+        // Derive hypervisors from cluster data
+        const hypervisors = new Set();
+        let maxCPU = 0;
+        let maxMemoryGB = 0;
+        let hasGPU = false;
+        if (clusters?.clusters) {
+            for (const cluster of clusters.clusters) {
+                if (cluster.servers) {
+                    for (const server of cluster.servers) {
+                        if (server.serverType) {
+                            hypervisors.add(server.serverType);
+                        }
+                        if (server.maxCpu && server.maxCpu > maxCPU) {
+                            maxCPU = server.maxCpu;
+                        }
+                        if (server.maxMemory && server.maxMemory > maxMemoryGB) {
+                            maxMemoryGB = Math.floor(server.maxMemory / (1024 * 1024 * 1024)); // Convert to GB
+                        }
+                        if (server.gpuCount && server.gpuCount > 0) {
+                            hasGPU = true;
+                        }
+                    }
+                }
+            }
+        }
+        // Process service plans for limits
+        const plans = servicePlans?.servicePlans?.map((plan) => ({
+            id: plan.id,
+            name: plan.name,
+            max_cpu: plan.maxCpu,
+            max_memory: plan.maxMemory,
+            max_storage: plan.maxStorage
+        })) || [];
+        // Process instance types
+        const instances = instanceTypes?.instanceTypes?.map((type) => ({
+            id: type.id,
+            name: type.name,
+            code: type.code
+        })) || [];
+        // Process virtual images
+        const images = virtualImages?.virtualImages?.map((img) => ({
+            id: img.id,
+            name: img.name,
+            os_type: img.osType?.name || "Unknown",
+            category: img.osType?.category || "unknown",
+            version: img.osType?.osVersion
+        })) || [];
+        return {
+            hypervisors: Array.from(hypervisors),
+            instance_types: instances,
+            service_plans: plans,
+            max_cpu_per_vm: maxCPU,
+            max_memory_per_vm: `${maxMemoryGB}GB`,
+            gpu_support: hasGPU,
+            available_images: images.slice(0, 10) // Limit to prevent token bloat
+        };
+    }
+    async discoverNetworkingCapabilities(forceRefresh = false) {
+        const [zones, networks] = await Promise.all([
+            capability_cache_js_1.capabilityCache.getField("zones", forceRefresh),
+            capability_cache_js_1.capabilityCache.getField("networks", forceRefresh).catch(() => null), // Optional
+        ]);
+        const zoneList = zones?.zones?.map((zone) => ({
+            id: zone.id,
+            name: zone.name,
+            description: zone.description
+        })) || [];
+        return {
+            zones: zoneList,
+            network_types: ["VLAN"], // Default for VME
+            load_balancer_support: false, // Would need to check features
+            firewall_support: false, // Would need to check features
+        };
+    }
+    async discoverStorageCapabilities(forceRefresh = false) {
+        // Get real data from VME API
+        const servicePlans = await capability_cache_js_1.capabilityCache.getField("service_plans", forceRefresh);
+        // Derive storage capabilities from actual service plans and other data
+        const storageTypes = new Set();
+        let maxVolumeSize = "1TB"; // Default
+        if (servicePlans?.servicePlans) {
+            for (const plan of servicePlans.servicePlans) {
+                // Look for storage-related info in service plans
+                if (plan.maxStorage) {
+                    const sizeGB = Math.floor(plan.maxStorage / (1024 * 1024 * 1024));
+                    if (sizeGB > parseInt(maxVolumeSize)) {
+                        maxVolumeSize = `${sizeGB}GB`;
+                    }
+                }
+            }
+        }
+        // Basic storage types - would need more VME API endpoints to get real storage info
+        storageTypes.add("Local"); // VME always has local storage
+        return {
+            storage_types: Array.from(storageTypes),
+            max_volume_size: maxVolumeSize,
+            snapshot_support: true, // VME typically supports snapshots
+            encryption_support: false, // Would need to check actual VME features
+        };
+    }
+    async discoverPlatformCapabilities(forceRefresh = false) {
+        const groups = await capability_cache_js_1.capabilityCache.getField("groups", forceRefresh);
+        const groupList = groups?.groups?.map((group) => ({
+            id: group.id,
+            name: group.name,
+            description: group.description
+        })) || [];
+        return {
+            api_version: "6.2.x", // Would get from API info endpoint
+            groups: groupList,
+            enabled_features: ["VM Provisioning", "Resource Management"], // Would derive from license/features
+        };
+    }
+    getCacheStatusSummary() {
+        const statuses = capability_cache_js_1.capabilityCache.getCacheStatus();
+        return statuses.map(status => ({
+            field: status.field_name,
+            fresh: status.is_fresh,
+            age_seconds: status.age_seconds
+        }));
+    }
+}
+exports.CapabilityDiscoveryEngine = CapabilityDiscoveryEngine;
+// Global discovery engine instance
+exports.capabilityDiscovery = new CapabilityDiscoveryEngine();