language-operator 0.0.1 → 0.1.31

data/lib/language_operator/cli/helpers/cluster_context.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'cluster_validator'
+
+module LanguageOperator
+  module CLI
+    module Helpers
+      # Encapsulates cluster context (name, config, client) to reduce boilerplate
+      # in command implementations.
+      #
+      # Instead of repeating:
+      #   cluster = ClusterValidator.get_cluster(options[:cluster])
+      #   cluster_config = ClusterValidator.get_cluster_config(cluster)
+      #   k8s = ClusterValidator.kubernetes_client(options[:cluster])
+      #
+      # Use:
+      #   ctx = ClusterContext.from_options(options)
+      #   # Access: ctx.name, ctx.config, ctx.client, ctx.namespace
+      class ClusterContext
+        attr_reader :name, :config, :client, :namespace
+
+        # Create ClusterContext from command options hash
+        # @param options [Hash] Thor command options (expects :cluster key)
+        # @return [ClusterContext] Initialized context
+        def self.from_options(options)
+          name = ClusterValidator.get_cluster(options[:cluster])
+          config = ClusterValidator.get_cluster_config(name)
+          client = ClusterValidator.kubernetes_client(options[:cluster])
+          new(name, config, client)
+        end
+
+        # Initialize with cluster details
+        # @param name [String] Cluster name
+        # @param config [Hash] Cluster configuration
+        # @param client [LanguageOperator::Kubernetes::Client] K8s client
+        def initialize(name, config, client)
+          @name = name
+          @config = config
+          @client = client
+          @namespace = config[:namespace]
+        end
+
+        # Build kubectl command args for this cluster context
+        # @return [Hash] kubectl arguments
+        def kubectl_args
+          {
+            kubeconfig: config[:kubeconfig] ? "--kubeconfig=#{config[:kubeconfig]}" : '',
+            context: config[:context] ? "--context=#{config[:context]}" : '',
+            namespace: "-n #{namespace}"
+          }
+        end
+
+        # Build kubectl command prefix string
+        # @return [String] kubectl command prefix
+        def kubectl_prefix
+          args = kubectl_args
+          "kubectl #{args[:kubeconfig]} #{args[:context]} #{args[:namespace]}".strip.squeeze(' ')
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/helpers/cluster_validator.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative '../formatters/progress_formatter'
+require_relative '../errors/handler'
+require_relative 'kubeconfig_validator'
+require_relative '../../config/cluster_config'
+
+module LanguageOperator
+  module CLI
+    module Helpers
+      # Validates that a cluster is selected before executing commands
+      module ClusterValidator
+        class << self
+          # Ensure a cluster is selected, exit with helpful message if not
+          def ensure_cluster_selected!
+            return current_cluster if current_cluster
+
+            Errors::Handler.handle_no_cluster_selected
+          end
+
+          # Get current cluster, or allow override via --cluster flag
+          def get_cluster(cluster_override = nil)
+            if cluster_override
+              validate_cluster_exists!(cluster_override)
+              cluster_override
+            else
+              ensure_cluster_selected!
+            end
+          end
+
+          # Validate that a specific cluster exists
+          def validate_cluster_exists!(name)
+            return if Config::ClusterConfig.cluster_exists?(name)
+
+            # Build context with available clusters for fuzzy matching
+            clusters = Config::ClusterConfig.list_clusters
+            available_names = clusters.map { |c| c[:name] }
+
+            # Use error handler with fuzzy matching
+            error = K8s::Error::NotFound.new(404, 'Not Found', 'cluster')
+            Errors::Handler.handle_not_found(error,
+                                             resource_type: 'cluster',
+                                             resource_name: name,
+                                             available_resources: available_names)
+          end
+
+          # Get current cluster name
+          def current_cluster
+            Config::ClusterConfig.current_cluster
+          end
+
+          # Get current cluster config
+          def current_cluster_config
+            cluster_name = ensure_cluster_selected!
+            Config::ClusterConfig.get_cluster(cluster_name)
+          end
+
+          # Get cluster config by name (with validation)
+          def get_cluster_config(name)
+            validate_cluster_exists!(name)
+            config = Config::ClusterConfig.get_cluster(name)
+
+            # Validate kubeconfig exists and is accessible
+            validate_kubeconfig!(config)
+
+            config
+          end
+
+          # Validate kubeconfig for the given cluster config
+          def validate_kubeconfig!(cluster_config)
+            # Check if kubeconfig file exists
+            kubeconfig_path = cluster_config[:kubeconfig]
+            return if kubeconfig_path && File.exist?(kubeconfig_path)
+
+            Formatters::ProgressFormatter.error("Kubeconfig not found: #{kubeconfig_path}")
+            puts
+            puts 'The kubeconfig file for this cluster does not exist.'
+            puts
+            puts 'To fix this issue:'
+            puts '  1. Verify the kubeconfig path in ~/.aictl/config.yaml'
+            puts '  2. Re-create the cluster configuration:'
+            puts "     aictl cluster create #{cluster_config[:name]}"
+            exit 1
+          end
+
+          # Create a Kubernetes client for the given cluster
+          def kubernetes_client(cluster_override = nil)
+            cluster = get_cluster(cluster_override)
+            cluster_config = get_cluster_config(cluster)
+
+            require_relative '../../kubernetes/client'
+            Kubernetes::Client.new(
+              kubeconfig: cluster_config[:kubeconfig],
+              context: cluster_config[:context]
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/helpers/editor_helper.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+module LanguageOperator
+  module CLI
+    module Helpers
+      # Helper module for editing content in the user's preferred editor.
+      # Handles tempfile creation, cleanup, and editor invocation.
+      module EditorHelper
+        # Edit content in the user's preferred editor
+        #
+        # @param content [String] Content to edit
+        # @param filename_prefix [String] Prefix for the temp file name
+        # @param extension [String] File extension (default: '.txt')
+        # @param default_editor [String] Editor to use if $EDITOR not set (default: 'vi')
+        # @return [String] The edited content
+        # @raise [RuntimeError] If editor command fails
+        #
+        # @example Edit agent instructions
+        #   new_content = EditorHelper.edit_content(
+        #     current_instructions,
+        #     'agent-instructions-',
+        #     '.txt'
+        #   )
+        #
+        # @example Edit YAML configuration
+        #   new_yaml = EditorHelper.edit_content(
+        #     model.to_yaml,
+        #     'model-',
+        #     '.yaml',
+        #     default_editor: 'vim'
+        #   )
+        def self.edit_content(content, filename_prefix, extension = '.txt', default_editor: 'vi')
+          editor = ENV['EDITOR'] || default_editor
+          tempfile = Tempfile.new([filename_prefix, extension])
+
+          begin
+            # Write content and flush to ensure it's on disk
+            tempfile.write(content)
+            tempfile.flush
+            tempfile.close
+
+            # Open in editor
+            success = system("#{editor} #{tempfile.path}")
+            raise "Editor command failed: #{editor}" unless success
+
+            # Read edited content
+            File.read(tempfile.path)
+          ensure
+            # Clean up temp file
+            tempfile.unlink
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/helpers/kubeconfig_validator.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require_relative '../formatters/progress_formatter'
+require_relative '../../kubernetes/client'
+
+module LanguageOperator
+  module CLI
+    module Helpers
+      # Validates kubeconfig and cluster connectivity
+      class KubeconfigValidator
+        class << self
+          # Validate kubeconfig exists and cluster is accessible
+          # Returns [valid, error_message]
+          def validate
+            # Check if kubeconfig file exists
+            kubeconfig_path = detect_kubeconfig
+            return [false, kubeconfig_missing_message(kubeconfig_path)] unless kubeconfig_path && File.exist?(kubeconfig_path)
+
+            # Try to connect to cluster
+            begin
+              k8s = Kubernetes::Client.new(kubeconfig: kubeconfig_path)
+
+              # Test connectivity by listing namespaces
+              k8s.client.api('v1').resource('namespaces').list
+
+              # Check if operator is installed
+              return [false, operator_missing_message] unless k8s.operator_installed?
+
+              [true, nil]
+            rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT => e
+              [false, connection_failed_message(e)]
+            rescue K8s::Error::Unauthorized => e
+              [false, auth_failed_message(e)]
+            rescue StandardError => e
+              [false, generic_error_message(e)]
+            end
+          end
+
+          # Validate and exit with error if invalid
+          def validate!
+            valid, error_message = validate
+            return if valid
+
+            Formatters::ProgressFormatter.error(error_message)
+            exit 1
+          end
+
+          # Detect kubeconfig path
+          def detect_kubeconfig
+            ENV.fetch('KUBECONFIG', nil) || default_kubeconfig_path
+          end
+
+          # Check if kubeconfig exists
+          def kubeconfig_exists?
+            path = detect_kubeconfig
+            path && File.exist?(path)
+          end
+
+          private
+
+          def default_kubeconfig_path
+            File.expand_path('~/.kube/config')
+          end
+
+          def kubeconfig_missing_message(path)
+            <<~MSG
+              Kubeconfig file not found
+
+              Expected location: #{path || default_kubeconfig_path}
+
+              To fix this issue:
+              1. Ensure you have a Kubernetes cluster configured
+              2. Set KUBECONFIG environment variable to point to your kubeconfig file:
+                 export KUBECONFIG=/path/to/your/kubeconfig
+
+              Or place your kubeconfig at: ~/.kube/config
+
+              For local development, you can use:
+              - kind (https://kind.sigs.k8s.io/)
+              - k3d (https://k3d.io/)
+              - minikube (https://minikube.sigs.k8s.io/)
+            MSG
+          end
+
+          def connection_failed_message(error)
+            <<~MSG
+              Failed to connect to Kubernetes cluster
+
+              Error: #{error.message}
+
+              To fix this issue:
+              1. Check if your cluster is running:
+                 kubectl cluster-info
+
+              2. Verify your kubeconfig is correct:
+                 kubectl config view
+
+              3. Check your cluster context:
+                 kubectl config current-context
+
+              4. Test basic connectivity:
+                 kubectl get namespaces
+            MSG
+          end
+
+          def auth_failed_message(error)
+            <<~MSG
+              Kubernetes authentication failed
+
+              Error: #{error.message}
+
+              To fix this issue:
+              1. Verify your credentials are valid:
+                 kubectl config view
+
+              2. Check if your authentication token/certificate is expired
+
+              3. Re-authenticate with your cluster provider
+
+              4. Test authentication:
+                 kubectl get namespaces
+            MSG
+          end
+
+          def operator_missing_message
+            <<~MSG
+              Language Operator is not installed in the cluster
+
+              The Language Operator CRDs were not found in the cluster.
+
+              To install the operator:
+
+              1. Using aictl (recommended):
+                 aictl install
+
+              2. Or manually with Helm:
+                 helm repo add language-operator https://language-operator.github.io/charts
+                 helm repo update
+                 helm install language-operator language-operator/language-operator
+
+              3. Verify installation:
+                 kubectl get deployment -n language-operator-system language-operator
+
+              For more information, visit: https://github.com/language-operator/language-operator
+            MSG
+          end
+
+          def generic_error_message(error)
+            <<~MSG
+              Unexpected error validating cluster connection
+
+              Error: #{error.class}: #{error.message}
+
+              Please check:
+              1. Your kubeconfig file is valid
+              2. Your cluster is accessible
+              3. You have appropriate permissions
+
+              For debugging, run with DEBUG=1:
+                DEBUG=1 aictl <command>
+            MSG
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/helpers/pastel_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'pastel'
+
+module LanguageOperator
+  module CLI
+    module Helpers
+      # Shared module providing Pastel color functionality
+      # to CLI commands, formatters, and helpers.
+      #
+      # Usage:
+      #   include PastelHelper
+      #   puts pastel.green("Success!")
+      module PastelHelper
+        # Returns a memoized Pastel instance for colorizing terminal output
+        #
+        # @return [Pastel] Pastel instance
+        def pastel
+          @pastel ||= Pastel.new
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/helpers/resource_dependency_checker.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Helpers
+      # Helper module for checking which agents depend on specific resources
+      # (tools, models, personas). Used by CLI commands to warn before deletion.
+      module ResourceDependencyChecker
+        # Find agents that use a specific tool
+        #
+        # @param agents [Array<Hash>] Array of agent resources from kubectl
+        # @param tool_name [String] Name of the tool to check
+        # @return [Array<Hash>] Agents that reference this tool
+        def self.agents_using_tool(agents, tool_name)
+          agents.select do |agent|
+            agent_tools = agent.dig('spec', 'tools') || []
+            agent_tools.include?(tool_name)
+          end
+        end
+
+        # Find agents that use a specific language model
+        #
+        # @param agents [Array<Hash>] Array of agent resources from kubectl
+        # @param model_name [String] Name of the model to check
+        # @return [Array<Hash>] Agents that reference this model
+        def self.agents_using_model(agents, model_name)
+          agents.select do |agent|
+            agent_model_refs = agent.dig('spec', 'modelRefs') || []
+            agent_models = agent_model_refs.map { |ref| ref['name'] }
+            agent_models.include?(model_name)
+          end
+        end
+
+        # Find agents that use a specific persona
+        #
+        # @param agents [Array<Hash>] Array of agent resources from kubectl
+        # @param persona_name [String] Name of the persona to check
+        # @return [Array<Hash>] Agents that reference this persona
+        def self.agents_using_persona(agents, persona_name)
+          agents.select do |agent|
+            agent.dig('spec', 'persona') == persona_name
+          end
+        end
+
+        # Count how many agents use a specific tool
+        #
+        # @param agents [Array<Hash>] Array of agent resources
+        # @param tool_name [String] Name of the tool
+        # @return [Integer] Count of agents using this tool
+        def self.tool_usage_count(agents, tool_name)
+          agents_using_tool(agents, tool_name).size
+        end
+
+        # Count how many agents use a specific model
+        #
+        # @param agents [Array<Hash>] Array of agent resources
+        # @param model_name [String] Name of the model
+        # @return [Integer] Count of agents using this model
+        def self.model_usage_count(agents, model_name)
+          agents_using_model(agents, model_name).size
+        end
+
+        # Count how many agents use a specific persona
+        #
+        # @param agents [Array<Hash>] Array of agent resources
+        # @param persona_name [String] Name of the persona
+        # @return [Integer] Count of agents using this persona
+        def self.persona_usage_count(agents, persona_name)
+          agents_using_persona(agents, persona_name).size
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/helpers/schedule_builder.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Helpers
+      # Helper for building schedules from natural language inputs
+      class ScheduleBuilder
+        class << self
+          # Parse natural language time input and return 24-hour format
+          # Examples: "4pm" -> "16:00", "9:30am" -> "09:30", "16:00" -> "16:00"
+          def parse_time(input)
+            input = input.strip.downcase
+
+            # Handle 24-hour format (e.g., "16:00", "9:30")
+            if input.match?(/^\d{1,2}:\d{2}$/)
+              hours, minutes = input.split(':').map(&:to_i)
+              return format_time(hours, minutes) if valid_time?(hours, minutes)
+
+              raise ArgumentError, "Invalid time: #{input}"
+            end
+
+            # Handle 12-hour format with am/pm (e.g., "4pm", "9:30am")
+            match = input.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)$/i)
+            raise ArgumentError, "Invalid time format: #{input}" unless match
+
+            hours = match[1].to_i
+            minutes = match[2].to_i
+            period = match[3].downcase
+
+            # Convert to 24-hour format
+            hours = 0 if hours == 12 && period == 'am'
+            hours = 12 if hours == 12 && period == 'pm'
+            hours += 12 if period == 'pm' && hours != 12
+
+            raise ArgumentError, "Invalid time: #{input}" unless valid_time?(hours, minutes)
+
+            format_time(hours, minutes)
+          end
+
+          # Build a cron expression for daily execution at a specific time
+          def daily_cron(time_string)
+            hours, minutes = time_string.split(':').map(&:to_i)
+            "#{minutes} #{hours} * * *"
+          end
+
+          # Build a cron expression for interval-based execution
+          def interval_cron(interval, unit)
+            case unit.downcase
+            when 'minutes', 'minute'
+              "*/#{interval} * * * *"
+            when 'hours', 'hour'
+              "0 */#{interval} * * *"
+            when 'days', 'day'
+              "0 0 */#{interval} * *"
+            else
+              raise ArgumentError, "Invalid unit: #{unit}"
+            end
+          end
+
+          # Convert cron expression to human-readable format
+          def cron_to_human(cron_expr)
+            parts = cron_expr.split
+            return cron_expr if parts.length != 5
+
+            minute, hour, day, month, weekday = parts
+
+            # Daily at specific time
+            if minute =~ /^\d+$/ && hour =~ /^\d+$/ && day == '*' && month == '*' && weekday == '*'
+              time_str = format_time(hour.to_i, minute.to_i)
+              return "Daily at #{time_str}"
+            end
+
+            # Every N minutes
+            if minute.start_with?('*/') && hour == '*'
+              interval = minute[2..].to_i
+              return "Every #{interval} minute#{'s' if interval > 1}"
+            end
+
+            # Every N hours
+            if minute == '0' && hour.start_with?('*/')
+              interval = hour[2..].to_i
+              return "Every #{interval} hour#{'s' if interval > 1}"
+            end
+
+            # Every N days
+            if minute == '0' && hour == '0' && day.start_with?('*/')
+              interval = day[2..].to_i
+              return "Every #{interval} day#{'s' if interval > 1}"
+            end
+
+            # Fallback to cron expression
+            cron_expr
+          end
+
+          private
+
+          def valid_time?(hours, minutes)
+            hours >= 0 && hours < 24 && minutes >= 0 && minutes < 60
+          end
+
+          def format_time(hours, minutes)
+            format('%<hours>02d:%<minutes>02d', hours: hours, minutes: minutes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/helpers/user_prompts.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Helpers
+      # Helper module for user confirmation prompts and interactive input.
+      # Consolidates the repeated confirmation pattern used throughout commands.
+      module UserPrompts
+        # Ask user for confirmation
+        # @param message [String] The confirmation message
+        # @param force [Boolean] Skip prompt if true (default: false)
+        # @return [Boolean] true if confirmed, false otherwise
+        # rubocop:disable Naming/PredicateMethod
+        def self.confirm(message, force: false)
+          return true if force
+
+          print "#{message} (y/N): "
+          response = $stdin.gets&.chomp || ''
+          puts
+          response.downcase == 'y'
+        end
+        # rubocop:enable Naming/PredicateMethod
+
+        # Ask user for confirmation and exit if not confirmed
+        # @param message [String] The confirmation message
+        # @param force [Boolean] Skip prompt if true (default: false)
+        # @param cancel_message [String] Message to display on cancellation
+        # @return [void] Returns if confirmed, exits otherwise
+        def self.confirm!(message, force: false, cancel_message: 'Operation cancelled')
+          return if confirm(message, force: force)
+
+          puts cancel_message
+          exit 0
+        end
+
+        # Ask user for text input
+        # @param prompt [String] The prompt message
+        # @param default [String, nil] Default value if user enters nothing
+        # @return [String] User input
+        def self.ask(prompt, default: nil)
+          prompt_text = default ? "#{prompt} [#{default}]" : prompt
+          print "#{prompt_text}: "
+          response = $stdin.gets&.chomp || ''
+          response.empty? && default ? default : response
+        end
+
+        # Ask user to select from options
+        # @param prompt [String] The prompt message
+        # @param options [Array<String>] Available options
+        # @return [String] Selected option
+        def self.select(prompt, options)
+          puts prompt
+          options.each_with_index do |option, index|
+            puts "  #{index + 1}. #{option}"
+          end
+          print "\nSelect (1-#{options.length}): "
+
+          selection = $stdin.gets&.chomp.to_i
+          if selection.between?(1, options.length)
+            options[selection - 1]
+          else
+            puts 'Invalid selection'
+            exit 1
+          end
+        end
+      end
+    end
+  end
+end