language-operator 0.1.30 → 0.1.35

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

@@ -1,24 +1,30 @@
 # frozen_string_literal: true
 
 require 'thor'
+require_relative '../base_command'
 require_relative '../formatters/progress_formatter'
 require_relative '../formatters/table_formatter'
 require_relative '../formatters/value_formatter'
+require_relative '../formatters/log_formatter'
+require_relative '../formatters/status_formatter'
 require_relative '../helpers/cluster_validator'
 require_relative '../helpers/cluster_context'
 require_relative '../helpers/user_prompts'
 require_relative '../helpers/editor_helper'
+require_relative '../helpers/pastel_helper'
 require_relative '../errors/handler'
 require_relative '../../config/cluster_config'
 require_relative '../../kubernetes/client'
 require_relative '../../kubernetes/resource_builder'
+require_relative '../../ux/create_agent'
 
 module LanguageOperator
   module CLI
     module Commands
       # Agent management commands
-      class Agent < Thor
+      class Agent < BaseCommand
         include Helpers::ClusterValidator
+        include Helpers::PastelHelper
 
         desc 'create [DESCRIPTION]', 'Create a new agent with natural language description'
         long_desc <<-DESC
@@ -41,241 +47,216 @@ module LanguageOperator
         option :dry_run, type: :boolean, default: false, desc: 'Preview what would be created without applying'
         option :wizard, type: :boolean, default: false, desc: 'Use interactive wizard mode'
         def create(description = nil)
-          # Activate wizard mode if --wizard flag or no description provided
-          if options[:wizard] || description.nil?
-            require_relative '../wizards/agent_wizard'
-            wizard = Wizards::AgentWizard.new
-            description = wizard.run
-
-            # User cancelled wizard
-            unless description
-              Formatters::ProgressFormatter.info('Agent creation cancelled')
-              return
+          handle_command_error('create agent') do
+            # Activate wizard mode if --wizard flag or no description provided
+            if options[:wizard] || description.nil?
+              description = Ux::CreateAgent.execute(ctx)
+
+              # User cancelled wizard
+              unless description
+                Formatters::ProgressFormatter.info('Agent creation cancelled')
+                return
+              end
             end
-          end
 
-          # Handle --create-cluster flag
-          if options[:create_cluster]
-            cluster_name = options[:create_cluster]
-            unless Config::ClusterConfig.cluster_exists?(cluster_name)
-              Formatters::ProgressFormatter.info("Creating cluster '#{cluster_name}'...")
-              # Delegate to cluster create command
-              require_relative 'cluster'
-              Cluster.new.invoke(:create, [cluster_name], switch: true)
+            # Handle --create-cluster flag
+            if options[:create_cluster]
+              cluster_name = options[:create_cluster]
+              unless Config::ClusterConfig.cluster_exists?(cluster_name)
+                Formatters::ProgressFormatter.info("Creating cluster '#{cluster_name}'...")
+                # Delegate to cluster create command
+                require_relative 'cluster'
+                Cluster.new.invoke(:create, [cluster_name], switch: true)
+              end
+              cluster = cluster_name
+            else
+              # Validate cluster selection (this will exit if none selected)
+              cluster = Helpers::ClusterValidator.get_cluster(options[:cluster])
             end
-            cluster = cluster_name
-          else
-            # Validate cluster selection (this will exit if none selected)
-            cluster = Helpers::ClusterValidator.get_cluster(options[:cluster])
-          end
 
-          cluster_config = Helpers::ClusterValidator.get_cluster_config(cluster)
+            ctx = Helpers::ClusterContext.from_options(options.merge(cluster: cluster))
 
-          Formatters::ProgressFormatter.info("Creating agent in cluster '#{cluster}'")
-          puts
-
-          # Generate agent name from description if not provided
-          agent_name = options[:name] || generate_agent_name(description)
-
-          # Get models: use specified models, or default to all available models in cluster
-          models = options[:models]
-          if models.nil? || models.empty?
-            k8s = Helpers::ClusterValidator.kubernetes_client(options[:cluster])
-            available_models = k8s.list_resources('LanguageModel', namespace: cluster_config[:namespace])
-            models = available_models.map { |m| m.dig('metadata', 'name') }
+            Formatters::ProgressFormatter.info("Creating agent in cluster '#{ctx.name}'")
+            puts
 
-            Errors::Handler.handle_no_models_available(cluster: cluster) if models.empty?
-          end
+            # Generate agent name from description if not provided
+            agent_name = options[:name] || generate_agent_name(description)
 
