@vfarcic/dot-ai 0.57.0 → 0.59.0

package/dist/core/claude.js

@@ -137,7 +137,7 @@ ${response.content}`;
             if (this.apiKey.startsWith('sk-ant-') && this.client) {
                 // Make real API call to Claude
                 const completion = await this.client.messages.create({
-                    model: 'claude-3-5-sonnet-20241022',
+                    model: 'claude-sonnet-4-20250514', // Latest Claude Sonnet 4 - check for newer versions periodically
                     max_tokens: 4000,
                     messages: [{ role: 'user', content: message }]
                 });

package/dist/core/schema.d.ts

@@ -157,7 +157,27 @@ export declare class ResourceRecommender {
     /**
      * Find the best resource solution(s) for user intent using two-phase analysis
      */
-    findBestSolutions(intent: string, explainResource: (resource: string) => Promise<any>): Promise<ResourceSolution[]>;
+    findBestSolutions(intent: string, _explainResource: (resource: string) => Promise<any>): Promise<ResourceSolution[]>;
+    /**
+     * Phase 2: AI assembles and ranks complete solutions (replaces separate selection + ranking)
+     */
+    private assembleAndRankSolutions;
+    /**
+     * Parse AI response for simple solution structure (no schema matching needed)
+     */
+    private parseSimpleSolutionResponse;
+    /**
+     * Load and format solution assembly prompt from file
+     */
+    private loadSolutionAssemblyPrompt;
+    /**
+     * Add pattern-suggested resources that are missing from capability search results
+     */
+    private addMissingPatternResources;
+    /**
+     * Infer cloud providers from resource name
+     */
+    private inferProvidersFromResourceName;
     /**
      * Extract Kubernetes kind from resource name (e.g., "sqls.devopstoolkit.live" -> "SQL")
      */
@@ -176,25 +196,105 @@ export declare class ResourceRecommender {
      */
     private searchRelevantPatterns;
     /**
-     * Phase 1: AI selects promising resource candidates from lightweight list
-     */
-    private selectResourceCandidates;
+        const basic = `${index}: ${resource.kind} (${resource.apiVersion})
+     Group: ${resource.group || 'core'}
+     Namespaced: ${resource.namespaced}`;
+        
+        // Include rich capability context if available (from capability-based pre-filtering)
+        if (resource.capabilities) {
+          const cap = resource.capabilities;
+          return `${basic}
+     Resource Name: ${resource.resourceName || 'Not specified'}
+     Capabilities: ${cap.capabilities?.join(', ') || 'Not specified'}
+     Providers: ${cap.providers?.join(', ') || 'Not specified'}
+     Complexity: ${cap.complexity || 'Not specified'}
+     Use Case: ${cap.useCase || 'Not specified'}
+     Description: ${cap.description || 'Not specified'}
+     Confidence: ${cap.confidence || 'N/A'}`;
+        }
+        
+        return basic;
+      }).join('\n\n');
+  
+      // Format organizational patterns for AI context
+      const patternsContext = patterns.length > 0
+        ? patterns.map(pattern =>
+            `- ID: ${pattern.id}
+              Description: ${pattern.description}
+              Suggested Resources: ${pattern.suggestedResources?.join(', ') || 'Not specified'}
+              Rationale: ${pattern.rationale}
+              Triggers: ${pattern.triggers?.join(', ') || 'None'}`
+          ).join('\n')
+        : 'No organizational patterns found for this request.';
+  
+  
+      const fs = await import('fs');
+      const path = await import('path');
+      
+      const promptPath = path.join(__dirname, '..', '..', 'prompts', 'resource-selection.md');
+      const template = fs.readFileSync(promptPath, 'utf8');
+      
+      const selectionPrompt = template
+        .replace('{intent}', intent)
+        .replace('{resources}', resourceSummary)
+        .replace('{patterns}', patternsContext);
+  
+  
+      const response = await this.claudeIntegration.sendMessage(selectionPrompt, 'resource-selection');
+      
+      try {
+        // Extract JSON from response with robust parsing
+        let jsonContent = response.content;
+        
+        // First try to find JSON array wrapped in code blocks
+        const codeBlockMatch = response.content.match(/```(?:json)?\s*(\[[\s\S]*?\])\s*```/);
+        if (codeBlockMatch) {
+          jsonContent = codeBlockMatch[1];
+        } else {
+          // Try to find JSON array that starts with [ and find the matching closing ]
+          const startIndex = response.content.indexOf('[');
+          if (startIndex !== -1) {
+            let bracketCount = 0;
+            let endIndex = startIndex;
+            
+            for (let i = startIndex; i < response.content.length; i++) {
+              if (response.content[i] === '[') bracketCount++;
+              if (response.content[i] === ']') bracketCount--;
+              if (bracketCount === 0) {
+                endIndex = i;
+                break;
+              }
+            }
+            
+            if (bracketCount === 0) {
+              jsonContent = response.content.substring(startIndex, endIndex + 1);
+            }
+          }
+        }
+        
+        const selectedResources = JSON.parse(jsonContent.trim());
+        
+        if (!Array.isArray(selectedResources)) {
+          throw new Error('AI response is not an array');
+        }
+        
+        // Validate that each resource has required fields
+        for (const resource of selectedResources) {
+          if (!resource.kind || !resource.apiVersion) {
+            throw new Error(`AI selected invalid resource: ${JSON.stringify(resource)}`);
+          }
+        }
+        
+        return selectedResources;
+      } catch (error) {
+        throw new Error(`AI failed to select resources in valid JSON format. Error: ${(error as Error).message}. AI response: "${response.content.substring(0, 200)}..."`);
+      }
+    }
+  
     /**
      * Phase 2: Fetch detailed schemas for selected candidates
      */
     private fetchDetailedSchemas;
-    /**
-     * Phase 3: Rank resources with detailed schema information
-     */
-    private rankWithDetailedSchemas;
-    /**
-     * Load and format prompt template from file
-     */
-    private loadPromptTemplate;
-    /**
-     * Parse AI response into solution results
-     */
-    private parseAISolutionResponse;
     /**
      * Discover cluster options for dynamic question generation
      */

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/core/schema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAWlD,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAGD,MAAM,WAAW,SAAS;IACxB,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC;CAC3B;AAGD,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACxD,OAAO,EAAE,SAAS,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,aAAa,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC/D,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE;QACX,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,MAAM,CAAC,EAAE,GAAG,CAAC;CAEd;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAGD,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACrC,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,QAAQ,GAAG,aAAa,CAAC;IAC/B,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,aAAa,CAAC;IACzB,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAC;IACvC,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;CACtB;AAKD,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,eAAe,CAAC,EAAE;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE,CAAC;CACrD;AAED;;GAEG;AACH,qBAAa,YAAY;IACvB;;OAEG;IACH,wBAAwB,CAAC,WAAW,EAAE,mBAAmB,GAAG,cAAc;IAgD1E;;OAEG;IACH,OAAO,CAAC,cAAc;IAoBtB;;OAEG;IACH,OAAO,CAAC,aAAa;IAqBrB;;OAEG;IACH,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,gBAAgB;CAyD3E;AAED;;GAEG;AACH,qBAAa,iBAAiB;IAC5B;;;OAGG;IACG,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;KAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA+C3I;;OAEG;IACH,OAAO,CAAC,uBAAuB;CAWhC;AAED;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,cAAc,CAAC,CAAuB;IAC9C,OAAO,CAAC,iBAAiB,CAAC,CAA0B;gBAExC,MAAM,EAAE,eAAe;IAyBnC;;OAEG;IACG,iBAAiB,CACrB,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,GAClD,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA+D9B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAanC;;OAEG;IACH,OAAO,CAAC,4BAA4B;IASpC;;OAEG;IACH,OAAO,CAAC,mCAAmC;IAU3C;;;OAGG;YACW,sBAAsB;IAmBpC;;OAEG;YACW,wBAAwB;IAiHtC;;OAEG;YACW,oBAAoB;IAgDlC;;OAEG;YACW,uBAAuB;IAarC;;OAEG;YACW,kBAAkB;IAuChC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IA0E/B;;OAEG;YACW,sBAAsB;IAiEpC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAgCjC;;OAEG;YACW,uBAAuB;CA6EtC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/core/schema.ts"],"names":[],"mappings":"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"}

package/dist/core/schema.js

@@ -290,7 +290,7 @@ class ResourceRecommender {
     /**
      * Find the best resource solution(s) for user intent using two-phase analysis
      */
-    async findBestSolutions(intent, explainResource) {
+    async findBestSolutions(intent, _explainResource) {
         if (!this.claudeIntegration.isInitialized()) {
             throw new Error('Claude integration not initialized. API key required for AI-powered resource ranking.');
         }
@@ -329,16 +329,175 @@ class ResourceRecommender {
                 namespaced: true, // Default assumption, could be enhanced
                 capabilities: cap.data // Include capability data for AI decision-making
             }));
-            // Phase 1b: AI selects best candidates from capability-filtered resources (maintains existing logic)
-            const candidates = await this.selectResourceCandidates(intent, capabilityFilteredResources, relevantPatterns);
-            // Phase 2: Fetch detailed schemas for AI-selected candidates and rank (unchanged)
-            const schemas = await this.fetchDetailedSchemas(candidates, explainResource);
-            return await this.rankWithDetailedSchemas(intent, schemas, relevantPatterns);
+            // Phase 1: Add missing pattern-suggested resources to available resources list
+            const enhancedResources = await this.addMissingPatternResources(capabilityFilteredResources, relevantPatterns);
+            // Phase 2: AI assembles and ranks complete solutions (replaces separate selection + ranking phases)
+            const solutions = await this.assembleAndRankSolutions(intent, enhancedResources, relevantPatterns);
+            // Phase 3: Generate questions for each solution
+            for (const solution of solutions) {
+                solution.questions = await this.generateQuestionsWithAI(intent, solution);
+            }
+            return solutions;
         }
         catch (error) {
             throw new Error(`AI-powered resource solution analysis failed: ${error}`);
         }
     }
+    /**
+     * Phase 2: AI assembles and ranks complete solutions (replaces separate selection + ranking)
+     */
+    async assembleAndRankSolutions(intent, availableResources, patterns) {
+        const prompt = await this.loadSolutionAssemblyPrompt(intent, availableResources, patterns);
+        const response = await this.claudeIntegration.sendMessage(prompt, 'solution-assembly');
+        return this.parseSimpleSolutionResponse(response.content);
+    }
+    /**
+     * Parse AI response for simple solution structure (no schema matching needed)
+     */
+    parseSimpleSolutionResponse(aiResponse) {
+        try {
+            // Use robust JSON extraction
+            const parsed = this.extractJsonFromAIResponse(aiResponse);
+            const solutions = parsed.solutions.map((solution) => {
+                const isDebugMode = process.env.DOT_AI_DEBUG === 'true';
+                if (isDebugMode) {
+                    console.debug('DEBUG: solution object:', JSON.stringify(solution, null, 2));
+                }
+                // Convert resource references to ResourceSchema format for compatibility
+                const resources = (solution.resources || []).map((resource) => ({
+                    kind: resource.kind,
+                    apiVersion: resource.apiVersion,
+                    group: resource.group || '',
+                    description: `${resource.kind} resource from ${resource.group || 'core'} group`,
+                    properties: new Map(),
+                    namespace: true // Default assumption for new architecture
+                }));
+                return {
+                    type: solution.type,
+                    resources,
+                    score: solution.score,
+                    description: solution.description,
+                    reasons: solution.reasons || [],
+                    analysis: solution.analysis || '',
+                    questions: { required: [], basic: [], advanced: [], open: { question: '', placeholder: '' } },
+                    patternInfluences: solution.patternInfluences || [],
+                    usedPatterns: solution.usedPatterns || false
+                };
+            });
+            // Sort by score descending
+            return solutions.sort((a, b) => b.score - a.score);
+        }
+        catch (error) {
+            // Enhanced error message with more context
+            const errorMsg = `Failed to parse AI solution response: ${error.message}`;
+            const contextMsg = `\nAI Response (first 500 chars): "${aiResponse.substring(0, 500)}..."`;
+            throw new Error(errorMsg + contextMsg);
+        }
+    }
+    /**
+     * Load and format solution assembly prompt from file
+     */
+    async loadSolutionAssemblyPrompt(intent, resources, patterns) {
+        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+        const path = await Promise.resolve().then(() => __importStar(require('path')));
+        const promptPath = path.join(__dirname, '..', '..', 'prompts', 'resource-selection.md');
+        const template = fs.readFileSync(promptPath, 'utf8');
+        // Format resources for the prompt with capability information
+        const resourcesText = resources.map((resource, index) => {
+            return `${index}: ${resource.kind.toUpperCase()} (${resource.apiVersion})
+   Group: ${resource.group || 'core'}
+   Namespaced: ${resource.namespaced}
+   Resource Name: ${resource.resourceName}
+   Capabilities: ${Array.isArray(resource.capabilities.capabilities) ? resource.capabilities.capabilities.join(', ') : 'Not specified'}
+   Providers: ${Array.isArray(resource.capabilities.providers) ? resource.capabilities.providers.join(', ') : resource.capabilities.providers || 'kubernetes'}
+   Complexity: ${resource.capabilities.complexity || 'medium'}
+   Use Case: ${resource.capabilities.useCase || resource.capabilities.description || 'General purpose'}
+   Description: ${resource.capabilities.description || 'Kubernetes resource'}
+   Confidence: ${resource.capabilities.confidence || 1.0}`;
+        }).join('\n\n');
+        // Format organizational patterns for AI context
+        const patternsContext = patterns.length > 0
+            ? patterns.map(pattern => `- ID: ${pattern.id}
+            Description: ${pattern.description}
+            Suggested Resources: ${pattern.suggestedResources?.join(', ') || 'Not specified'}
+            Rationale: ${pattern.rationale}
+            Triggers: ${pattern.triggers?.join(', ') || 'None'}`).join('\n')
+            : 'No organizational patterns found for this request.';
+        return template
+            .replace('{intent}', intent)
+            .replace('{resources}', resourcesText)
+            .replace('{patterns}', patternsContext);
+    }
+    /**
+     * Add pattern-suggested resources that are missing from capability search results
+     */
+    async addMissingPatternResources(capabilityResources, patterns) {
+        if (!patterns.length) {
+            return capabilityResources;
+        }
+        // Extract all resource names already in capability results
+        const existingResourceNames = new Set(capabilityResources.map(r => r.resourceName));
+        // Collect missing pattern resources
+        const missingPatternResources = [];
+        for (const pattern of patterns) {
+            if (pattern.suggestedResources) {
+                for (const suggestedResource of pattern.suggestedResources) {
+                    // Skip null/undefined resources
+                    if (!suggestedResource || typeof suggestedResource !== 'string') {
+                        continue;
+                    }
+                    // Convert pattern resource format to resource name (e.g., "resourcegroups.azure.upbound.io" -> resourceName)
+                    const resourceName = suggestedResource.includes('.') ? suggestedResource : `${suggestedResource}.core`;
+                    // Only add if not already present in capability results
+                    if (!existingResourceNames.has(resourceName)) {
+                        try {
+                            // Parse resource components
+                            const parts = suggestedResource.split('.');
+                            const kind = parts[0]; // Use resource name as-is: resourcegroups, servicemonitors, etc.
+                            const group = parts.length > 1 ? parts.slice(1).join('.') : '';
+                            const version = 'v1beta1'; // Default version for CRDs, could be enhanced
+                            const apiVersion = group ? `${group}/${version}` : version;
+                            missingPatternResources.push({
+                                kind,
+                                group,
+                                apiVersion,
+                                resourceName,
+                                namespaced: true, // Default assumption for pattern resources
+                                capabilities: {
+                                    resourceName,
+                                    description: `Resource suggested by organizational pattern: ${pattern.description}`,
+                                    capabilities: [`organizational pattern`, pattern.description.toLowerCase()],
+                                    providers: this.inferProvidersFromResourceName(suggestedResource),
+                                    complexity: 'medium',
+                                    useCase: `Pattern-suggested resource for: ${pattern.rationale}`,
+                                    confidence: 1.0, // High confidence since it's from organizational pattern
+                                    source: 'organizational-pattern',
+                                    patternId: pattern.id
+                                }
+                            });
+                            existingResourceNames.add(resourceName);
+                        }
+                        catch (error) {
+                            console.warn(`Failed to parse pattern resource ${suggestedResource}:`, error);
+                        }
+                    }
+                }
+            }
+        }
+        return [...capabilityResources, ...missingPatternResources];
+    }
+    /**
+     * Infer cloud providers from resource name
+     */
+    inferProvidersFromResourceName(resourceName) {
+        if (resourceName.includes('azure'))
+            return ['azure'];
+        if (resourceName.includes('aws'))
+            return ['aws'];
+        if (resourceName.includes('gcp') || resourceName.includes('google'))
+            return ['gcp'];
+        return ['kubernetes'];
+    }
     /**
      * Extract Kubernetes kind from resource name (e.g., "sqls.devopstoolkit.live" -> "SQL")
      */
@@ -395,104 +554,104 @@ class ResourceRecommender {
             return [];
         }
     }
+    // REMOVED: selectResourceCandidates - replaced by single-phase assembleAndRankSolutions
+    // REMOVED: fetchDetailedSchemas - no longer needed in single-phase architecture
     /**
-     * Phase 1: AI selects promising resource candidates from lightweight list
-     */
-    async selectResourceCandidates(intent, resources, patterns = []) {
-        // Normalize resource structures between standard resources and CRDs
-        const normalizedResources = resources.map(resource => {
-            // Handle both standard resources and CRDs
-            const apiVersion = resource.apiVersion ||
-                (resource.group ? `${resource.group}/${resource.version}` : resource.version);
-            const isNamespaced = resource.namespaced !== undefined ?
-                resource.namespaced :
-                resource.scope === 'Namespaced';
-            return {
-                ...resource,
-                apiVersion,
-                namespaced: isNamespaced
-            };
-        });
-        const resourceSummary = normalizedResources.map((resource, index) => {
-            const basic = `${index}: ${resource.kind} (${resource.apiVersion})
-   Group: ${resource.group || 'core'}
-   Namespaced: ${resource.namespaced}`;
-            // Include rich capability context if available (from capability-based pre-filtering)
-            if (resource.capabilities) {
-                const cap = resource.capabilities;
-                return `${basic}
-   Resource Name: ${resource.resourceName || 'Not specified'}
-   Capabilities: ${cap.capabilities?.join(', ') || 'Not specified'}
-   Providers: ${cap.providers?.join(', ') || 'Not specified'}
-   Complexity: ${cap.complexity || 'Not specified'}
-   Use Case: ${cap.useCase || 'Not specified'}
-   Description: ${cap.description || 'Not specified'}
-   Confidence: ${cap.confidence || 'N/A'}`;
-            }
-            return basic;
-        }).join('\n\n');
-        // Format organizational patterns for AI context
-        const patternsContext = patterns.length > 0
-            ? patterns.map(pattern => `- ID: ${pattern.id}
-            Description: ${pattern.description}
-            Suggested Resources: ${pattern.suggestedResources?.join(', ') || 'Not specified'}
-            Rationale: ${pattern.rationale}
-            Triggers: ${pattern.triggers?.join(', ') || 'None'}`).join('\n')
-            : 'No organizational patterns found for this request.';
-        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-        const path = await Promise.resolve().then(() => __importStar(require('path')));
-        const promptPath = path.join(__dirname, '..', '..', 'prompts', 'resource-selection.md');
-        const template = fs.readFileSync(promptPath, 'utf8');
-        const selectionPrompt = template
-            .replace('{intent}', intent)
-            .replace('{resources}', resourceSummary)
-            .replace('{patterns}', patternsContext);
-        const response = await this.claudeIntegration.sendMessage(selectionPrompt, 'resource-selection');
-        try {
-            // Extract JSON from response with robust parsing
-            let jsonContent = response.content;
-            // First try to find JSON array wrapped in code blocks
-            const codeBlockMatch = response.content.match(/```(?:json)?\s*(\[[\s\S]*?\])\s*```/);
-            if (codeBlockMatch) {
-                jsonContent = codeBlockMatch[1];
-            }
-            else {
-                // Try to find JSON array that starts with [ and find the matching closing ]
-                const startIndex = response.content.indexOf('[');
-                if (startIndex !== -1) {
-                    let bracketCount = 0;
-                    let endIndex = startIndex;
-                    for (let i = startIndex; i < response.content.length; i++) {
-                        if (response.content[i] === '[')
-                            bracketCount++;
-                        if (response.content[i] === ']')
-                            bracketCount--;
-                        if (bracketCount === 0) {
-                            endIndex = i;
-                            break;
-                        }
-                    }
-                    if (bracketCount === 0) {
-                        jsonContent = response.content.substring(startIndex, endIndex + 1);
-                    }
-                }
-            }
-            const selectedResources = JSON.parse(jsonContent.trim());
-            if (!Array.isArray(selectedResources)) {
-                throw new Error('AI response is not an array');
+        const basic = `${index}: ${resource.kind} (${resource.apiVersion})
+     Group: ${resource.group || 'core'}
+     Namespaced: ${resource.namespaced}`;
+        
+        // Include rich capability context if available (from capability-based pre-filtering)
+        if (resource.capabilities) {
+          const cap = resource.capabilities;
+          return `${basic}
+     Resource Name: ${resource.resourceName || 'Not specified'}
+     Capabilities: ${cap.capabilities?.join(', ') || 'Not specified'}
+     Providers: ${cap.providers?.join(', ') || 'Not specified'}
+     Complexity: ${cap.complexity || 'Not specified'}
+     Use Case: ${cap.useCase || 'Not specified'}
+     Description: ${cap.description || 'Not specified'}
+     Confidence: ${cap.confidence || 'N/A'}`;
+        }
+        
+        return basic;
+      }).join('\n\n');
+  
+      // Format organizational patterns for AI context
+      const patternsContext = patterns.length > 0
+        ? patterns.map(pattern =>
+            `- ID: ${pattern.id}
+              Description: ${pattern.description}
+              Suggested Resources: ${pattern.suggestedResources?.join(', ') || 'Not specified'}
+              Rationale: ${pattern.rationale}
+              Triggers: ${pattern.triggers?.join(', ') || 'None'}`
+          ).join('\n')
+        : 'No organizational patterns found for this request.';
+  
+  
+      const fs = await import('fs');
+      const path = await import('path');
+      
+      const promptPath = path.join(__dirname, '..', '..', 'prompts', 'resource-selection.md');
+      const template = fs.readFileSync(promptPath, 'utf8');
+      
+      const selectionPrompt = template
+        .replace('{intent}', intent)
+        .replace('{resources}', resourceSummary)
+        .replace('{patterns}', patternsContext);
+  
+  
+      const response = await this.claudeIntegration.sendMessage(selectionPrompt, 'resource-selection');
+      
+      try {
+        // Extract JSON from response with robust parsing
+        let jsonContent = response.content;
+        
+        // First try to find JSON array wrapped in code blocks
+        const codeBlockMatch = response.content.match(/```(?:json)?\s*(\[[\s\S]*?\])\s*```/);
+        if (codeBlockMatch) {
+          jsonContent = codeBlockMatch[1];
+        } else {
+          // Try to find JSON array that starts with [ and find the matching closing ]
+          const startIndex = response.content.indexOf('[');
+          if (startIndex !== -1) {
+            let bracketCount = 0;
+            let endIndex = startIndex;
+            
+            for (let i = startIndex; i < response.content.length; i++) {
+              if (response.content[i] === '[') bracketCount++;
+              if (response.content[i] === ']') bracketCount--;
+              if (bracketCount === 0) {
+                endIndex = i;
+                break;
+              }
             }
-            // Validate that each resource has required fields
-            for (const resource of selectedResources) {
-                if (!resource.kind || !resource.apiVersion) {
-                    throw new Error(`AI selected invalid resource: ${JSON.stringify(resource)}`);
-                }
+            
+            if (bracketCount === 0) {
+              jsonContent = response.content.substring(startIndex, endIndex + 1);
             }
-            return selectedResources;
-        }
-        catch (error) {
-            throw new Error(`AI failed to select resources in valid JSON format. Error: ${error.message}. AI response: "${response.content.substring(0, 200)}..."`);
-        }
+          }
+        }
+        
+        const selectedResources = JSON.parse(jsonContent.trim());
+        
+        if (!Array.isArray(selectedResources)) {
+          throw new Error('AI response is not an array');
+        }
+        
+        // Validate that each resource has required fields
+        for (const resource of selectedResources) {
+          if (!resource.kind || !resource.apiVersion) {
+            throw new Error(`AI selected invalid resource: ${JSON.stringify(resource)}`);
+          }
+        }
+        
+        return selectedResources;
+      } catch (error) {
+        throw new Error(`AI failed to select resources in valid JSON format. Error: ${(error as Error).message}. AI response: "${response.content.substring(0, 200)}..."`);
+      }
     }
+  
     /**
      * Phase 2: Fetch detailed schemas for selected candidates
      */
@@ -536,117 +695,6 @@ class ResourceRecommender {
         }
         return schemas;
     }
-    /**
-     * Phase 3: Rank resources with detailed schema information
-     */
-    async rankWithDetailedSchemas(intent, schemas, patterns = []) {
-        const prompt = await this.loadPromptTemplate(intent, schemas, patterns);
-        const response = await this.claudeIntegration.sendMessage(prompt, 'resource-ranking');
-        const solutions = this.parseAISolutionResponse(response.content, schemas);
-        // Generate AI-powered questions for each solution
-        for (const solution of solutions) {
-            solution.questions = await this.generateQuestionsWithAI(intent, solution);
-        }
-        return solutions;
-    }
-    /**
-     * Load and format prompt template from file
-     */
-    async loadPromptTemplate(intent, schemas, patterns = []) {
-        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-        const path = await Promise.resolve().then(() => __importStar(require('path')));
-        const promptPath = path.join(__dirname, '..', '..', 'prompts', 'resource-solution-ranking.md');
-        const template = fs.readFileSync(promptPath, 'utf8');
-        // Format resources for the prompt with detailed schema information
-        const resourcesText = schemas.map((schema, index) => {
-            let resourceInfo = `${index}: ${schema.kind} (${schema.apiVersion})
-   Group: ${schema.group || 'core'}
-   Description: ${schema.description}
-   Namespaced: ${schema.namespace}`;
-            // Include detailed schema information for capability analysis
-            if (schema.rawExplanation) {
-                resourceInfo += `\n\n   Complete Schema Information:\n${schema.rawExplanation}`;
-            }
-            return resourceInfo;
-        }).join('\n\n');
-        // Format organizational patterns for AI context
-        const patternsContext = patterns.length > 0
-            ? patterns.map(pattern => `- ID: ${pattern.id}
-            Description: ${pattern.description}
-            Suggested Resources: ${pattern.suggestedResources?.join(', ') || 'Not specified'}
-            Rationale: ${pattern.rationale}
-            Triggers: ${pattern.triggers?.join(', ') || 'None'}`).join('\n')
-            : 'No organizational patterns found for this request.';
-        return template
-            .replace('{intent}', intent)
-            .replace('{resources}', resourcesText)
-            .replace('{patterns}', patternsContext);
-    }
-    /**
-     * Parse AI response into solution results
-     */
-    parseAISolutionResponse(aiResponse, schemas) {
-        try {
-            // Use robust JSON extraction
-            const parsed = this.extractJsonFromAIResponse(aiResponse);
-            const solutions = parsed.solutions.map((solution) => {
-                const isDebugMode = process.env.DOT_AI_DEBUG === 'true';
-                if (isDebugMode) {
-                    console.debug('DEBUG: solution object:', JSON.stringify(solution, null, 2));
-                }
-                // Find matching schemas for the requested resources
-                const resources = [];
-                const notFound = [];
-                for (const requestedResource of solution.resources || []) {
-                    const matchingSchema = schemas.find(schema => schema.kind === requestedResource.kind &&
-                        schema.apiVersion === requestedResource.apiVersion &&
-                        schema.group === requestedResource.group);
-                    if (matchingSchema) {
-                        resources.push(matchingSchema);
-                    }
-                    else {
-                        notFound.push(requestedResource);
-                    }
-                }
-                if (resources.length === 0) {
-                    if (isDebugMode) {
-                        console.debug('DEBUG: No matching resources found');
-                        console.debug('DEBUG: Requested resources:', solution.resources);
-                        console.debug('DEBUG: Available schemas:', schemas.map(s => ({ kind: s.kind, apiVersion: s.apiVersion, group: s.group })));
-                    }
-                    const debugInfo = {
-                        requestedResources: solution.resources || [],
-                        notFoundResources: notFound,
-                        availableSchemas: schemas.map(s => ({ kind: s.kind, apiVersion: s.apiVersion, group: s.group }))
-                    };
-                    throw new Error(`No matching resources found: ${JSON.stringify(debugInfo, null, 2)}`);
-                }
-                if (notFound.length > 0 && isDebugMode) {
-                    console.debug('DEBUG: Some resources not found:', notFound);
-                }
-                return {
-                    type: solution.type,
-                    resources,
-                    score: solution.score,
-                    description: solution.description,
-                    reasons: solution.reasons || [],
-                    analysis: solution.analysis || '',
-                    questions: { required: [], basic: [], advanced: [], open: { question: '', placeholder: '' } },
-                    patternInfluences: solution.patternInfluences || [],
-                    usedPatterns: solution.usedPatterns || false
-                };
-            });
-            // Sort by score descending
-            return solutions.sort((a, b) => b.score - a.score);
-        }
-        catch (error) {
-            // Enhanced error message with more context
-            const errorMsg = `Failed to parse AI solution response: ${error.message}`;
-            const contextMsg = `\nAI Response (first 500 chars): "${aiResponse.substring(0, 500)}..."`;
-            const schemasMsg = `\nAvailable schemas: ${schemas.map(s => s.kind).join(', ')} (total: ${schemas.length})`;
-            throw new Error(errorMsg + contextMsg + schemasMsg);
-        }
-    }
     /**
      * Discover cluster options for dynamic question generation
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vfarcic/dot-ai",
-  "version": "0.57.0",
+  "version": "0.59.0",
   "description": "Universal Kubernetes application deployment agent with CLI and MCP interfaces",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/prompts/resource-selection.md

@@ -1,6 +1,6 @@
-# Resource Selection Prompt
+# Solution Assembly and Ranking Prompt
 
-You are a Kubernetes expert. Given this user intent and available resources, select the resources that could be relevant for detailed analysis.
+You are a Kubernetes expert. Given this user intent, available resources, and organizational patterns, create and rank complete solutions that address the user's needs.
 
 ## User Intent
 {intent}
@@ -15,14 +15,30 @@ You are a Kubernetes expert. Given this user intent and available resources, sel
 
 ## 🏆 PATTERN PRIORITIZATION (HIGHEST PRIORITY)
 
-**If any organizational pattern above matches this intent (based on pattern triggers), prioritize those resources above all others:**
-- **Golden Path Priority** - Pattern resources represent approved organizational standards and should rank higher than cloud-native alternatives
-- **Pattern Recognition** - Match pattern triggers against user intent keywords. If triggers match, the pattern's "Suggested Resources" become high-priority candidates
+**Pattern-Aware Resource Selection:**
+- **Pattern resources are included** in the Available Resources list below with source marked as "organizational-pattern"
+- **Golden Path Priority** - Pattern resources represent approved organizational standards and should rank higher than alternatives
 - **Higher-Level Abstractions** - Pattern resources often provide better user experience than low-level cloud provider resources
-- **Resource Name Matching** - Find exact "Suggested Resources" names in the "Resource Name" field of available resources
 
-Select all resources that could be relevant for this intent. Consider:
-- **🥇 FIRST: Organizational pattern resources** - When patterns match the intent, their suggested resources should appear early in your selection
+**SOLUTION ASSEMBLY APPROACH:**
+
+1. **Analyze Available Resources**: Review capabilities, providers, complexity, and use cases
+2. **Apply Pattern Logic**: Read pattern rationales to understand when they apply
+3. **Create Complete Solutions**: Assemble resources into working combinations
+4. **Rank by Effectiveness**: Score based on capability match, pattern compliance, and user intent
+
+**CRITICAL: Pattern Conditional Logic**
+- **Read each pattern's "Rationale" field carefully** - it specifies WHEN the pattern applies
+- **Apply patterns conditionally** - only include pattern resources when their technical conditions are met
+- **Resource compatibility analysis**: Before including pattern resources in a solution, verify the pattern's rationale matches the resources you're selecting
+- **API group dependencies**: If a pattern rationale mentions specific API groups (e.g., "solutions using X.api"), only apply that pattern when the solution actually uses resources from those API groups
+- **Multi-provider abstractions**: Higher-level abstractions that work across providers should not automatically trigger provider-specific auxiliary patterns unless technically required
+- **Pattern compliance increases solution score** - solutions following organizational patterns should rank higher, but only when patterns are correctly applied based on technical compatibility
+
+Create multiple alternative solutions. Consider:
+- **🥇 FIRST: Pattern-based solutions** - Complete solutions using organizational patterns when applicable
+- **🥈 SECOND: Technology-focused solutions** - Solutions optimized for specific technologies or providers  
+- **🥉 THIRD: Complexity variations** - Simple vs comprehensive approaches
 - Direct relevance to the user's needs (applications, infrastructure, operators, networking, storage)  
 - Common Kubernetes patterns and best practices
 - Resource relationships and combinations
@@ -36,28 +52,47 @@ Select all resources that could be relevant for this intent. Consider:
 - **Operator patterns**: Look for operators that provide simplified management of complex infrastructure
 - **CRD Selection Priority**: If you see multiple CRDs from the same group with similar purposes (like "App" and "AppClaim"), include the namespace-scoped ones (marked as "Namespaced: true") rather than cluster-scoped ones, as they're more appropriate for application deployments
 
-Don't limit yourself - if the intent is complex, select as many resources as needed. **Be extra inclusive** - the detailed schema analysis phase will filter out inappropriate resources, so it's better to include more candidates initially.
+**Generate 2-5 different solutions** that genuinely address the user intent. Prioritize relevance over quantity - it's better to provide 2-3 high-quality, relevant solutions than to include irrelevant alternatives just to reach a target number.
 
 ## Response Format
 
-Respond with ONLY a JSON array of resource objects with full identifiers. Do NOT wrap in an object - just return the array:
+Respond with ONLY a JSON object containing an array of complete solutions. Each solution should include resources, description, scoring, and pattern compliance:
 
 ```json
