@vfarcic/dot-ai 0.124.0 → 0.126.0

package/dist/core/capability-scan-workflow.js

@@ -8,7 +8,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleResourceSelection = handleResourceSelection;
 exports.handleResourceSpecification = handleResourceSpecification;
-exports.handleProcessingMode = handleProcessingMode;
 exports.handleScanning = handleScanning;
 const discovery_1 = require("./discovery");
 const capabilities_1 = require("./capabilities");
@@ -36,7 +35,7 @@ function createResourceDefinitionErrorMessage(resourceName, error) {
 /**
  * Handle resource selection step
  */
-async function handleResourceSelection(session, args, _logger, _requestId, parseNumericResponse, transitionCapabilitySession) {
+async function handleResourceSelection(session, args, logger, requestId, capabilityService, parseNumericResponse, transitionCapabilitySession, cleanupCapabilitySession, createCapabilityScanCompletionResponse, handleScanningFn) {
     if (!args.response) {
         // Show initial resource selection prompt
         return {
@@ -83,49 +82,13 @@ async function handleResourceSelection(session, args, _logger, _requestId, parse
     // Process user response
     const normalizedResponse = parseNumericResponse(args.response, ['all', 'specific']);
     if (normalizedResponse === 'all') {
-        // Transition to processing mode for all resources
-        transitionCapabilitySession(session, 'processing-mode', { selectedResources: 'all' }, args);
-        return {
-            success: true,
-            operation: 'scan',
-            dataType: 'capabilities',
-            // CRITICAL: Put required parameters at top level for maximum visibility
-            REQUIRED_NEXT_CALL: {
-                tool: 'dot-ai:manageOrgData',
-                parameters: {
-                    dataType: 'capabilities',
-                    operation: 'scan',
-                    sessionId: session.sessionId,
-                    step: 'processing-mode', // MANDATORY PARAMETER
-                    response: 'user_choice_here' // Replace with actual user choice
-                },
-                note: 'The step parameter is MANDATORY when sessionId is provided'
-            },
-            workflow: {
-                step: 'processing-mode',
-                question: 'Processing mode: auto (batch process) or manual (review each)?',
-                options: [
-                    { number: 1, value: 'auto', display: '1. auto - Batch process automatically' },
-                    { number: 2, value: 'manual', display: '2. manual - Review each step' }
-                ],
-                sessionId: session.sessionId,
-                selectedResources: 'all',
-                instruction: 'IMPORTANT: You MUST ask the user to make a choice. Do NOT automatically select a processing mode.',
-                userPrompt: 'How would you like to process the resources?',
-                clientInstructions: {
-                    behavior: 'interactive',
-                    requirement: 'Ask user to choose processing mode',
-                    prohibit: 'Do not auto-select processing mode',
-                    nextStep: `Call with step='processing-mode', sessionId='${session.sessionId}', and response parameter containing the semantic value (auto or manual)`,
-                    responseFormat: 'Convert user input to semantic values: 1→auto, 2→manual, or pass through semantic words directly',
-                    requiredParameters: {
-                        step: 'processing-mode',
-                        sessionId: session.sessionId,
-                        response: 'user choice (auto or manual)'
-                    }
-                }
-            }
-        };
+        // Transition directly to scanning (auto mode only - manual mode removed)
+        transitionCapabilitySession(session, 'scanning', {
+            selectedResources: 'all',
+            currentResourceIndex: 0 // Start with first resource
+        }, args);
+        // Begin actual capability scanning and return completion summary
+        return await handleScanningFn(session, { ...args, response: undefined }, logger, requestId, capabilityService, parseNumericResponse, transitionCapabilitySession, cleanupCapabilitySession, createCapabilityScanCompletionResponse);
     }
     if (normalizedResponse === 'specific') {
         // Transition to resource specification
@@ -190,7 +153,7 @@ async function handleResourceSelection(session, args, _logger, _requestId, parse
 /**
  * Handle resource specification step
  */
-async function handleResourceSpecification(session, args, _logger, _requestId, transitionCapabilitySession) {
+async function handleResourceSpecification(session, args, logger, requestId, capabilityService, parseNumericResponse, transitionCapabilitySession, cleanupCapabilitySession, createCapabilityScanCompletionResponse, handleScanningFn) {
     if (!args.resourceList) {
         return {
             success: false,
@@ -218,176 +181,49 @@ async function handleResourceSpecification(session, args, _logger, _requestId, t
             }
         };
     }
-    // Transition to processing mode for specific resources
-    transitionCapabilitySession(session, 'processing-mode', {
-        selectedResources: resources,
-        resourceList: args.resourceList
-    }, args);
-    return {
-        success: true,
-        operation: 'scan',
-        dataType: 'capabilities',
-        // CRITICAL: Put required parameters at top level for maximum visibility
-        REQUIRED_NEXT_CALL: {
-            tool: 'dot-ai:manageOrgData',
-            parameters: {
-                dataType: 'capabilities',
-                operation: 'scan',
-                sessionId: session.sessionId,
-                step: 'processing-mode', // MANDATORY PARAMETER
-                response: 'user_choice_here' // Replace with actual user choice
-            },
-            note: 'The step parameter is MANDATORY when sessionId is provided'
-        },
-        workflow: {
-            step: 'processing-mode',
-            question: `Processing mode for ${resources.length} selected resources: auto (batch process) or manual (review each)?`,
-            options: [
-                { number: 1, value: 'auto', display: '1. auto - Batch process automatically' },
-                { number: 2, value: 'manual', display: '2. manual - Review each step' }
-            ],
-            sessionId: session.sessionId,
-            selectedResources: resources,
-            instruction: 'IMPORTANT: You MUST ask the user to choose processing mode for the specified resources.',
-            userPrompt: `How would you like to process these ${resources.length} resources?`,
-            clientInstructions: {
-                behavior: 'interactive',
-                requirement: 'Ask user to choose processing mode for specific resources',
-                context: `Processing ${resources.length} user-specified resources: ${resources.join(', ')}`,
-                prohibit: 'Do not auto-select processing mode',
-                nextStep: `Call with step='processing-mode', sessionId='${session.sessionId}', and response parameter containing the semantic value (auto or manual)`,
-                responseFormat: 'Convert user input to semantic values: 1→auto, 2→manual, or pass through semantic words directly',
-                requiredParameters: {
-                    step: 'processing-mode',
-                    sessionId: session.sessionId,
-                    response: 'user choice (auto or manual)'
-                }
-            }
-        }
-    };
-}
-/**
- * Handle processing mode step
- */
-async function handleProcessingMode(session, args, logger, requestId, capabilityService, parseNumericResponse, transitionCapabilitySession, cleanupCapabilitySession, createCapabilityScanCompletionResponse, handleScanningFn) {
-    if (!args.response) {
-        return {
-            success: false,
-            operation: 'scan',
-            dataType: 'capabilities',
-            error: {
-                message: 'Missing processing mode response',
-                details: 'Expected response parameter with processing mode choice',
-                currentStep: session.currentStep,
-                expectedCall: `Call with step='processing-mode' and response parameter (auto or manual)`
-            }
-        };
-    }
-    // Process user response
-    const processingModeResponse = parseNumericResponse(args.response, ['auto', 'manual']);
-    if (processingModeResponse !== 'auto' && processingModeResponse !== 'manual') {
-        return {
-            success: false,
-            operation: 'scan',
-            dataType: 'capabilities',
-            error: {
-                message: 'Invalid processing mode response',
-                details: `Expected 'auto' or 'manual', got: ${args.response}`,
-                currentStep: session.currentStep
-            }
-        };
-    }
-    // Transition to scanning with processing mode and initialize resource tracking
+    // Transition directly to scanning (auto mode only - manual mode removed)
     transitionCapabilitySession(session, 'scanning', {
-        processingMode: processingModeResponse,
+        selectedResources: resources,
+        resourceList: args.resourceList,
         currentResourceIndex: 0 // Start with first resource
     }, args);
-    // Begin actual capability scanning - clear response from previous step
+    // Begin actual capability scanning and return completion summary
     return await handleScanningFn(session, { ...args, response: undefined }, logger, requestId, capabilityService, parseNumericResponse, transitionCapabilitySession, cleanupCapabilitySession, createCapabilityScanCompletionResponse);
 }
 /**
- * Handle scanning step (actual capability analysis)
+ * Handle scanning step (actual capability analysis - auto mode only)
  */
 async function handleScanning(session, args, logger, requestId, capabilityService, parseNumericResponse, transitionCapabilitySession, cleanupCapabilitySession, createCapabilityScanCompletionResponse) {
     try {
-        // If this is a response to a manual mode preview, handle it first
-        if (session.processingMode === 'manual' && args.response) {
-            const userResponse = parseNumericResponse(args.response, ['yes', 'no', 'stop']);
-            if (userResponse === 'stop') {
-                // User wants to stop scanning
-                transitionCapabilitySession(session, 'complete', {}, args);
-                cleanupCapabilitySession(session, args, logger, requestId);
-                const currentIndex = session.currentResourceIndex || 0;
-                const totalResources = Array.isArray(session.selectedResources) ? session.selectedResources.length : 1;
-                return createCapabilityScanCompletionResponse(session.sessionId, totalResources, currentIndex, // Resources processed so far
-                0, 'stopped interactively', 'manual', true // stopped = true
-                );
-            }
-            if (userResponse === 'yes' || userResponse === 'no') {
-                // TODO: If 'yes', store the capability in Vector DB (Milestone 2)
-                // For now, just log the decision
-                logger.info(`User ${userResponse === 'yes' ? 'accepted' : 'skipped'} capability for resource`, {
-                    requestId,
-                    sessionId: session.sessionId,
-                    resourceIndex: session.currentResourceIndex,
-                    decision: userResponse
-                });
-                // Move to the next resource
-                const nextIndex = (session.currentResourceIndex || 0) + 1;
-                transitionCapabilitySession(session, 'scanning', { currentResourceIndex: nextIndex }, args);
-                // Continue processing (will handle the next resource or complete if done)
-                return await handleScanning(session, { ...args, response: undefined }, logger, requestId, capabilityService, parseNumericResponse, transitionCapabilitySession, cleanupCapabilitySession, createCapabilityScanCompletionResponse);
-            }
-            // Invalid response
-            return {
-                success: false,
-                operation: 'scan',
-                dataType: 'capabilities',
-                error: {
-                    message: 'Invalid response to capability preview',
-                    details: `Expected 'yes', 'no', or 'stop', got: ${args.response}`,
-                    currentStep: session.currentStep
-                }
-            };
-        }
-        // Import capability engine
-        // Already imported at top of file
-        // Validate AI provider - skip in test environment
-        const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.JEST_WORKER_ID;
-        if (!isTestEnvironment) {
-            try {
-                const aiProvider = (0, ai_provider_factory_1.createAIProvider)();
-                if (!aiProvider.isInitialized()) {
-                    return {
-                        success: false,
-                        operation: 'scan',
-                        dataType: 'capabilities',
-                        error: {
-                            message: 'AI provider API key required for capability inference',
-                            details: 'Configure AI provider credentials to enable AI-powered capability analysis'
-                        }
-                    };
-                }
-            }
-            catch (error) {
+        // Validate and initialize AI provider
+        let aiProvider;
+        try {
+            aiProvider = (0, ai_provider_factory_1.createAIProvider)();
+            if (!aiProvider.isInitialized()) {
                 return {
                     success: false,
                     operation: 'scan',
                     dataType: 'capabilities',
                     error: {
-                        message: 'AI provider initialization failed',
-                        details: error instanceof Error ? error.message : 'Unknown error'
+                        message: 'AI provider API key required for capability inference',
+                        details: 'Configure AI provider credentials to enable AI-powered capability analysis'
                     }
                 };
             }
         }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'scan',
+                dataType: 'capabilities',
+                error: {
+                    message: 'AI provider initialization failed',
+                    details: error instanceof Error ? error.message : 'Unknown error'
+                }
+            };
+        }
         // Initialize capability engine
-        const aiProvider = (0, ai_provider_factory_1.createAIProvider)();
         const engine = new capabilities_1.CapabilityInferenceEngine(aiProvider, logger);
-        // Get the resource to analyze
-        let resourceName;
-        let currentIndex;
-        let totalResources;
         if (session.selectedResources === 'all') {
             // For 'all' mode, discover actual cluster resources first
             try {
@@ -435,13 +271,9 @@ async function handleScanning(session, args, logger, requestId, capabilityServic
                 // Update session with discovered resources and start batch processing
                 transitionCapabilitySession(session, 'scanning', {
                     selectedResources: discoveredResourceNames,
-                    processingMode: session.processingMode,
                     currentResourceIndex: 0
                 }, args);
-                // Continue to batch processing with discovered resources
-                resourceName = discoveredResourceNames[0]; // First resource for manual mode
-                currentIndex = 0;
-                totalResources = discoveredResourceNames.length;
+                // Fall through to batch processing with discovered resources
             }
             catch (error) {
                 logger.error('Failed to discover cluster resources', error, {
@@ -465,286 +297,201 @@ async function handleScanning(session, args, logger, requestId, capabilityServic
                 };
             }
         }
-        else if (Array.isArray(session.selectedResources)) {
-            // Get the current resource based on currentResourceIndex
-            currentIndex = session.currentResourceIndex || 0;
-            totalResources = session.selectedResources.length;
-            if (currentIndex >= totalResources) {
-                // All resources processed - mark as complete
-                transitionCapabilitySession(session, 'complete', {}, args);
-                cleanupCapabilitySession(session, args, logger, requestId);
-                return createCapabilityScanCompletionResponse(session.sessionId, totalResources, totalResources, // Assume all successful for manual mode
-                0, 'completed interactively', 'manual');
-            }
-            resourceName = session.selectedResources[currentIndex];
-            if (!resourceName) {
-                throw new Error(`No resource found at index ${currentIndex}`);
-            }
-        }
-        else {
-            throw new Error('Invalid selectedResources in session state');
+        // Auto mode: Process ALL resources in batch without user interaction
+        // At this point, selectedResources should always be an array (either discovered or specified)
+        if (!Array.isArray(session.selectedResources)) {
+            throw new Error(`Invalid selectedResources state: expected array, got ${typeof session.selectedResources}. This indicates a bug in resource discovery.`);
         }
-        // Get complete resource definition for comprehensive analysis
-        let resourceDefinition;
-        try {
-            // Import and connect to discovery engine for kubectl access
-            const discovery = new discovery_1.KubernetesDiscovery();
-            await discovery.connect();
-            // Get complete CRD definition if it's a custom resource
-            if (resourceName.includes('.')) {
-                const crdOutput = await discovery.executeKubectl(['get', 'crd', resourceName, '-o', 'yaml']);
-                resourceDefinition = crdOutput;
-                logger.info('Found complete CRD definition for capability analysis', {
-                    requestId,
-                    sessionId: session.sessionId,
-                    resource: resourceName,
-                    hasDefinition: !!resourceDefinition,
-                    definitionSize: resourceDefinition?.length || 0
-                });
-            }
-            else {
-                // For core resources, use kubectl explain to get schema information
-                const explainOutput = await discovery.explainResource(resourceName);
-                resourceDefinition = explainOutput;
-                logger.info('Found core resource explanation for capability analysis', {
-                    requestId,
-                    sessionId: session.sessionId,
-                    resource: resourceName,
-                    hasDefinition: !!resourceDefinition
-                });
-            }
-        }
-        catch (error) {
-            logger.error('Failed to retrieve resource definition for capability analysis', error, {
-                requestId,
-                sessionId: session.sessionId,
-                resource: resourceName
-            });
-            throw new Error(createResourceDefinitionErrorMessage(resourceName, error));
-        }
-        logger.info('Analyzing resource for capability inference', {
+        const resources = session.selectedResources;
+        const totalResources = resources.length;
+        const processedResults = [];
+        const errors = [];
+        logger.info('Starting auto batch processing', {
             requestId,
             sessionId: session.sessionId,
-            resource: resourceName,
-            mode: session.processingMode
+            totalResources,
+            resources: resources
         });
-        if (session.processingMode === 'manual') {
-            // Manual mode: Show capability data for user review
-            const capability = await engine.inferCapabilities(resourceName, resourceDefinition, args.interaction_id);
-            const capabilityId = capabilities_1.CapabilityInferenceEngine.generateCapabilityId(resourceName);
-            return {
-                success: true,
-                operation: 'scan',
-                dataType: 'capabilities',
-                mode: 'manual',
-                step: 'scanning',
-                sessionId: session.sessionId,
-                preview: {
-                    resource: resourceName,
-                    resourceIndex: `${currentIndex + 1}/${totalResources}`,
-                    id: capabilityId,
-                    data: capability,
-                    question: 'Continue storing this capability?',
-                    options: [
-                        { number: 1, value: 'yes', display: '1. yes - Store this capability' },
-                        { number: 2, value: 'no', display: '2. no - Skip this resource' },
-                        { number: 3, value: 'stop', display: '3. stop - End scanning process' }
-                    ],
-                    instruction: 'Review the capability analysis results before storing',
-                    clientInstructions: {
-                        behavior: 'interactive',
-                        requirement: 'Ask user to review capability data and decide on storage',
-                        nextStep: `Call with step='scanning' and response parameter containing their choice (yes/no/stop)`,
-                        responseFormat: 'Convert user input to semantic values: 1→yes, 2→no, 3→stop'
-                    }
-                }
+        // Initialize progress tracking
+        const startTime = Date.now();
+        const updateProgress = (current, currentResource, successful, failed, recentErrors) => {
+            const elapsed = Date.now() - startTime;
+            const percentage = Math.round((current / totalResources) * 100);
+            // Calculate estimated time remaining
+            let estimatedTimeRemaining;
+            if (current > 0) {
+                const avgTimePerResource = elapsed / current;
+                const remainingResources = totalResources - current;
+                const estimatedRemainingMs = remainingResources * avgTimePerResource;
+                const estimatedMinutes = Math.round(estimatedRemainingMs / 60000 * 10) / 10;
+                estimatedTimeRemaining = estimatedMinutes > 1 ?
+                    `${estimatedMinutes} minutes` :
+                    `${Math.round(estimatedRemainingMs / 1000)} seconds`;
+            }
+            const progressData = {
+                status: 'processing',
+                current: current,
+                total: totalResources,
+                percentage: percentage,
+                currentResource: currentResource,
+                startedAt: new Date(startTime).toISOString(),
+                lastUpdated: new Date().toISOString(),
+                estimatedTimeRemaining,
+                successfulResources: successful,
+                failedResources: failed,
+                errors: recentErrors.slice(-5) // Keep last 5 errors for troubleshooting
             };
+            // Update session file with progress
+            transitionCapabilitySession(session, 'scanning', {
+                selectedResources: session.selectedResources,
+                currentResourceIndex: current - 1,
+                progress: progressData
+            }, args);
+        };
+        // Setup kubectl access for getting complete resource definitions
+        let discovery;
+        try {
+            discovery = new discovery_1.KubernetesDiscovery();
+            await discovery.connect();
+            logger.info('Connected to Kubernetes for batch resource definition retrieval', {
+                requestId,
+                sessionId: session.sessionId
+            });
         }
-        else {
-            // Auto mode: Process ALL resources in batch without user interaction
-            // At this point, selectedResources should always be an array (either discovered or specified)
-            if (!Array.isArray(session.selectedResources)) {
-                throw new Error(`Invalid selectedResources state: expected array, got ${typeof session.selectedResources}. This indicates a bug in resource discovery.`);
-            }
-            const resources = session.selectedResources;
-            const totalResources = resources.length;
-            const processedResults = [];
-            const errors = [];
-            logger.info('Starting auto batch processing', {
+        catch (error) {
+            logger.warn('Could not connect to Kubernetes for batch processing, falling back to name-based inference', {
                 requestId,
                 sessionId: session.sessionId,
-                totalResources,
-                resources: resources
+                error: error instanceof Error ? error.message : String(error)
             });
-            // Initialize progress tracking
-            const startTime = Date.now();
-            const updateProgress = (current, currentResource, successful, failed, recentErrors) => {
-                const elapsed = Date.now() - startTime;
-                const percentage = Math.round((current / totalResources) * 100);
-                // Calculate estimated time remaining
-                let estimatedTimeRemaining;
-                if (current > 0) {
-                    const avgTimePerResource = elapsed / current;
-                    const remainingResources = totalResources - current;
-                    const estimatedRemainingMs = remainingResources * avgTimePerResource;
-                    const estimatedMinutes = Math.round(estimatedRemainingMs / 60000 * 10) / 10;
-                    estimatedTimeRemaining = estimatedMinutes > 1 ?
-                        `${estimatedMinutes} minutes` :
-                        `${Math.round(estimatedRemainingMs / 1000)} seconds`;
-                }
-                const progressData = {
-                    status: 'processing',
-                    current: current,
-                    total: totalResources,
-                    percentage: percentage,
-                    currentResource: currentResource,
-                    startedAt: new Date(startTime).toISOString(),
-                    lastUpdated: new Date().toISOString(),
-                    estimatedTimeRemaining,
-                    successfulResources: successful,
-                    failedResources: failed,
-                    errors: recentErrors.slice(-5) // Keep last 5 errors for troubleshooting
-                };
-                // Update session file with progress
-                transitionCapabilitySession(session, 'scanning', {
-                    processingMode: session.processingMode,
-                    selectedResources: session.selectedResources,
-                    currentResourceIndex: current - 1,
-                    progress: progressData
-                }, args);
-            };
-            // Setup kubectl access for getting complete resource definitions
-            let discovery;
-            try {
-                discovery = new discovery_1.KubernetesDiscovery();
-                await discovery.connect();
-                logger.info('Connected to Kubernetes for batch resource definition retrieval', {
-                    requestId,
-                    sessionId: session.sessionId
-                });
-            }
-            catch (error) {
-                logger.warn('Could not connect to Kubernetes for batch processing, falling back to name-based inference', {
-                    requestId,
-                    sessionId: session.sessionId,
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
-            // Process each resource in the batch with progress tracking
-            for (let i = 0; i < resources.length; i++) {
-                const currentResource = resources[i];
-                // Get complete resource definition for this resource
-                let currentResourceDefinition;
-                if (discovery) {
+        }
+        // Process each resource in the batch with progress tracking
+        for (let i = 0; i < resources.length; i++) {
+            const currentResource = resources[i];
+            // Get complete resource definition for this resource
+            let currentResourceDefinition;
+            if (discovery) {
+                try {
+                    // Try kubectl explain with full name first (works for CRDs and core resources)
                     try {
+                        currentResourceDefinition = await discovery.explainResource(currentResource);
+                    }
+                    catch (explainError) {
+                        // If explain fails and resource has a dot (like Deployment.apps), try with just the Kind
                         if (currentResource.includes('.')) {
-                            // Get complete CRD definition
-                            currentResourceDefinition = await discovery.executeKubectl(['get', 'crd', currentResource, '-o', 'yaml']);
+                            const resourceKind = currentResource.split('.')[0];
+                            logger.info(`kubectl explain failed for ${currentResource}, attempting with Kind only: ${resourceKind}`, {
+                                requestId,
+                                sessionId: session.sessionId,
+                                resource: currentResource,
+                                resourceKind
+                            });
+                            currentResourceDefinition = await discovery.explainResource(resourceKind);
                         }
                         else {
-                            // Get core resource explanation
-                            currentResourceDefinition = await discovery.explainResource(currentResource);
+                            // Re-throw explain error for resources without dots
+                            throw explainError;
                         }
                     }
-                    catch (error) {
-                        logger.error(`Failed to get resource definition for ${currentResource}`, error, {
-                            requestId,
-                            sessionId: session.sessionId,
-                            resource: currentResource
-                        });
-                        // Add to errors array and skip processing this resource
-                        errors.push({
-                            resource: currentResource,
-                            error: createResourceDefinitionErrorMessage(currentResource, error),
-                            timestamp: new Date().toISOString()
-                        });
-                        // Skip processing this resource
-                        continue;
-                    }
                 }
-                // Update progress before processing
-                updateProgress(i + 1, currentResource, processedResults.length, errors.length, errors);
-                try {
-                    logger.info(`Processing resource ${i + 1}/${totalResources}`, {
-                        requestId,
-                        sessionId: session.sessionId,
-                        resource: currentResource,
-                        percentage: Math.round(((i + 1) / totalResources) * 100)
-                    });
-                    const capability = await engine.inferCapabilities(currentResource, currentResourceDefinition, args.interaction_id);
-                    const capabilityId = capabilities_1.CapabilityInferenceEngine.generateCapabilityId(currentResource);
-                    // Store capability in Vector DB
-                    await capabilityService.storeCapability(capability);
-                    processedResults.push({
-                        resource: currentResource,
-                        id: capabilityId,
-                        capabilities: capability.capabilities,
-                        providers: capability.providers,
-                        complexity: capability.complexity,
-                        confidence: capability.confidence
-                    });
-                    logger.info(`Successfully processed resource ${i + 1}/${totalResources}`, {
+                catch (error) {
+                    logger.error(`Failed to get resource definition for ${currentResource}`, error, {
                         requestId,
                         sessionId: session.sessionId,
-                        resource: currentResource,
-                        capabilitiesFound: capability.capabilities.length,
-                        percentage: Math.round(((i + 1) / totalResources) * 100)
+                        resource: currentResource
                     });
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    const errorDetail = {
+                    // Add to errors array and skip processing this resource
+                    errors.push({
                         resource: currentResource,
-                        error: errorMessage,
-                        index: i + 1,
+                        error: createResourceDefinitionErrorMessage(currentResource, error),
                         timestamp: new Date().toISOString()
-                    };
-                    logger.error(`Failed to process resource ${i + 1}/${totalResources}`, error, {
-                        requestId,
-                        sessionId: session.sessionId,
-                        resource: currentResource,
-                        percentage: Math.round(((i + 1) / totalResources) * 100)
                     });
-                    errors.push(errorDetail);
+                    // Skip processing this resource
+                    continue;
                 }
             }
-            // Final progress update - mark as completed
-            const finalElapsed = Date.now() - startTime;
-            const finalMinutes = Math.round(finalElapsed / 60000 * 10) / 10;
-            const successful = processedResults.length;
-            const failed = errors.length;
-            const completionData = {
-                status: 'completed',
-                current: totalResources,
-                total: totalResources,
-                percentage: 100,
-                currentResource: 'Processing complete',
-                startedAt: new Date(startTime).toISOString(),
-                lastUpdated: new Date().toISOString(),
-                completedAt: new Date().toISOString(),
-                totalProcessingTime: finalMinutes > 1 ? `${finalMinutes} minutes` : `${Math.round(finalElapsed / 1000)} seconds`,
-                successfulResources: successful,
-                failedResources: failed,
-                errors: errors.slice(-5)
-            };
-            // Update session with completion status
-            transitionCapabilitySession(session, 'complete', {
-                progress: completionData
-            }, args);
-            logger.info('Auto batch processing completed', {
-                requestId,
-                sessionId: session.sessionId,
-                processed: totalResources,
-                successful,
-                failed,
-                processingTime: completionData.totalProcessingTime
-            });
-            // Clean up session file after a brief delay to allow progress viewing
-            setTimeout(() => {
-                cleanupCapabilitySession(session, args, logger, requestId);
-            }, 30000); // Keep for 30 seconds after completion
-            return createCapabilityScanCompletionResponse(session.sessionId, totalResources, successful, failed, completionData.totalProcessingTime || 'completed', 'auto');
+            // Update progress before processing
+            updateProgress(i + 1, currentResource, processedResults.length, errors.length, errors);
+            try {
+                logger.info(`Processing resource ${i + 1}/${totalResources}`, {
+                    requestId,
+                    sessionId: session.sessionId,
+                    resource: currentResource,
+                    percentage: Math.round(((i + 1) / totalResources) * 100)
+                });
+                const capability = await engine.inferCapabilities(currentResource, currentResourceDefinition, args.interaction_id);
+                const capabilityId = capabilities_1.CapabilityInferenceEngine.generateCapabilityId(currentResource);
+                // Store capability in Vector DB
+                await capabilityService.storeCapability(capability);
+                processedResults.push({
+                    resource: currentResource,
+                    id: capabilityId,
+                    capabilities: capability.capabilities,
+                    providers: capability.providers,
+                    complexity: capability.complexity,
+                    confidence: capability.confidence
+                });
+                logger.info(`Successfully processed resource ${i + 1}/${totalResources}`, {
+                    requestId,
+                    sessionId: session.sessionId,
+                    resource: currentResource,
+                    capabilitiesFound: capability.capabilities.length,
+                    percentage: Math.round(((i + 1) / totalResources) * 100)
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const errorDetail = {
+                    resource: currentResource,
+                    error: errorMessage,
+                    index: i + 1,
+                    timestamp: new Date().toISOString()
+                };
+                logger.error(`Failed to process resource ${i + 1}/${totalResources}`, error, {
+                    requestId,
+                    sessionId: session.sessionId,
+                    resource: currentResource,
+                    percentage: Math.round(((i + 1) / totalResources) * 100)
+                });
+                errors.push(errorDetail);
+            }
         }
+        // Final progress update - mark as completed
+        const finalElapsed = Date.now() - startTime;
+        const finalMinutes = Math.round(finalElapsed / 60000 * 10) / 10;
+        const successful = processedResults.length;
+        const failed = errors.length;
+        const completionData = {
+            status: 'completed',
+            current: totalResources,
+            total: totalResources,
+            percentage: 100,
+            currentResource: 'Processing complete',
+            startedAt: new Date(startTime).toISOString(),
+            lastUpdated: new Date().toISOString(),
+            completedAt: new Date().toISOString(),
+            totalProcessingTime: finalMinutes > 1 ? `${finalMinutes} minutes` : `${Math.round(finalElapsed / 1000)} seconds`,
+            successfulResources: successful,
+            failedResources: failed,
+            errors: errors.slice(-5)
+        };
+        // Update session with completion status
+        transitionCapabilitySession(session, 'complete', {
+            progress: completionData
+        }, args);
+        logger.info('Auto batch processing completed', {
+            requestId,
+            sessionId: session.sessionId,
+            processed: totalResources,
+            successful,
+            failed,
+            processingTime: completionData.totalProcessingTime
+        });
+        // Clean up session file after a brief delay to allow progress viewing
+        setTimeout(() => {
+            cleanupCapabilitySession(session, args, logger, requestId);
+        }, 30000); // Keep for 30 seconds after completion
+        return createCapabilityScanCompletionResponse(session.sessionId, totalResources, successful, failed, completionData.totalProcessingTime || 'completed', 'auto');
     }
     catch (error) {
         logger.error('Capability scanning failed', error, {