-          # Build LanguageAgent resource
-          agent_resource = Kubernetes::ResourceBuilder.language_agent(
-            agent_name,
-            instructions: description,
-            cluster: cluster_config[:namespace],
-            persona: options[:persona],
-            tools: options[:tools] || [],
-            models: models
-          )
+            # Get models: use specified models, or default to all available models in cluster
+            models = options[:models]
+            if models.nil? || models.empty?
+              available_models = ctx.client.list_resources('LanguageModel', namespace: ctx.namespace)
+              models = available_models.map { |m| m.dig('metadata', 'name') }
 
-          # Dry-run mode: preview without applying
-          if options[:dry_run]
-            display_dry_run_preview(agent_resource, cluster, description)
-            return
-          end
+              Errors::Handler.handle_no_models_available(cluster: ctx.name) if models.empty?
+            end
 
-          # Connect to Kubernetes
-          k8s = Helpers::ClusterValidator.kubernetes_client(options[:cluster])
+            # Build LanguageAgent resource
+            agent_resource = Kubernetes::ResourceBuilder.language_agent(
+              agent_name,
+              instructions: description,
+              cluster: ctx.namespace,
+              persona: options[:persona],
+              tools: options[:tools] || [],
+              models: models
+            )
 
-          # Apply resource to cluster
-          Formatters::ProgressFormatter.with_spinner("Creating agent '#{agent_name}'") do
-            k8s.apply_resource(agent_resource)
-          end
+            # Dry-run mode: preview without applying
+            if options[:dry_run]
+              display_dry_run_preview(agent_resource, ctx.name, description)
+              return
+            end
 
-          # Watch synthesis status
-          synthesis_result = watch_synthesis_status(k8s, agent_name, cluster_config[:namespace])
+            # Apply resource to cluster
+            Formatters::ProgressFormatter.with_spinner("Creating agent '#{agent_name}'") do
+              ctx.client.apply_resource(agent_resource)
+            end
 
-          # Exit if synthesis failed
-          exit 1 unless synthesis_result[:success]
+            # Watch synthesis status
+            synthesis_result = watch_synthesis_status(ctx.client, agent_name, ctx.namespace)
 
-          # Fetch the updated agent to get complete details
-          agent = k8s.get_resource('LanguageAgent', agent_name, cluster_config[:namespace])
+            # Exit if synthesis failed
+            exit 1 unless synthesis_result[:success]
 
-          # Display enhanced success output
-          display_agent_created(agent, cluster, description, synthesis_result)
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Failed to create agent: #{e.message}")
-          raise if ENV['DEBUG']
+            # Fetch the updated agent to get complete details
+            agent = ctx.client.get_resource('LanguageAgent', agent_name, ctx.namespace)
 
-          exit 1
+            # Display enhanced success output
+            display_agent_created(agent, ctx.name, description, synthesis_result)
+          end
         end
 
         desc 'list', 'List all agents in current cluster'
         option :cluster, type: :string, desc: 'Override current cluster context'
         option :all_clusters, type: :boolean, default: false, desc: 'Show agents across all clusters'
         def list
-          if options[:all_clusters]
-            list_all_clusters
-          else
-            cluster = Helpers::ClusterValidator.get_cluster(options[:cluster])
-            list_cluster_agents(cluster)
+          handle_command_error('list agents') do
+            if options[:all_clusters]
+              list_all_clusters
+            else
+              ctx = Helpers::ClusterContext.from_options(options)
+              list_cluster_agents(ctx.name)
+            end
           end
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Failed to list agents: #{e.message}")
-          raise if ENV['DEBUG']
-
-          exit 1
         end
 
         desc 'inspect NAME', 'Show detailed agent information'
         option :cluster, type: :string, desc: 'Override current cluster context'
         def inspect(name)
-          cluster = Helpers::ClusterValidator.get_cluster(options[:cluster])
-          cluster_config = Helpers::ClusterValidator.get_cluster_config(cluster)
-
-          k8s = Helpers::ClusterValidator.kubernetes_client(options[:cluster])
-
-          agent = k8s.get_resource('LanguageAgent', name, cluster_config[:namespace])
-
-          puts "Agent: #{name}"
-          puts "  Cluster:   #{cluster}"
-          puts "  Namespace: #{cluster_config[:namespace]}"
-          puts
-
-          # Status
-          status = agent.dig('status', 'phase') || 'Unknown'
-          puts "Status: #{format_status(status)}"
-          puts
+          handle_command_error('inspect agent') do
+            ctx = Helpers::ClusterContext.from_options(options)
 
-          # Spec details
-          puts 'Configuration:'
-          puts "  Mode:         #{agent.dig('spec', 'mode') || 'autonomous'}"
-          puts "  Schedule:     #{agent.dig('spec', 'schedule') || 'N/A'}" if agent.dig('spec', 'schedule')
-          puts "  Persona:      #{agent.dig('spec', 'persona') || '(auto-selected)'}"
-          puts
+            begin
+              agent = ctx.client.get_resource('LanguageAgent', name, ctx.namespace)
+            rescue K8s::Error::NotFound
+              handle_agent_not_found(name, ctx)
+              return
+            end
 
