@vfarcic/dot-ai 0.5.1 → 0.6.0

package/src/core/claude.ts

@@ -1,280 +0,0 @@
-/**
- * Claude Integration Module
- * 
- * Handles AI communication, YAML generation, and learning integration
- */
-
-import Anthropic from '@anthropic-ai/sdk';
-
-export interface ClaudeResponse {
-  content: string;
-  usage: {
-    input_tokens: number;
-    output_tokens: number;
-  };
-}
-
-export interface YAMLResponse {
-  yaml: string;
-  explanation: string;
-}
-
-export interface Interaction {
-  input: string;
-  output: string;
-  success: boolean;
-  timestamp?: Date;
-}
-
-export class ClaudeIntegration {
-  private client: Anthropic | null = null;
-  private apiKey: string;
-  private conversationHistory: any[] = [];
-  private interactions: Interaction[] = [];
-
-  constructor(apiKey: string) {
-    this.apiKey = apiKey;
-    this.validateApiKey();
-    
-    if (this.apiKey) {
-      this.client = new Anthropic({
-        apiKey: this.apiKey,
-      });
-    }
-  }
-
-  private validateApiKey(): void {
-    // Allow test-friendly initialization
-    if (this.apiKey === 'test-key' || this.apiKey === 'mock-key') {
-      return; // Allow test keys
-    }
-    
-    if (!this.apiKey) {
-      throw new Error('API key is required for Claude integration');
-    }
-    if (this.apiKey.length === 0) {
-      throw new Error('Invalid API key: API key cannot be empty');
-    }
-  }
-
-  async sendMessage(message: string): Promise<ClaudeResponse> {
-    if (!this.client) {
-      throw new Error('Claude client not initialized due to missing API key');
-    }
-
-    if (this.apiKey === 'invalid-key') {
-      throw new Error('Authentication failed: Invalid API key');
-    }
-
-    try {
-      // Add message to conversation history
-      this.conversationHistory.push({ role: 'user', content: message });
-
-      // Use real Claude API if we have a real API key, otherwise fall back to mocks
-      if (this.apiKey.startsWith('sk-ant-') && this.client) {
-        // Make real API call to Claude
-        const completion = await this.client.messages.create({
-          model: 'claude-3-5-sonnet-20241022',
-          max_tokens: 4000,
-          messages: [{ role: 'user', content: message }]
-        });
-
-        const content = completion.content[0].type === 'text' ? completion.content[0].text : '';
-        const response: ClaudeResponse = {
-          content,
-          usage: {
-            input_tokens: completion.usage.input_tokens,
-            output_tokens: completion.usage.output_tokens
-          }
-        };
-
-        this.conversationHistory.push({ role: 'assistant', content: response.content });
-        return response;
-      }
-
-      // For testing purposes, return mock responses
-      if (message.toLowerCase().includes('deploy a web application')) {
-        const response: ClaudeResponse = {
-          content: 'I can help you deploy a web application to Kubernetes. Let me guide you through the process of creating the necessary YAML manifests for your deployment.',
-          usage: { input_tokens: 10, output_tokens: 25 }
-        };
-        
-        this.conversationHistory.push({ role: 'assistant', content: response.content });
-        return response;
-      }
-
-      if (message.toLowerCase().includes('recommended resources') && 
-          this.conversationHistory.some(msg => msg.content.toLowerCase().includes('nginx'))) {
-        const response: ClaudeResponse = {
-          content: 'For nginx deployment, I recommend starting with 2 replicas, 500m CPU and 512Mi memory per pod. You can adjust these based on your traffic patterns.',
-          usage: { input_tokens: 8, output_tokens: 30 }
-        };
-        
-        this.conversationHistory.push({ role: 'assistant', content: response.content });
-        return response;
-      }
-
-      // Default mock response
-      const response: ClaudeResponse = {
-        content: 'I understand you want help with Kubernetes deployment. Could you provide more specific details about what you\'d like to deploy?',
-        usage: { input_tokens: message.length / 4, output_tokens: 20 }
-      };
-      
-      this.conversationHistory.push({ role: 'assistant', content: response.content });
-      return response;
-
-    } catch (error) {
-      throw new Error(`Claude API error: ${error}`);
-    }
-  }
-
-  async generateYAML(resourceType: string, config: any): Promise<YAMLResponse> {
-    if (!this.client) {
-      throw new Error('Claude client not initialized');
-    }
-
-    // Mock YAML generation for testing
-    if (resourceType === 'deployment' && config.app === 'nginx') {
-      return {
-        yaml: `apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: ${config.app}
-  labels:
-    app: ${config.app}
-spec:
-  replicas: ${config.replicas || 1}
-  selector:
-    matchLabels:
-      app: ${config.app}
-  template:
-    metadata:
-      labels:
-        app: ${config.app}
-    spec:
-      containers:
-      - name: ${config.app}
-        image: ${config.image}
-        ports:
-        - containerPort: 80`,
-        explanation: `This deployment creates ${config.replicas || 1} replica(s) of ${config.app} using the ${config.image} image. The container exposes port 80 for web traffic.`
-      };
-    }
-
-    // Default YAML response
-    return {
-      yaml: `apiVersion: apps/v1
-kind: ${resourceType.charAt(0).toUpperCase() + resourceType.slice(1)}
-metadata:
-  name: example-${resourceType}
-spec:
-  # Generated configuration would go here`,
-      explanation: `This is a basic ${resourceType} manifest. You should customize it based on your specific requirements.`
-    };
-  }
-
-  async recordInteraction(interaction: Interaction): Promise<void> {
-    const recordedInteraction = {
-      ...interaction,
-      timestamp: new Date()
-    };
-    
-    this.interactions.push(recordedInteraction);
-  }
-
-  async getSuccessfulPatterns(): Promise<Interaction[]> {
-    return this.interactions.filter(interaction => interaction.success);
-  }
-
-  getConversationHistory(): any[] {
-    return [...this.conversationHistory];
-  }
-
-  clearConversationHistory(): void {
-    this.conversationHistory = [];
-  }
-
-  async generateManifest(spec: any): Promise<string> {
-    if (!this.client) {
-      throw new Error('Claude client not initialized');
-    }
-
-    // Simulate manifest generation
-    const yamlContent = `
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: ${spec.name || 'app'}
-spec:
-  replicas: ${spec.replicas || 1}
-  selector:
-    matchLabels:
-      app: ${spec.name || 'app'}
-  template:
-    metadata:
-      labels:
-        app: ${spec.name || 'app'}
-    spec:
-      containers:
-      - name: app
-        image: ${spec.image || 'nginx:latest'}
-        ports:
-        - containerPort: 80
-`;
-    
-    return yamlContent.trim();
-  }
-
-  async analyzeError(error: string, _context?: any): Promise<string> {
-    if (!this.client) {
-      throw new Error('Claude client not initialized');
-    }
-
-    // Simulate error analysis
-    return `Error analysis: ${error}. Suggested fix: Check the configuration and try again.`;
-  }
-
-  async suggestImprovements(_manifest: string): Promise<string[]> {
-    if (!this.client) {
-      throw new Error('Claude client not initialized');
-    }
-
-    // Simulate improvement suggestions
-    return [
-      'Add resource limits and requests',
-      'Consider adding health checks',
-      'Add labels for better organization'
-    ];
-  }
-
-  async processUserInput(input: string, context?: any): Promise<any> {
-    if (!this.client) {
-      throw new Error('Claude client not initialized');
-    }
-
-    // Simulate interactive workflow processing
-    if (input.toLowerCase().includes('deploy') && context?.interactive) {
-      return {
-        phase: 'Planning',
-        questions: ['What type of database do you need?']
-      };
-    }
-
-    if (context?.responses) {
-      return {
-        phase: 'Validation',
-        nextSteps: ['Review generated manifest']
-      };
-    }
-
-    // Default response
-    return {
-      phase: 'Discovery',
-      suggestions: ['Start by exploring your cluster resources']
-    };
-  }
-
-  isInitialized(): boolean {
-    return this.client !== null;
-  }
-} 

