@vfarcic/dot-ai 0.49.0 → 0.51.0

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;;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,CAmOxD"}

package/dist/tools/recommend.js

@@ -65,7 +65,7 @@ async function validateIntentWithAI(intent, claudeIntegration) {
         // Replace template variables
         const validationPrompt = template.replace('{intent}', intent);
         // Send to Claude for validation
-        const response = await claudeIntegration.sendMessage(validationPrompt);
+        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
@@ -232,18 +232,14 @@ async function handleRecommendTool(args, dotAI, logger, requestId) {
         // Initialize AI-powered ResourceRecommender
         const rankingConfig = { claudeApiKey };
         const recommender = new schema_1.ResourceRecommender(rankingConfig);
-        // Create discovery functions
-        const discoverResourcesFn = async () => {
-            logger.debug('Discovering cluster resources', { requestId });
-            return await dotAI.discovery.discoverResources();
-        };
+        // Create discovery function
         const explainResourceFn = async (resource) => {
             logger.debug(`Explaining resource: ${resource}`, { requestId });
             return await dotAI.discovery.explainResource(resource);
         };
         // Find best solutions for the user intent
         logger.debug('Generating recommendations with AI', { requestId });
-        const solutions = await recommender.findBestSolutions(args.intent, discoverResourcesFn, explainResourceFn);
+        const solutions = await recommender.findBestSolutions(args.intent, explainResourceFn);
         logger.info('Recommendation process completed', {
             requestId,
             solutionCount: solutions.length,

package/dist/tools/version.d.ts

@@ -40,6 +40,15 @@ export interface SystemStatus {
         keyConfigured: boolean;
         error?: string;
     };
+    capabilities: {
+        systemReady: boolean;
+        vectorDBHealthy: boolean;
+        collectionAccessible: boolean;
+        storedCount?: number;
+        error?: string;
+        rawError?: string;
+        lastDiagnosis: string;
+    };
 }
 /**
  * Get version information from package.json

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

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/tools/version.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGhD,eAAO,MAAM,iBAAiB,YAAY,CAAC;AAC3C,eAAO,MAAM,wBAAwB,gMAAgM,CAAC;AACtO,eAAO,MAAM,yBAAyB;;;;;CAKrC,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,WAAW,CAAC;IACrB,QAAQ,EAAE;QACR,SAAS,EAAE,OAAO,CAAC;QACnB,GAAG,EAAE,MAAM,CAAC;QACZ,cAAc,EAAE,MAAM,CAAC;QACvB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,SAAS,EAAE;QACT,SAAS,EAAE,OAAO,CAAC;QACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;QACxB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACT,SAAS,EAAE,OAAO,CAAC;QACnB,aAAa,EAAE,OAAO,CAAC;QACvB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAmGD;;GAEG;AACH,wBAAgB,cAAc,IAAI,WAAW,CAqB5C;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,GAAG,CAAC,CAiEd"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/tools/version.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGhD,eAAO,MAAM,iBAAiB,YAAY,CAAC;AAC3C,eAAO,MAAM,wBAAwB,gMAAgM,CAAC;AACtO,eAAO,MAAM,yBAAyB;;;;;CAKrC,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,WAAW,CAAC;IACrB,QAAQ,EAAE;QACR,SAAS,EAAE,OAAO,CAAC;QACnB,GAAG,EAAE,MAAM,CAAC;QACZ,cAAc,EAAE,MAAM,CAAC;QACvB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,SAAS,EAAE;QACT,SAAS,EAAE,OAAO,CAAC;QACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;QACxB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACT,SAAS,EAAE,OAAO,CAAC;QACnB,aAAa,EAAE,OAAO,CAAC;QACvB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,YAAY,EAAE;QACZ,WAAW,EAAE,OAAO,CAAC;QACrB,eAAe,EAAE,OAAO,CAAC;QACzB,oBAAoB,EAAE,OAAO,CAAC;QAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AA4ND;;GAEG;AACH,wBAAgB,cAAc,IAAI,WAAW,CAqB5C;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,GAAG,CAAC,CAsEd"}

package/dist/tools/version.js

@@ -110,6 +110,111 @@ async function getEmbeddingStatus() {
         reason: status.reason
     };
 }
+/**
+ * Test capability system readiness
+ */
+async function getCapabilityStatus() {
+    const timestamp = new Date().toISOString();
+    try {
+        const capabilityService = new index_1.CapabilityVectorService();
+        // Test Vector DB health for capabilities
+        let vectorDBHealthy = false;
+        let collectionAccessible = false;
+        let storedCount;
+        try {
+            vectorDBHealthy = await capabilityService.healthCheck();
+        }
+        catch (error) {
+            return {
+                systemReady: false,
+                vectorDBHealthy: false,
+                collectionAccessible: false,
+                error: `Vector DB health check failed: ${error instanceof Error ? error.message : String(error)}`,
+                lastDiagnosis: timestamp
+            };
+        }
+        if (vectorDBHealthy) {
+            // Test collection accessibility and storage operations
+            try {
+                await capabilityService.initialize();
+                storedCount = await capabilityService.getCapabilitiesCount();
+                collectionAccessible = true;
+                // Test actual storage operation to detect dimension mismatches and other storage issues
+                const testCapability = {
+                    resourceName: 'test.version.diagnostic',
+                    capabilities: ['version-test'],
+                    providers: ['test'],
+                    abstractions: ['diagnostic'],
+                    complexity: 'low',
+                    description: 'Version tool diagnostic test capability',
+                    useCase: 'Testing capability storage pipeline',
+                    confidence: 0.95, // Should be 0-1 range, not 0-100
+                    analyzedAt: timestamp
+                };
+                // Test embedding generation directly first
+                const embeddingService = new index_1.EmbeddingService();
+                const testEmbedding = await embeddingService.generateEmbedding('test capability storage pipeline');
+                if (!testEmbedding || testEmbedding.length !== 1536) {
+                    throw new Error(`Embedding dimension mismatch: expected 1536, got ${testEmbedding?.length || 'null'} dimensions`);
+                }
+                // Validate embedding values are numbers (not NaN, Infinity, etc.)
+                if (testEmbedding.some(val => !Number.isFinite(val))) {
+                    throw new Error('Embedding contains invalid values (NaN or Infinity)');
+                }
+                // Attempt to store test capability
+                await capabilityService.storeCapability(testCapability);
+                // Attempt to retrieve test capability
+                const retrieved = await capabilityService.getCapability('test.version.diagnostic');
+                if (!retrieved) {
+                    throw new Error('Test capability storage failed - could not retrieve stored test data');
+                }
+                // Clean up test capability
+                await capabilityService.deleteCapability('test.version.diagnostic');
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                // Check for common Vector DB issues
+                const isDimensionMismatch = errorMessage.toLowerCase().includes('dimension') ||
+                    errorMessage.toLowerCase().includes('vector') ||
+                    errorMessage.toLowerCase().includes('size') ||
+                    errorMessage.toLowerCase().includes('bad request');
+                return {
+                    systemReady: false,
+                    vectorDBHealthy: true,
+                    collectionAccessible: collectionAccessible,
+                    storedCount: storedCount,
+                    error: isDimensionMismatch ?
+                        `Vector dimension mismatch detected: ${errorMessage}. The capabilities collection exists but has incompatible vector dimensions. Delete the collection to allow recreation with correct dimensions.` :
+                        `Capability storage test failed: ${errorMessage}`,
+                    lastDiagnosis: timestamp,
+                    // Add raw error for debugging
+                    rawError: errorMessage
+                };
+            }
+        }
+        // Check embedding service (required for semantic search)
+        const embeddingService = new index_1.EmbeddingService();
+        const embeddingAvailable = embeddingService.isAvailable();
+        // System is ready if Vector DB is healthy, collection is accessible, and embeddings available
+        const systemReady = vectorDBHealthy && collectionAccessible && embeddingAvailable;
+        return {
+            systemReady,
+            vectorDBHealthy,
+            collectionAccessible,
+            storedCount,
+            lastDiagnosis: timestamp
+        };
+    }
+    catch (error) {
+        return {
+            systemReady: false,
+            vectorDBHealthy: false,
+            collectionAccessible: false,
+            error: `Capability diagnostics failed: ${error instanceof Error ? error.message : String(error)}`,
+            lastDiagnosis: timestamp
+        };
+    }
+}
 /**
  * Test Anthropic API connectivity
  */
@@ -175,16 +280,18 @@ async function handleVersionTool(args, logger, requestId) {
         const version = getVersionInfo();
         // Run all diagnostics in parallel for better performance
         logger.info('Running system diagnostics...', { requestId });
-        const [vectorDBStatus, embeddingStatus, anthropicStatus] = await Promise.all([
+        const [vectorDBStatus, embeddingStatus, anthropicStatus, capabilityStatus] = await Promise.all([
             getVectorDBStatus(),
             getEmbeddingStatus(),
-            getAnthropicStatus()
+            getAnthropicStatus(),
+            getCapabilityStatus()
         ]);
         const systemStatus = {
             version,
             vectorDB: vectorDBStatus,
             embedding: embeddingStatus,
-            anthropic: anthropicStatus
+            anthropic: anthropicStatus,
+            capabilities: capabilityStatus
         };
         // Log summary of system health
         logger.info('System diagnostics completed', {
@@ -192,7 +299,8 @@ async function handleVersionTool(args, logger, requestId) {
             version: version.version,
             vectorDBConnected: vectorDBStatus.connected,
             embeddingAvailable: embeddingStatus.available,
-            anthropicConnected: anthropicStatus.connected
+            anthropicConnected: anthropicStatus.connected,
+            capabilitySystemReady: capabilityStatus.systemReady
         });
         return {
             content: [{
@@ -201,10 +309,12 @@ async function handleVersionTool(args, logger, requestId) {
                         status: 'success',
                         system: systemStatus,
                         summary: {
-                            overall: vectorDBStatus.connected && anthropicStatus.connected ? 'healthy' : 'degraded',
+                            overall: vectorDBStatus.connected && anthropicStatus.connected && capabilityStatus.systemReady ? 'healthy' : 'degraded',
                             patternSearch: embeddingStatus.available ? 'semantic+keyword' : 'keyword-only',
+                            capabilityScanning: capabilityStatus.systemReady ? 'ready' : 'not-ready',
                             capabilities: [
                                 vectorDBStatus.connected ? 'pattern-management' : null,
+                                capabilityStatus.systemReady ? 'capability-scanning' : null,
                                 embeddingStatus.available ? 'semantic-search' : null,
                                 anthropicStatus.connected ? 'ai-recommendations' : null
                             ].filter(Boolean)

package/package.json

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

package/prompts/capability-inference.md

@@ -0,0 +1,122 @@
+# Generic Kubernetes Resource Capability Analysis
+
+Analyze this Kubernetes resource and identify its capabilities for semantic matching and AI recommendations.
+
+## Resource Information
+- **Resource**: {resourceName}
+
+## Resource Definition
+```yaml
+{resourceDefinition}
+```
+
+## Analysis Instructions
+
+Analyze the provided resource definition to understand what this resource does and extract its capabilities. Use only information present in the definition - do not guess or assume.
+
+### 1. Functional Capabilities
+From the resource definition, identify what this resource enables users to do:
+- Look at schema properties, descriptions, and field names
+- Identify the core functionality (e.g., "database", "storage", "networking")
+- Be specific about technologies (e.g., "postgresql" vs generic "database")
+- Extract capabilities from field names, descriptions, and structure
+
+### 2. Provider/Platform Support  
+Identify what platforms or providers this resource works with:
+- Look for provider-specific configuration sections or fields
+- Check for multi-provider abstractions vs single-provider resources
+- Identify on-premises vs cloud-only resources
+- Only list providers explicitly mentioned or configured in the definition
+
+### 3. Abstraction Level
+Determine what abstractions this resource provides:
+- High-level managed services with minimal configuration
+- Infrastructure abstractions (auto-scaling, high availability, etc.)
+- Integration capabilities (backup, monitoring, security features)
+- Look at required vs optional fields to gauge abstraction level
+
+### 4. User Experience Complexity
+Assess complexity considering both configuration and assembly requirements:
+
+**Configuration Complexity:**
+- Number and difficulty of required fields
+- Technical knowledge needed for the resource itself
+- Clarity of purpose and abstractions provided
+
+**Assembly Complexity:**
+- **Standalone**: Resource works independently, creates/manages all dependencies
+- **Coordinated**: Requires 2-3 other resources to be functional
+- **Orchestrated**: Needs many resources and complex relationships to work
+
+**Final Complexity Rating:**
+- **Low**: Simple configuration AND works standalone or with minimal dependencies
+- **Medium**: Moderate configuration OR needs some coordination with other resources  
+- **High**: Complex configuration OR requires orchestrating many resources OR both
+
+## Response Format
+
+Respond **only** with valid JSON in this exact format:
+
+```json
+{
+  "capabilities": ["capability1", "capability2", "capability3"],
+  "providers": ["provider1", "provider2"],
+  "abstractions": ["abstraction1", "abstraction2"],
+  "complexity": "low|medium|high",
+  "description": "Brief description of what this resource does (1-2 sentences)",
+  "useCase": "Primary use case for this resource (1 sentence)",
+  "confidence": 0.8
+}
+```
+
+## Examples
+
+### Database Resource Example
+```json
+{
+  "capabilities": ["postgresql", "mysql", "database", "managed database"],
+  "providers": ["azure", "gcp", "aws"],
+  "abstractions": ["managed service", "high availability", "backup"],
+  "complexity": "low",
+  "description": "High-level managed database solution supporting multiple engines and cloud providers",
+  "useCase": "Simple database deployment without infrastructure complexity",
+  "confidence": 0.9
+}
+```
+
+### Storage Resource Example
+```json
+{
+  "capabilities": ["object storage", "backup", "storage"],
+  "providers": ["aws"],
+  "abstractions": ["managed service", "auto scaling"],
+  "complexity": "medium",
+  "description": "AWS S3-compatible object storage with backup capabilities",
+  "useCase": "Object storage and backup for applications",
+  "confidence": 0.85
+}
+```
+
+### Application Resource Example  
+```json
+{
+  "capabilities": ["web service", "api", "application"],
+  "providers": ["multi cloud"],
+  "abstractions": ["auto scaling", "monitoring"],
+  "complexity": "medium",
+  "description": "Web application deployment with auto scaling and monitoring",
+  "useCase": "Scalable web application hosting",
+  "confidence": 0.8
+}
+```
+
+## Important Notes
+
+- **Be specific**: Use precise capability terms that users would search for
+- **Be comprehensive**: Include all relevant capabilities, not just the primary one
+- **Be accurate**: Only include capabilities that are clearly supported
+- **Focus on user intent**: Think about what users would search for to find this resource
+- **Consider abstraction**: Higher abstraction = lower complexity for users
+- **Confidence score**: 0.1-1.0 based on how certain you are about the analysis
+
+Analyze the provided resource and respond with the JSON format above.

package/prompts/doc-testing-test-section.md

@@ -63,6 +63,42 @@ Check every claim in the documentation:
 
 ## Testing Approach
 
+### EXECUTION REQUIREMENTS FOR TESTABLE CONTENT
+**When documentation contains executable examples, you MUST actually execute them:**
+
+**Types of executable content that require actual testing:**
+- **CLI Commands**: `kubectl get pods`, `npm install`, `docker run`
+- **API Calls**: HTTP requests, REST endpoints, GraphQL queries
+- **MCP Tool Calls**: `mcp__tool_name` with documented parameters
+- **Configuration Examples**: Creating files, environment variables, config files
+- **Web Navigation**: URLs, web interface interactions, form submissions
+- **Database Queries**: SQL commands, database operations
+- **Script Execution**: Shell scripts, Python scripts, automation workflows
+
+**Testing Protocol for Executable Content:**
+✅ REQUIRED: Execute each example exactly as documented
+✅ REQUIRED: Test with the exact parameters/inputs shown  
+✅ REQUIRED: Compare actual results with documented expected results
+❌ FORBIDDEN: Analyze implementation code instead of running examples
+❌ FORBIDDEN: Skip execution because "it looks similar to previous tests"
+❌ FORBIDDEN: Rely on testing from other sections of the documentation
+
+### NON-TESTABLE CONTENT (Testing Not Required)
+**These types of content should be analyzed but not executed:**
+- **Conceptual explanations**: Architecture descriptions, background theory
+- **Screenshots**: Visual examples that can't be directly executed
+- **Future roadmaps**: Planned features not yet implemented
+- **External dependencies**: Third-party services you don't control
+- **Destructive operations**: Commands that could damage systems
+- **Hardware-specific instructions**: When you lack the specific hardware
+- **Security credentials**: Examples containing sensitive information
+
+### CRITICAL: Section-Specific Testing Required (When Testable)
+**Each documentation section with executable content requires independent validation:**
+- Execute the specific testable examples shown in the current section
+- Previous successful tests cannot substitute for current section validation
+- Clearly distinguish between testable and non-testable content in your analysis
+
 ### Functional Testing (Execute Documentation)
 **Execute documented examples first** - Always prioritize running the actual commands/procedures shown in the documentation, adapting for safety when needed. Use help commands only as supplements for understanding, not as substitutes for real testing.
 
@@ -102,9 +138,11 @@ Return your results as JSON in this exact format:
 
 **whatWasDone** (string): Concise summary covering BOTH functional testing AND semantic analysis - what commands/procedures you executed and what claims you analyzed.
 
-**issues** (array): CRITICAL PROBLEMS that prevent users from succeeding (broken functionality, incorrect information, missing required steps). Include precise location and explain user impact.
+**issues** (array): CRITICAL PROBLEMS that prevent users from succeeding (broken functionality, incorrect information, missing required steps). Include precise location and explain user impact. Each issue must be ACTIONABLE - describe what needs to be changed/fixed.
+
+**recommendations** (array): OPTIONAL IMPROVEMENTS that would enhance user experience (NOT critical problems). Must be genuinely optional - user can succeed without these changes. Each recommendation must be ACTIONABLE - describe a specific change to make. Do NOT include statements that validate existing content is correct (e.g., "The format matches actual behavior - this is accurate"). Only include suggestions for actual changes or additions. Do NOT repeat anything from issues array.
 
-**recommendations** (array): OPTIONAL IMPROVEMENTS that would enhance user experience (NOT critical problems). Must be genuinely optional - user can succeed without these changes. Do NOT repeat anything from issues array.
+**ACTIONABILITY REQUIREMENT**: Both issues and recommendations must suggest concrete changes. Avoid validation statements like "X is correct" or "Y matches expected behavior." If something is working correctly, don't mention it unless suggesting an enhancement.
 
 **ANTI-DUPLICATION RULES**: If something is broken/incorrect → issues only. If something could be enhanced but works fine → recommendations only. Never put the same concept in both arrays.
 

package/prompts/resource-selection.md

@@ -13,11 +13,18 @@ You are a Kubernetes expert. Given this user intent and available resources, sel
 
 ## Instructions
 
+## 🏆 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
+- **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:
-- Direct relevance to the user's needs (applications, infrastructure, operators, networking, storage)
+- **🥇 FIRST: Organizational pattern resources** - When patterns match the intent, their suggested resources should appear early in your selection
+- Direct relevance to the user's needs (applications, infrastructure, operators, networking, storage)  
 - Common Kubernetes patterns and best practices
-- **PRIORITY: Organizational pattern resources** - If organizational patterns are provided above, ALWAYS include ALL resources from patterns that match this intent, even if individual resources don't seem directly relevant
-- **Pattern resource completeness** - Organizational patterns represent complete, battle-tested solutions. Include entire pattern resource sets to avoid incomplete deployments
 - Resource relationships and combinations
 - Production deployment patterns
 - Complex multi-component solutions

package/shared-prompts/prd-update-decisions.md

@@ -54,6 +54,7 @@ For each identified decision, assess:
 - **Scope Impact**: Does this expand or contract the project scope?
 - **Timeline Impact**: Does this affect project phases or delivery dates?
 - **Architecture Impact**: Does this change technical constraints or approaches?
+- **Code Example Impact**: Which examples, interfaces, or snippets become outdated?
 - **Risk Impact**: Does this introduce new risks or mitigate existing ones?
 
 ### Decision Documentation Format
@@ -62,6 +63,7 @@ For each decision, record:
 - **Date**: When the decision was made
 - **Rationale**: Why this approach was chosen
 - **Impact**: How this affects the PRD requirements, scope, or approach
+- **Code Impact**: Which code examples, interfaces, or snippets need updating
 - **Owner**: Who made or approved the decision
 
 ## Step 4: PRD Updates
@@ -83,6 +85,13 @@ Update the appropriate PRD sections:
 - Modify architecture decisions if technical approach evolved
 - Adjust scope management if features were added, deferred, or removed
 
+### Code Example Validation and Updates
+- **Identify Outdated Examples**: Scan PRD for code snippets that may be affected by design decisions
+- **Interface Changes**: Update examples when function signatures, parameter types, or return values change
+- **API Modifications**: Revise examples when method names, class structures, or data formats evolve
+- **Workflow Updates**: Update process examples when user interaction patterns or step sequences change
+- **Mark for Verification**: Flag code examples that need manual testing to ensure they still work
+
 ### Risk and Dependency Updates
 - Add new risks introduced by design decisions
 - Update mitigation strategies if approach changed

package/shared-prompts/prd-update-progress.md

@@ -247,6 +247,39 @@ When applying updates:
 4. **Preserve unchecked items** that still need work
 5. **Update completion percentages** realistically
 
+## Step 7.5: Code Example Validation
+
+When updating PRDs based on implementation progress:
+
+**CRITICAL**: Always check if code examples in PRD match current implementation
+
+### Example Impact Detection
+1. **Interface Changes**: Function signatures, parameter types, return formats
+2. **API Evolution**: Method names, class structures, data models
+3. **Workflow Updates**: User interaction patterns, step sequences
+4. **Integration Changes**: How components connect and communicate
+
+### Code Example Update Process
+1. **Scan PRD**: Identify all code snippets and examples
+2. **Cross-reference Implementation**: Compare examples with actual code
+3. **Mark Outdated**: Flag examples that no longer match
+4. **Priority Assessment**: Determine which examples need immediate updates
+5. **Update Examples**: Revise code snippets to match current implementation
+6. **Validate Examples**: Test updated examples to ensure they work
+
+### Example Categories to Check
+- **Function calls**: Parameter order, types, names
+- **Interface definitions**: TypeScript interfaces, class structures
+- **API responses**: Data formats, field names, response structures  
+- **Workflow steps**: User interaction sequences, tool usage patterns
+- **Configuration**: Setup examples, environment variables, config files
+
+### When to Update Examples
+- **Immediately**: When interface changes break existing examples
+- **Before completion**: When marking implementation milestones complete
+- **During reviews**: When validating PRD accuracy
+- **User feedback**: When someone reports examples don't work
+
 ## Step 8: Commit Progress Updates
 
 After successfully updating the PRD, commit all changes to preserve the progress checkpoint:

package/prompts/concept-extraction.md

@@ -1,95 +0,0 @@
-# Concept Extraction for Pattern Matching
-
-You are a Kubernetes deployment expert. Extract multiple deployment concepts from user intent to enable comprehensive pattern matching.
-
-## User Intent
-{intent}
-
-## Instructions
-
-Analyze the user intent and extract all relevant deployment concepts. Consider these categories:
-
-### **Application Architecture**
-- Application types: web application, API service, microservice, monolith, frontend, backend
-- Architectural patterns: stateless, stateful, serverless, event-driven, batch processing
-- Service types: REST API, GraphQL API, gRPC service, websocket service, message consumer
-
-### **Infrastructure & Integration**  
-- Data storage: database, cache, persistent storage, file storage, object storage
-- Database services: PostgreSQL, MongoDB, MySQL, Redis, Elasticsearch clusters
-- Connectivity: external database, message queue, third-party API, service mesh
-- Networking: public access, internal service, load balancing, ingress, networking policies
-- Infrastructure operators: monitoring, logging, backup, security operators
-
-### **Operational Requirements**
-- Scaling: auto-scaling, high availability, load balancing, horizontal scaling
-- Data management: schema management, database migrations, backup, monitoring
-- Security: authentication, authorization, network policies, secrets management
-- Deployment: CI/CD, blue-green deployment, canary deployment, rolling updates
-
-### **Technology Stack**
-- Programming languages: golang, java, python, nodejs, react, angular
-- Frameworks: spring boot, express, flask, django, rails
-- Databases: postgresql, mysql, mongodb, redis, elasticsearch
-- Infrastructure tools: prometheus, grafana, ingress-nginx, istio, knative
-- Operators: database operators, monitoring operators, backup operators
-
-## Response Format
-
-Extract 3-8 specific concepts that organizational patterns might address. Focus on concepts that would have dedicated deployment patterns.
-
-```json
-{
-  "concepts": [
-    {
-      "category": "application_architecture|infrastructure|operational|technology",
-      "concept": "specific concept name",
-      "importance": "high|medium|low",
-      "keywords": ["keyword1", "keyword2", "keyword3"]
-    }
-  ]
-}
-```
-
-## Examples
-
-**Input**: "deploy a stateless golang API that connects to PostgreSQL with auto-scaling"
-**Output**:
-```json
-{
-  "concepts": [
-    {
-      "category": "application_architecture", 
-      "concept": "stateless application",
-      "importance": "high",
-      "keywords": ["stateless", "stateless app", "stateless service", "stateless workload"]
-    },
-    {
-      "category": "application_architecture",
-      "concept": "REST API service", 
-      "importance": "high",
-      "keywords": ["api", "rest api", "api service", "web service", "http service"]
-    },
-    {
-      "category": "technology",
-      "concept": "golang application",
-      "importance": "medium", 
-      "keywords": ["golang", "go", "golang app", "go application", "go service"]
-    },
-    {
-      "category": "infrastructure",
-      "concept": "database connection",
-      "importance": "high",
-      "keywords": ["database", "postgresql", "db connection", "external database"]
-    },
-    {
-      "category": "operational", 
-      "concept": "auto-scaling",
-      "importance": "medium",
-      "keywords": ["auto-scaling", "horizontal scaling", "scaling", "hpa"]
-    }
-  ]
-}
-```
-
-**IMPORTANT**: Return ONLY the JSON object, nothing else.