@vfarcic/dot-ai 0.150.0 → 0.152.0

package/dist/tools/deploy-manifests.js

@@ -1,6 +1,7 @@
 "use strict";
 /**
- * Deploy Manifests Tool - Apply Kubernetes manifests with readiness checking
+ * Deploy Manifests Tool - Apply Kubernetes manifests or execute Helm installations
+ * Supports both capability-based solutions (kubectl apply) and Helm-based solutions (helm install)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEPLOYMANIFESTS_TOOL_INPUT_SCHEMA = exports.DEPLOYMANIFESTS_TOOL_DESCRIPTION = exports.DEPLOYMANIFESTS_TOOL_NAME = void 0;
@@ -9,6 +10,9 @@ const zod_1 = require("zod");
 const error_handling_1 = require("../core/error-handling");
 const deploy_operation_1 = require("../core/deploy-operation");
 const cluster_utils_1 = require("../core/cluster-utils");
+const generic_session_manager_1 = require("../core/generic-session-manager");
+const solution_utils_1 = require("../core/solution-utils");
+const helm_utils_1 = require("../core/helm-utils");
 // Tool metadata for direct MCP registration
 exports.DEPLOYMANIFESTS_TOOL_NAME = 'deployManifests';
 exports.DEPLOYMANIFESTS_TOOL_DESCRIPTION = 'Deploy Kubernetes manifests from generated solution with kubectl apply --wait';
@@ -31,10 +35,89 @@ async function handleDeployManifestsTool(args, dotAI, logger, requestId) {
         // args are already validated and typed when we reach this point
         // Ensure cluster connectivity before proceeding
         await (0, cluster_utils_1.ensureClusterConnection)(dotAI, logger, requestId, 'DeployManifestsTool');
+        // Load solution session to determine solution type
+        const sessionManager = new generic_session_manager_1.GenericSessionManager('sol');
+        const session = sessionManager.getSession(args.solutionId);
+        if (!session) {
+            throw new Error(`Solution not found: ${args.solutionId}`);
+        }
+        const solution = session.data;
+        const timeout = args.timeout || 30;
+        logger.debug('Solution loaded successfully', {
+            solutionId: args.solutionId,
+            solutionType: solution.type
+        });
+        // Branch based on solution type
+        if (solution.type === 'helm') {
+            logger.info('Detected Helm solution, using Helm deployment flow', {
+                solutionId: args.solutionId,
+                chart: solution.chart ? `${solution.chart.repositoryName}/${solution.chart.chartName}` : 'unknown'
+            });
+            if (!solution.chart) {
+                throw new Error('Helm solution missing chart information');
+            }
+            const chart = solution.chart;
+            const userAnswers = (0, solution_utils_1.extractUserAnswers)(solution);
+            const releaseName = userAnswers.name;
+            const namespace = userAnswers.namespace || 'default';
+            if (!releaseName) {
+                throw new Error('Release name (name) is required for Helm deployment');
+            }
+            // Get values path if values file exists
+            const valuesPath = (0, helm_utils_1.helmValuesExist)(args.solutionId)
+                ? (0, helm_utils_1.getHelmValuesPath)(args.solutionId)
+                : undefined;
+            logger.info('Starting Helm deployment', {
+                solutionId: args.solutionId,
+                chart: `${chart.repositoryName}/${chart.chartName}`,
+                releaseName,
+                namespace,
+                hasValuesFile: !!valuesPath,
+                timeout,
+                requestId
+            });
+            const result = await (0, helm_utils_1.deployHelmRelease)(chart, releaseName, namespace, valuesPath, timeout);
+            logger.info('Helm deployment completed', {
+                success: result.success,
+                solutionId: args.solutionId,
+                releaseName,
+                namespace,
+                requestId
+            });
+            const response = {
+                success: result.success,
+                solutionId: args.solutionId,
+                solutionType: 'helm',
+                releaseName,
+                namespace,
+                chart: {
+                    repository: chart.repository,
+                    repositoryName: chart.repositoryName,
+                    chartName: chart.chartName,
+                    version: chart.version
+                },
+                message: result.success
+                    ? `Helm release "${releaseName}" deployed successfully to namespace "${namespace}"`
+                    : `Helm deployment failed: ${result.error}`,
+                helmOutput: result.output || result.error,
+                deploymentComplete: result.success,
+                timestamp: new Date().toISOString()
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(response, null, 2)
+                    }]
+            };
+        }
+        // Capability-based solution: Use existing DeployOperation
+        logger.info('Using capability-based deployment flow', {
+            solutionId: args.solutionId
+        });
         const deployOp = new deploy_operation_1.DeployOperation();
         const deployOptions = {
             solutionId: args.solutionId,
-            timeout: args.timeout || 30
+            timeout
         };
         logger.info('Starting deployment operation', {
             solutionId: args.solutionId,
@@ -53,6 +136,7 @@ async function handleDeployManifestsTool(args, dotAI, logger, requestId) {
         const response = {
             success: result.success,
             solutionId: result.solutionId,
+            solutionType: 'capability',
             manifestPath: result.manifestPath,
             readinessTimeout: result.readinessTimeout,
             message: result.message,

package/dist/tools/generate-manifests.d.ts

@@ -1,5 +1,6 @@
 /**
  * Generate Manifests Tool - AI-driven manifest generation with validation loop
+ * Supports both capability-based solutions (K8s manifests) and Helm-based solutions (values.yaml)
  */
 import { z } from 'zod';
 import { DotAI } from '../core/index';

