@vfarcic/dot-ai 0.5.1 → 0.6.0

package/tests/core/schema.test.ts

@@ -1,1658 +0,0 @@
-/**
- * Schema Parser and Validator Tests
- * 
- * TDD test suite for Task 3: Resource Schema Parser and Validator
- * Following the same TDD methodology used in Task 2
- */
-
-import { SchemaParser, ResourceSchema, SchemaField, ResourceRecommender, ValidationResult, ResourceSolution, AIRankingConfig, Question, QuestionGroup, ClusterOptions } from '../../src/core/schema';
-// SolutionEnhancer moved to legacy - see src/legacy/core/solution-enhancer.ts for reference
-// import { SolutionEnhancer } from '../../src/legacy/core/solution-enhancer';
-import { ResourceExplanation } from '../../src/core/discovery';
-
-describe('ResourceSchema Interface and Core Types', () => {
-  describe('ResourceSchema interface', () => {
-    it('should define complete schema structure with all required fields', () => {
-      const schema: ResourceSchema = {
-        apiVersion: 'apps/v1',
-        kind: 'Deployment',
-        group: 'apps',
-        version: 'v1',
-        description: 'Deployment enables declarative updates for Pods and ReplicaSets',
-        properties: new Map(),
-        required: ['metadata', 'spec'],
-        namespace: true
-      };
-
-      expect(schema.apiVersion).toBe('apps/v1');
-      expect(schema.kind).toBe('Deployment');
-      expect(schema.group).toBe('apps');
-      expect(schema.version).toBe('v1');
-      expect(schema.description).toContain('Deployment');
-      expect(schema.properties).toBeInstanceOf(Map);
-      expect(schema.required).toEqual(['metadata', 'spec']);
-      expect(schema.namespace).toBe(true);
-    });
-
-    it('should support nested properties with SchemaField structure', () => {
-      const field: SchemaField = {
-        name: 'spec.replicas',
-        type: 'integer',
-        description: 'Number of desired pods',
-        required: false,
-        default: 1,
-        constraints: {
-          minimum: 0,
-          maximum: 1000
-        },
-        nested: new Map()
-      };
-
-      expect(field.name).toBe('spec.replicas');
-      expect(field.type).toBe('integer');
-      expect(field.description).toContain('pods');
-      expect(field.required).toBe(false);
-      expect(field.default).toBe(1);
-      expect(field.constraints?.minimum).toBe(0);
-      expect(field.constraints?.maximum).toBe(1000);
-      expect(field.nested).toBeInstanceOf(Map);
-    });
-
-    it('should handle different field types correctly', () => {
-      const stringField: SchemaField = {
-        name: 'metadata.name',
-        type: 'string',
-        description: 'Name of the resource',
-        required: true,
-        nested: new Map()
-      };
-
-      const arrayField: SchemaField = {
-        name: 'spec.containers',
-        type: 'array',
-        description: 'List of containers',
-        required: true,
-        nested: new Map()
-      };
-
-      const objectField: SchemaField = {
-        name: 'spec.selector',
-        type: 'object',
-        description: 'Label selector',
-        required: true,
-        nested: new Map()
-      };
-
-      expect(stringField.type).toBe('string');
-      expect(arrayField.type).toBe('array');
-      expect(objectField.type).toBe('object');
-    });
-  });
-});
-
-describe('SchemaParser Class', () => {
-  let parser: SchemaParser;
-
-  beforeEach(() => {
-    parser = new SchemaParser();
-  });
-
-  describe('parseResourceExplanation method', () => {
-    it('should convert ResourceExplanation to ResourceSchema', () => {
-      const explanation: ResourceExplanation = {
-        kind: 'Pod',
-        version: 'v1',
-        group: '',
-        description: 'Pod is a collection of containers',
-        fields: [
-          {
-            name: 'metadata',
-            type: 'Object',
-            description: 'Standard object metadata',
-            required: true
-          },
-          {
-            name: 'spec',
-            type: 'Object',
-            description: 'Specification of the desired behavior',
-            required: true
-          },
-          {
-            name: 'status',
-            type: 'Object',
-            description: 'Most recently observed status',
-            required: false
-          }
-        ]
-      };
-
-      const schema = parser.parseResourceExplanation(explanation);
-
-      expect(schema.kind).toBe('Pod');
-      expect(schema.version).toBe('v1');
-      expect(schema.group).toBe('');
-      expect(schema.apiVersion).toBe('v1');
-      expect(schema.description).toContain('Pod is a collection');
-      expect(schema.required).toContain('metadata');
-      expect(schema.required).toContain('spec');
-      expect(schema.required).not.toContain('status');
-      expect(schema.properties.has('metadata')).toBe(true);
-      expect(schema.properties.has('spec')).toBe(true);
-      expect(schema.properties.has('status')).toBe(true);
-    });
-
-    it('should handle nested field parsing correctly', () => {
-      const explanation: ResourceExplanation = {
-        kind: 'Deployment',
-        version: 'v1',
-        group: 'apps',
-        description: 'Deployment description',
-        fields: [
-          {
-            name: 'spec.replicas',
-            type: 'integer',
-            description: 'Number of desired pods',
-            required: false
-          },
-          {
-            name: 'spec.selector.matchLabels',
-            type: 'object',
-            description: 'Map of label selectors',
-            required: true
-          },
-          {
-            name: 'spec.template.metadata.labels',
-            type: 'object',
-            description: 'Map of string keys and values',
-            required: false
-          }
-        ]
-      };
-
-      const schema = parser.parseResourceExplanation(explanation);
-
-      expect(schema.properties.has('spec')).toBe(true);
-      const specField = schema.properties.get('spec');
-      expect(specField?.nested?.has('replicas')).toBe(true);
-      expect(specField?.nested?.has('selector')).toBe(true);
-      expect(specField?.nested?.has('template')).toBe(true);
-
-      const selectorField = specField?.nested?.get('selector');
-      expect(selectorField?.nested?.has('matchLabels')).toBe(true);
-    });
-
-    it('should extract type constraints from field descriptions', () => {
-      const explanation: ResourceExplanation = {
-        kind: 'Pod',
-        version: 'v1',
-        group: '',
-        description: 'Pod description',
-        fields: [
-          {
-            name: 'spec.activeDeadlineSeconds',
-            type: 'integer',
-            description: 'Optional duration in seconds (minimum: 1)',
-            required: false
-          },
-          {
-            name: 'spec.restartPolicy',
-            type: 'string',
-            description: 'Restart policy. Possible values: Always, OnFailure, Never',
-            required: false
-          }
-        ]
-      };
-
-      const schema = parser.parseResourceExplanation(explanation);
-      const specField = schema.properties.get('spec');
-      
-      const deadlineField = specField?.nested?.get('activeDeadlineSeconds');
-      expect(deadlineField?.constraints?.minimum).toBe(1);
-
-      const restartField = specField?.nested?.get('restartPolicy');
-      expect(restartField?.constraints?.enum).toEqual(['Always', 'OnFailure', 'Never']);
-    });
-
-    it('should handle different kubectl explain output formats', () => {
-      // Test with minimal field information
-      const minimalExplanation: ResourceExplanation = {
-        kind: 'ConfigMap',
-        version: 'v1',
-        group: '',
-        description: 'ConfigMap holds configuration data',
-        fields: [
-          {
-            name: 'data',
-            type: 'object',
-            description: 'Data contains the configuration data',
-            required: false
-          }
-        ]
-      };
-
-      const schema = parser.parseResourceExplanation(minimalExplanation);
-      expect(schema.kind).toBe('ConfigMap');
-      expect(schema.properties.has('data')).toBe(true);
-    });
-  });
-
-  describe('parseFieldConstraints method', () => {
-    it('should extract minimum and maximum values from descriptions', () => {
-      const constraints1 = parser.parseFieldConstraints('integer', 'Port number (minimum: 1, maximum: 65535)');
-      expect(constraints1.minimum).toBe(1);
-      expect(constraints1.maximum).toBe(65535);
-
-      const constraints2 = parser.parseFieldConstraints('integer', 'Replicas (min: 0, max: 100)');
-      expect(constraints2.minimum).toBe(0);
-      expect(constraints2.maximum).toBe(100);
-    });
-
-    it('should extract enum values from descriptions', () => {
-      const constraints1 = parser.parseFieldConstraints('string', 'Policy. Possible values: Always, OnFailure, Never');
-      expect(constraints1.enum).toEqual(['Always', 'OnFailure', 'Never']);
-
-      const constraints2 = parser.parseFieldConstraints('string', 'Type. Valid values are: ClusterIP, NodePort, LoadBalancer');
-      expect(constraints2.enum).toEqual(['ClusterIP', 'NodePort', 'LoadBalancer']);
-    });
-
-    it('should extract default values from descriptions', () => {
-      const constraints1 = parser.parseFieldConstraints('string', 'Image pull policy (default: IfNotPresent)');
-      expect(constraints1.default).toBe('IfNotPresent');
-
-      const constraints2 = parser.parseFieldConstraints('integer', 'Port number. Defaults to 80');
-      expect(constraints2.default).toBe(80);
-    });
-
-    it('should handle complex constraint descriptions', () => {
-      const constraints = parser.parseFieldConstraints(
-        'string',
-        'DNS policy. Valid values: ClusterFirst, Default, None. Default: ClusterFirst. Min length: 1'
-      );
-      expect(constraints.enum).toEqual(['ClusterFirst', 'Default', 'None']);
-      expect(constraints.default).toBe('ClusterFirst');
-      expect(constraints.minLength).toBe(1);
-    });
-  });
-});
-
-describe('ResourceRecommender Class (AI-Powered Two-Phase)', () => {
-  let ranker: ResourceRecommender;
-  let config: AIRankingConfig;
-  let mockClaudeIntegration: any;
-  let mockDiscoverResources: jest.Mock;
-  let mockExplainResource: jest.Mock;
-
-  beforeEach(() => {
-    config = { claudeApiKey: 'test-key' };
-    
-    // Mock discovery functions
-    mockDiscoverResources = jest.fn();
-    mockExplainResource = jest.fn();
-
-    // Mock the Claude integration
-    const ClaudeIntegration = require('../../src/core/claude').ClaudeIntegration;
-    mockClaudeIntegration = {
-      isInitialized: jest.fn().mockReturnValue(true),
-      sendMessage: jest.fn()
-    };
-    jest.spyOn(ClaudeIntegration.prototype, 'isInitialized').mockReturnValue(true);
-    jest.spyOn(ClaudeIntegration.prototype, 'sendMessage').mockImplementation(mockClaudeIntegration.sendMessage);
-
-    ranker = new ResourceRecommender(config);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  describe('findBestSolutions method with functional approach', () => {
-    it('should perform two-phase analysis for simple intent', async () => {
-      const intent = 'run a simple container';
-      
-      // Mock discovery data
-      mockDiscoverResources.mockResolvedValue({
-        resources: [
-          { kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true },
-          { kind: 'Deployment', apiVersion: 'apps/v1', group: 'apps', namespaced: true }
-        ],
-        custom: []
-      });
-
-      // Mock resource explanation - now returns kubectl explain string format
-      mockExplainResource.mockResolvedValue(`GROUP:      
-KIND:       Pod
-VERSION:    v1
-
-DESCRIPTION:
-     Pod is a collection of containers that can run on a host
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata
-
-   spec	<Object> -required-
-     Specification of the desired behavior`);
-
-      // Mock kubectl for cluster discovery
-      const mockExecuteKubectl = jest.fn();
-      jest.doMock('../../src/core/kubernetes-utils', () => ({
-        executeKubectl: mockExecuteKubectl
-      }));
-      
-      mockExecuteKubectl
-        .mockResolvedValueOnce('default') // namespaces
-        .mockResolvedValueOnce('') // storage classes
-        .mockResolvedValueOnce('') // ingress classes
-        .mockResolvedValueOnce('{"items":[]}'); // nodes
-
-      // Mock fs.readFileSync for all three prompt templates
-      const fs = require('fs');
-      jest.spyOn(fs, 'readFileSync')
-        .mockReturnValueOnce('User Intent: {intent}\n\nAvailable Resources:\n{resources}') // Phase 1 template
-        .mockReturnValueOnce('User Intent: {intent}\n\nSelected Resources:\n{resources}') // Phase 2 template
-        .mockReturnValueOnce('User Intent: {intent}\nSolution: {solution_description}\nResources: {resource_details}\nCluster Options: {cluster_options}'); // Question generation template
-
-      // Mock AI responses for all three phases (selection, ranking, questions)
-      mockClaudeIntegration.sendMessage
-        .mockResolvedValueOnce({
-          content: `\`\`\`json
-[
-  {
-    "kind": "Pod",
-    "apiVersion": "v1",
-    "group": ""
-  }
-]
-\`\`\``
-        })
-        .mockResolvedValueOnce({
-          content: `\`\`\`json
-{
-  "solutions": [
-    {
-      "type": "single",
-      "resources": [{"kind": "Pod", "apiVersion": "v1", "group": ""}],
-      "score": 85,
-      "description": "Pod for simple container execution",
-      "reasons": ["Direct container hosting", "Simple use case"],
-      "analysis": "Pod is the perfect choice for running a simple container without complex orchestration needs"
-    }
-  ]
-}
-\`\`\``
-        })
-        .mockResolvedValueOnce({
-          content: `\`\`\`json
-{
-  "required": [{
-    "id": "container-image",
-    "question": "What container image do you want to deploy?",
-    "type": "text",
-    "validation": {"required": true}
-  }],
-  "basic": [],
-  "advanced": [],
-  "open": {
-    "question": "Any additional requirements?",
-    "placeholder": "Enter details..."
-  }
-}
-\`\`\``
-        });
-
-      const solutions = await ranker.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      expect(mockDiscoverResources).toHaveBeenCalledTimes(1);
-      expect(mockExplainResource).toHaveBeenCalledWith('Pod');
-      expect(mockClaudeIntegration.sendMessage).toHaveBeenCalledTimes(3);
-      expect(solutions).toHaveLength(1);
-      expect(solutions[0].type).toBe('single');
-      expect(solutions[0].resources[0].kind).toBe('Pod');
-      expect(solutions[0].score).toBe(85);
-      expect(solutions[0].questions).toBeDefined();
-      expect(solutions[0].questions.required).toHaveLength(1);
-    });
-
-    it('should handle CRD resources in two-phase approach', async () => {
-      const intent = 'provision a new Kubernetes cluster';
-      
-      // Mock discovery with CRD
-      mockDiscoverResources.mockResolvedValue({
-        resources: [
-          { kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true }
-        ],
-        custom: [
-          { kind: 'Cluster', version: 'v1beta1', group: 'infrastructure.cluster.x-k8s.io', scope: 'Namespaced' }
-        ]
-      });
-
-      // Mock CRD explanation
-      mockExplainResource.mockResolvedValue(`GROUP:      infrastructure.cluster.x-k8s.io
-KIND:       Cluster
-VERSION:    v1beta1
-
-DESCRIPTION:
-     Cluster is the Schema for the clusters API
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata
-
-   spec	<Object> -required-
-     Desired state of the cluster`);
-
-      const fs = require('fs');
-      jest.spyOn(fs, 'readFileSync')
-        .mockReturnValueOnce('{intent}\n{resources}')
-        .mockReturnValueOnce('{intent}\n{resources}');
-
-      mockClaudeIntegration.sendMessage
-        .mockResolvedValueOnce({
-          content: `[{
-            "kind": "Cluster",
-            "apiVersion": "infrastructure.cluster.x-k8s.io/v1beta1",
-            "group": "infrastructure.cluster.x-k8s.io"
-          }]`
-        })
-        .mockResolvedValueOnce({
-          content: `{
-            "solutions": [{
-              "type": "single",
-              "resources": [{"kind": "Cluster", "apiVersion": "infrastructure.cluster.x-k8s.io/v1beta1", "group": "infrastructure.cluster.x-k8s.io"}],
-              "score": 98,
-              "description": "Custom resource for cluster provisioning",
-              "reasons": ["Cluster management", "Infrastructure as code"],
-              "analysis": "This CRD is specifically designed for cluster provisioning"
-            }]
-          }`
-        });
-
-      const solutions = await ranker.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      expect(solutions[0].resources[0].kind).toBe('Cluster');
-      expect(solutions[0].resources[0].group).toBe('infrastructure.cluster.x-k8s.io');
-      expect(solutions[0].score).toBe(98);
-    });
-
-    it('should handle resource selection errors gracefully', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [{ kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true }],
-        custom: []
-      });
-
-      const fs = require('fs');
-      jest.spyOn(fs, 'readFileSync').mockReturnValue('{intent}\n{resources}');
-
-      // Mock invalid AI response for resource selection
-      mockClaudeIntegration.sendMessage.mockResolvedValue({
-        content: 'Invalid JSON response'
-      });
-
-      await expect(ranker.findBestSolutions(intent, mockDiscoverResources, mockExplainResource))
-        .rejects.toThrow('AI failed to select resources in valid JSON format');
-    });
-
-    it('should handle schema fetching failures', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [{ kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true }],
-        custom: []
-      });
-
-      // Mock successful resource selection but failed schema fetching
-      const fs = require('fs');
-      jest.spyOn(fs, 'readFileSync').mockReturnValue('{intent}\n{resources}');
-
-      mockClaudeIntegration.sendMessage.mockResolvedValue({
-        content: `[{"kind": "Pod", "apiVersion": "v1", "group": ""}]`
-      });
-
-      mockExplainResource.mockRejectedValue(new Error('Resource not found'));
-
-      await expect(ranker.findBestSolutions(intent, mockDiscoverResources, mockExplainResource))
-        .rejects.toThrow('Could not fetch schemas for any selected resources');
-    });
-
-    it('should throw error when Claude integration not initialized', async () => {
-      // Mock isInitialized to return false
-      const ClaudeIntegration = require('../../src/core/claude').ClaudeIntegration;
-      jest.spyOn(ClaudeIntegration.prototype, 'isInitialized').mockReturnValue(false);
-      
-      const uninitializedRanker = new ResourceRecommender(config);
-
-      await expect(uninitializedRanker.findBestSolutions('test intent', mockDiscoverResources, mockExplainResource))
-        .rejects.toThrow('Claude integration not initialized');
-    });
-
-    it('should validate AI-selected resources have required fields', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [{ kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true }],
-        custom: []
-      });
-
-      const fs = require('fs');
-      jest.spyOn(fs, 'readFileSync').mockReturnValue('{intent}\n{resources}');
-
-      // Mock AI response with invalid resource (missing apiVersion)
-      mockClaudeIntegration.sendMessage.mockResolvedValue({
-        content: `[{"kind": "Pod", "group": ""}]`
-      });
-
-      await expect(ranker.findBestSolutions(intent, mockDiscoverResources, mockExplainResource))
-        .rejects.toThrow('AI selected invalid resource');
-    });
-
-    it('should handle complex multi-resource solutions', async () => {
-      const intent = 'deploy a scalable web application';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [
-          { kind: 'Deployment', apiVersion: 'apps/v1', group: 'apps', namespaced: true },
-          { kind: 'Service', apiVersion: 'v1', group: '', namespaced: true }
-        ],
-        custom: []
-      });
-
-      // Mock explanations for both resources
-      mockExplainResource
-        .mockResolvedValueOnce(`GROUP:      apps
-KIND:       Deployment
-VERSION:    v1
-
-DESCRIPTION:
-     Deployment enables declarative updates for Pods and ReplicaSets
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata
-
-   spec	<Object> -required-
-     Specification of the desired behavior`)
-        .mockResolvedValueOnce(`GROUP:      
-KIND:       Service
-VERSION:    v1
-
-DESCRIPTION:
-     Service is a named abstraction of software service
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata
-
-   spec	<Object> -required-
-     Specification of the desired behavior`);
-
-      const fs = require('fs');
-      jest.spyOn(fs, 'readFileSync')
-        .mockReturnValueOnce('{intent}\n{resources}')
-        .mockReturnValueOnce('{intent}\n{resources}');
-
-      mockClaudeIntegration.sendMessage
-        .mockResolvedValueOnce({
-          content: `[
-            {"kind": "Deployment", "apiVersion": "apps/v1", "group": "apps"},
-            {"kind": "Service", "apiVersion": "v1", "group": ""}
-          ]`
-        })
-        .mockResolvedValueOnce({
-          content: `{
-            "solutions": [{
-              "type": "combination",
-              "resources": [{"kind": "Deployment", "apiVersion": "apps/v1", "group": "apps"}, {"kind": "Service", "apiVersion": "v1", "group": ""}],
-              "score": 95,
-              "description": "Complete web application stack",
-              "reasons": ["Scalable architecture", "Load balancing"],
-              "analysis": "Deployment provides scalability, Service enables network access"
-            }]
-          }`
-        });
-
-      const solutions = await ranker.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      expect(mockExplainResource).toHaveBeenCalledTimes(2);
-      expect(solutions[0].type).toBe('combination');
-      expect(solutions[0].resources).toHaveLength(2);
-      expect(solutions[0].resources[0].kind).toBe('Deployment');
-      expect(solutions[0].resources[1].kind).toBe('Service');
-      expect(solutions[0].score).toBe(95);
-    });
-
-    it('should load correct prompt templates for both phases', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [{ kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true }],
-        custom: []
-      });
-
-      mockExplainResource.mockResolvedValue(`GROUP:      
-KIND:       Pod
-VERSION:    v1
-
-DESCRIPTION:
-     Pod description
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`);
-
-      const fs = require('fs');
-      // Reset the mock and set clear expectations
-      const mockReadFileSync = jest.spyOn(fs, 'readFileSync');
-      mockReadFileSync.mockClear();
-      mockReadFileSync
-        .mockReturnValueOnce('Selection template: {intent}\n{resources}')
-        .mockReturnValueOnce('Ranking template: {intent}\n{resources}');
-
-      mockClaudeIntegration.sendMessage
-        .mockResolvedValueOnce({ content: `[{"kind": "Pod", "apiVersion": "v1", "group": ""}]` })
-        .mockResolvedValueOnce({ content: `{"solutions": [{"type": "single", "resources": [{"kind": "Pod", "apiVersion": "v1", "group": ""}], "score": 50, "description": "Test", "reasons": [], "analysis": ""}]}` });
-
-      await ranker.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      // Verify that the correct prompt files were loaded
-      expect(mockReadFileSync.mock.calls.find((call: any) => 
-        call[0] && call[0].includes('prompts/resource-selection.md')
-      )).toBeDefined();
-      expect(mockReadFileSync.mock.calls.find((call: any) => 
-        call[0] && call[0].includes('prompts/resource-solution-ranking.md')  
-      )).toBeDefined();
-    });
-  });
-
-  describe('Resource Structure Normalization', () => {
-    it('should normalize standard resources and CRDs to consistent structure', async () => {
-      const intent = 'deploy web application';
-      
-      // Mock mixed resources - standard and CRDs with different structures
-      mockDiscoverResources.mockResolvedValue({
-        resources: [
-          // Standard resource structure
-          { 
-            kind: 'Deployment', 
-            apiVersion: 'apps/v1', 
-            group: 'apps', 
-            namespaced: true 
-          },
-          // Core resource (no group)
-          { 
-            kind: 'Service', 
-            apiVersion: 'v1', 
-            group: '', 
-            namespaced: true 
-          }
-        ],
-        custom: [
-          // CRD structure (different properties)
-          { 
-            kind: 'AppClaim', 
-            group: 'devopstoolkit.live', 
-            version: 'v1alpha1', 
-            scope: 'Namespaced' 
-          },
-          // Another CRD with cluster scope
-          { 
-            kind: 'App', 
-            group: 'devopstoolkit.live', 
-            version: 'v1alpha1', 
-            scope: 'Cluster' 
-          }
-        ]
-      });
-
-      // Mock AI response that includes both standard and custom resources
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `[
-          {"kind": "Deployment", "apiVersion": "apps/v1", "group": "apps"},
-          {"kind": "AppClaim", "apiVersion": "devopstoolkit.live/v1alpha1", "group": "devopstoolkit.live"}
-        ]`
-      });
-
-      // Mock explanations for selected resources
-      mockExplainResource
-        .mockResolvedValueOnce(`GROUP:      apps
-KIND:       Deployment
-VERSION:    v1
-
-DESCRIPTION:
-     Deployment manages pods
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard metadata
-
-   spec	<Object> -required-
-     Deployment spec`)
-        .mockResolvedValueOnce(`GROUP:      devopstoolkit.live
-KIND:       AppClaim
-VERSION:    v1alpha1
-
-DESCRIPTION:
-     AppClaim for application deployment
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard metadata
-
-   spec	<Object> -required-
-     App specification`);
-
-      // Mock final AI ranking response
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `{
-          "solutions": [{
-            "type": "combination",
-            "score": 95,
-            "description": "Complete app deployment with AppClaim",
-            "resources": [{"kind": "AppClaim", "apiVersion": "devopstoolkit.live/v1alpha1", "group": "devopstoolkit.live"}],
-            "reasons": ["AppClaim provides simple app deployment"],
-            "analysis": "AppClaim simplifies application deployment"
-          }]
-        }`
-      });
-
-      // Mock question generation response
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `{"required": [], "basic": [], "advanced": [], "open": {"question": "test", "placeholder": "test"}}`
-      });
-
-      const solutions = await ranker.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      // Verify the solution includes the CRD (it references resource index 1 which is AppClaim)
-      expect(solutions).toHaveLength(1);
-      expect(solutions[0].type).toBe('combination');
-      expect(solutions[0].score).toBe(95);
-
-      // Verify AI received normalized resource summary in first call
-      const firstCall = mockClaudeIntegration.sendMessage.mock.calls[0][0];
-      
-      // Should contain normalized AppClaim with proper apiVersion format
-      expect(firstCall).toContain('AppClaim (devopstoolkit.live/v1alpha1)');
-      expect(firstCall).toContain('Group: devopstoolkit.live');
-      expect(firstCall).toContain('Namespaced: true');
-      
-      // Should contain normalized standard resources
-      expect(firstCall).toContain('Deployment (apps/v1)');
-      expect(firstCall).toContain('Service (v1)');
-    });
-
-    it('should handle CRDs without group in apiVersion format', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [],
-        custom: [
-          // CRD without group (core-like)
-          { 
-            kind: 'TestResource', 
-            group: '', 
-            version: 'v1', 
-            scope: 'Namespaced' 
-          }
-        ]
-      });
-
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `[{"kind": "TestResource", "apiVersion": "v1", "group": ""}]`
-      });
-
-      mockExplainResource.mockResolvedValueOnce(`GROUP:      
-KIND:       TestResource
-VERSION:    v1
-
-DESCRIPTION:
-     Test resource
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`);
-
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `{
-          "solutions": [{
-            "type": "single",
-            "score": 80,
-            "description": "Test resource solution",
-            "resources": [{"kind": "TestResource", "apiVersion": "v1", "group": ""}],
-            "reasons": ["TestResource for testing"],
-            "analysis": "Basic test resource"
-          }]
-        }`
-      });
-
-      // Mock question generation response
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `{"required": [], "basic": [], "advanced": [], "open": {"question": "test", "placeholder": "test"}}`
-      });
-
-      await ranker.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      // Verify resource summary format for CRD without group
-      const firstCall = mockClaudeIntegration.sendMessage.mock.calls[0][0];
-      expect(firstCall).toContain('TestResource (v1)');
-      expect(firstCall).toContain('Group: core');
-    });
-
-    it('should include custom resources in general deployment intents without requiring platform knowledge', async () => {
-      const intent = 'deploy a web application'; // Generic intent, no mention of Crossplane
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [
-          { kind: 'Deployment', apiVersion: 'apps/v1', group: 'apps', namespaced: true },
-          { kind: 'Service', apiVersion: 'v1', group: '', namespaced: true }
-        ],
-        custom: [
-          { kind: 'AppClaim', group: 'devopstoolkit.live', version: 'v1alpha1', scope: 'Namespaced' }
-        ]
-      });
-
-      // Mock AI response that includes both standard and custom resources for general intent
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `[
-          {"kind": "Deployment", "apiVersion": "apps/v1", "group": "apps"},
-          {"kind": "Service", "apiVersion": "v1", "group": ""},
-          {"kind": "AppClaim", "apiVersion": "devopstoolkit.live/v1alpha1", "group": "devopstoolkit.live"}
-        ]`
-      });
-
-      // Mock explanations
-      mockExplainResource
-        .mockResolvedValueOnce(`GROUP:      apps
-KIND:       Deployment
-VERSION:    v1
-
-DESCRIPTION:
-     Deployment manages pods
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`)
-        .mockResolvedValueOnce(`GROUP:      
-KIND:       Service
-VERSION:    v1
-
-DESCRIPTION:
-     Service exposes apps
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`)
-        .mockResolvedValueOnce(`GROUP:      devopstoolkit.live
-KIND:       AppClaim
-VERSION:    v1alpha1
-
-DESCRIPTION:
-     AppClaim provides simple app deployment
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`);
-
-      // Mock ranking that prefers the simpler CRD approach
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `{
-          "solutions": [{
-            "type": "single",
-            "score": 90,
-            "description": "Simple application deployment using AppClaim",
-            "resources": [{"kind": "AppClaim", "apiVersion": "devopstoolkit.live/v1alpha1", "group": "devopstoolkit.live"}],
-            "reasons": ["AppClaim provides declarative app deployment", "Higher-level abstraction"],
-            "analysis": "AppClaim offers simpler deployment"
-          }, {
-            "type": "combination", 
-            "score": 80,
-            "description": "Traditional Kubernetes deployment",
-            "resources": [{"kind": "Deployment", "apiVersion": "apps/v1", "group": "apps"}, {"kind": "Service", "apiVersion": "v1", "group": ""}],
-            "reasons": ["Standard Kubernetes pattern"],
-            "analysis": "Traditional approach"
-          }]
-        }`
-      });
-
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `{"required": [], "basic": [], "advanced": [], "open": {"question": "test", "placeholder": "test"}}`
-      });
-
-      const solutions = await ranker.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      // Verify both traditional and CRD solutions are considered
-      expect(solutions).toHaveLength(2);
-      
-      // Verify CRD solution scored higher (90 vs 80)
-      const crdSolution = solutions.find(s => s.score === 90);
-      const traditionalSolution = solutions.find(s => s.score === 80);
-      
-      expect(crdSolution).toBeDefined();
-      expect(traditionalSolution).toBeDefined();
-
-      // Verify the resource selection prompt encourages considering CRDs for general intents
-      const resourceSelectionCall = mockClaudeIntegration.sendMessage.mock.calls[0][0];
-      
-      // Skip prompt content verification in test environment - the important thing is that
-      // the AI selected both standard and custom resources for general intents
-      // The prompt template loading might fail in test environment due to working directory issues
-      // 
-      // expect(resourceSelectionCall).toContain('Custom Resource Definitions (CRDs)');
-      // expect(resourceSelectionCall).toContain('higher-level abstractions');
-      // expect(resourceSelectionCall).toContain('Don\'t assume user knowledge');
-      
-      // Just verify that the call was made with some content
-      expect(resourceSelectionCall).toBeDefined();
-      expect(resourceSelectionCall.length).toBeGreaterThan(0);
-    });
-  });
-});
-
-describe('Question Generation and Dynamic Discovery', () => {
-  let recommender: ResourceRecommender;
-  let config: AIRankingConfig;
-  let mockClaudeIntegration: any;
-  let mockDiscoverResources: jest.Mock;
-  let mockExplainResource: jest.Mock;
-
-  beforeEach(() => {
-    config = { claudeApiKey: 'test-key' };
-    
-    mockDiscoverResources = jest.fn();
-    mockExplainResource = jest.fn();
-
-    // Mock the Claude integration
-    const ClaudeIntegration = require('../../src/core/claude').ClaudeIntegration;
-    mockClaudeIntegration = {
-      isInitialized: jest.fn().mockReturnValue(true),
-      sendMessage: jest.fn()
-    };
-    jest.spyOn(ClaudeIntegration.prototype, 'isInitialized').mockReturnValue(true);
-    jest.spyOn(ClaudeIntegration.prototype, 'sendMessage').mockImplementation(mockClaudeIntegration.sendMessage);
-
-    recommender = new ResourceRecommender(config);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  describe('Question structure interfaces', () => {
-    it('should support Question interface with all required fields', () => {
-      const question: Question = {
-        id: 'test-question',
-        question: 'What is your application name?',
-        type: 'text',
-        placeholder: 'my-app',
-        validation: {
-          required: true,
-          pattern: '^[a-z0-9-]+$'
-        }
-      };
-
-      expect(question.id).toBe('test-question');
-      expect(question.type).toBe('text');
-      expect(question.validation?.required).toBe(true);
-    });
-
-    it('should support QuestionGroup interface with all categories', () => {
-      const questionGroup: QuestionGroup = {
-        required: [{
-          id: 'req-1',
-          question: 'Required question?',
-          type: 'text'
-        }],
-        basic: [{
-          id: 'basic-1',
-          question: 'Basic question?',
-          type: 'select',
-          options: ['option1', 'option2']
-        }],
-        advanced: [{
-          id: 'adv-1',
-          question: 'Advanced question?',
-          type: 'boolean'
-        }],
-        open: {
-          question: 'Any additional requirements?',
-          placeholder: 'Enter details...'
-        }
-      };
-
-      expect(questionGroup.required).toHaveLength(1);
-      expect(questionGroup.basic).toHaveLength(1);
-      expect(questionGroup.advanced).toHaveLength(1);
-      expect(questionGroup.open.question).toContain('additional');
-    });
-
-    it('should support ClusterOptions interface for dynamic discovery', () => {
-      const clusterOptions: ClusterOptions = {
-        namespaces: ['default', 'production', 'staging'],
-        storageClasses: ['gp2', 'fast-ssd'],
-        ingressClasses: ['nginx', 'traefik'],
-        nodeLabels: ['environment', 'node-type'],
-        serviceAccounts: {
-          'default': ['default'],
-          'production': ['app-service-account']
-        }
-      };
-
-      expect(clusterOptions.namespaces).toContain('default');
-      expect(clusterOptions.storageClasses).toContain('gp2');
-      expect(clusterOptions.ingressClasses).toContain('nginx');
-      expect(clusterOptions.nodeLabels).toContain('environment');
-    });
-  });
-
-  describe('Cluster options discovery', () => {
-    it('should discover cluster options and populate questions', async () => {
-      const intent = 'deploy a web application';
-      
-      // Mock discovery data
-      mockDiscoverResources.mockResolvedValue({
-        resources: [
-          { kind: 'Deployment', apiVersion: 'apps/v1', group: 'apps', namespaced: true }
-        ],
-        custom: []
-      });
-
-      mockExplainResource.mockResolvedValue(`GROUP:      apps
-KIND:       Deployment
-VERSION:    v1
-
-DESCRIPTION:
-     Deployment enables declarative updates for Pods and ReplicaSets
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata
-
-   spec	<Object> -required-
-     Specification of the desired behavior`);
-
-      // Mock kubectl commands for cluster discovery
-      const mockExecuteKubectl = jest.fn();
-      jest.doMock('../../src/core/kubernetes-utils', () => ({
-        executeKubectl: mockExecuteKubectl
-      }));
-
-      mockExecuteKubectl
-        .mockResolvedValueOnce('default production staging') // namespaces
-        .mockResolvedValueOnce('gp2 fast-ssd') // storage classes
-        .mockResolvedValueOnce('nginx traefik') // ingress classes
-        .mockResolvedValueOnce(JSON.stringify({ // nodes
-          items: [{
-            metadata: {
-              labels: {
-                'kubernetes.io/hostname': 'node1',
-                'environment': 'production',
-                'node-type': 'worker'
-              }
-            }
-          }]
-        }));
-
-      // Mock filesystem for prompt loading
-      const fs = require('fs');
-      jest.spyOn(fs, 'readFileSync').mockReturnValue(
-        'User Intent: {intent}\nSolution: {solution_description}\nResources: {resource_details}\nCluster Options: {cluster_options}'
-      );
-
-      // Mock AI response for both phases
-      mockClaudeIntegration.sendMessage
-        .mockResolvedValueOnce({
-          content: `[{"kind": "Deployment", "apiVersion": "apps/v1", "group": "apps"}]`
-        })
-        .mockResolvedValueOnce({
-          content: `{
-            "solutions": [{
-              "type": "single",
-              "resources": [{"kind": "Deployment", "apiVersion": "apps/v1", "group": "apps"}],
-              "score": 85,
-              "description": "Simple deployment",
-              "reasons": ["Basic web app"],
-              "analysis": "Perfect for simple apps"
-            }]
-          }`
-        })
-        .mockResolvedValueOnce({
-          content: `\`\`\`json
-          {
-            "required": [{
-              "id": "app-name",
-              "question": "What should we name your application?",
-              "type": "text",
-              "validation": {"required": true}
-            }],
-            "basic": [{
-              "id": "target-namespace",
-              "question": "Which namespace should we deploy to?",
-              "type": "select",
-              "options": ["default", "production", "staging"]
-            }],
-            "advanced": [{
-              "id": "resource-limits",
-              "question": "Do you need resource limits?",
-              "type": "boolean"
-            }],
-            "open": {
-              "question": "Any additional requirements?",
-              "placeholder": "Enter details..."
-            }
-          }
-          \`\`\``
-        });
-
-      const solutions = await recommender.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      expect(solutions).toHaveLength(1);
-      expect(solutions[0].questions).toBeDefined();
-      expect(solutions[0].questions.required).toHaveLength(1);
-      expect(solutions[0].questions.basic).toHaveLength(1);
-      expect(solutions[0].questions.advanced).toHaveLength(1);
-      expect(solutions[0].questions.open.question).toContain('additional');
-      
-      // Verify cluster options were used in questions
-      const namespaceQuestion = solutions[0].questions.basic.find(q => q.id === 'target-namespace');
-      expect(namespaceQuestion?.options).toEqual(['default', 'production', 'staging']);
-    });
-
-    it('should handle kubectl discovery failures gracefully', async () => {
-      const intent = 'deploy a simple app';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [{ kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true }],
-        custom: []
-      });
-
-      mockExplainResource.mockResolvedValue(`GROUP:      
-KIND:       Pod
-VERSION:    v1
-
-DESCRIPTION:
-     Pod description
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`);
-
-      // Mock kubectl failures
-      const mockExecuteKubectl = jest.fn().mockRejectedValue(new Error('kubectl not found'));
-      jest.doMock('../../src/core/kubernetes-utils', () => ({
-        executeKubectl: mockExecuteKubectl
-      }));
-
-      const fs = require('fs');
-      jest.spyOn(fs, 'readFileSync').mockReturnValue('template content {intent} {solution_description} {resource_details} {cluster_options}');
-
-      mockClaudeIntegration.sendMessage
-        .mockResolvedValueOnce({ content: `[{"kind": "Pod", "apiVersion": "v1", "group": ""}]` })
-        .mockResolvedValueOnce({
-          content: `{"solutions": [{"type": "single", "resources": [{"kind": "Pod", "apiVersion": "v1", "group": ""}], "score": 50, "description": "Pod", "reasons": [], "analysis": ""}]}`
-        })
-        .mockResolvedValueOnce({
-          content: `{"required": [], "basic": [], "advanced": [], "open": {"question": "fallback", "placeholder": "fallback"}}`
-        });
-
-      const solutions = await recommender.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      expect(solutions).toHaveLength(1);
-      expect(solutions[0].questions).toBeDefined();
-      // Should still work with fallback questions
-    });
-
-    it('should handle AI question generation failures gracefully', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [{ kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true }],
-        custom: []
-      });
-
-      mockExplainResource.mockResolvedValue(`GROUP:      
-KIND:       Pod
-VERSION:    v1
-
-DESCRIPTION:
-     Pod description
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`);
-
-      const mockExecuteKubectl = jest.fn().mockResolvedValue('default');
-      jest.doMock('../../src/core/kubernetes-utils', () => ({
-        executeKubectl: mockExecuteKubectl
-      }));
-
-      const fs = require('fs');
-      jest.spyOn(fs, 'readFileSync').mockReturnValue('template');
-
-      // AI succeeds for solution ranking but fails for question generation
-      mockClaudeIntegration.sendMessage
-        .mockResolvedValueOnce({ content: `[{"kind": "Pod", "apiVersion": "v1", "group": ""}]` })
-        .mockResolvedValueOnce({
-          content: `{"solutions": [{"type": "single", "resources": [{"kind": "Pod", "apiVersion": "v1", "group": ""}], "score": 50, "description": "Pod", "reasons": [], "analysis": ""}]}`
-        })
-        .mockRejectedValueOnce(new Error('AI service unavailable'));
-
-      const solutions = await recommender.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      expect(solutions).toHaveLength(1);
-      expect(solutions[0].questions).toBeDefined();
-      expect(solutions[0].questions.open.question).toContain('requirements or constraints');
-      // Should use fallback questions when AI fails
-    });
-  });
-
-  describe('Solution ID generation', () => {
-    // NOTE: The id field has been removed from ResourceSolution objects
-    // This test has been removed as solution IDs are no longer generated
-  });
-
-  describe('JSON Response Parsing', () => {
-    it('should parse JSON wrapped in markdown code blocks', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [{ kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true }],
-        custom: []
-      });
-
-      mockExplainResource.mockResolvedValue(`GROUP:      
-KIND:       Pod
-VERSION:    v1
-
-DESCRIPTION:
-     Pod description
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`);
-
-      // Mock AI response for resource selection (phase 1) - needs to be an array
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `Looking at your intent, here's my resource selection:
-
-\`\`\`json
-[{
-  "kind": "Pod",
-  "apiVersion": "v1",
-  "group": ""
-}]
-\`\`\`
-
-These resources should work well.`
-      });
-
-      // Mock AI response for solution ranking (phase 2) wrapped in markdown
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `\`\`\`json
-{
-  "solutions": [{
-    "type": "single",
-    "score": 90,
-    "description": "Pod for basic deployment",
-    "resources": [{"kind": "Pod", "apiVersion": "v1", "group": ""}],
-    "reasons": ["Pod handles the deployment"],
-    "analysis": "Simple pod deployment"
-  }]
-}
-\`\`\``
-      });
-
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `{"required": [], "basic": [], "advanced": [], "open": {"question": "test", "placeholder": "test"}}`
-      });
-
-      const solutions = await recommender.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      expect(solutions).toHaveLength(1);
-      expect(solutions[0].score).toBe(90);
-      expect(solutions[0].description).toBe('Pod for basic deployment');
-    });
-
-    it('should parse JSON with extra content after the JSON block', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [{ kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true }],
-        custom: []
-      });
-
-      mockExplainResource.mockResolvedValue(`GROUP:      
-KIND:       Pod
-VERSION:    v1
-
-DESCRIPTION:
-     Pod description
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`);
-
-      // Mock AI response for resource selection (phase 1) with extra text after
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `[{
-  "kind": "Pod",
-  "apiVersion": "v1",
-  "group": ""
-}]
-
-Some additional text after the JSON array.`
-      });
-
-      // Mock AI response for solution ranking (phase 2) with extra text after
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `{
-  "solutions": [{
-    "type": "single",
-    "score": 85,
-    "description": "Pod solution",
-    "resources": [{"kind": "Pod", "apiVersion": "v1", "group": ""}],
-    "reasons": ["Pod works"],
-    "analysis": "Basic analysis"
-  }]
-}
-
-Additional explanatory text that might break simple JSON parsing.
-This often happens when AI adds context after the JSON.`
-      });
-
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `{"required": [], "basic": [], "advanced": [], "open": {"question": "test", "placeholder": "test"}}`
-      });
-
-      const solutions = await recommender.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      expect(solutions).toHaveLength(1);
-      expect(solutions[0].score).toBe(85);
-      expect(solutions[0].description).toBe('Pod solution');
-    });
-
-    it('should handle malformed JSON gracefully', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [{ kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true }],
-        custom: []
-      });
-
-      mockExplainResource.mockResolvedValue(`GROUP:      
-KIND:       Pod
-VERSION:    v1
-
-DESCRIPTION:
-     Pod description
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`);
-
-      // Mock AI response with malformed JSON in resource selection phase
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `[{
-  "kind": "Pod",
-  "apiVersion": "v1",
-  // This comment breaks JSON
-  "group": ""
-}]`
-      });
-
-      await expect(recommender.findBestSolutions(intent, mockDiscoverResources, mockExplainResource))
-        .rejects.toThrow('AI failed to select resources in valid JSON format');
-    });
-  });
-
-});
-
-describe('Enhanced Error Handling and Debugging', () => {
-  let recommender: ResourceRecommender;
-  let config: AIRankingConfig;
-  let mockClaudeIntegration: any;
-  let mockDiscoverResources: jest.Mock;
-  let mockExplainResource: jest.Mock;
-
-  beforeEach(() => {
-    config = { claudeApiKey: 'test-key' };
-    
-    mockDiscoverResources = jest.fn();
-    mockExplainResource = jest.fn();
-
-    // Mock the Claude integration
-    const ClaudeIntegration = require('../../src/core/claude').ClaudeIntegration;
-    mockClaudeIntegration = {
-      isInitialized: jest.fn().mockReturnValue(true),
-      sendMessage: jest.fn()
-    };
-    jest.spyOn(ClaudeIntegration.prototype, 'isInitialized').mockReturnValue(true);
-    jest.spyOn(ClaudeIntegration.prototype, 'sendMessage').mockImplementation(mockClaudeIntegration.sendMessage);
-
-    recommender = new ResourceRecommender(config);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  describe('Enhanced error handling for invalid resource indexes', () => {
-    it('should provide detailed debugging info for invalid resource indexes', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [
-          { kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true },
-          { kind: 'Service', apiVersion: 'v1', group: '', namespaced: true }
-        ],
-        custom: []
-      });
-
-      mockExplainResource.mockResolvedValue(`GROUP:      
-KIND:       Pod
-VERSION:    v1
-
-DESCRIPTION:
-     Pod description
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`);
-
-      // Mock resource selection returning valid resources
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `[{"kind": "Pod", "apiVersion": "v1", "group": ""}]`
-      });
-
-      // Mock AI ranking returning invalid indexes (higher than available schemas)
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `{
-          "solutions": [{
-            "type": "single",
-            "resources": [{"kind": "NonExistent", "apiVersion": "v1", "group": ""}],
-            "score": 90,
-            "description": "Invalid solution",
-            "reasons": ["test"],
-            "analysis": "test"
-          }]
-        }`
-      });
-
-      // Mock question generation
-      mockClaudeIntegration.sendMessage.mockResolvedValue({
-        content: `{"required": [], "basic": [], "advanced": [], "open": {"question": "test", "placeholder": "test"}}`
-      });
-
-      await expect(recommender.findBestSolutions(intent, mockDiscoverResources, mockExplainResource))
-        .rejects.toThrow(/No matching resources found/);
-    });
-
-    it('should include AI response context in error messages', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [{ kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true }],
-        custom: []
-      });
-
-      mockExplainResource.mockResolvedValue(`GROUP:      
-KIND:       Pod
-VERSION:    v1
-
-DESCRIPTION:
-     Pod description
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`);
-
-      // Mock resource selection
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `[{"kind": "Pod", "apiVersion": "v1", "group": ""}]`
-      });
-
-      // Mock AI ranking with completely malformed JSON
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `This is not JSON at all`
-      });
-
-      try {
-        await recommender.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-        fail('Expected error to be thrown');
-      } catch (error: any) {
-        expect(error.message).toContain('Failed to parse AI solution response');
-        expect(error.message).toContain('AI Response (first 500 chars)');
-        expect(error.message).toContain('Available schemas');
-      }
-    });
-
-    it('should handle conditional debug logging based on environment variable', () => {
-      const originalEnv = process.env.DOT_AI_DEBUG;
-      
-      // Test with debug enabled
-      process.env.DOT_AI_DEBUG = 'true';
-      
-      const consoleSpy = jest.spyOn(console, 'debug').mockImplementation(() => {});
-      
-      // This would trigger debug logging if the error path is hit
-      // For this test, we just verify the environment variable is read correctly
-      expect(process.env.DOT_AI_DEBUG).toBe('true');
-      
-      // Test with debug disabled
-      process.env.DOT_AI_DEBUG = 'false';
-      expect(process.env.DOT_AI_DEBUG).toBe('false');
-      
-      // Restore original environment
-      if (originalEnv !== undefined) {
-        process.env.DOT_AI_DEBUG = originalEnv;
-      } else {
-        delete process.env.DOT_AI_DEBUG;
-      }
-      
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('Enhanced schema fetching error handling', () => {
-    it('should provide detailed error info when no schemas can be fetched', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [
-          { kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true },
-          { kind: 'Service', apiVersion: 'v1', group: '', namespaced: true }
-        ],
-        custom: []
-      });
-
-      // Mock explainResource to always fail
-      mockExplainResource.mockRejectedValue(new Error('Resource explanation failed'));
-
-      // Mock resource selection
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `[
-          {"kind": "Pod", "apiVersion": "v1", "group": ""},
-          {"kind": "Service", "apiVersion": "v1", "group": ""}
-        ]`
-      });
-
-      try {
-        await recommender.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-        fail('Expected error to be thrown');
-      } catch (error: any) {
-        expect(error.message).toContain('Could not fetch schemas for any selected resources');
-        expect(error.message).toContain('Candidates: Pod, Service');
-        expect(error.message).toContain('Errors:');
-      }
-    });
-
-    it('should warn about partial schema fetch failures', async () => {
-      const intent = 'test intent';
-      
-      mockDiscoverResources.mockResolvedValue({
-        resources: [
-          { kind: 'Pod', apiVersion: 'v1', group: '', namespaced: true },
-          { kind: 'Service', apiVersion: 'v1', group: '', namespaced: true }
-        ],
-        custom: []
-      });
-
-      // Mock explainResource to succeed for Pod but fail for Service
-      mockExplainResource.mockImplementation((kind: string) => {
-        if (kind === 'Pod') {
-          return Promise.resolve(`GROUP:      
-KIND:       Pod
-VERSION:    v1
-
-DESCRIPTION:
-     Pod description
-
-FIELDS:
-   metadata	<Object> -required-
-     Standard object metadata`);
-        }
-        return Promise.reject(new Error('Service explanation failed'));
-      });
-
-      // Mock resource selection
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `[
-          {"kind": "Pod", "apiVersion": "v1", "group": ""},
-          {"kind": "Service", "apiVersion": "v1", "group": ""}
-        ]`
-      });
-
-      // Mock AI ranking
-      mockClaudeIntegration.sendMessage.mockResolvedValueOnce({
-        content: `{
-          "solutions": [{
-            "type": "single",
-            "resources": [{"kind": "Pod", "apiVersion": "v1", "group": ""}],
-            "score": 90,
-            "description": "Pod solution",
-            "reasons": ["test"],
-            "analysis": "test"
-          }]
-        }`
-      });
-
-      // Mock question generation
-      mockClaudeIntegration.sendMessage.mockResolvedValue({
-        content: `{"required": [], "basic": [], "advanced": [], "open": {"question": "test", "placeholder": "test"}}`
-      });
-
-      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-
-      const solutions = await recommender.findBestSolutions(intent, mockDiscoverResources, mockExplainResource);
-
-      expect(solutions).toHaveLength(1);
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Some resources could not be analyzed'));
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Successfully fetched schemas for: Pod'));
-
-      consoleSpy.mockRestore();
-    });
-  });
-});
-
-// REMOVED: SolutionEnhancer tests - moved to legacy reference
-// See src/legacy/core/solution-enhancer.ts for reference implementation and original test patterns
-