language-operator 0.1.61 → 0.1.62

data/lib/language_operator/cli/commands/agent/learning.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../../command_loader'
+require_relative '../../../constants/kubernetes_labels'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Agent
+        # Learning monitoring and control for agents
+        module Learning
+          def self.included(base)
+            base.class_eval do
+              desc 'learning SUBCOMMAND ...ARGS', 'Monitor and control agent learning'
+              subcommand 'learning', LearningCommands
+            end
+          end
+
+          # Learning subcommand class
+          class LearningCommands < BaseCommand
+            include Constants
+            include CLI::Helpers::ClusterValidator
+            include CLI::Helpers::UxHelper
+
+            desc 'status NAME', 'Show current learning status and optimization history'
+            long_desc <<-DESC
+              Display the current learning status and optimization history for an agent.
+
+              Shows learned tasks, confidence scores, and automatic optimization progress
+              managed by the operator.
+
+              Examples:
+                aictl agent learning status my-agent
+                aictl agent learning status my-agent --cluster production
+            DESC
+            option :cluster, type: :string, desc: 'Override current cluster context'
+            def status(name)
+              handle_command_error('get learning status') do
+                ctx = CLI::Helpers::ClusterContext.from_options(options)
+
+                # Get agent to verify it exists
+                agent = ctx.client.get_resource(RESOURCE_AGENT, name, ctx.namespace)
+
+                # Query learning status ConfigMap
+                learning_status = get_learning_status(ctx.client, name, ctx.namespace)
+
+                # Display learning information
+                display_learning_status(agent, learning_status, ctx.name)
+              end
+            rescue K8s::Error::NotFound
+              # Handle agent not found
+              ctx = CLI::Helpers::ClusterContext.from_options(options)
+              available_agents = ctx.client.list_resources(RESOURCE_AGENT, namespace: ctx.namespace)
+              available_names = available_agents.map { |a| a.dig('metadata', 'name') }
+
+              error = K8s::Error::NotFound.new(404, 'Not Found', RESOURCE_AGENT)
+              CLI::Errors::Handler.handle_not_found(error,
+                                                    resource_type: RESOURCE_AGENT,
+                                                    resource_name: name,
+                                                    cluster: ctx.name,
+                                                    available_resources: available_names)
+            end
+
+            desc 'enable NAME', 'Enable automatic learning for an agent'
+            long_desc <<-DESC
+              Enable automatic learning for an agent by removing the learning-disabled annotation.
+
+              Learning is enabled by default, so this command only needs to be used if learning
+              was previously disabled.
+
+              Examples:
+                aictl agent learning enable my-agent
+            DESC
+            option :cluster, type: :string, desc: 'Override current cluster context'
+            def enable(name)
+              handle_command_error('enable learning') do
+                ctx = CLI::Helpers::ClusterContext.from_options(options)
+
+                # Get agent to verify it exists
+                agent = ctx.client.get_resource(RESOURCE_AGENT, name, ctx.namespace)
+
+                # Check current status
+                annotations = agent.dig('metadata', 'annotations') || {}
+                disabled_annotation = Constants::KubernetesLabels::LEARNING_DISABLED_LABEL
+
+                unless annotations.key?(disabled_annotation)
+                  Formatters::ProgressFormatter.info("Learning is already enabled for agent '#{name}'")
+                  return
+                end
+
+                # Remove the learning-disabled annotation
+                Formatters::ProgressFormatter.with_spinner("Enabling learning for agent '#{name}'") do
+                  remove_annotation(ctx.client, name, ctx.namespace, disabled_annotation)
+                end
+
+                Formatters::ProgressFormatter.success("Learning enabled for agent '#{name}'")
+              end
+            end
+
+            desc 'disable NAME', 'Disable automatic learning for an agent'
+            long_desc <<-DESC
+              Disable automatic learning for an agent by adding the learning-disabled annotation.
+
+              This prevents the operator from automatically optimizing the agent's tasks but
+              does not affect existing learned optimizations.
+
+              Examples:
+                aictl agent learning disable my-agent
+            DESC
+            option :cluster, type: :string, desc: 'Override current cluster context'
+            def disable(name)
+              handle_command_error('disable learning') do
+                ctx = CLI::Helpers::ClusterContext.from_options(options)
+
+                # Get agent to verify it exists
+                agent = ctx.client.get_resource(RESOURCE_AGENT, name, ctx.namespace)
+
+                # Check current status
+                annotations = agent.dig('metadata', 'annotations') || {}
+                disabled_annotation = Constants::KubernetesLabels::LEARNING_DISABLED_LABEL
+
+                if annotations.key?(disabled_annotation)
+                  Formatters::ProgressFormatter.info("Learning is already disabled for agent '#{name}'")
+                  return
+                end
+
+                # Add the learning-disabled annotation
+                Formatters::ProgressFormatter.with_spinner("Disabling learning for agent '#{name}'") do
+                  add_annotation(ctx.client, name, ctx.namespace, disabled_annotation, 'true')
+                end
+
+                Formatters::ProgressFormatter.success("Learning disabled for agent '#{name}'")
+              end
+            end
+
+            private
+
+            def get_learning_status(client, name, namespace)
+              config_map_name = "#{name}-learning-status"
+              begin
+                client.get_resource('ConfigMap', config_map_name, namespace)
+              rescue K8s::Error::NotFound
+                # Learning status ConfigMap doesn't exist yet - return nil
+                nil
+              end
+            end
+
+            def display_learning_status(agent, learning_status, cluster_name)
+              agent_name = agent.dig('metadata', 'name')
+              annotations = agent.dig('metadata', 'annotations') || {}
+
+              puts
+
+              # Learning enablement status
+              learning_enabled = !annotations.key?(Constants::KubernetesLabels::LEARNING_DISABLED_LABEL)
+              status_color = learning_enabled ? :green : :yellow
+              status_text = learning_enabled ? 'Enabled' : 'Disabled'
+
+              highlighted_box(
+                title: 'Learning Status',
+                rows: {
+                  'Agent' => pastel.white.bold(agent_name),
+                  'Cluster' => cluster_name,
+                  'Learning' => pastel.send(status_color).bold(status_text),
+                  'Last Updated' => agent.dig('metadata', 'resourceVersion') || 'Unknown'
+                }
+              )
+              puts
+
+              # If learning status ConfigMap exists, show detailed information
+              if learning_status
+                display_detailed_learning_status(learning_status)
+              else
+                puts pastel.dim('No learning status data available yet.')
+                puts pastel.dim('Learning data will appear after the agent has run and the operator has analyzed its behavior.')
+                puts
+              end
+
+              # Show next steps
+              puts pastel.white.bold('Available Commands:')
+              if learning_enabled
+                puts pastel.dim("  aictl agent learning disable #{agent_name}")
+              else
+                puts pastel.dim("  aictl agent learning enable #{agent_name}")
+              end
+              puts pastel.dim("  aictl agent versions #{agent_name}")
+              puts pastel.dim("  aictl agent inspect #{agent_name}")
+            end
+
+            def display_detailed_learning_status(learning_status)
+              data = learning_status['data'] || {}
+
+              # Parse learning data if available
+              if data['tasks']
+                tasks_data = begin
+                  JSON.parse(data['tasks'])
+                rescue StandardError
+                  {}
+                end
+
+                if tasks_data.any?
+                  puts pastel.white.bold('Learned Tasks:')
+                  tasks_data.each do |task_name, task_info|
+                    confidence = task_info['confidence'] || 0
+                    executions = task_info['executions'] || 0
+                    status = task_info['status'] || 'neural'
+
+                    confidence_color = if confidence >= 85
+                                         :green
+                                       else
+                                         confidence >= 70 ? :yellow : :red
+                                       end
+
+                    puts "  #{pastel.cyan(task_name)}"
+                    puts "    Status: #{format_task_status(status)}"
+                    confidence_text = pastel.send(confidence_color, "#{confidence}%")
+                    puts "    Confidence: #{confidence_text} (#{executions} executions)"
+                  end
+                  puts
+                end
+              end
+
+              # Show optimization history if available
+              return unless data['history']
+
+              history_data = begin
+                JSON.parse(data['history'])
+              rescue StandardError
+                []
+              end
+
+              return unless history_data.any?
+
+              puts pastel.white.bold('Optimization History:')
+              history_data.last(5).each do |event|
+                timestamp = event['timestamp'] || 'Unknown'
+                action = event['action'] || 'Unknown'
+                task = event['task'] || 'Unknown'
+
+                puts "  #{pastel.dim(timestamp)} - #{action} #{pastel.cyan(task)}"
+              end
+              puts
+            end
+
+            def format_task_status(status)
+              case status
+              when 'symbolic'
+                pastel.green('Learned (Symbolic)')
+              when 'neural'
+                pastel.yellow('Learning (Neural)')
+              when 'hybrid'
+                pastel.blue('Hybrid')
+              else
+                pastel.dim(status.capitalize)
+              end
+            end
+
+            def add_annotation(client, name, namespace, annotation_key, annotation_value)
+              # Get current agent
+              agent = client.get_resource(RESOURCE_AGENT, name, namespace)
+
+              # Add annotation
+              annotations = agent.dig('metadata', 'annotations') || {}
+              annotations[annotation_key] = annotation_value
+              agent['metadata']['annotations'] = annotations
+
+              # Update the agent
+              client.update_resource(agent)
+            end
+
+            def remove_annotation(client, name, namespace, annotation_key)
+              # Get current agent
+              agent = client.get_resource(RESOURCE_AGENT, name, namespace)
+
+              # Remove annotation
+              annotations = agent.dig('metadata', 'annotations') || {}
+              annotations.delete(annotation_key)
+              agent['metadata']['annotations'] = annotations
+
+              # Update the agent
+              client.update_resource(agent)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/commands/agent/lifecycle.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Agent
+        # Lifecycle management for agents (pause/resume)
+        module Lifecycle
+          def self.included(base)
+            base.class_eval do
+              desc 'pause NAME', 'Pause scheduled agent execution'
+              option :cluster, type: :string, desc: 'Override current cluster context'
+              def pause(name)
+                handle_command_error('pause agent') do
+                  ctx = CLI::Helpers::ClusterContext.from_options(options)
+
+                  # Get agent
+                  agent = get_resource_or_exit(LanguageOperator::Constants::RESOURCE_AGENT, name)
+
+                  mode = agent.dig('spec', 'mode') || 'autonomous'
+                  unless mode == 'scheduled'
+                    Formatters::ProgressFormatter.warn("Agent '#{name}' is not a scheduled agent (mode: #{mode})")
+                    puts
+                    puts 'Only scheduled agents can be paused.'
+                    puts 'Autonomous agents can be stopped by deleting them.'
+                    exit 1
+                  end
+
+                  # Suspend the CronJob by setting spec.suspend = true
+                  # This is done by patching the underlying CronJob resource
+                  cronjob_name = name
+
+                  Formatters::ProgressFormatter.with_spinner("Pausing agent '#{name}'") do
+                    # Use kubectl to patch the cronjob
+                    cmd = "#{ctx.kubectl_prefix} patch cronjob #{cronjob_name} -p '{\"spec\":{\"suspend\":true}}'"
+                    _, stderr, status = Open3.capture3(cmd)
+
+                    unless status.success?
+                      error_msg = "Failed to pause agent '#{name}': kubectl command failed (exit code: #{status.exitstatus})"
+                      error_msg += "\nError: #{stderr.strip}" unless stderr.nil? || stderr.strip.empty?
+                      raise error_msg
+                    end
+                  end
+
+                  Formatters::ProgressFormatter.success("Agent '#{name}' paused")
+                  puts
+                  puts 'The agent will not execute on its schedule until resumed.'
+                  puts
+                  puts 'Resume with:'
+                  puts "  aictl agent resume #{name}"
+                end
+              end
+
+              desc 'resume NAME', 'Resume paused agent'
+              option :cluster, type: :string, desc: 'Override current cluster context'
+              def resume(name)
+                handle_command_error('resume agent') do
+                  ctx = CLI::Helpers::ClusterContext.from_options(options)
+
+                  # Get agent
+                  agent = get_resource_or_exit(LanguageOperator::Constants::RESOURCE_AGENT, name)
+
+                  mode = agent.dig('spec', 'mode') || 'autonomous'
+                  unless mode == 'scheduled'
+                    Formatters::ProgressFormatter.warn("Agent '#{name}' is not a scheduled agent (mode: #{mode})")
+                    puts
+                    puts 'Only scheduled agents can be resumed.'
+                    exit 1
+                  end
+
+                  # Resume the CronJob by setting spec.suspend = false
+                  cronjob_name = name
+
+                  Formatters::ProgressFormatter.with_spinner("Resuming agent '#{name}'") do
+                    # Use kubectl to patch the cronjob
+                    cmd = "#{ctx.kubectl_prefix} patch cronjob #{cronjob_name} -p '{\"spec\":{\"suspend\":false}}'"
+                    _, stderr, status = Open3.capture3(cmd)
+
+                    unless status.success?
+                      error_msg = "Failed to resume agent '#{name}': kubectl command failed (exit code: #{status.exitstatus})"
+                      error_msg += "\nError: #{stderr.strip}" unless stderr.nil? || stderr.strip.empty?
+                      raise error_msg
+                    end
+                  end
+
+                  Formatters::ProgressFormatter.success("Agent '#{name}' resumed")
+                  puts
+                  puts 'The agent will now execute according to its schedule.'
+                  puts
+                  puts 'View next execution time with:'
+                  puts "  aictl agent inspect #{name}"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/commands/agent/logs.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'open3'
+require_relative '../../helpers/label_utils'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Agent
+        # Log streaming for agents
+        module Logs
+          def self.included(base)
+            base.class_eval do
+              desc 'logs NAME', 'Show agent execution logs'
+              long_desc <<-DESC
+                Stream agent execution logs in real-time.
+
+                Use -f to follow logs continuously (like tail -f).
+
+                Examples:
+                  aictl agent logs my-agent
+                  aictl agent logs my-agent -f
+              DESC
+              option :cluster, type: :string, desc: 'Override current cluster context'
+              option :follow, type: :boolean, aliases: '-f', default: false, desc: 'Follow logs'
+              option :tail, type: :numeric, default: 100, desc: 'Number of lines to show from the end'
+              def logs(name)
+                handle_command_error('get logs') do
+                  ctx = CLI::Helpers::ClusterContext.from_options(options)
+
+                  # Get agent to determine the pod name
+                  agent = get_resource_or_exit(LanguageOperator::Constants::RESOURCE_AGENT, name)
+
+                  mode = agent.dig('spec', 'mode') || 'autonomous'
+
+                  # Build kubectl command for log streaming
+                  tail_arg = "--tail=#{options[:tail]}"
+                  follow_arg = options[:follow] ? '-f' : ''
+
+                  # For scheduled agents, logs come from CronJob pods
+                  # For autonomous agents, logs come from Deployment pods
+                  if mode == 'scheduled'
+                  # Get most recent job from cronjob
+                  else
+                    # Get pod from deployment
+                  end
+                  # Use normalized label selector for pod discovery
+                  label_selector = CLI::Helpers::LabelUtils.agent_pod_selector(name)
+
+                  # Use kubectl logs with label selector
+                  cmd = "#{ctx.kubectl_prefix} logs -l #{label_selector} #{tail_arg} #{follow_arg} --all-containers"
+
+                  Formatters::ProgressFormatter.info("Streaming logs for agent '#{name}'...")
+                  puts
+
+                  # Track threads and interruption state for cleanup
+                  stdout_thread = nil
+                  stderr_thread = nil
+                  interrupted = false
+
+                  # Install signal handler for graceful interruption
+                  original_int_handler = Signal.trap('INT') do
+                    interrupted = true
+                    stdout_thread&.terminate
+                    stderr_thread&.terminate
+                    puts "\n[Interrupted]"
+                    exit(0)
+                  end
+
+                  begin
+                    # Stream raw logs in real-time without formatting
+                    Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
+                      # Close unused stdin immediately to prevent resource leak
+                      stdin.close
+
+                      # Handle stdout (logs)
+                      stdout_thread = Thread.new do
+                        stdout.each_line do |line|
+                          break if interrupted
+
+                          puts line
+                          $stdout.flush
+                        end
+                      rescue IOError
+                        # Expected when stream is closed during interruption
+                      end
+
+                      # Handle stderr (errors)
+                      stderr_thread = Thread.new do
+                        stderr.each_line do |line|
+                          break if interrupted
+
+                          warn line
+                        end
+                      rescue IOError
+                        # Expected when stream is closed during interruption
+                      end
+
+                      # Wait for both streams to complete or interruption
+                      stdout_thread.join unless interrupted
+                      stderr_thread.join unless interrupted
+
+                      # Check exit status if not interrupted
+                      unless interrupted
+                        exit_status = wait_thr.value
+                        exit exit_status.exitstatus unless exit_status.success?
+                      end
+                    end
+                  ensure
+                    # Restore original signal handler
+                    Signal.trap('INT', original_int_handler)
+
+                    # Cleanup threads if they're still running
+                    stdout_thread&.terminate
+                    stderr_thread&.terminate
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end