@vfarcic/dot-ai 0.5.1 → 0.7.0

package/tests/core/session-utils.test.ts

@@ -1,245 +0,0 @@
-/**
- * Session Utils Tests
- * Tests for shared session directory utilities including relative path support
- */
-
-import { getSessionDirectory, validateSessionDirectory, getAndValidateSessionDirectory } from '../../src/core/session-utils';
-import * as fs from 'fs';
-import * as path from 'path';
-
-describe('Session Utils', () => {
-  let testDir: string;
-  let originalCwd: string;
-  let originalEnv: string | undefined;
-
-  beforeEach(() => {
-    // Create test directory
-    testDir = path.join(process.cwd(), 'tmp', 'session-utils-test', Date.now().toString());
-    fs.mkdirSync(testDir, { recursive: true });
-    
-    // Save original state
-    originalCwd = process.cwd();
-    originalEnv = process.env.DOT_AI_SESSION_DIR;
-  });
-
-  afterEach(() => {
-    // Restore original state
-    process.chdir(originalCwd);
-    if (originalEnv) {
-      process.env.DOT_AI_SESSION_DIR = originalEnv;
-    } else {
-      delete process.env.DOT_AI_SESSION_DIR;
-    }
-    
-    // Clean up test directory
-    try {
-      fs.rmSync(testDir, { recursive: true, force: true });
-    } catch (error) {
-      console.warn('Could not clean up test directory:', error);
-    }
-  });
-
-  describe('getSessionDirectory', () => {
-    it('should prefer CLI args over environment variable', () => {
-      process.env.DOT_AI_SESSION_DIR = '/env/path';
-      const args = { sessionDir: '/cli/path' };
-      
-      const result = getSessionDirectory(args);
-      
-      expect(result).toBe('/cli/path');
-    });
-
-    it('should use environment variable when CLI args not provided', () => {
-      process.env.DOT_AI_SESSION_DIR = '/env/path';
-      const args = {};
-      
-      const result = getSessionDirectory(args);
-      
-      expect(result).toBe('/env/path');
-    });
-
-    it('should throw error when neither CLI args nor environment variable provided', () => {
-      delete process.env.DOT_AI_SESSION_DIR;
-      const args = {};
-      
-      expect(() => getSessionDirectory(args)).toThrow(
-        'Session directory must be specified via --session-dir parameter or DOT_AI_SESSION_DIR environment variable'
-      );
-    });
-
-    it('should work with relative paths from environment variable', () => {
-      process.env.DOT_AI_SESSION_DIR = './relative/path';
-      const args = {};
-      
-      const result = getSessionDirectory(args);
-      
-      expect(result).toBe('./relative/path');
-    });
-  });
-
-  describe('validateSessionDirectory', () => {
-    it('should validate existing absolute directory', () => {
-      expect(() => validateSessionDirectory(testDir)).not.toThrow();
-    });
-
-    it('should validate existing relative directory', () => {
-      // Create relative directory structure
-      const relativeTestDir = path.join(testDir, 'relative-test');
-      const relativeSessionDir = path.join(relativeTestDir, 'sessions');
-      fs.mkdirSync(relativeSessionDir, { recursive: true });
-      
-      // Change to test directory and validate relative path
-      process.chdir(relativeTestDir);
-      
-      expect(() => validateSessionDirectory('./sessions')).not.toThrow();
-    });
-
-    it('should throw error for non-existent directory', () => {
-      const nonExistentDir = path.join(testDir, 'does-not-exist');
-      
-      expect(() => validateSessionDirectory(nonExistentDir)).toThrow(
-        `Session directory does not exist: ${nonExistentDir}`
-      );
-    });
-
-    it('should throw error when path is not a directory', () => {
-      const filePath = path.join(testDir, 'test-file.txt');
-      fs.writeFileSync(filePath, 'test');
-      
-      expect(() => validateSessionDirectory(filePath)).toThrow(
-        `Session directory path is not a directory: ${filePath}`
-      );
-    });
-
-    it('should test write permissions when required', () => {
-      expect(() => validateSessionDirectory(testDir, true)).not.toThrow();
-    });
-
-    it('should throw error when directory is not writable', () => {
-      // Create read-only directory (only works on Unix systems)
-      const readOnlyDir = path.join(testDir, 'readonly');
-      fs.mkdirSync(readOnlyDir);
-      
-      // Make directory read-only
-      try {
-        fs.chmodSync(readOnlyDir, 0o444);
-        
-        expect(() => validateSessionDirectory(readOnlyDir, true)).toThrow();
-        
-        // Restore permissions for cleanup
-        fs.chmodSync(readOnlyDir, 0o755);
-      } catch (error) {
-        // Skip this test on systems where chmod doesn't work (e.g., Windows)
-        console.warn('Skipping write permission test - chmod not supported');
-      }
-    });
-  });
-
-  describe('getAndValidateSessionDirectory', () => {
-    it('should get and validate session directory from environment variable', () => {
-      process.env.DOT_AI_SESSION_DIR = testDir;
-      const args = {};
-      
-      const result = getAndValidateSessionDirectory(args, false);
-      
-      expect(result).toBe(testDir);
-    });
-
-    it('should get and validate session directory with write permissions', () => {
-      process.env.DOT_AI_SESSION_DIR = testDir;
-      const args = {};
-      
-      const result = getAndValidateSessionDirectory(args, true);
-      
-      expect(result).toBe(testDir);
-    });
-
-    it('should work with relative paths when cwd is set', () => {
-      // Create test directory structure
-      const testCwd = path.join(testDir, 'cwd-test');
-      const relativeSessionDir = './sessions';
-      const absoluteSessionDir = path.join(testCwd, 'sessions');
-      
-      fs.mkdirSync(testCwd, { recursive: true });
-      fs.mkdirSync(absoluteSessionDir, { recursive: true });
-      
-      // Change to test directory and set relative path
-      process.chdir(testCwd);
-      process.env.DOT_AI_SESSION_DIR = relativeSessionDir;
-      
-      const args = {};
-      const result = getAndValidateSessionDirectory(args, true);
-      
-      expect(result).toBe('./sessions');
-      
-      // Verify the relative path actually resolves to the correct absolute path
-      expect(path.resolve(result)).toBe(absoluteSessionDir);
-    });
-
-    it('should throw error when session directory not configured', () => {
-      delete process.env.DOT_AI_SESSION_DIR;
-      const args = {};
-      
-      expect(() => getAndValidateSessionDirectory(args)).toThrow(
-        'Session directory must be specified via --session-dir parameter or DOT_AI_SESSION_DIR environment variable'
-      );
-    });
-
-    it('should throw error when session directory does not exist', () => {
-      const nonExistentDir = path.join(testDir, 'does-not-exist');
-      process.env.DOT_AI_SESSION_DIR = nonExistentDir;
-      const args = {};
-      
-      expect(() => getAndValidateSessionDirectory(args)).toThrow(
-        `Session directory does not exist: ${nonExistentDir}`
-      );
-    });
-  });
-
-  describe('MCP cwd simulation', () => {
-    it('should work exactly like MCP server with cwd and relative DOT_AI_SESSION_DIR', () => {
-      // Simulate MCP configuration:
-      // {
-      //   "mcpServers": {
-      //     "dot-ai": {
-      //       "command": "npm",
-      //       "args": ["run", "mcp:start"],
-      //       "cwd": "/path/to/dot-ai",
-      //       "env": {
-      //         "DOT_AI_SESSION_DIR": "./tmp/sessions"
-      //       }
-      //     }
-      //   }
-      // }
-      
-      const mcpCwd = path.join(testDir, 'mcp-simulation');
-      const relativeSessionDir = './tmp/sessions';
-      const absoluteSessionDir = path.join(mcpCwd, 'tmp', 'sessions');
-      
-      // Create directories
-      fs.mkdirSync(mcpCwd, { recursive: true });
-      fs.mkdirSync(absoluteSessionDir, { recursive: true });
-      
-      // Change to MCP cwd and set relative environment variable
-      process.chdir(mcpCwd);
-      process.env.DOT_AI_SESSION_DIR = relativeSessionDir;
-      
-      // This simulates what happens when MCP tools are called
-      const args = {}; // MCP tools don't get sessionDir as args
-      const context = { requestId: 'mcp-test-123' };
-      
-      const result = getAndValidateSessionDirectory(args, true);
-      
-      // Should return the relative path as configured
-      expect(result).toBe('./tmp/sessions');
-      
-      // But should resolve to the correct absolute path
-      expect(path.resolve(result)).toBe(absoluteSessionDir);
-      
-      // Should be able to write to it
-      const testFile = path.join(result, 'test-solution.json');
-      fs.writeFileSync(testFile, JSON.stringify({ test: 'data' }));
-      expect(fs.existsSync(testFile)).toBe(true);
-    });
-  });
-});

