@vfarcic/dot-ai 0.66.0 → 0.67.0

package/dist/core/claude.d.ts

@@ -20,6 +20,29 @@ export interface Interaction {
     success: boolean;
     timestamp?: Date;
 }
+export type ImpactLevel = 'HIGH' | 'MEDIUM' | 'LOW';
+export type ClarificationCategory = 'TECHNICAL_SPECIFICATIONS' | 'ARCHITECTURAL_CONTEXT' | 'OPERATIONAL_REQUIREMENTS' | 'SECURITY_COMPLIANCE' | 'ORGANIZATIONAL_ALIGNMENT';
+export interface ClarificationOpportunity {
+    category: ClarificationCategory;
+    missingContext: string;
+    impactLevel: ImpactLevel;
+    reasoning: string;
+    suggestedQuestions?: string[];
+    patternAlignment?: string;
+}
+export interface IntentAnalysisResult {
+    clarificationOpportunities: ClarificationOpportunity[];
+    overallAssessment: {
+        enhancementPotential: ImpactLevel;
+        primaryGaps: string[];
+        recommendedFocus: string;
+    };
+    intentQuality: {
+        currentSpecificity: string;
+        strengthAreas: string[];
+        improvementAreas: string[];
+    };
+}
 export declare class ClaudeIntegration {
     private client;
     private apiKey;
@@ -50,6 +73,14 @@ export declare class ClaudeIntegration {
     analyzeError(error: string, _context?: any): Promise<string>;
     suggestImprovements(_manifest: string): Promise<string[]>;
     processUserInput(input: string, context?: any): Promise<any>;
+    /**
+     * Analyze user intent for clarification opportunities
+     *
+     * @param intent User's deployment intent
+     * @param organizationalPatterns Available organizational patterns context
+     * @returns Analysis result with clarification opportunities
+     */
+    analyzeIntentForClarification(intent: string, organizationalPatterns?: string): Promise<IntentAnalysisResult>;
     isInitialized(): boolean;
 }
 //# sourceMappingURL=claude.d.ts.map

package/dist/core/claude.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../src/core/claude.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE;QACL,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,IAAI,CAAC;CAClB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,SAAS,CAAU;gBAEf,MAAM,EAAE,MAAM;IAY1B,OAAO,CAAC,cAAc;IActB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAQ5B;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA+BrB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,MAAkB,GAAG,OAAO,CAAC,cAAc,CAAC;IA+EpF,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,YAAY,CAAC;IA6CtE,iBAAiB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAS1D,qBAAqB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAIrD,sBAAsB,IAAI,GAAG,EAAE;IAI/B,wBAAwB,IAAI,IAAI;IAI1B,gBAAgB,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IA+B5C,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IAS5D,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAazD,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IA2BlE,aAAa,IAAI,OAAO;CAGzB"}
+{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../src/core/claude.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE;QACL,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,IAAI,CAAC;CAClB;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AACpD,MAAM,MAAM,qBAAqB,GAC7B,0BAA0B,GAC1B,uBAAuB,GACvB,0BAA0B,GAC1B,qBAAqB,GACrB,0BAA0B,CAAC;AAE/B,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,qBAAqB,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,oBAAoB;IACnC,0BAA0B,EAAE,wBAAwB,EAAE,CAAC;IACvD,iBAAiB,EAAE;QACjB,oBAAoB,EAAE,WAAW,CAAC;QAClC,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,gBAAgB,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,aAAa,EAAE;QACb,kBAAkB,EAAE,MAAM,CAAC;QAC3B,aAAa,EAAE,MAAM,EAAE,CAAC;QACxB,gBAAgB,EAAE,MAAM,EAAE,CAAC;KAC5B,CAAC;CACH;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,SAAS,CAAU;gBAEf,MAAM,EAAE,MAAM;IAY1B,OAAO,CAAC,cAAc;IActB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAQ5B;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA+BrB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,MAAkB,GAAG,OAAO,CAAC,cAAc,CAAC;IA+EpF,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,YAAY,CAAC;IA6CtE,iBAAiB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAS1D,qBAAqB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAIrD,sBAAsB,IAAI,GAAG,EAAE;IAI/B,wBAAwB,IAAI,IAAI;IAI1B,gBAAgB,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IA+B5C,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IAS5D,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAazD,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IA2BlE;;;;;;OAMG;IACG,6BAA6B,CAAC,MAAM,EAAE,MAAM,EAAE,sBAAsB,GAAE,MAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAkEvH,aAAa,IAAI,OAAO;CAGzB"}

package/dist/core/claude.js

@@ -318,6 +318,70 @@ spec:
             suggestions: ['Start by exploring your cluster resources']
         };
     }