package/dist/tools/generate-manifests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-manifests.d.ts","sourceRoot":"","sources":["../../src/tools/generate-manifests.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,EAA2B,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAehD,eAAO,MAAM,2BAA2B,sBAAsB,CAAC;AAC/D,eAAO,MAAM,kCAAkC,+IAA+I,CAAC;AAG/L,eAAO,MAAM,mCAAmC;;;CAG/C,CAAC;AAsMF;;GAEG;AACH,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,EACrD,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,CAAC,CAqNxD"}
+{"version":3,"file":"generate-manifests.d.ts","sourceRoot":"","sources":["../../src/tools/generate-manifests.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,EAA2B,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAsBhD,eAAO,MAAM,2BAA2B,sBAAsB,CAAC;AAC/D,eAAO,MAAM,kCAAkC,+IAA+I,CAAC;AAG/L,eAAO,MAAM,mCAAmC;;;CAG/C,CAAC;AAmdF;;GAEG;AACH,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,EACrD,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,CAAC,CA2OxD"}

package/dist/tools/generate-manifests.js

@@ -1,6 +1,7 @@
 "use strict";
 /**
  * Generate Manifests Tool - AI-driven manifest generation with validation loop
+ * Supports both capability-based solutions (K8s manifests) and Helm-based solutions (values.yaml)
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -52,6 +53,7 @@ const solution_utils_1 = require("../core/solution-utils");
 const platform_utils_1 = require("../core/platform-utils");
 const crd_availability_1 = require("../core/crd-availability");
 const solution_cr_1 = require("../core/solution-cr");
+const helm_utils_1 = require("../core/helm-utils");
 // Tool metadata for direct MCP registration
 exports.GENERATEMANIFESTS_TOOL_NAME = 'generateManifests';
 exports.GENERATEMANIFESTS_TOOL_DESCRIPTION = 'Generate final Kubernetes manifests from fully configured solution (ONLY after completing ALL stages: required, basic, advanced, and open)';
@@ -180,7 +182,7 @@ ${errorContext.previousManifests}
     // Prepare template variables
     const schemasData = JSON.stringify(resourceSchemas, null, 2);
     const labelsData = dotAiLabels ? JSON.stringify(dotAiLabels, null, 2) : '{}';
-    const aiPrompt = (0, shared_prompt_loader_1.loadPrompt)('manifest-generation', {
+    const aiPrompt = (0, shared_prompt_loader_1.loadPrompt)('capabilities-generation', {
         solution: solutionData,
         schemas: schemasData,
         previous_attempt: previousAttempt,
@@ -211,6 +213,194 @@ ${errorContext.previousManifests}
     });
     return manifestContent;
 }
+/**
+ * Generate Helm values.yaml using AI provider
+ */
+async function generateHelmValuesWithAI(solution, solutionId, dotAI, logger, errorContext, interaction_id) {
+    // Fetch chart values.yaml for reference
+    const chart = solution.chart;
+    const { valuesYaml } = await dotAI.schema.fetchHelmChartContent(chart);
+    // Prepare template variables
+    const solutionData = JSON.stringify(solution, null, 2);
+    const previousAttempt = errorContext ? `
+### Generated Values:
+\`\`\`yaml
+${errorContext.previousValues}
+\`\`\`
+` : 'None - this is the first attempt.';
+    const errorDetails = errorContext ? `
+**Attempt**: ${errorContext.attempt}
+**Validation Errors**: ${errorContext.validationResult.errors.join(', ')}
+**Validation Warnings**: ${errorContext.validationResult.warnings.join(', ')}
+` : 'None - this is the first attempt.';
+    const aiPrompt = (0, shared_prompt_loader_1.loadPrompt)('helm-generation', {
+        solution: solutionData,
+        chart_values: valuesYaml || '# No default values available',
+        previous_attempt: previousAttempt,
+        error_details: errorDetails
+    });
+    const isRetry = !!errorContext;
+    logger.info('Generating Helm values with AI', {
+        isRetry,
+        attempt: errorContext?.attempt,
+        hasErrorContext: !!errorContext,
+        solutionId,
+        chart: `${chart.repositoryName}/${chart.chartName}`
+    });
+    // Get AI provider from dotAI
+    const aiProvider = dotAI.ai;
+    // Send prompt to AI
+    const response = await aiProvider.sendMessage(aiPrompt, 'helm-values-generation', {
+        user_intent: solution.intent || 'Helm chart installation',
+        interaction_id: interaction_id
+    });
+    // Extract YAML content from response
+    const valuesContent = (0, platform_utils_1.extractContentFromMarkdownCodeBlocks)(response.content, 'yaml');
+    logger.info('AI Helm values generation completed', {
+        valuesLength: valuesContent.length,
+        isRetry,
+        solutionId
+    });
+    return valuesContent;
+}
+/**
+ * Validate Helm installation using dry-run (wrapper around shared utility)
+ */
+async function validateHelmInstallation(chart, releaseName, namespace, valuesPath, logger) {
+    logger.info('Running Helm dry-run validation', {
+        chart: `${chart.repositoryName}/${chart.chartName}`,
+        releaseName,
+        namespace
+    });
+    const result = await (0, helm_utils_1.validateHelmDryRun)(chart, releaseName, namespace, valuesPath);
+    if (result.success) {
+        logger.info('Helm dry-run validation successful');
+        return {
+            valid: true,
+            errors: [],
+            warnings: []
+        };
+    }
+    logger.warn('Helm dry-run validation failed', { error: result.error });
+    return {
+        valid: false,
+        errors: [result.error || 'Unknown Helm validation error'],
+        warnings: []
+    };
+}
+/**
+ * Handle Helm solution generation
+ */
+async function handleHelmGeneration(solution, solutionId, dotAI, logger, requestId, interaction_id) {
+    const maxAttempts = 10;
+    const chart = solution.chart;
+    const userAnswers = (0, solution_utils_1.extractUserAnswers)(solution);
+    // Extract release name and namespace from answers
+    const releaseName = userAnswers.name;
+    const namespace = userAnswers.namespace || 'default';
+    if (!releaseName) {
+        throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.VALIDATION, error_handling_1.ErrorSeverity.HIGH, 'Release name (name) is required for Helm installation', {
+            operation: 'helm_generation',
+            component: 'GenerateManifestsTool',
+            requestId,
+            suggestedActions: ['Ensure the "name" question was answered in the configuration']
+        });
+    }
+    // Prepare file paths using shared utilities
+    (0, helm_utils_1.ensureTmpDir)();
+    const valuesPath = (0, helm_utils_1.getHelmValuesPath)(solutionId);
+    // AI generation and validation loop
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        logger.info('Helm values generation attempt', {
+            attempt,
+            maxAttempts,
+            isRetry: attempt > 1,
+            requestId,
+            chart: `${chart.repositoryName}/${chart.chartName}`
+        });
+        try {
+            // Generate values.yaml with AI
+            const valuesYaml = await generateHelmValuesWithAI(solution, solutionId, dotAI, logger, lastError, interaction_id);
+            // Save values to file
+            fs.writeFileSync(valuesPath, valuesYaml, 'utf8');
+            logger.info('Helm values saved to file', { valuesPath, attempt, requestId });
+            // Save attempt for debugging
+            const attemptPath = valuesPath.replace('.yaml', `_attempt_${attempt.toString().padStart(2, '0')}.yaml`);
+            fs.writeFileSync(attemptPath, valuesYaml, 'utf8');
+            // Validate with helm dry-run
+            const validation = await validateHelmInstallation(chart, releaseName, namespace, valuesPath, logger);
+            if (validation.valid) {
+                logger.info('Helm validation successful', {
+                    attempt,
+                    valuesPath,
+                    requestId
+                });
+                // Build user-friendly helm command with generic values file path
+                // (internal valuesPath is used for actual execution, not shown to user)
+                const helmCommand = (0, helm_utils_1.buildHelmCommand)(chart, releaseName, namespace, 'values.yaml');
+                // Check if we should show feedback message
+                const feedbackMessage = (0, index_1.maybeGetFeedbackMessage)();
+                const response = {
+                    success: true,
+                    status: 'helm_command_generated',
+                    solutionId: solutionId,
+                    solutionType: 'helm',
+                    helmCommand: helmCommand,
+                    valuesYaml: valuesYaml,
+                    chart: {
+                        repository: chart.repository,
+                        repositoryName: chart.repositoryName,
+                        chartName: chart.chartName,
+                        version: chart.version
+                    },
+                    releaseName: releaseName,
+                    namespace: namespace,
+                    validationAttempts: attempt,
+                    timestamp: new Date().toISOString(),
+                    ...(feedbackMessage ? { message: feedbackMessage } : {})
+                };
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(response, null, 2)
+                        }]
+                };
+            }
+            // Validation failed, prepare error context for next attempt
+            lastError = {
+                attempt,
+                previousValues: valuesYaml,
+                validationResult: validation
+            };
+            logger.warn('Helm validation failed', {
+                attempt,
+                maxAttempts,
+                validationErrors: validation.errors,
+                validationWarnings: validation.warnings,
+                requestId
+            });
+        }
+        catch (error) {
+            logger.error('Error during Helm values generation attempt', error);
+            if (attempt === maxAttempts) {
+                throw error;
+            }
+            // Prepare error context for retry
+            lastError = {
+                attempt,
+                previousValues: lastError?.previousValues || '',
+                validationResult: {
+                    valid: false,
+                    errors: [error instanceof Error ? error.message : String(error)],
+                    warnings: []
+                }
+            };
+        }
+    }
+    // All attempts failed
+    throw new Error(`Failed to generate valid Helm values after ${maxAttempts} attempts. Last errors: ${lastError?.validationResult.errors.join(', ')}`);
+}
 /**
  * Direct MCP tool handler for generateManifests functionality
  */