package/tests/core.test.ts

@@ -1,439 +0,0 @@
-/**
- * Core Module Tests
- * 
- * These tests define the API contracts and behavior for our core intelligence modules
- * Following TDD approach - these tests define what we SHOULD implement
- */
-
-import { 
-  DotAI, 
-  KubernetesDiscovery, 
-  MemorySystem, 
-  WorkflowEngine, 
-  ClaudeIntegration 
-} from '../src/core';
-import { ErrorClassifier, buildKubectlCommand, executeKubectl } from '../src/core/kubernetes-utils';
-import * as path from 'path';
-
-describe('Core Module Structure', () => {
-  describe('DotAI Class', () => {
-    test('should be constructible with configuration options', () => {
-      const agent = new DotAI({
-        kubernetesConfig: '/path/to/kubeconfig',
-        anthropicApiKey: 'test-key'
-      });
-      
-      expect(agent).toBeInstanceOf(DotAI);
-      expect(agent.getVersion()).toBe('0.1.0');
-    });
-
-    test('should provide access to all core modules', async () => {
-      // Use project's working kubeconfig.yaml for integration tests
-      const projectKubeconfig = path.join(process.cwd(), 'kubeconfig.yaml');
-      const agent = new DotAI({ kubernetesConfig: projectKubeconfig });
-      await agent.initialize();
-      
-      expect(agent.discovery).toBeInstanceOf(KubernetesDiscovery);
-      expect(agent.memory).toBeInstanceOf(MemorySystem);
-      expect(agent.workflow).toBeInstanceOf(WorkflowEngine);
-      expect(agent.claude).toBeInstanceOf(ClaudeIntegration);
-    });
-
-    test('should handle initialization errors gracefully', async () => {
-      // Use project's working kubeconfig.yaml for integration tests
-      const projectKubeconfig = path.join(process.cwd(), 'kubeconfig.yaml');
-      const agent = new DotAI({ kubernetesConfig: projectKubeconfig });
-      
-      // Mock the discovery connect method to fail
-      jest.spyOn(agent.discovery, 'connect').mockRejectedValue(new Error('Connection failed'));
-      
-      await expect(agent.initialize()).rejects.toThrow();
-      expect(agent.isInitialized()).toBe(false);
-    });
-
-    test('should provide configuration validation', () => {
-      expect(() => {
-        new DotAI({ anthropicApiKey: '' });
-      }).toThrow('Invalid configuration');
-    });
-  });
-
-  describe('Module Integration', () => {
-    test('should allow modules to communicate with each other', async () => {
-      // Use project's working kubeconfig.yaml for integration tests
-      const projectKubeconfig = path.join(process.cwd(), 'kubeconfig.yaml');
-      const agent = new DotAI({ kubernetesConfig: projectKubeconfig });
-      await agent.initialize();
-      
-      // Memory should be able to store discovery results
-      const discoveryData = { resources: ['deployment', 'service'] };
-      await agent.memory.store('cluster-capabilities', discoveryData);
-      
-      // Workflow should be able to access memory
-      const stored = await agent.memory.retrieve('cluster-capabilities');
-      expect(stored).toEqual(discoveryData);
-    });
-
-    test('should handle module dependency failures', async () => {
-      // Use project's working kubeconfig.yaml for integration tests
-      const projectKubeconfig = path.join(process.cwd(), 'kubeconfig.yaml');
-      const agent = new DotAI({ kubernetesConfig: projectKubeconfig });
-      
-      // Mock discovery connect to fail, but other modules should still initialize
-      jest.spyOn(agent.discovery, 'connect').mockRejectedValue(new Error('Discovery failed'));
-      
-      try {
-        await agent.initialize();
-      } catch (error) {
-        // Initialization should fail, but modules should still be accessible
-        expect(agent.memory).toBeDefined();
-        expect(agent.workflow).toBeDefined();
-        expect(agent.discovery).toBeDefined();
-      }
-    });
-  });
-});
-
-describe('Memory System Module', () => {
-  let memory: MemorySystem;
-
-  beforeEach(() => {
-    memory = new MemorySystem();
-  });
-
-  describe('Basic Storage Operations', () => {
-    test('should store and retrieve data', async () => {
-      const testData = { key: 'value', number: 42 };
-      
-      await memory.store('test-key', testData);
-      const retrieved = await memory.retrieve('test-key');
-      
-      expect(retrieved).toEqual(testData);
-    });
-
-    test('should handle non-existent keys gracefully', async () => {
-      const result = await memory.retrieve('non-existent');
-      expect(result).toBeNull();
-    });
-
-    test('should support different data types', async () => {
-      await memory.store('string', 'hello');
-      await memory.store('number', 123);
-      await memory.store('boolean', true);
-      await memory.store('array', [1, 2, 3]);
-      await memory.store('object', { nested: { value: 'test' } });
-      
-      expect(await memory.retrieve('string')).toBe('hello');
-      expect(await memory.retrieve('number')).toBe(123);
-      expect(await memory.retrieve('boolean')).toBe(true);
-      expect(await memory.retrieve('array')).toEqual([1, 2, 3]);
-      expect(await memory.retrieve('object')).toEqual({ nested: { value: 'test' } });
-    });
-  });
-
-  describe('Learning and Context', () => {
-    test('should learn from successful deployments', async () => {
-      const deployment = {
-        app: 'nginx',
-        namespace: 'production',
-        replicas: 3,
-        resources: { cpu: '500m', memory: '1Gi' }
-      };
-      
-      await memory.learnSuccess('deployment', deployment);
-      
-      const patterns = await memory.getSuccessPatterns('deployment');
-      expect(patterns).toContainEqual(expect.objectContaining({
-        config: deployment,
-        type: 'deployment'
-      }));
-    });
-
-    test('should track failure patterns to avoid repetition', async () => {
-      const failedConfig = {
-        app: 'broken-app',
-        issue: 'insufficient resources'
-      };
-      
-      await memory.learnFailure('deployment', failedConfig, 'Pod failed to schedule');
-      
-      const failures = await memory.getFailurePatterns('deployment');
-      expect(failures).toContainEqual(expect.objectContaining({
-        config: failedConfig,
-        error: 'Pod failed to schedule'
-      }));
-    });
-
-    test('should provide recommendations based on learning', async () => {
-      // Store successful pattern
-      await memory.learnSuccess('service', {
-        type: 'LoadBalancer',
-        ports: [{ port: 80, targetPort: 8080 }]
-      });
-      
-      const recommendations = await memory.getRecommendations('service', {
-        type: 'LoadBalancer'
-      });
-      
-      expect(recommendations).toContainEqual(expect.objectContaining({
-        suggestion: expect.any(String),
-        confidence: expect.any(Number)
-      }));
-    });
-  });
-
-  describe('Context Management', () => {
-    test('should maintain session context', async () => {
-      await memory.setContext('current-namespace', 'my-app');
-      await memory.setContext('deployment-strategy', 'rolling');
-      
-      const context = await memory.getContext();
-      expect(context).toHaveProperty('current-namespace', 'my-app');
-      expect(context).toHaveProperty('deployment-strategy', 'rolling');
-    });
-
-    test('should clear context when needed', async () => {
-      await memory.setContext('temp-setting', 'value');
-      await memory.clearContext('temp-setting');
-      
-      const context = await memory.getContext();
-      expect(context).not.toHaveProperty('temp-setting');
-    });
-  });
-});
-
-describe('Workflow Engine Module', () => {
-  let workflow: WorkflowEngine;
-
-  beforeEach(() => {
-    workflow = new WorkflowEngine();
-  });
-
-  describe('Workflow Creation', () => {
-    test('should create deployment workflows', async () => {
-      const spec = {
-        app: 'my-app',
-        image: 'nginx:latest',
-        replicas: 2
-      };
-      
-      const workflowId = await workflow.createDeploymentWorkflow(spec);
-      expect(typeof workflowId).toBe('string');
-      expect(workflowId.length).toBeGreaterThan(0);
-    });
-
-    test('should validate workflow specifications', async () => {
-      const invalidSpec = {
-        // Missing required fields
-        replicas: 'invalid'
-      };
-      
-      await expect(workflow.createDeploymentWorkflow(invalidSpec)).rejects.toThrow('Invalid workflow specification');
-    });
-  });
-
-  describe('Workflow Execution', () => {
-    test('should execute workflows step by step', async () => {
-      const spec = { app: 'test-app', image: 'nginx:latest' };
-      const workflowId = await workflow.createDeploymentWorkflow(spec);
-      
-      const execution = await workflow.execute(workflowId);
-      expect(execution).toHaveProperty('id');
-      expect(execution).toHaveProperty('status');
-      expect(execution).toHaveProperty('steps');
-    });
-
-    test('should handle step failures gracefully', async () => {
-      const spec = { app: 'failing-app', image: 'invalid:image' };
-      const workflowId = await workflow.createDeploymentWorkflow(spec);
-      
-      const execution = await workflow.execute(workflowId);
-      expect(execution.status).toBe('failed');
-      expect(execution).toHaveProperty('error');
-    });
-
-    test('should support workflow rollback', async () => {
-      const spec = { app: 'rollback-test', image: 'nginx:latest' };
-      const workflowId = await workflow.createDeploymentWorkflow(spec);
-      
-      const execution = await workflow.execute(workflowId);
-      const rollbackResult = await workflow.rollback(execution.id);
-      
-      expect(rollbackResult).toHaveProperty('success', true);
-    });
-  });
-
-  describe('Workflow Templates', () => {
-    test('should support predefined workflow templates', async () => {
-      const templates = await workflow.getAvailableTemplates();
-      
-      expect(Array.isArray(templates)).toBe(true);
-      expect(templates).toContainEqual(expect.objectContaining({
-        name: expect.any(String),
-        description: expect.any(String),
-        parameters: expect.any(Array)
-      }));
-    });
-
-    test('should create workflows from templates', async () => {
-      const templateParams = {
-        template: 'web-app',
-        parameters: {
-          appName: 'my-web-app',
-          image: 'nginx:latest',
-          domain: 'my-app.example.com'
-        }
-      };
-      
-      const workflowId = await workflow.createFromTemplate(templateParams);
-      expect(typeof workflowId).toBe('string');
-    });
-  });
-});
-
-describe('Claude Integration Module', () => {
-  let claude: ClaudeIntegration;
-
-  beforeEach(() => {
-    claude = new ClaudeIntegration('test-api-key');
-  });
-
-  describe('AI Communication', () => {
-    test('should send messages to Claude and receive responses', async () => {
-      const response = await claude.sendMessage('Hello, can you help me deploy a web application?');
-      
-      expect(response).toHaveProperty('content');
-      expect(response).toHaveProperty('usage');
-      expect(typeof response.content).toBe('string');
-    });
-
-    test('should handle conversation context', async () => {
-      await claude.sendMessage('I want to deploy nginx');
-      const response = await claude.sendMessage('What are the recommended resources?');
-      
-      // Response should reference the previous nginx context
-      expect(response.content.toLowerCase()).toContain('nginx');
-    });
-
-    test('should format Kubernetes YAML properly', async () => {
-      const response = await claude.generateYAML('deployment', {
-        app: 'nginx',
-        replicas: 2,
-        image: 'nginx:latest'
-      });
-      
-      expect(response).toHaveProperty('yaml');
-      expect(response).toHaveProperty('explanation');
-      expect(response.yaml).toContain('apiVersion');
-      expect(response.yaml).toContain('kind: Deployment');
-    });
-  });
-
-  describe('Error Handling', () => {
-    test('should handle API errors gracefully', async () => {
-      const invalidClaude = new ClaudeIntegration('invalid-key');
-      
-      await expect(invalidClaude.sendMessage('test')).rejects.toThrow();
-    });
-
-    test('should provide meaningful error messages', async () => {
-      try {
-        const invalidClaude = new ClaudeIntegration('');
-        await invalidClaude.sendMessage('test');
-      } catch (error) {
-        expect((error as Error).message).toContain('API key');
-      }
-    });
-  });
-
-  describe('Learning Integration', () => {
-    test('should learn from successful interactions', async () => {
-      const interaction = {
-        input: 'Deploy nginx with 2 replicas',
-        output: 'Successfully created deployment',
-        success: true
-      };
-      
-      await claude.recordInteraction(interaction);
-      
-      const patterns = await claude.getSuccessfulPatterns();
-      expect(patterns).toContainEqual(expect.objectContaining(interaction));
-    });
-  });
-
-  describe('Centralized Configuration Management', () => {
-    const originalKubeconfig = process.env.KUBECONFIG;
-    const originalAnthropicKey = process.env.ANTHROPIC_API_KEY;
-
-    afterEach(() => {
-      // Restore original environment variables
-      if (originalKubeconfig) {
-        process.env.KUBECONFIG = originalKubeconfig;
-      } else {
-        delete process.env.KUBECONFIG;
-      }
-
-      if (originalAnthropicKey) {
-        process.env.ANTHROPIC_API_KEY = originalAnthropicKey;
-      } else {
-        delete process.env.ANTHROPIC_API_KEY;
-      }
-    });
-
-    test('should read ANTHROPIC_API_KEY from environment when not provided in config', () => {
-      process.env.ANTHROPIC_API_KEY = 'test-api-key-from-env';
-      delete process.env.KUBECONFIG;
-
-      const dotAI = new DotAI();
-      
-      // Use the public getter to verify API key was read from environment
-      expect(dotAI.getAnthropicApiKey()).toBe('test-api-key-from-env');
-    });
-
-    test('should use provided config values over environment variables', () => {
-      process.env.KUBECONFIG = '/env/kubeconfig.yaml';
-      process.env.ANTHROPIC_API_KEY = 'env-api-key';
-
-      const dotAI = new DotAI({
-        kubernetesConfig: '/override/kubeconfig.yaml',
-        anthropicApiKey: 'override-api-key'
-      });
-      
-      // Should use the provided config values, not environment
-      expect(dotAI.getAnthropicApiKey()).toBe('override-api-key');
-    });
-
-    test('should handle missing environment variables gracefully', () => {
-      delete process.env.KUBECONFIG;
-      delete process.env.ANTHROPIC_API_KEY;
-
-      const dotAI = new DotAI();
-      
-      expect(dotAI.getAnthropicApiKey()).toBeUndefined();
-    });
-
-    test('should provide public getter for API key', () => {
-      const dotAI = new DotAI({
-        anthropicApiKey: 'test-getter-key'
-      });
-      
-      expect(dotAI.getAnthropicApiKey()).toBe('test-getter-key');
-    });
-
-    test('should return undefined when no API key is available', () => {
-      delete process.env.ANTHROPIC_API_KEY;
-      
-      const dotAI = new DotAI();
-      
-      expect(dotAI.getAnthropicApiKey()).toBeUndefined();
-    });
-
-    test('should validate configuration and reject empty API key', () => {
-      expect(() => {
-        new DotAI({
-          anthropicApiKey: ''
-        });
-      }).toThrow('Invalid configuration: Empty API key provided');
-    });
-  });
-}); 

package/tests/fixtures/configmap-no-labels.yaml

@@ -1,8 +0,0 @@
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: configmap-no-best-practices
-  # Missing labels and namespace - should trigger warnings
-data:
-  config.yaml: |
-    setting: value

package/tests/fixtures/crossplane-app-configuration.yaml

@@ -1,6 +0,0 @@
-apiVersion: pkg.crossplane.io/v1
-kind: Configuration
-metadata:
-  name: crossplane-app
-spec:
-  package: xpkg.upbound.io/devops-toolkit/dot-application:v3.0.15