@vfarcic/dot-ai 0.5.1 → 0.6.0

package/src/core/kubernetes-utils.ts

@@ -1,218 +0,0 @@
-/**
- * Shared Kubernetes Utilities
- * 
- * Common functions for interacting with Kubernetes clusters
- */
-
-import { exec } from 'child_process';
-import { promisify } from 'util';
-
-const execAsync = promisify(exec);
-
-// Enhanced interfaces for kubectl-based discovery
-export interface KubectlConfig {
-  context?: string;
-  namespace?: string;
-  kubeconfig?: string;
-  timeout?: number;
-}
-
-/**
- * Execute kubectl command with proper configuration
- */
-export async function executeKubectl(args: string[], config?: KubectlConfig): Promise<string> {
-  const command = buildKubectlCommand(args, config);
-  const timeout = config?.timeout || 30000;
-
-  try {
-    const { stdout, stderr } = await execAsync(command, { 
-      timeout,
-      maxBuffer: 100 * 1024 * 1024  // 100MB buffer for large clusters with 1000+ CRDs
-    });
-    if (stderr && !stderr.includes('Warning')) {
-      throw new Error(`kubectl command failed: ${stderr}`);
-    }
-    return stdout.trim();
-  } catch (error: any) {
-    if (error.code === 'ENOENT') {
-      throw new Error('kubectl binary not found. Please install kubectl and ensure it\'s in your PATH.');
-    }
-    
-    // Use error classification for better error messages
-    const classified = ErrorClassifier.classifyError(error);
-    throw new Error(classified.enhancedMessage);
-  }
-}
-
-/**
- * Build kubectl command string with proper flags
- */
-export function buildKubectlCommand(args: string[], config?: KubectlConfig): string {
-  let command = 'kubectl';
-  
-  if (config?.kubeconfig) {
-    command += ` --kubeconfig=${config.kubeconfig}`;
-  }
-  
-  if (config?.context) {
-    command += ` --context=${config.context}`;
-  }
-  
-  if (config?.namespace) {
-    command += ` --namespace=${config.namespace}`;
-  }
-  
-  command += ` ${args.join(' ')}`;
-  return command;
-}
-
-// Enhanced Error Classification System
-export class ErrorClassifier {
-  static classifyError(error: Error): { type: string; enhancedMessage: string } {
-    const originalMessage = error.message;
-
-    // Connection and Network Errors
-    if (this.isNetworkError(originalMessage)) {
-      return {
-        type: 'network',
-        enhancedMessage: this.enhanceNetworkError(originalMessage)
-      };
-    }
-
-    // Authentication Errors
-    if (this.isAuthenticationError(originalMessage)) {
-      return {
-        type: 'authentication',
-        enhancedMessage: this.enhanceAuthenticationError(originalMessage)
-      };
-    }
-
-    // Authorization/RBAC Errors
-    if (this.isAuthorizationError(originalMessage)) {
-      return {
-        type: 'authorization',
-        enhancedMessage: this.enhanceAuthorizationError(originalMessage)
-      };
-    }
-
-    // API Availability Errors
-    if (this.isAPIAvailabilityError(originalMessage)) {
-      return {
-        type: 'api-availability',
-        enhancedMessage: this.enhanceAPIAvailabilityError(originalMessage)
-      };
-    }
-
-    // Kubeconfig Validation Errors
-    if (this.isKubeconfigError(originalMessage)) {
-      return {
-        type: 'kubeconfig',
-        enhancedMessage: this.enhanceKubeconfigError(originalMessage)
-      };
-    }
-
-    // Version Compatibility Errors
-    if (this.isVersionCompatibilityError(originalMessage)) {
-      return {
-        type: 'version',
-        enhancedMessage: this.enhanceVersionCompatibilityError(originalMessage)
-      };
-    }
-
-    // Default: return original message with basic enhancement
-    return {
-      type: 'unknown',
-      enhancedMessage: `${originalMessage}\n\nTroubleshooting steps:\n- Run 'kubectl cluster-info' to verify cluster connectivity\n- Check your kubeconfig with 'kubectl config view'\n- Verify cluster endpoint accessibility`
-    };
-  }
-
-  private static isNetworkError(message: string): boolean {
-    return /getaddrinfo ENOTFOUND|timeout|ECONNREFUSED|ENOTFOUND|network|unreachable/i.test(message);
-  }
-
-  private static isAuthenticationError(message: string): boolean {
-    return /unauthorized|invalid bearer token|certificate|auth|authentication/i.test(message);
-  }
-
-  private static isAuthorizationError(message: string): boolean {
-    return /forbidden|cannot list|cannot get|cannot create|RBAC|permission denied/i.test(message);
-  }
-
-  private static isAPIAvailabilityError(message: string): boolean {
-    return /server could not find|resource type.*not found|doesn't have a resource type|no matches for kind/i.test(message);
-  }
-
-  private static isKubeconfigError(message: string): boolean {
-    // Be more specific - don't match "path does not exist" errors which are about manifest files
-    return /context.*does not exist|kubeconfig.*not found|invalid.*kubeconfig|config.*not found|no Auth Provider/i.test(message) && 
-           !/the path.*does not exist/.test(message);
-  }
-
-  private static isVersionCompatibilityError(message: string): boolean {
-    return /server version|version.*old|unsupported.*version|api.*version/i.test(message);
-  }
-
-  private static enhanceNetworkError(message: string): string {
-    if (message.includes('getaddrinfo ENOTFOUND')) {
-      return `DNS resolution failed: Cannot resolve cluster endpoint hostname.\n\nTroubleshooting steps:\n- Check cluster endpoint in kubeconfig: kubectl config view\n- Verify network connectivity and DNS settings\n- Confirm cluster is running and accessible\n- Check VPN connection if using private cluster\n\nOriginal error: ${message}`;
-    }
-
-    if (message.includes('timeout')) {
-      return `Connection timeout: Unable to reach cluster within timeout period.\n\nTroubleshooting steps:\n- Check network latency to cluster endpoint\n- Increase timeout value if needed\n- Verify cluster is responsive: kubectl get nodes\n- Check firewall and proxy settings\n\nOriginal error: ${message}`;
-    }
-
-    return `Network connectivity issue detected.\n\nTroubleshooting steps:\n- Verify cluster endpoint accessibility\n- Run 'kubectl cluster-info' to test connectivity\n- Check network and firewall settings\n- Confirm cluster is running\n\nOriginal error: ${message}`;
-  }
-
-  private static enhanceAuthenticationError(message: string): string {
-    if (message.includes('invalid bearer token')) {
-      return `Token may be expired: Bearer token authentication failed.\n\nTroubleshooting steps:\n- Token may be expired - refresh credentials\n- Check token format in kubeconfig\n- Re-authenticate with cluster: kubectl auth login\n- Verify service account token if applicable\n\nOriginal error: ${message}`;
-    }
-
-    if (message.includes('certificate')) {
-      return `Certificate authentication failed: Client certificate validation error.\n\nTroubleshooting steps:\n- Verify certificate path in kubeconfig\n- Check certificate expiration date\n- Ensure certificate authority (CA) bundle is correct\n- Re-generate client certificates if needed\n\nOriginal error: ${message}`;
-    }
-
-    if (message.includes('no Auth Provider found')) {
-      return `Authentication provider not available: Required auth plugin missing.\n\nTroubleshooting steps:\n- Install required authentication plugin (e.g., OIDC)\n- Check kubectl config for auth provider configuration\n- Verify authentication method compatibility\n- Consult cluster administrator for auth setup\n\nOriginal error: ${message}`;
-    }
-
-    return `Authentication failed: Invalid or missing credentials.\n\nTroubleshooting steps:\n- Verify credentials in kubeconfig\n- Re-authenticate with cluster\n- Check authentication method configuration\n- Contact cluster administrator if needed\n\nOriginal error: ${message}`;
-  }
-
-  private static enhanceAuthorizationError(message: string): string {
-    if (message.includes('customresourcedefinitions')) {
-      return `CRD discovery requires cluster-level permissions: Insufficient RBAC permissions.\n\nTroubleshooting steps:\n- CRD discovery requires admin privileges\n- Request cluster-admin role or CRD read permissions\n- Contact cluster administrator for permission escalation\n- Use 'kubectl auth can-i list customresourcedefinitions' to check permissions\n\nOriginal error: ${message}`;
-    }
-
-    if (message.includes('forbidden')) {
-      return `Insufficient permissions: RBAC restrictions prevent this operation.\n\nTroubleshooting steps:\n- RBAC role required for resource access\n- Request appropriate permissions from cluster administrator\n- Check current permissions: kubectl auth can-i list <resource>\n- Consider using cluster-admin role for discovery operations\n\nOriginal error: ${message}`;
-    }
-
-    return `Permission denied: Insufficient RBAC permissions for cluster access.\n\nTroubleshooting steps:\n- Request appropriate RBAC permissions\n- Check current access: kubectl auth can-i list <resource>\n- Contact cluster administrator for role assignment\n- Verify service account permissions if applicable\n\nOriginal error: ${message}`;
-  }
-
-  private static enhanceAPIAvailabilityError(message: string): string {
-    if (message.includes('apps/v1beta1')) {
-      return `API version not supported: Cluster doesn't support requested API version.\n\nTroubleshooting steps:\n- Try different API version (e.g., apps/v1 instead of apps/v1beta1)\n- Check available API versions: kubectl api-versions\n- Verify Kubernetes cluster version compatibility\n- Consult API migration guides for version changes\n\nOriginal error: ${message}`;
-    }
-
-    return `API resource not available: Requested resource type not found in cluster.\n\nTroubleshooting steps:\n- Check available resources: kubectl api-resources\n- Verify cluster supports required resource types\n- Check Kubernetes version compatibility\n- Confirm cluster configuration and enabled APIs\n\nOriginal error: ${message}`;
-  }
-
-  private static enhanceKubeconfigError(message: string): string {
-    if (message.includes('context') && message.includes('does not exist')) {
-      return `Context not found: Specified context doesn't exist in kubeconfig.\n\nTroubleshooting steps:\n- List available contexts: kubectl config get-contexts\n- Set correct context: kubectl config use-context <context-name>\n- Verify kubeconfig file contains required context\n- Check context name spelling and case sensitivity\n\nOriginal error: ${message}`;
-    }
-
-    if (message.includes('not found')) {
-      return `Kubeconfig file not found: Cannot locate configuration file.\n\nTroubleshooting steps:\n- Check file path exists and is accessible\n- Verify kubeconfig file permissions\n- Set KUBECONFIG environment variable if needed\n- Create kubeconfig file or copy from cluster administrator\n\nOriginal error: ${message}`;
-    }
-
-    return `Invalid kubeconfig format: Configuration file has syntax or format errors.\n\nTroubleshooting steps:\n- Validate YAML syntax in kubeconfig file\n- Check file structure: kubectl config view\n- Restore from backup or re-download from cluster\n- Verify all required sections (clusters, contexts, users)\n\nOriginal error: ${message}`;
-  }
-
-  private static enhanceVersionCompatibilityError(message: string): string {
-    return `Kubernetes version compatibility issue: Version mismatch detected.\n\nTroubleshooting steps:\n- Check cluster and client versions: kubectl version\n- Verify supported Kubernetes versions for this tool\n- Update kubectl client if needed\n- Consult compatibility matrix for version support\n\nOriginal error: ${message}`;
-  }
-} 