-          # Instructions
-          instructions = agent.dig('spec', 'instructions')
-          if instructions
-            puts 'Instructions:'
-            puts "  #{instructions}"
+            puts "Agent: #{name}"
+            puts "  Cluster:   #{ctx.name}"
+            puts "  Namespace: #{ctx.namespace}"
             puts
-          end
 
-          # Tools
-          tools = agent.dig('spec', 'tools') || []
-          if tools.any?
-            puts "Tools (#{tools.length}):"
-            tools.each { |tool| puts "  - #{tool}" }
+            # Status
+            status = agent.dig('status', 'phase') || 'Unknown'
+            puts "Status: #{format_status(status)}"
             puts
-          end
 
-          # Models
-          model_refs = agent.dig('spec', 'modelRefs') || []
-          if model_refs.any?
-            puts "Models (#{model_refs.length}):"
-            model_refs.each { |ref| puts "  - #{ref['name']}" }
+            # Spec details
+            puts 'Configuration:'
+            puts "  Mode:         #{agent.dig('spec', 'mode') || 'autonomous'}"
+            puts "  Schedule:     #{agent.dig('spec', 'schedule') || 'N/A'}" if agent.dig('spec', 'schedule')
+            puts "  Persona:      #{agent.dig('spec', 'persona') || '(auto-selected)'}"
             puts
-          end
 
-          # Synthesis info
-          synthesis = agent.dig('status', 'synthesis')
-          if synthesis
-            puts 'Synthesis:'
-            puts "  Status:       #{synthesis['status']}"
-            puts "  Model:        #{synthesis['model']}" if synthesis['model']
-            puts "  Completed:    #{synthesis['completedAt']}" if synthesis['completedAt']
-            puts "  Duration:     #{synthesis['duration']}" if synthesis['duration']
-            puts "  Token Count:  #{synthesis['tokenCount']}" if synthesis['tokenCount']
-            puts
-          end
+            # Instructions
+            instructions = agent.dig('spec', 'instructions')
+            if instructions
+              puts 'Instructions:'
+              puts "  #{instructions}"
+              puts
+            end
 
-          # Execution stats
-          execution_count = agent.dig('status', 'executionCount') || 0
-          last_execution = agent.dig('status', 'lastExecution')
-          next_run = agent.dig('status', 'nextRun')
+            # Tools
+            tools = agent.dig('spec', 'tools') || []
+            if tools.any?
+              puts "Tools (#{tools.length}):"
+              tools.each { |tool| puts "  - #{tool}" }
+              puts
+            end
 
-          puts 'Execution:'
-          puts "  Total Runs:   #{execution_count}"
-          puts "  Last Run:     #{last_execution || 'Never'}"
-          puts "  Next Run:     #{next_run || 'N/A'}" if agent.dig('spec', 'schedule')
-          puts
+            # Models
+            model_refs = agent.dig('spec', 'modelRefs') || []
+            if model_refs.any?
+              puts "Models (#{model_refs.length}):"
+              model_refs.each { |ref| puts "  - #{ref['name']}" }
+              puts
+            end
 
-          # Conditions
-          conditions = agent.dig('status', 'conditions') || []
-          if conditions.any?
-            puts "Conditions (#{conditions.length}):"
-            conditions.each do |condition|
-              status_icon = condition['status'] == 'True' ? '✓' : '✗'
-              puts "  #{status_icon} #{condition['type']}: #{condition['message'] || condition['reason']}"
+            # Synthesis info
+            synthesis = agent.dig('status', 'synthesis')
+            if synthesis
+              puts 'Synthesis:'
+              puts "  Status:       #{synthesis['status']}"
+              puts "  Model:        #{synthesis['model']}" if synthesis['model']
+              puts "  Completed:    #{synthesis['completedAt']}" if synthesis['completedAt']
+              puts "  Duration:     #{synthesis['duration']}" if synthesis['duration']
+              puts "  Token Count:  #{synthesis['tokenCount']}" if synthesis['tokenCount']
+              puts
             end
+
+            # Execution stats
+            execution_count = agent.dig('status', 'executionCount') || 0
+            last_execution = agent.dig('status', 'lastExecution')
+            next_run = agent.dig('status', 'nextRun')
+
+            puts 'Execution:'
+            puts "  Total Runs:   #{execution_count}"
+            puts "  Last Run:     #{last_execution || 'Never'}"
+            puts "  Next Run:     #{next_run || 'N/A'}" if agent.dig('spec', 'schedule')
             puts
-          end
 