@@ -247,9 +437,22 @@ async function handleGenerateManifestsTool(args, dotAI, logger, requestId) {
         const solution = session.data;
         logger.debug('Solution loaded successfully', {
             solutionId: args.solutionId,
+            solutionType: solution.type,
             hasQuestions: !!solution.questions,
             primaryResources: solution.resources
         });
+        // Branch based on solution type
+        if (solution.type === 'helm') {
+            logger.info('Detected Helm solution, using Helm generation flow', {
+                solutionId: args.solutionId,
+                chart: solution.chart ? `${solution.chart.repositoryName}/${solution.chart.chartName}` : 'unknown'
+            });
+            return await handleHelmGeneration(solution, args.solutionId, dotAI, logger, requestId, args.interaction_id);
+        }
+        // Capability-based solution: Generate Kubernetes manifests
+        logger.info('Using capability-based manifest generation flow', {
+            solutionId: args.solutionId
+        });
         // Prepare file path for manifests (store in tmp directory)
         const tmpDir = path.join(process.cwd(), 'tmp');
         if (!fs.existsSync(tmpDir)) {

package/dist/tools/recommend.d.ts

@@ -4,6 +4,7 @@
 import { z } from 'zod';
 import { DotAI } from '../core/index';
 import { Logger } from '../core/error-handling';
+import { HelmChartInfo } from '../core/helm-types';
 export declare const RECOMMEND_TOOL_NAME = "recommend";
 export declare const RECOMMEND_TOOL_DESCRIPTION = "Deploy applications, infrastructure, and services using Kubernetes resources with AI recommendations. Supports cloud resources via operators like Crossplane, cluster management via CAPI, and traditional Kubernetes workloads. Describe what you want to deploy. Does NOT handle policy creation, organizational patterns, or resource capabilities - use manageOrgData for those.";
 export declare const RECOMMEND_TOOL_INPUT_SCHEMA: {
@@ -21,13 +22,13 @@ export interface SolutionData {
     score: number;
     description: string;
     reasons: string[];
-    analysis: string;
-    resources: Array<{
+    resources?: Array<{
         kind: string;
         apiVersion: string;
         group: string;
         description: string;
     }>;
+    chart?: HelmChartInfo;
     questions: {
         required?: any[];
         basic?: any[];

package/dist/tools/recommend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recommend.d.ts","sourceRoot":"","sources":["../../src/tools/recommend.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAWhD,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAC/C,eAAO,MAAM,0BAA0B,yXAAyX,CAAC;AAGja,eAAO,MAAM,2BAA2B;;;;;;;;CAWvC,CAAC;AAGF,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,KAAK,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;IACH,SAAS,EAAE;QACT,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;QACjB,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC;QACd,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,CAAC;QACX,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;KAC7B,CAAC;IACF,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAuED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,GAAG,EACT,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,CAAC,CAgPxD"}
+{"version":3,"file":"recommend.d.ts","sourceRoot":"","sources":["../../src/tools/recommend.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAUhD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGnD,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAC/C,eAAO,MAAM,0BAA0B,yXAAyX,CAAC;AAGja,eAAO,MAAM,2BAA2B;;;;;;;;CAWvC,CAAC;AAIF,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAElB,SAAS,CAAC,EAAE,KAAK,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;IAEH,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,SAAS,EAAE;QACT,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;QACjB,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC;QACd,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,CAAC;QACX,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;KAC7B,CAAC;IACF,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAuED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,GAAG,EACT,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,CAAC,CAuXxD"}

package/dist/tools/recommend.js

@@ -16,6 +16,7 @@ const generate_manifests_1 = require("./generate-manifests");
 const deploy_manifests_1 = require("./deploy-manifests");
 const shared_prompt_loader_1 = require("../core/shared-prompt-loader");
 const platform_utils_1 = require("../core/platform-utils");
+const artifacthub_1 = require("../core/artifacthub");
 // Tool metadata for direct MCP registration
 exports.RECOMMEND_TOOL_NAME = 'recommend';
 exports.RECOMMEND_TOOL_DESCRIPTION = 'Deploy applications, infrastructure, and services using Kubernetes resources with AI recommendations. Supports cloud resources via operators like Crossplane, cluster management via CAPI, and traditional Kubernetes workloads. Describe what you want to deploy. Does NOT handle policy creation, organizational patterns, or resource capabilities - use manageOrgData for those.';
@@ -187,7 +188,121 @@ async function handleRecommendTool(args, dotAI, logger, requestId) {
         };
         // Find best solutions for the user intent
         logger.debug('Generating recommendations with AI', { requestId });
-        const solutions = await recommender.findBestSolutions(args.intent, explainResourceFn, args.interaction_id);
+        const solutionResult = await recommender.findBestSolutions(args.intent, explainResourceFn, args.interaction_id);
+        // Handle Helm recommendation case
+        if (solutionResult.helmRecommendation) {
+            logger.info('Helm installation recommended, searching ArtifactHub', {
+                requestId,
+                suggestedTool: solutionResult.helmRecommendation.suggestedTool,
+                searchQuery: solutionResult.helmRecommendation.searchQuery,
+                reason: solutionResult.helmRecommendation.reason
+            });
+            // Search ArtifactHub for matching charts
+            const artifactHub = new artifacthub_1.ArtifactHubService();
+            const charts = await artifactHub.searchCharts(solutionResult.helmRecommendation.searchQuery, 10 // Get top 10 results for AI to analyze
+            );
+            if (charts.length === 0) {
+                // No charts found on ArtifactHub
+                logger.warn('No charts found on ArtifactHub', { requestId, searchQuery: solutionResult.helmRecommendation.searchQuery });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                status: 'no_charts_found',
+                                searchQuery: solutionResult.helmRecommendation.searchQuery,
+                                reason: solutionResult.helmRecommendation.reason,
+                                message: `No Helm charts found on ArtifactHub for "${solutionResult.helmRecommendation.suggestedTool}". We currently only support charts available on ArtifactHub. If you need support for charts from other sources, please open an issue at https://github.com/vfarcic/dot-ai/issues/new`
+                            }, null, 2)
+                        }]
+                };
+            }
+            // Format charts for AI analysis
+            const chartsText = artifactHub.formatChartsForAI(charts);
+            // Load prompt and send to AI for chart selection
+            const chartSelectionPrompt = (0, shared_prompt_loader_1.loadPrompt)('helm-chart-selection', {
+                intent: args.intent,
+                charts: chartsText
+            });
+            const aiResponse = await dotAI.ai.sendMessage(chartSelectionPrompt, 'recommend-helm-chart-selection', {
+                user_intent: args.intent,
+                interaction_id: args.interaction_id
+            });
+            // Parse AI response
+            const aiSelection = (0, platform_utils_1.extractJsonFromAIResponse)(aiResponse.content);
+            if (!aiSelection.solutions || aiSelection.solutions.length === 0) {
+                // AI couldn't find matching charts
+                logger.warn('AI found no matching charts', { requestId, noMatchReason: aiSelection.noMatchReason });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                status: 'no_matching_charts',
+                                reason: aiSelection.noMatchReason || 'No charts matched the user intent',
+                                searchQuery: solutionResult.helmRecommendation.searchQuery,
+                                instruction: 'Consider refining your request or manually specifying a Helm chart.'
+                            }, null, 2)
+                        }]
+                };
+            }
+            // Create sessions for Helm solutions
+            const timestamp = new Date().toISOString();
+            const helmSolutionSummaries = [];
+            for (const aiSolution of aiSelection.solutions) {
+                // Find the original chart data from ArtifactHub results
+                const originalChart = charts.find(c => c.name === aiSolution.chartName);
+                const solutionData = {
+                    intent: args.intent,
+                    type: 'helm',
+                    score: aiSolution.score,
+                    description: aiSolution.description,
+                    reasons: aiSolution.reasons,
+                    chart: {
+                        repository: aiSolution.repositoryUrl,
+                        repositoryName: aiSolution.repositoryName,
+                        chartName: aiSolution.chartName,
+                        version: aiSolution.version,
+                        appVersion: aiSolution.appVersion,
+                        official: originalChart?.official || originalChart?.repository?.official,
+                        verifiedPublisher: originalChart?.verified_publisher || originalChart?.repository?.verified_publisher
+                    },
+                    questions: { required: [], basic: [], advanced: [] }, // Will be generated from chart values later
+                    answers: {},
+                    timestamp
+                };
+                const session = sessionManager.createSession(solutionData);
+                const solutionId = session.sessionId;
+                logger.debug('Helm solution session created', { requestId, solutionId });
+                helmSolutionSummaries.push({
+                    solutionId,
+                    type: 'helm',
+                    score: aiSolution.score,
+                    description: aiSolution.description,
+                    chart: solutionData.chart,
+                    reasons: aiSolution.reasons
+                });
+            }
+            // Build Helm solutions response
+            const helmResponse = {
+                intent: args.intent,
+                solutions: helmSolutionSummaries,
+                helmInstallation: true,
+                nextAction: 'Call recommend tool with stage: chooseSolution and your preferred solutionId',
+                guidance: '🔴 CRITICAL: Present these Helm chart options to the user and ask them to choose. DO NOT automatically call chooseSolution() without user input. Show the chart details (repository, version, official status) to help users decide.',
+                timestamp
+            };
+            logger.info('Helm solutions prepared', {
+                requestId,
+                solutionCount: helmSolutionSummaries.length,
+                topScore: helmSolutionSummaries[0]?.score
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(helmResponse, null, 2)
+                    }]
+            };
+        }
+        const solutions = solutionResult.solutions;
         logger.info('Recommendation process completed', {
             requestId,
             solutionCount: solutions.length,
@@ -206,7 +321,6 @@ async function handleRecommendTool(args, dotAI, logger, requestId) {
                 score: solution.score,
                 description: solution.description,
                 reasons: solution.reasons,
-                analysis: solution.analysis,
                 resources: solution.resources.map(r => ({
                     kind: r.kind,
                     apiVersion: r.apiVersion,
@@ -236,7 +350,6 @@ async function handleRecommendTool(args, dotAI, logger, requestId) {
                     description: r.description?.split('\n')[0] || `${r.kind} resource` // Use first line of description or fallback
                 })),
                 reasons: solution.reasons,
-                analysis: solution.analysis,
                 appliedPatterns: solution.appliedPatterns || [],
                 relevantPolicies: solution.questions?.relevantPolicies || []
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vfarcic/dot-ai",
-  "version": "0.150.0",
+  "version": "0.152.0",
   "description": "AI-powered development productivity platform that enhances software development workflows through intelligent automation and AI-driven assistance",
   "mcpName": "io.github.vfarcic/dot-ai",
   "main": "dist/index.js",
@@ -18,16 +18,16 @@
     "test:integration:server": "KUBECONFIG=./kubeconfig-test.yaml PORT=3456 DOT_AI_SESSION_DIR=./tmp/sessions TRANSPORT_TYPE=http QDRANT_URL=http://localhost:6335 QDRANT_CAPABILITIES_COLLECTION=capabilities-policies ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY OPENAI_API_KEY=$OPENAI_API_KEY node dist/mcp/server.js",
     "test:integration": "./tests/integration/infrastructure/run-integration-tests.sh",
     "test:integration:watch": "vitest --config=vitest.integration.config.ts --test-timeout=1200000",
-    "test:integration:sonnet": "AI_PROVIDER=anthropic AI_PROVIDER_SDK=vercel DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
-    "test:integration:opus": "AI_PROVIDER=anthropic_opus AI_PROVIDER_SDK=vercel DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
-    "test:integration:haiku": "AI_PROVIDER=anthropic_haiku AI_PROVIDER_SDK=vercel DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
-    "test:integration:gpt": "AI_PROVIDER=openai AI_PROVIDER_SDK=vercel DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
-    "test:integration:gemini": "AI_PROVIDER=google AI_PROVIDER_SDK=vercel DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
-    "test:integration:grok": "AI_PROVIDER=xai AI_PROVIDER_SDK=vercel DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
-    "test:integration:kimi": "AI_PROVIDER=kimi AI_PROVIDER_SDK=vercel DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
-    "test:integration:kimi-thinking": "AI_PROVIDER=kimi_thinking AI_PROVIDER_SDK=vercel DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
-    "test:integration:bedrock": "AI_PROVIDER=amazon_bedrock AI_MODEL=global.anthropic.claude-sonnet-4-20250514-v1:0 AI_PROVIDER_SDK=vercel DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
-    "test:integration:custom-endpoint": "AI_PROVIDER=openai AI_PROVIDER_SDK=vercel DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
+    "test:integration:sonnet": "AI_PROVIDER=anthropic DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
+    "test:integration:opus": "AI_PROVIDER=anthropic_opus DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
+    "test:integration:haiku": "AI_PROVIDER=anthropic_haiku DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
+    "test:integration:gpt": "AI_PROVIDER=openai DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
+    "test:integration:gemini": "AI_PROVIDER=google DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
+    "test:integration:grok": "AI_PROVIDER=xai DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
+    "test:integration:kimi": "AI_PROVIDER=kimi DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
+    "test:integration:kimi-thinking": "AI_PROVIDER=kimi_thinking DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
+    "test:integration:bedrock": "AI_PROVIDER=amazon_bedrock AI_MODEL=global.anthropic.claude-sonnet-4-20250514-v1:0 DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
+    "test:integration:custom-endpoint": "AI_PROVIDER=openai DEBUG_DOT_AI=true ./tests/integration/infrastructure/run-integration-tests.sh",
     "eval:comparative": "DEBUG_DOT_AI=true npx tsx src/evaluation/eval-runner.ts",
     "eval:platform-synthesis": "DEBUG_DOT_AI=true npx tsx src/evaluation/run-platform-synthesis.ts",
     "clean": "rm -rf dist",
@@ -100,7 +100,6 @@
     "@ai-sdk/google": "^2.0.17",
     "@ai-sdk/openai": "^2.0.42",
     "@ai-sdk/xai": "^2.0.26",
-    "@anthropic-ai/sdk": "^0.65.0",
     "@kubernetes/client-node": "^1.3.0",
     "@modelcontextprotocol/sdk": "^1.13.2",
     "@openrouter/ai-sdk-provider": "^1.2.0",