package/src/core/deploy-operation.ts

@@ -1,127 +0,0 @@
-/**
- * Deploy Operation - Handles Kubernetes manifest deployment with readiness checking
- */
-
-import { access } from 'fs/promises';
-import { join } from 'path';
-import { ErrorHandler } from './error-handling';
-import { executeKubectl, KubectlConfig } from './kubernetes-utils';
-
-export interface DeployOptions {
-  solutionId: string;
-  sessionDir?: string;
-  timeout?: number;
-  kubeconfig?: string;
-}
-
-export interface DeployResult {
-  success: boolean;
-  solutionId: string;
-  manifestPath: string;
-  readinessTimeout: boolean;
-  message: string;
-  kubectlOutput: string;
-}
-
-export class DeployOperation {
-  private kubectlConfig: KubectlConfig;
-
-  constructor(kubeconfig?: string) {
-    this.kubectlConfig = {
-      kubeconfig: kubeconfig || process.env.KUBECONFIG
-    };
-  }
-
-  /**
-   * Deploy Kubernetes manifests from generated solution
-   */
-  public async deploy(options: DeployOptions): Promise<DeployResult> {
-    return ErrorHandler.withErrorHandling(
-      async () => {
-        const manifestPath = this.getManifestPath(options);
-        
-        // Verify manifest file exists
-        await this.verifyManifestExists(manifestPath);
-
-        // Update kubeconfig if provided in options
-        const kubectlConfig = {
-          ...this.kubectlConfig,
-          kubeconfig: options.kubeconfig || this.kubectlConfig.kubeconfig
-        };
-
-        // Apply manifests with kubectl
-        const kubectlOutput = await this.applyManifests(manifestPath, options.timeout || 30, kubectlConfig);
-
-        return {
-          success: true,
-          solutionId: options.solutionId,
-          manifestPath,
-          readinessTimeout: false,
-          message: 'Deployment completed successfully',
-          kubectlOutput
-        };
-      },
-      {
-        operation: 'deploy',
-        component: 'deploy-operation'
-      }
-    );
-  }
-
-  /**
-   * Get the manifest file path for the solution
-   */
-  private getManifestPath(options: DeployOptions): string {
-    const sessionDir = options.sessionDir || process.env.DOT_AI_SESSION_DIR;
-    if (!sessionDir) {
-      throw new Error('Session directory not configured. Set DOT_AI_SESSION_DIR environment variable or provide sessionDir parameter.');
-    }
-    
-    return join(sessionDir, `${options.solutionId}.yaml`);
-  }
-
-  /**
-   * Verify that the manifest file exists
-   */
-  private async verifyManifestExists(manifestPath: string): Promise<void> {
-    try {
-      await access(manifestPath);
-    } catch (error) {
-      throw new Error(`Manifest file not found: ${manifestPath}`);
-    }
-  }
-
-  /**
-   * Apply manifests using kubectl with readiness checking
-   */
-  private async applyManifests(manifestPath: string, timeout: number, kubectlConfig: KubectlConfig): Promise<string> {
-    // First, apply the manifests
-    const applyResult = await executeKubectl(['apply', '-f', `"${manifestPath}"`], kubectlConfig);
-    
-    // Try to wait for deployments to be ready (ignore failures for other resource types)
-    let waitOutput = '';
-    try {
-      const waitResult = await executeKubectl([
-        'wait', 
-        '--for=condition=available', 
-        'deployments', 
-        '--all', 
-        `--timeout=${timeout}s`, 
-        '--all-namespaces'
-      ], {
-        ...kubectlConfig,
-        timeout: (timeout + 10) * 1000 // Add 10 seconds buffer for kubectl command itself
-      });
-      waitOutput = `\n\nWait output:\n${waitResult}`;
-    } catch (waitError: any) {
-      // If no deployments found or wait fails, that's OK for ConfigMaps, Services, etc.
-      if (waitError.message && waitError.message.includes('no matching resources found')) {
-        waitOutput = '\n\nWait output: No deployments found to wait for (likely ConfigMaps, Services, etc.)';
-      } else {
-        waitOutput = `\n\nWait output: Warning - ${waitError.message}`;
-      }
-    }
-
-    return `Apply output:\n${applyResult}${waitOutput}`;
-  }
-}