-          # Recent events (if available)
-          # This would require querying events, which we can add later
-        rescue K8s::Error::NotFound
-          handle_agent_not_found(name, cluster, k8s, cluster_config)
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Failed to inspect agent: #{e.message}")
-          raise if ENV['DEBUG']
+            # Conditions
+            conditions = agent.dig('status', 'conditions') || []
+            if conditions.any?
+              puts "Conditions (#{conditions.length}):"
+              conditions.each do |condition|
+                status_icon = condition['status'] == 'True' ? '✓' : '✗'
+                puts "  #{status_icon} #{condition['type']}: #{condition['message'] || condition['reason']}"
+              end
+              puts
+            end
 
-          exit 1
+            # Recent events (if available)
+            # This would require querying events, which we can add later
+          end
         end
 
         desc 'delete NAME', 'Delete an agent'
         option :cluster, type: :string, desc: 'Override current cluster context'
         option :force, type: :boolean, default: false, desc: 'Skip confirmation'
         def delete(name)
-          ctx = Helpers::ClusterContext.from_options(options)
+          handle_command_error('delete agent') do
+            ctx = Helpers::ClusterContext.from_options(options)
 
-          # Get agent to show details before deletion
-          begin
-            agent = ctx.client.get_resource('LanguageAgent', name, ctx.namespace)
-          rescue K8s::Error::NotFound
-            Formatters::ProgressFormatter.error("Agent '#{name}' not found in cluster '#{ctx.name}'")
-            exit 1
-          end
-
-          # Confirm deletion using UserPrompts helper
-          unless options[:force]
-            puts "This will delete agent '#{name}' from cluster '#{ctx.name}':"
-            puts "  Instructions: #{agent.dig('spec', 'instructions')}"
-            puts "  Mode:         #{agent.dig('spec', 'mode') || 'autonomous'}"
-            puts
-            return unless Helpers::UserPrompts.confirm('Are you sure?')
-          end
+            # Get agent to show details before deletion
+            agent = get_resource_or_exit('LanguageAgent', name)
 
-          # Delete the agent
-          Formatters::ProgressFormatter.with_spinner("Deleting agent '#{name}'") do
-            ctx.client.delete_resource('LanguageAgent', name, ctx.namespace)
-          end
+            # Confirm deletion
+            details = {
+              'Instructions' => agent.dig('spec', 'instructions'),
+              'Mode' => agent.dig('spec', 'mode') || 'autonomous'
+            }
+            return unless confirm_deletion('agent', name, ctx.name, details: details, force: options[:force])
 
-          Formatters::ProgressFormatter.success("Agent '#{name}' deleted successfully")
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Failed to delete agent: #{e.message}")
-          raise if ENV['DEBUG']
+            # Delete the agent
+            Formatters::ProgressFormatter.with_spinner("Deleting agent '#{name}'") do
+              ctx.client.delete_resource('LanguageAgent', name, ctx.namespace)
+            end
 
-          exit 1
+            Formatters::ProgressFormatter.success("Agent '#{name}' deleted successfully")
+          end
         end
 
         desc 'logs NAME', 'Show agent execution logs'
@@ -292,276 +273,217 @@ module LanguageOperator
         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)
-          cluster = Helpers::ClusterValidator.get_cluster(options[:cluster])
-          cluster_config = Helpers::ClusterValidator.get_cluster_config(cluster)
+          handle_command_error('get logs') do
+            ctx = Helpers::ClusterContext.from_options(options)
 
-          k8s = Helpers::ClusterValidator.kubernetes_client(options[:cluster])
+            # Get agent to determine the pod name
+            agent = get_resource_or_exit('LanguageAgent', name)
 
-          # Get agent to determine the pod name
-          begin
-            agent = k8s.get_resource('LanguageAgent', name, cluster_config[:namespace])
-          rescue K8s::Error::NotFound
-            Formatters::ProgressFormatter.error("Agent '#{name}' not found in cluster '#{cluster}'")
-            exit 1
-          end
+            mode = agent.dig('spec', 'mode') || 'autonomous'
 
-          mode = agent.dig('spec', 'mode') || 'autonomous'
+            # Build kubectl command for log streaming
+            tail_arg = "--tail=#{options[:tail]}"
+            follow_arg = options[:follow] ? '-f' : ''
 
-          # Build kubectl command for log streaming
-          kubeconfig_arg = cluster_config[:kubeconfig] ? "--kubeconfig=#{cluster_config[:kubeconfig]}" : ''
-          context_arg = cluster_config[:context] ? "--context=#{cluster_config[:context]}" : ''
-          namespace_arg = "-n #{cluster_config[:namespace]}"
-          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
-          label_selector = "app.kubernetes.io/name=#{name}"
+            # 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
+            label_selector = "app.kubernetes.io/name=#{name}"
 