-[
-  {
-    "kind": "Deployment",
-    "apiVersion": "apps/v1",
-    "group": "apps"
-  },
-  {
-    "kind": "Service", 
-    "apiVersion": "v1",
-    "group": ""
-  }
-]
+{
+  "solutions": [
+    {
+      "type": "combination",
+      "resources": [
+        {
+          "kind": "Deployment",
+          "apiVersion": "apps/v1",
+          "group": "apps"
+        },
+        {
+          "kind": "Service",
+          "apiVersion": "v1",
+          "group": ""
+        }
+      ],
+      "score": 95,
+      "description": "Complete web application deployment with networking",
+      "reasons": ["High capability match for web applications", "Includes essential networking"],
+      "patternInfluences": [
+        {
+          "patternId": "web-app-pattern-123",
+          "description": "Web application deployment pattern",
+          "influence": "high",
+          "matchedTriggers": ["web application", "frontend"]
+        }
+      ],
+      "usedPatterns": true
+    }
+  ]
+}
 ```
 
-IMPORTANT: Your response must be ONLY the JSON array, nothing else.
+IMPORTANT: Your response must be ONLY the JSON object, nothing else.
 
 ## Selection Philosophy
 

package/prompts/resource-solution-ranking.md

@@ -1,158 +0,0 @@
-# Resource Solution Ranking Prompt
-
-You are a Kubernetes expert helping to determine which resource(s) best meet a user's needs.
-
-## User Intent
-{intent}
-
-## Available Resources
-{resources}
-
-## Organizational Patterns
-{patterns}
-
-**Note**: If no organizational patterns are provided above, this means pattern matching is unavailable (Vector DB not configured). Focus on pure Kubernetes resource analysis and recommendations.
-
-## Instructions
-
-Analyze the user's intent and determine the best solution(s). **Provide multiple alternative approaches** ranked by effectiveness, such as:
-- A single resource that fully addresses the need
-- A combination of resources that can actually integrate and work together to create a complete solution
-- Different approaches with varying complexity and capabilities
-
-**Organizational Patterns**: Multiple organizational patterns may be provided, each addressing different aspects of the deployment:
-
-- **Generic Application Patterns**: Apply to all applications (networking, monitoring, security)
-- **Architectural Patterns**: Apply to specific architectural styles (stateless, microservice, etc.)  
-- **Infrastructure Patterns**: Apply to specific integrations (database, messaging, etc.)
-- **Operational Patterns**: Apply to specific operational requirements (scaling, schema management, etc.)
-
-**Pattern Composition Strategy**:
-- **Combine relevant patterns** - A single solution can be influenced by multiple patterns
-- **Prioritize by specificity** - More specific patterns should have higher influence than generic ones
-- **Layer pattern guidance** - Generic patterns provide baseline, specific patterns add requirements
-- **Use complete patterns** - When a pattern is relevant, include ALL resources from that pattern unless you have a specific technical reason to exclude them
-- **Pattern resource completeness** - Organizational patterns represent battle-tested, complete solutions. Missing pattern resources often leads to incomplete deployments
-- **Avoid conflicts** - If patterns conflict, prioritize user intent and technical accuracy
-
-**IMPORTANT**: Always provide at least 2-3 different solution alternatives when possible, even if some score lower than others. Users benefit from seeing multiple options to choose from.
-
-## Validation Requirements
-
-**Capability Verification**: For each resource in your solution, examine its schema fields to verify it can fulfill the user's requirements. Do not assume capabilities that aren't explicitly present in the schema fields.
-
-**IMPORTANT - Pattern vs Individual Resource Validation**: When using organizational patterns, validate the PATTERN as a whole, not individual resources. Individual resources in a pattern may serve supporting roles and don't need to individually fulfill the complete user requirement - they work together as a complete solution.
-
-**Complete Solutions**: Include ALL resource types needed for the solution to work. If your analysis mentions integration with other resources, include those resources in your resources array. For example, if a workload resource has built-in templates or references to other resource types, include those referenced resource types in your solution even if they're managed through the primary resource.
-
-**Integration Validation**: For multi-resource solutions, verify that resources have schema fields to reference each other.
-
-## Scoring Guidelines
-
-**CRITICAL**: Identify whether each solution uses CRDs or standard Kubernetes resources, then apply the appropriate scoring range:
-
-### For CRD/Custom Resource Solutions:
-- **90-100**: CRD that clearly addresses user intent - operators provide higher-level abstractions and automatic resource management
-- **70-89**: CRD with partial relevance to user intent - may work but not ideal fit
-- **30-69**: CRD with limited relevance - significant gaps for this use case
-- **0-29**: CRD completely irrelevant to user intent
-
-### For Standard Kubernetes Resource Solutions:
-- **80-89**: Standard resource combination that fully addresses user intent
-- **60-79**: Standard resources with minor gaps or additional complexity  
-- **30-59**: Standard resources with significant limitations - major gaps in functionality
-- **0-29**: Standard resources poorly suited for this intent
-
-**Rationale**: CRDs get preference when relevant because operators provide domain expertise and simplified management. Standard resources remain reliable when no suitable CRDs exist.
-
-**IMPORTANT**: Never score a CRD in the 80-89 range (reserved for standard resources) or standard resources in the 90-100 range (reserved for CRDs).
-
-## Response Format
-
-```json
-{
-  "solutions": [
-    {
-      "type": "combination",
-      "resources": [
-        {
-          "kind": "Deployment",
-          "apiVersion": "apps/v1",
-          "group": "apps"
-        },
-        {
-          "kind": "Service",
-          "apiVersion": "v1",
-          "group": ""
-        }
-      ],
-      "score": 95,
-      "description": "Complete application deployment with networking",
-      "reasons": ["Provides full application lifecycle", "Includes network access"],
-      "analysis": "Detailed explanation of schema analysis and why this solution meets the user's needs",
-      "patternInfluences": [
-        {
-          "patternId": "stateless-app-pattern-123",
-          "description": "Stateless application deployment pattern",
-          "influence": "high",
-          "matchedTriggers": ["stateless app", "web application"],
-          "matchedConcept": "stateless application"
-        },
-        {
-          "patternId": "network-policy-pattern-456", 
-          "description": "Standard networking and security pattern",
-          "influence": "medium",
-          "matchedTriggers": ["application", "deployment"],
-          "matchedConcept": "generic application"
-        }
-      ],
-      "usedPatterns": true
-    },
-    {
-      "type": "single",
-      "resources": [
-        {
-          "kind": "Deployment",
-          "apiVersion": "apps/v1",
-          "group": "apps"
-        }
-      ],
-      "score": 75,
-      "description": "Basic application deployment",
-      "reasons": ["Simple deployment option", "Lower complexity"],
-      "analysis": "Alternative approach with reduced functionality but simpler setup",
-      "patternInfluences": [],
-      "usedPatterns": false
-    }
-  ]
-}
-```
-
-## Pattern Influence Tracking
-
-For each solution, you MUST include pattern influence information:
-
-**If organizational patterns influenced this solution:**
-- Set `"usedPatterns": true`
-- Include `"patternInfluences"` array with:
-  - `patternId`: Use the pattern's ID from the organizational patterns section
-  - `description`: Brief description of the pattern  
-  - `influence`: Rate as "high", "medium", or "low" based on how much the pattern shaped this solution
-  - `matchedTriggers`: Which pattern triggers matched the user's intent
-
-**If no patterns influenced this solution (or no patterns available):**
-- Set `"usedPatterns": false`
-- Use empty array: `"patternInfluences": []`
-
-**Pattern Influence Guidelines:**
-- **High influence**: Pattern directly suggested these specific resources or architecture
-- **Medium influence**: Pattern informed the approach but didn't dictate specific resources
-- **Low influence**: Pattern provided general guidance but minimal impact on final solution
-
-**Multiple Pattern Handling:**
-- **Include all relevant patterns** that influenced the solution, even if slightly
-- **Use different influence levels** to show relative importance of each pattern
-- **Match concept context** - Reference which deployment concept led to each pattern match
-- **Show composition** - Demonstrate how multiple patterns work together
-
-**IMPORTANT**: In your analysis field, explicitly explain which schema fields enable each requirement from the user intent. If a requirement cannot be fulfilled by available schema fields, explain this and score accordingly.