+    /**
+     * Analyze user intent for clarification opportunities
+     *
+     * @param intent User's deployment intent
+     * @param organizationalPatterns Available organizational patterns context
+     * @returns Analysis result with clarification opportunities
+     */
+    async analyzeIntentForClarification(intent, organizationalPatterns = '') {
+        if (!this.client) {
+            throw new Error('Claude client not initialized');
+        }
+        try {
+            // Load intent analysis prompt template
+            const promptPath = path.join(__dirname, '..', '..', 'prompts', 'intent-analysis.md');
+            const template = fs.readFileSync(promptPath, 'utf8');
+            // Replace template variables
+            const analysisPrompt = template
+                .replaceAll('{intent}', intent)
+                .replaceAll('{organizational_patterns}', organizationalPatterns || 'No specific organizational patterns available');
+            // Send to Claude for analysis
+            const response = await this.sendMessage(analysisPrompt, 'intent-analysis');
+            // Parse JSON response with robust error handling
+            let jsonContent = response.content;
+            // Try to find JSON object wrapped in code blocks
+            const codeBlockMatch = response.content.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
+            if (codeBlockMatch) {
+                jsonContent = codeBlockMatch[1];
+            }
+            else {
+                // Try to find JSON object that starts with { and find the matching closing }
+                const jsonMatch = response.content.match(/\{[\s\S]*\}/);
+                if (jsonMatch) {
+                    jsonContent = jsonMatch[0];
+                }
+            }
+            // Parse the JSON
+            const analysisResult = JSON.parse(jsonContent);
+            // Validate the response structure
+            if (!analysisResult.clarificationOpportunities || !Array.isArray(analysisResult.clarificationOpportunities)) {
+                throw new Error('Invalid analysis result structure: missing clarificationOpportunities array');
+            }
+            if (!analysisResult.overallAssessment || !analysisResult.intentQuality) {
+                throw new Error('Invalid analysis result structure: missing overallAssessment or intentQuality');
+            }
+            return analysisResult;
+        }
+        catch (error) {
+            // If parsing fails or API call fails, return a fallback minimal analysis
+            console.warn('Intent analysis failed, returning minimal analysis:', error);
+            return {
+                clarificationOpportunities: [],
+                overallAssessment: {
+                    enhancementPotential: 'LOW',
+                    primaryGaps: [],
+                    recommendedFocus: 'Proceed with original intent - analysis unavailable'
+                },
+                intentQuality: {
+                    currentSpecificity: 'Unable to analyze - using original intent',
+                    strengthAreas: ['User provided clear deployment intent'],
+                    improvementAreas: []
+                }
+            };
+        }
+    }
     isInitialized() {
         return this.client !== null;
     }

package/dist/tools/recommend.d.ts