-          # Use kubectl logs with label selector
-          cmd = "kubectl #{kubeconfig_arg} #{context_arg} #{namespace_arg} logs -l #{label_selector} #{tail_arg} #{follow_arg} --prefix --all-containers"
+            # Use kubectl logs with label selector
+            cmd = "#{ctx.kubectl_prefix} logs -l #{label_selector} #{tail_arg} #{follow_arg} --prefix --all-containers"
 
-          Formatters::ProgressFormatter.info("Streaming logs for agent '#{name}'...")
-          puts
+            Formatters::ProgressFormatter.info("Streaming logs for agent '#{name}'...")
+            puts
 
-          # Stream and format logs in real-time
-          require 'open3'
-          Open3.popen3(cmd) do |_stdin, stdout, stderr, wait_thr|
-            # Handle stdout (logs)
-            stdout_thread = Thread.new do
-              stdout.each_line do |line|
-                puts Formatters::LogFormatter.format_line(line.chomp)
-                $stdout.flush
+            # Stream and format logs in real-time
+            require 'open3'
+            Open3.popen3(cmd) do |_stdin, stdout, stderr, wait_thr|
+              # Handle stdout (logs)
+              stdout_thread = Thread.new do
+                stdout.each_line do |line|
+                  puts Formatters::LogFormatter.format_line(line.chomp)
+                  $stdout.flush
+                end
               end
-            end
 
-            # Handle stderr (errors)
-            stderr_thread = Thread.new do
-              stderr.each_line do |line|
-                warn line
+              # Handle stderr (errors)
+              stderr_thread = Thread.new do
+                stderr.each_line do |line|
+                  warn line
+                end
               end
-            end
 
-            # Wait for both streams to complete
-            stdout_thread.join
-            stderr_thread.join
+              # Wait for both streams to complete
+              stdout_thread.join
+              stderr_thread.join
 
-            # Check exit status
-            exit_status = wait_thr.value
-            exit exit_status.exitstatus unless exit_status.success?
+              # Check exit status
+              exit_status = wait_thr.value
+              exit exit_status.exitstatus unless exit_status.success?
+            end
           end
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Failed to get logs: #{e.message}")
-          raise if ENV['DEBUG']
-
-          exit 1
         end
 
         desc 'code NAME', 'Display synthesized agent code'
         option :cluster, type: :string, desc: 'Override current cluster context'
         def code(name)
-          require_relative '../formatters/code_formatter'
-
-          cluster = Helpers::ClusterValidator.get_cluster(options[:cluster])
-          cluster_config = Helpers::ClusterValidator.get_cluster_config(cluster)
+          handle_command_error('get code') do
+            require_relative '../formatters/code_formatter'
 
-          k8s = Helpers::ClusterValidator.kubernetes_client(options[:cluster])
+            ctx = Helpers::ClusterContext.from_options(options)
 
-          # Get the code ConfigMap for this agent
-          configmap_name = "#{name}-code"
-          begin
-            configmap = k8s.get_resource('ConfigMap', configmap_name, cluster_config[:namespace])
-          rescue K8s::Error::NotFound
-            Formatters::ProgressFormatter.error("Synthesized code not found for agent '#{name}'")
-            puts
-            puts 'Possible reasons:'
-            puts '  - Agent synthesis not yet complete'
-            puts '  - Agent synthesis failed'
-            puts
-            puts 'Check synthesis status with:'
-            puts "  aictl agent inspect #{name}"
-            exit 1
-          end
-
-          # Get the agent.rb code from the ConfigMap
-          code_content = configmap.dig('data', 'agent.rb')
-          unless code_content
-            Formatters::ProgressFormatter.error('Code content not found in ConfigMap')
-            exit 1
-          end
+            # Get the code ConfigMap for this agent
+            configmap_name = "#{name}-code"
+            begin
+              configmap = ctx.client.get_resource('ConfigMap', configmap_name, ctx.namespace)
+            rescue K8s::Error::NotFound
+              Formatters::ProgressFormatter.error("Synthesized code not found for agent '#{name}'")
+              puts
+              puts 'Possible reasons:'
+              puts '  - Agent synthesis not yet complete'
+              puts '  - Agent synthesis failed'
+              puts
+              puts 'Check synthesis status with:'
+              puts "  aictl agent inspect #{name}"
+              exit 1
+            end
 
-          # Display with syntax highlighting
-          Formatters::CodeFormatter.display_ruby_code(
-            code_content,
-            title: "Synthesized Code for Agent: #{name}"
-          )
+            # Get the agent.rb code from the ConfigMap
+            code_content = configmap.dig('data', 'agent.rb')
+            unless code_content
+              Formatters::ProgressFormatter.error('Code content not found in ConfigMap')
+              exit 1
+            end
 