package/src/core/memory.ts

@@ -1,148 +0,0 @@
-/**
- * Memory System Module
- * 
- * Handles learning, context management, and recommendation storage
- */
-
-export interface SuccessPattern {
-  type: string;
-  config: any;
-  timestamp: Date;
-}
-
-export interface FailurePattern {
-  type: string;
-  config: any;
-  error: string;
-  timestamp: Date;
-}
-
-export interface Recommendation {
-  suggestion: string;
-  confidence: number;
-  based_on: string[];
-}
-
-export class MemorySystem {
-  private storage: Map<string, any> = new Map();
-  private successPatterns: Map<string, SuccessPattern[]> = new Map();
-  private failurePatterns: Map<string, FailurePattern[]> = new Map();
-  private context: Map<string, any> = new Map();
-  private initialized: boolean = false;
-
-  async initialize(): Promise<void> {
-    // Initialize storage (in production, this would connect to persistent storage)
-    this.initialized = true;
-  }
-
-  async store(key: string, data: any): Promise<void> {
-    this.storage.set(key, data);
-  }
-
-  async retrieve(key: string): Promise<any> {
-    return this.storage.get(key) || null;
-  }
-
-  async learnSuccess(type: string, config: any): Promise<void> {
-    const pattern: SuccessPattern = {
-      type,
-      config,
-      timestamp: new Date()
-    };
-
-    const existing = this.successPatterns.get(type) || [];
-    existing.push(pattern);
-    this.successPatterns.set(type, existing);
-  }
-
-  async learnFailure(type: string, config: any, error: string): Promise<void> {
-    const pattern: FailurePattern = {
-      type,
-      config,
-      error,
-      timestamp: new Date()
-    };
-
-    const existing = this.failurePatterns.get(type) || [];
-    existing.push(pattern);
-    this.failurePatterns.set(type, existing);
-  }
-
-  async getSuccessPatterns(type: string): Promise<SuccessPattern[]> {
-    return this.successPatterns.get(type) || [];
-  }
-
-  async getFailurePatterns(type: string): Promise<FailurePattern[]> {
-    return this.failurePatterns.get(type) || [];
-  }
-
-  async getRecommendations(type: string, partialConfig: any): Promise<Recommendation[]> {
-    const successPatterns = await this.getSuccessPatterns(type);
-    const recommendations: Recommendation[] = [];
-
-    // Simple recommendation algorithm
-    for (const pattern of successPatterns) {
-      const similarity = this.calculateSimilarity(partialConfig, pattern.config);
-      if (similarity >= 0.5) {
-        recommendations.push({
-          suggestion: `Consider using configuration similar to successful ${type}`,
-          confidence: similarity,
-          based_on: [`Success pattern from ${pattern.timestamp.toISOString()}`]
-        });
-      }
-    }
-
-    return recommendations;
-  }
-
-  async storePattern(type: string, pattern: any): Promise<void> {
-    // Store pattern as a success by default
-    await this.learnSuccess(type, pattern);
-  }
-
-  async retrievePattern(type: string): Promise<any[]> {
-    const patterns = await this.getSuccessPatterns(type);
-    return patterns.map(p => p.config);
-  }
-
-  async storeLessons(type: string, lessons: any): Promise<void> {
-    // Store lessons in the general storage
-    await this.store(`lessons-${type}`, lessons);
-  }
-
-  private calculateSimilarity(config1: any, config2: any): number {
-    // Simple similarity calculation
-    const keys1 = Object.keys(config1);
-    const keys2 = Object.keys(config2);
-    const commonKeys = keys1.filter(key => keys2.includes(key));
-    
-    if (keys1.length === 0 && keys2.length === 0) return 1;
-    if (keys1.length === 0 || keys2.length === 0) return 0;
-    
-    return commonKeys.length / Math.max(keys1.length, keys2.length);
-  }
-
-  async setContext(key: string, value: any): Promise<void> {
-    this.context.set(key, value);
-  }
-
-  async getContext(): Promise<Record<string, any>> {
-    const result: Record<string, any> = {};
-    for (const [key, value] of this.context.entries()) {
-      result[key] = value;
-    }
-    return result;
-  }
-
-  async clearContext(key?: string): Promise<void> {
-    if (key) {
-      this.context.delete(key);
-    } else {
-      this.context.clear();
-    }
-  }
-
-  isInitialized(): boolean {
-    return this.initialized;
-  }
-}