@@ -8,12 +8,14 @@ export declare const RECOMMEND_TOOL_NAME = "recommend";
 export declare const RECOMMEND_TOOL_DESCRIPTION = "Deploy, create, setup, install, or run applications, infrastructure, and services on Kubernetes with AI recommendations. Describe what you want to deploy.";
 export declare const RECOMMEND_TOOL_INPUT_SCHEMA: {
     intent: z.ZodString;
+    final: z.ZodOptional<z.ZodBoolean>;
 };
 /**
  * Direct MCP tool handler for recommend functionality
  */
 export declare function handleRecommendTool(args: {
     intent: string;
+    final?: boolean;
 }, dotAI: DotAI, logger: Logger, requestId: string): Promise<{
     content: {
         type: 'text';

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;AAQhD,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAC/C,eAAO,MAAM,0BAA0B,+JAA+J,CAAC;AAGvM,eAAO,MAAM,2BAA2B;;CAEvC,CAAC;AAyHF;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EACxB,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,CAyOxD"}
+{"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;AAQhD,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAC/C,eAAO,MAAM,0BAA0B,+JAA+J,CAAC;AAGvM,eAAO,MAAM,2BAA2B;;;CAGvC,CAAC;AA2EF;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,EACzC,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,CAuQxD"}

package/dist/tools/recommend.js

@@ -52,74 +52,36 @@ exports.RECOMMEND_TOOL_NAME = 'recommend';
 exports.RECOMMEND_TOOL_DESCRIPTION = 'Deploy, create, setup, install, or run applications, infrastructure, and services on Kubernetes with AI recommendations. Describe what you want to deploy.';
 // Zod schema for MCP registration
 exports.RECOMMEND_TOOL_INPUT_SCHEMA = {
-    intent: zod_1.z.string().min(1).max(1000).describe('What the user wants to deploy, create, setup, install, or run on Kubernetes. Examples: "deploy web application", "create PostgreSQL database", "setup Redis cache", "install Prometheus monitoring", "configure Ingress controller", "provision storage volumes", "launch MongoDB operator", "run Node.js API", "setup CI/CD pipeline", "create load balancer", "install Grafana dashboard", "deploy React frontend"')
+    intent: zod_1.z.string().min(1).max(1000).describe('What the user wants to deploy, create, setup, install, or run on Kubernetes. Examples: "deploy web application", "create PostgreSQL database", "setup Redis cache", "install Prometheus monitoring", "configure Ingress controller", "provision storage volumes", "launch MongoDB operator", "run Node.js API", "setup CI/CD pipeline", "create load balancer", "install Grafana dashboard", "deploy React frontend"'),
+    final: zod_1.z.boolean().optional().describe('Set to true to skip intent clarification and proceed directly with recommendations. If false or omitted, the tool will analyze the intent and provide clarification questions to help improve recommendation quality.')
 };
 /**
- * Validate intent meaningfulness using AI
+ * Analyze intent for clarification opportunities using AI
  */
-async function validateIntentWithAI(intent, claudeIntegration) {
+async function analyzeIntentForClarification(intent, claudeIntegration, logger) {
     try {
-        // Load prompt template
-        const promptPath = path.join(__dirname, '..', '..', 'prompts', 'intent-validation.md');
-        const template = fs.readFileSync(promptPath, 'utf8');
-        // Replace template variables
-        const validationPrompt = template.replace('{intent}', intent);
-        // Send to Claude for validation
-        const response = await claudeIntegration.sendMessage(validationPrompt, 'intent-validation');
-        // Parse JSON response with robust error handling
-        let jsonContent = response.content;
-        // Try to find JSON object wrapped in code blocks
-        const codeBlockMatch = response.content.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
-        if (codeBlockMatch) {
-            jsonContent = codeBlockMatch[1];
-        }
-        else {
-            // Try to find JSON object that starts with { and find the matching closing }
-            const startIndex = response.content.indexOf('{');
-            if (startIndex !== -1) {
-                let braceCount = 0;
-                let endIndex = startIndex;
-                for (let i = startIndex; i < response.content.length; i++) {
-                    if (response.content[i] === '{')
-                        braceCount++;
-                    if (response.content[i] === '}')
-                        braceCount--;
-                    if (braceCount === 0) {
-                        endIndex = i;
-                        break;
-                    }
-                }
-                if (braceCount === 0) {
-                    jsonContent = response.content.substring(startIndex, endIndex + 1);
-                }
-            }
-        }
-        const validation = JSON.parse(jsonContent.trim());
-        // Validate response structure
-        if (typeof validation.isSpecific !== 'boolean' ||
-            typeof validation.reason !== 'string' ||
-            !Array.isArray(validation.suggestions)) {
-            throw new Error('AI response has invalid structure');
-        }
-        // If intent is not specific enough, throw error with suggestions
-        if (!validation.isSpecific) {
-            const suggestions = validation.suggestions.length
-                ? validation.suggestions.map((s) => `• ${s}`).join('\n')
-                : '• Include specific technology (Node.js, PostgreSQL, React, etc.)\n• Describe the purpose or function\n• Add context about requirements';
-            throw new Error(`Intent needs more specificity: ${validation.reason}\n\n` +
-                `Suggestions to improve your intent:\n${suggestions}\n\n` +
-                `Original intent: "${intent}"`);
-        }
+        // Use the Claude service method for intent analysis
+        const analysisResult = await claudeIntegration.analyzeIntentForClarification(intent);
+        return analysisResult;
     }
     catch (error) {
-        // If it's our validation error, re-throw it
-        if (error instanceof Error && error.message.includes('Intent needs more specificity')) {
-            throw error;
-        }
-        // For other errors (AI service issues, JSON parsing, etc.), 
-        // continue without blocking the user - log the issue but don't fail
-        console.warn('Intent validation failed, continuing with original intent:', error);
-        return;
+        logger.warn?.('Intent analysis failed, proceeding without clarification', {
+            error: error instanceof Error ? error.message : String(error)
+        });
+        // Return minimal analysis that indicates no clarification available
+        return {
+            clarificationOpportunities: [],
+            overallAssessment: {
+                enhancementPotential: 'LOW',
+                primaryGaps: [],
+                recommendedFocus: 'Proceeding with original intent - analysis unavailable'
+            },
+            intentQuality: {
+                currentSpecificity: 'Analysis unavailable',
+                strengthAreas: ['User provided deployment intent'],
+                improvementAreas: []
+            }
+        };
     }
 }
 /**
@@ -197,38 +159,66 @@ async function handleRecommendTool(args, dotAI, logger, requestId) {
                 ]
             }, error instanceof Error ? error : new Error(String(error)));
         }
-        // Ensure cluster connectivity before proceeding
-        await (0, cluster_utils_1.ensureClusterConnection)(dotAI, logger, requestId, 'RecommendTool');
         logger.info('Starting resource recommendation process', {
             requestId,
             intent: args.intent,
             hasApiKey: !!claudeApiKey
         });
-        // Validate intent specificity with AI before expensive resource discovery
-        logger.debug('Validating intent specificity', { requestId, intent: args.intent });
-        try {
-            const claudeIntegration = new claude_1.ClaudeIntegration(claudeApiKey);
-            await validateIntentWithAI(args.intent, claudeIntegration);
-            logger.debug('Intent validation passed', { requestId });
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('Intent needs more specificity')) {
-                // This is a validation error that should be returned to the user
-                throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.VALIDATION, error_handling_1.ErrorSeverity.MEDIUM, error.message, {
-                    operation: 'intent_validation',
-                    component: 'RecommendTool',
+        // Initialize Claude integration for potential clarification analysis
+        const claudeIntegration = new claude_1.ClaudeIntegration(claudeApiKey);
+        // Check if intent clarification is needed (unless final=true)
+        if (!args.final) {
+            logger.debug('Analyzing intent for clarification opportunities', { requestId, intent: args.intent });
+            const analysisResult = await analyzeIntentForClarification(args.intent, claudeIntegration, logger);
+            // If clarification opportunities exist, return them to the client agent
+            if (analysisResult.clarificationOpportunities &&
+                analysisResult.clarificationOpportunities.length > 0 &&
+                analysisResult.overallAssessment.enhancementPotential !== 'LOW') {
+                // Convert analysis to structured questions for client agent
+                const questions = analysisResult.clarificationOpportunities
+                    .filter((opp) => opp.impactLevel === 'HIGH' || opp.impactLevel === 'MEDIUM')
+                    .slice(0, 5) // Limit to 5 most important questions
+                    .map((opp, index) => ({
+                    id: `clarification-${index + 1}`,
+                    question: opp.suggestedQuestions?.[0] || `Can you provide more details about ${opp.missingContext.toLowerCase()}?`,
+                    category: opp.category,
+                    reasoning: opp.reasoning,
+                    examples: opp.suggestedQuestions?.slice(1) || []
+                }));
+                const clarificationResponse = {
+                    status: 'clarification_available',
+                    intent: args.intent,
+                    analysis: {
+                        enhancementPotential: analysisResult.overallAssessment.enhancementPotential,
+                        recommendedFocus: analysisResult.overallAssessment.recommendedFocus,
+                        currentSpecificity: analysisResult.intentQuality.currentSpecificity,
+                        strengthAreas: analysisResult.intentQuality.strengthAreas,
+                        improvementAreas: analysisResult.intentQuality.improvementAreas
+                    },
+                    questions,
+                    agentInstructions: 'Present these clarification questions to help the user provide a more specific intent. When the user provides a refined intent (or confirms the current intent is sufficient), call the recommend tool again with final: true to proceed with recommendations.'
+                };
+                logger.debug('Returning clarification questions', {
                     requestId,
-                    input: { intent: args.intent },
-                    suggestedActions: [
-                        'Provide more specific details about your deployment',
-                        'Include technology stack information',
-                        'Describe the purpose or function of what you want to deploy'
+                    questionsCount: questions.length,
+                    enhancementPotential: analysisResult.overallAssessment.enhancementPotential
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(clarificationResponse, null, 2)
+                        }
                     ]
-                }, error);
+                };
             }
-            // For other errors, log but continue (don't block user due to AI service issues)
-            logger.warn('Intent validation failed, continuing with recommendation', { requestId, error: error instanceof Error ? error.message : 'Unknown error' });
+            logger.debug('No significant clarification opportunities found, proceeding with recommendations', { requestId });
         }
+        else {
+            logger.debug('Skipping intent clarification (final=true), proceeding directly with recommendations', { requestId });
+        }
+        // Ensure cluster connectivity before proceeding with recommendations
+        await (0, cluster_utils_1.ensureClusterConnection)(dotAI, logger, requestId, 'RecommendTool');
         // Initialize AI-powered ResourceRecommender
         const rankingConfig = { claudeApiKey };
         const recommender = new schema_1.ResourceRecommender(rankingConfig);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vfarcic/dot-ai",
-  "version": "0.66.0",
+  "version": "0.67.0",
   "description": "Universal Kubernetes application deployment agent with MCP interface",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/prompts/intent-analysis.md

@@ -0,0 +1,122 @@
+# Intent Analysis for Clarification Opportunities
+
+You are an expert Kubernetes deployment consultant analyzing user intents to identify opportunities for clarification that would lead to better deployment recommendations.
+
+## User Intent
+{intent}
+
+## Organizational Patterns Context
+{organizational_patterns}
+
+## Analysis Framework
+
+Analyze the user's intent for **clarification opportunities** that would significantly improve the quality and relevance of deployment recommendations. Focus on identifying missing context that, when provided, would lead to more targeted and appropriate solutions.
+
+### Clarification Categories
+
+**1. TECHNICAL SPECIFICATIONS**
+- Specific technology versions, frameworks, or implementations
+- Performance requirements (CPU, memory, throughput, latency)
+- Scalability expectations (traffic patterns, growth projections)
+- Storage requirements (data persistence, volume sizes, access patterns)
+
+**2. ARCHITECTURAL CONTEXT**
+- Application architecture patterns (microservices, monolith, serverless)
+- Integration requirements (databases, external services, APIs)
+- Communication patterns (synchronous, asynchronous, event-driven)
+- Deployment patterns (blue-green, rolling, canary)
+
+**3. OPERATIONAL REQUIREMENTS**
+- Environment targets (development, staging, production)
+- High availability and disaster recovery needs
+- Monitoring and observability requirements
+- Backup and maintenance procedures
+
+**4. SECURITY & COMPLIANCE**
+- Authentication and authorization requirements
+- Data classification and encryption needs  
+- Compliance frameworks (GDPR, HIPAA, SOC2, PCI-DSS)
+- Network security policies and isolation requirements
+
+**5. ORGANIZATIONAL ALIGNMENT**
+- Team responsibilities and ownership models
+- Existing infrastructure integration points
+- Budget and resource constraints
+- Timeline and rollout preferences
+
+### Opportunity Assessment
+
+For each category, evaluate:
+- **Missing Context**: What specific information is absent?
+- **Impact Level**: How much would this information improve recommendations?
+- **Question Potential**: Can this be addressed with a clear, actionable question?
+- **Pattern Alignment**: Does this relate to organizational patterns or standards?
+
+### Question Generation Priorities
+
+**HIGH PRIORITY**: Missing context that would fundamentally change the recommended solution
+**MEDIUM PRIORITY**: Information that would optimize the deployment for the user's environment
+**LOW PRIORITY**: Nice-to-have details that provide minor refinements
+
+## Organizational Pattern Integration
+
+Use the provided organizational patterns to inform your analysis:
+- Identify alignment opportunities with existing patterns
+- Recognize potential governance requirements
+- Consider standard approaches within the organization
+- Highlight areas where clarification could ensure compliance
+
+## Analysis Guidelines
+
+**DO NOT suggest clarification for:**
+- Information that is clearly implied by the intent
+- Standard Kubernetes configurations that have sensible defaults
+- Details that don't significantly impact solution recommendations
+- Overly technical specifics that most users wouldn't know
+
+**DO suggest clarification for:**
+- Ambiguous requirements that could lead to multiple valid interpretations  
+- Missing context that would change the fundamental solution approach
+- Organizational-specific requirements that align with provided patterns
+- Performance, security, or compliance needs that aren't specified
+
+## Response Format
+
+Respond with ONLY a JSON object in this exact format:
+
+```json
+{
+  "clarificationOpportunities": [
+    {
+      "category": "TECHNICAL_SPECIFICATIONS|ARCHITECTURAL_CONTEXT|OPERATIONAL_REQUIREMENTS|SECURITY_COMPLIANCE|ORGANIZATIONAL_ALIGNMENT",
+      "missingContext": "Specific description of what context is missing",
+      "impactLevel": "HIGH|MEDIUM|LOW",
+      "reasoning": "Why this clarification would improve recommendations",
+      "suggestedQuestions": [
+        "Specific question that could gather this information",
+        "Alternative question approach for the same context"
+      ],
+      "patternAlignment": "How this relates to organizational patterns (if applicable)"
+    }
+  ],
+  "overallAssessment": {
+    "enhancementPotential": "HIGH|MEDIUM|LOW",
+    "primaryGaps": ["Most important missing context area 1", "Most important missing context area 2"],
+    "recommendedFocus": "The single most valuable clarification opportunity"
+  },
+  "intentQuality": {
+    "currentSpecificity": "Assessment of how specific the intent currently is",
+    "strengthAreas": ["What aspects of the intent are already clear"],
+    "improvementAreas": ["What aspects would benefit most from clarification"]
+  }
+}
+```
+
+## Important Notes
+
+- Focus on **meaningful clarification opportunities** that would lead to measurably better recommendations
+- Consider the **user's perspective** - suggest questions they can actually answer
+- **Prioritize ruthlessly** - only suggest clarification that provides significant value
+- **Leverage organizational patterns** to identify governance and compliance opportunities
+- **Be practical** - ensure suggested questions are actionable and specific
+- **Quality over quantity** - fewer high-impact opportunities are better than many low-impact ones

package/shared-prompts/prd-done.md

@@ -58,9 +58,21 @@ Complete the PRD implementation workflow including branch management, pull reque
 ### 4. Review and Merge Process
 - [ ] **Check ongoing processes**: Use `gh pr checks [pr-number]` to check for any ongoing CI/CD, security analysis, or automated reviews (CodeRabbit, CodeQL, etc.)
 - [ ] **Check PR details**: Use `gh pr view [pr-number]` to check for human review comments and PR metadata
+- [ ] **Review all automated feedback**: Check PR comments section for automated code review feedback (bots, linters, analyzers)
+  - Look for actionable suggestions about code quality, security, performance, or maintainability
+  - Check for recommendations about test coverage, error handling, or architectural improvements
+  - Review suggestions for refactoring, type safety, or code organization
+- [ ] **Assess feedback priority**: Categorize review feedback
+  - **Critical**: Security issues, breaking changes, test failures - MUST address before merge
+  - **Important**: Code quality, maintainability, performance - SHOULD address for production readiness
+  - **Optional**: Style preferences, minor optimizations - MAY address based on project standards
 - [ ] **Wait for completion**: Do NOT merge if checks show pending processes or PR comments indicate reviews still in progress
-- [ ] **Address review feedback**: Make any required changes from code review (both automated and human)
+- [ ] **Address review feedback**: Make required changes from code review (both automated and human)
+  - Create additional commits on the feature branch to address feedback
+  - Update tests if needed to cover suggested improvements
+  - Document any feedback that was intentionally not addressed and why
 - [ ] **Verify all checks pass**: Ensure all CI/CD, tests, security analysis, and automated processes are complete and passing
+- [ ] **Final review**: Confirm the PR addresses the original PRD requirements and maintains code quality
 - [ ] **Merge to main**: Complete the pull request merge only after all feedback addressed and processes complete
 - [ ] **Verify deployment**: Ensure feature works in production environment
 - [ ] **Monitor for issues**: Watch for any post-deployment problems

package/prompts/intent-validation.md

@@ -1,74 +0,0 @@
-# Intent Validation for Kubernetes Deployment Recommendations
-
-You are a Kubernetes expert analyzing user intents for deployment recommendations. Evaluate whether this intent provides enough specificity to generate meaningful Kubernetes deployment recommendations.
-
-## User Intent
-{intent}
-
-## Evaluation Criteria
-
-An intent is **TOO VAGUE OR GENERIC** if it:
-- Completely generic terms without context (e.g., just "app", "something", "service" alone)
-- Single action words without objects (e.g., "deploy", "create", "setup", "run" alone)
-- Meaningless requests (e.g., "help", "please", "can you")
-- Extremely short without any technical context (1-2 words like "database", "container")
-
-An intent is **SPECIFIC ENOUGH** if it includes ANY of:
-- Specific technology or framework (Node.js, PostgreSQL, Redis, React, Python, Prometheus, Grafana, etc.)
-- Clear architectural pattern (stateless app, microservice, web server, REST API, operator, etc.)
-- Application type or purpose (frontend, backend, database, cache, queue, monitoring, storage, etc.)
-- Infrastructure component (load balancer, ingress controller, persistent storage, networking, etc.)
-- Deployment context that helps understand Kubernetes resource needs
-
-**IMPORTANT**: Be generous in accepting intents. Focus on rejecting only truly meaningless requests. Terms like "stateless app", "web application", "microservice", "database cluster" provide sufficient Kubernetes deployment context.
-
-## Examples
-
-**TOO VAGUE:**
-- "create an app" (no architectural or technical context)
-- "deploy something" (completely generic)
-- "database" (single word, no context)
-- "help" (not a deployment request)
-- "app" (single word)
-- "setup" (action without object)
-
-**SPECIFIC ENOUGH:**
-- "stateless app" (architectural pattern + type)
-- "web application" (clear application type)
-- "microservice" (architectural pattern)
-- "REST API" (clear service type)
-- "database cluster" (type + deployment pattern)
-- "Node.js application" (technology + type)
-- "frontend service" (purpose + type)
-- "cache service" (purpose + type)
-- "PostgreSQL database" (technology + infrastructure type)
-- "Redis cache" (technology + infrastructure purpose)
-- "Prometheus monitoring" (technology + infrastructure purpose)
-- "Ingress controller" (infrastructure component + type)
-- "MongoDB operator" (technology + operator pattern)
-- "load balancer" (infrastructure component)
-- "persistent storage" (infrastructure capability)
-- "CI/CD pipeline" (workflow automation)
-
-## Response Format
-
-Respond with ONLY a JSON object in this exact format:
-
-```json
-{
-  "isSpecific": boolean,
-  "reason": "brief explanation of why it is or isn't specific enough",
-  "suggestions": [
-    "specific suggestion 1 to improve the intent",
-    "specific suggestion 2 to improve the intent", 
-    "specific suggestion 3 to improve the intent"
-  ]
-}
-```
-
-**IMPORTANT:** 
-- Your response must be ONLY the JSON object, nothing else
-- If `isSpecific` is true, still provide 3 suggestions for making it even more detailed
-- If `isSpecific` is false, provide 3 concrete suggestions to make it deployable
-- Keep suggestions practical and actionable
-- Focus on what technologies, purposes, or contexts are missing