-          puts
-          puts 'This code was automatically synthesized from the agent instructions.'
-          puts "View full agent details with: aictl agent inspect #{name}"
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Failed to get code: #{e.message}")
-          raise if ENV['DEBUG']
+            # Display with syntax highlighting
+            Formatters::CodeFormatter.display_ruby_code(
+              code_content,
+              title: "Synthesized Code for Agent: #{name}"
+            )
 
-          exit 1
+            puts
+            puts 'This code was automatically synthesized from the agent instructions.'
+            puts "View full agent details with: aictl agent inspect #{name}"
+          end
         end
 
         desc 'edit NAME', 'Edit agent instructions'
         option :cluster, type: :string, desc: 'Override current cluster context'
         def edit(name)
-          cluster = Helpers::ClusterValidator.get_cluster(options[:cluster])
-          cluster_config = Helpers::ClusterValidator.get_cluster_config(cluster)
+          handle_command_error('edit agent') do
+            ctx = Helpers::ClusterContext.from_options(options)
 
-          k8s = Helpers::ClusterValidator.kubernetes_client(options[:cluster])
+            # Get current agent
+            agent = get_resource_or_exit('LanguageAgent', name)
 
-          # Get current agent
-          begin
-            agent = k8s.get_resource('LanguageAgent', name, cluster_config[:namespace])
-          rescue K8s::Error::NotFound
-            Formatters::ProgressFormatter.error("Agent '#{name}' not found in cluster '#{cluster}'")
-            exit 1
-          end
+            current_instructions = agent.dig('spec', 'instructions')
 
-          current_instructions = agent.dig('spec', 'instructions')
+            # Edit instructions in user's editor
+            new_instructions = Helpers::EditorHelper.edit_content(
+              current_instructions,
+              'agent-instructions-',
+              '.txt'
+            ).strip
 
-          # Edit instructions in user's editor
-          new_instructions = Helpers::EditorHelper.edit_content(
-            current_instructions,
-            'agent-instructions-',
-            '.txt'
-          ).strip
+            # Check if changed
+            if new_instructions == current_instructions
+              Formatters::ProgressFormatter.info('No changes made')
+              return
+            end
 
-          # Check if changed
-          if new_instructions == current_instructions
-            Formatters::ProgressFormatter.info('No changes made')
-            return
-          end
+            # Update agent resource
+            agent['spec']['instructions'] = new_instructions
 
-          # Update agent resource
-          agent['spec']['instructions'] = new_instructions
+            Formatters::ProgressFormatter.with_spinner('Updating agent instructions') do
+              ctx.client.apply_resource(agent)
+            end
 
-          Formatters::ProgressFormatter.with_spinner('Updating agent instructions') do
-            k8s.apply_resource(agent)
+            Formatters::ProgressFormatter.success('Agent instructions updated')
+            puts
+            puts 'The operator will automatically re-synthesize the agent code.'
+            puts
+            puts 'Watch synthesis progress with:'
+            puts "  aictl agent inspect #{name}"
           end
-
-          Formatters::ProgressFormatter.success('Agent instructions updated')
-          puts
-          puts 'The operator will automatically re-synthesize the agent code.'
-          puts
-          puts 'Watch synthesis progress with:'
-          puts "  aictl agent inspect #{name}"
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Failed to edit agent: #{e.message}")
-          raise if ENV['DEBUG']
-
-          exit 1
         end
 
         desc 'pause NAME', 'Pause scheduled agent execution'
         option :cluster, type: :string, desc: 'Override current cluster context'
         def pause(name)
-          cluster = Helpers::ClusterValidator.get_cluster(options[:cluster])
-          cluster_config = Helpers::ClusterValidator.get_cluster_config(cluster)
+          handle_command_error('pause agent') do
+            ctx = Helpers::ClusterContext.from_options(options)
 
-          k8s = Helpers::ClusterValidator.kubernetes_client(options[:cluster])
+            # Get agent
+            agent = get_resource_or_exit('LanguageAgent', name)
 
-          # Get agent
-          begin
-            agent = k8s.get_resource('LanguageAgent', name, cluster_config[:namespace])
-          rescue K8s::Error::NotFound
-            Formatters::ProgressFormatter.error("Agent '#{name}' not found in cluster '#{cluster}'")
-            exit 1
-          end
-
-          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
+            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
-          namespace = cluster_config[:namespace]
+            # Suspend the CronJob by setting spec.suspend = true
+            # This is done by patching the underlying CronJob resource
+            cronjob_name = name
+            ctx.namespace
 
-          Formatters::ProgressFormatter.with_spinner("Pausing agent '#{name}'") do
-            # Use kubectl to patch the cronjob
-            kubeconfig_arg = cluster_config[:kubeconfig] ? "--kubeconfig=#{cluster_config[:kubeconfig]}" : ''
-            context_arg = cluster_config[:context] ? "--context=#{cluster_config[:context]}" : ''
+            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}}'"
+              system(cmd)
+            end
 
-            cmd = "kubectl #{kubeconfig_arg} #{context_arg} -n #{namespace} patch cronjob #{cronjob_name} -p '{\"spec\":{\"suspend\":true}}'"
-            system(cmd)
+            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
-
-          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}"
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Failed to pause agent: #{e.message}")
-          raise if ENV['DEBUG']
-
-          exit 1
         end
 
         desc 'resume NAME', 'Resume paused agent'
         option :cluster, type: :string, desc: 'Override current cluster context'
         def resume(name)
-          cluster = Helpers::ClusterValidator.get_cluster(options[:cluster])
-          cluster_config = Helpers::ClusterValidator.get_cluster_config(cluster)
-
-          k8s = Helpers::ClusterValidator.kubernetes_client(options[:cluster])
+          handle_command_error('resume agent') do
+            ctx = Helpers::ClusterContext.from_options(options)
 
-          # Get agent
-          begin
-            agent = k8s.get_resource('LanguageAgent', name, cluster_config[:namespace])
-          rescue K8s::Error::NotFound
-            Formatters::ProgressFormatter.error("Agent '#{name}' not found in cluster '#{cluster}'")
-            exit 1
-          end
+            # Get agent
+            agent = get_resource_or_exit('LanguageAgent', 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
+            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
-          namespace = cluster_config[:namespace]
+            # Resume the CronJob by setting spec.suspend = false
+            cronjob_name = name
+            ctx.namespace
 
-          Formatters::ProgressFormatter.with_spinner("Resuming agent '#{name}'") do
-            # Use kubectl to patch the cronjob
-            kubeconfig_arg = cluster_config[:kubeconfig] ? "--kubeconfig=#{cluster_config[:kubeconfig]}" : ''
-            context_arg = cluster_config[:context] ? "--context=#{cluster_config[:context]}" : ''
+            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}}'"
+              system(cmd)
+            end
 
-            cmd = "kubectl #{kubeconfig_arg} #{context_arg} -n #{namespace} patch cronjob #{cronjob_name} -p '{\"spec\":{\"suspend\":false}}'"
-            system(cmd)
+            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
-
-          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}"
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Failed to resume agent: #{e.message}")
-          raise if ENV['DEBUG']
-
-          exit 1
         end
 
         desc 'workspace NAME', 'Browse agent workspace files'
@@ -580,63 +502,52 @@ module LanguageOperator
         option :path, type: :string, desc: 'View specific file contents'
         option :clean, type: :boolean, desc: 'Clear workspace (with confirmation)'
         def workspace(name)
-          ctx = Helpers::ClusterContext.from_options(options)
+          handle_command_error('access workspace') do
+            ctx = Helpers::ClusterContext.from_options(options)
 
-          # Get agent to verify it exists
-          begin
-            agent = ctx.client.get_resource('LanguageAgent', name, ctx.namespace)
-          rescue K8s::Error::NotFound
-            Formatters::ProgressFormatter.error("Agent '#{name}' not found in cluster '#{ctx.name}'")
-            exit 1
-          end
+            # Get agent to verify it exists
+            agent = get_resource_or_exit('LanguageAgent', name)
 
-          # Check if workspace is enabled
-          workspace_enabled = agent.dig('spec', 'workspace', 'enabled')
-          unless workspace_enabled
-            Formatters::ProgressFormatter.warn("Workspace is not enabled for agent '#{name}'")
-            puts
-            puts 'Enable workspace in agent configuration:'
-            puts '  spec:'
-            puts '    workspace:'
-            puts '      enabled: true'
-            puts '      size: 10Gi'
-            exit 1
-          end
+            # Check if workspace is enabled
+            workspace_enabled = agent.dig('spec', 'workspace', 'enabled')
+            unless workspace_enabled
+              Formatters::ProgressFormatter.warn("Workspace is not enabled for agent '#{name}'")
+              puts
+              puts 'Enable workspace in agent configuration:'
+              puts '  spec:'
+              puts '    workspace:'
+              puts '      enabled: true'
+              puts '      size: 10Gi'
+              exit 1
+            end
 
-          if options[:path]
-            view_workspace_file(ctx, name, options[:path])
-          elsif options[:clean]
-            clean_workspace(ctx, name)
-          else
-            list_workspace_files(ctx, name)
+            if options[:path]
+              view_workspace_file(ctx, name, options[:path])
+            elsif options[:clean]
+              clean_workspace(ctx, name)
+            else
+              list_workspace_files(ctx, name)
+            end
           end
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("Failed to access workspace: #{e.message}")
-          raise if ENV['DEBUG']
-
-          exit 1
         end
 
         private
 
-        def handle_agent_not_found(name, cluster, k8s, cluster_config)
+        def handle_agent_not_found(name, ctx)
           # Get available agents for fuzzy matching
-          agents = k8s.list_resources('LanguageAgent', namespace: cluster_config[:namespace])
+          agents = ctx.client.list_resources('LanguageAgent', namespace: ctx.namespace)
           available_names = agents.map { |a| a.dig('metadata', 'name') }
 
           error = K8s::Error::NotFound.new(404, 'Not Found', 'LanguageAgent')
           Errors::Handler.handle_not_found(error,
                                            resource_type: 'LanguageAgent',
                                            resource_name: name,
-                                           cluster: cluster,
+                                           cluster: ctx.name,
                                            available_resources: available_names)
         end
 
         def display_agent_created(agent, cluster, _description, synthesis_result)
-          require 'pastel'
           require_relative '../formatters/code_formatter'
-
-          pastel = Pastel.new
           agent_name = agent.dig('metadata', 'name')
 
           puts
@@ -645,10 +556,9 @@ module LanguageOperator
 
           # Get synthesized code if available
           begin
-            cluster_config = Helpers::ClusterValidator.get_cluster_config(cluster)
-            k8s = Helpers::ClusterValidator.kubernetes_client(cluster)
+            ctx = Helpers::ClusterContext.from_options(cluster: cluster)
             configmap_name = "#{agent_name}-code"
-            configmap = k8s.get_resource('ConfigMap', configmap_name, cluster_config[:namespace])
+            configmap = ctx.client.get_resource('ConfigMap', configmap_name, ctx.namespace)
             code_content = configmap.dig('data', 'agent.rb')
 
             if code_content
@@ -832,21 +742,7 @@ module LanguageOperator
         end
 
         def format_status(status)
-          require 'pastel'
-          pastel = Pastel.new
-
-          case status.downcase
-          when 'ready', 'running', 'active'
-            "#{pastel.green('●')} #{status}"
-          when 'pending', 'creating', 'synthesizing'
-            "#{pastel.yellow('●')} #{status}"
-          when 'failed', 'error'
-            "#{pastel.red('●')} #{status}"
-          when 'paused', 'stopped'
-            "#{pastel.dim('●')} #{status}"
-          else
-            "#{pastel.dim('●')} #{status}"
-          end
+          Formatters::StatusFormatter.format(status)
         end
 
         def generate_agent_name(description)
@@ -940,13 +836,11 @@ module LanguageOperator
         end
 
         def list_cluster_agents(cluster)
-          cluster_config = Helpers::ClusterValidator.get_cluster_config(cluster)
+          ctx = Helpers::ClusterContext.from_options(cluster: cluster)
 
           Formatters::ProgressFormatter.info("Agents in cluster '#{cluster}'")
 
-          k8s = Helpers::ClusterValidator.kubernetes_client(cluster)
-
-          agents = k8s.list_resources('LanguageAgent', namespace: cluster_config[:namespace])
+          agents = ctx.client.list_resources('LanguageAgent', namespace: ctx.namespace)
 
           table_data = agents.map do |agent|
             {
@@ -981,9 +875,9 @@ module LanguageOperator
           all_agents = []
 
           clusters.each do |cluster|
-            k8s = Helpers::ClusterValidator.kubernetes_client(cluster[:name])
+            ctx = Helpers::ClusterContext.from_options(cluster: cluster[:name])
 
-            agents = k8s.list_resources('LanguageAgent', namespace: cluster[:namespace])
+            agents = ctx.client.list_resources('LanguageAgent', namespace: ctx.namespace)
 
             agents.each do |agent|
               all_agents << {
@@ -1059,9 +953,6 @@ module LanguageOperator
         end
 
         def list_workspace_files(ctx, agent_name)
-          require 'pastel'
-          pastel = Pastel.new
-
           pod_name = get_agent_pod(ctx, agent_name)
 
           # Check if workspace directory exists
@@ -1148,9 +1039,6 @@ module LanguageOperator
         end
 
         def view_workspace_file(ctx, agent_name, file_path)
-          require 'pastel'
-          pastel = Pastel.new
-
           pod_name = get_agent_pod(ctx, agent_name)
 
           # Check if file exists
@@ -1191,9 +1079,6 @@ module LanguageOperator
         end
 
         def clean_workspace(ctx, agent_name)
-          require 'pastel'
-          pastel = Pastel.new
-
           pod_name = get_agent_pod(ctx, agent_name)
 
           # Get current workspace usage