language-operator 0.1.61 → 0.1.62

data/lib/language_operator/cli/commands/tool/test.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require_relative '../../../constants/kubernetes_labels'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Tool
+        # Tool testing commands
+        module Test
+          def self.included(base)
+            base.class_eval do
+              desc 'test NAME', 'Test tool connectivity and health'
+              option :cluster, type: :string, desc: 'Override current cluster context'
+              def test(tool_name)
+                handle_command_error('test tool') do
+                  tool = get_resource_or_exit(LanguageOperator::Constants::RESOURCE_TOOL, tool_name)
+
+                  puts "Testing tool '#{tool_name}' in cluster '#{ctx.name}'"
+                  puts
+
+                  # Check phase
+                  phase = tool.dig('status', 'phase') || 'Unknown'
+                  status_indicator = case phase
+                                     when 'Running' then '✓'
+                                     when 'Pending' then '⏳'
+                                     when 'Failed' then '✗'
+                                     else '?'
+                                     end
+
+                  puts "Status:   #{status_indicator} #{phase}"
+
+                  # Check replicas
+                  ready_replicas = tool.dig('status', 'readyReplicas') || 0
+                  desired_replicas = tool.dig('spec', 'replicas') || 1
+                  puts "Replicas: #{ready_replicas}/#{desired_replicas} ready"
+
+                  # Check endpoint
+                  endpoint = tool.dig('status', 'endpoint')
+                  if endpoint
+                    puts "Endpoint: #{endpoint}"
+                  else
+                    puts 'Endpoint: Not available yet'
+                  end
+
+                  # Get pod status
+                  puts
+                  puts 'Pod Status:'
+
+                  label_selector = Constants::KubernetesLabels.tool_selector(tool_name)
+                  pods = ctx.client.list_resources('Pod', namespace: ctx.namespace, label_selector: label_selector)
+
+                  if pods.empty?
+                    puts '  No pods found'
+                  else
+                    pods.each do |pod|
+                      pod_name = pod.dig('metadata', 'name')
+                      pod_phase = pod.dig('status', 'phase') || 'Unknown'
+                      pod_indicator = case pod_phase
+                                      when 'Running' then '✓'
+                                      when 'Pending' then '⏳'
+                                      when 'Failed' then '✗'
+                                      else '?'
+                                      end
+
+                      puts "  #{pod_indicator} #{pod_name}: #{pod_phase}"
+
+                      # Check container status
+                      container_statuses = pod.dig('status', 'containerStatuses') || []
+                      container_statuses.each do |status|
+                        ready = status['ready'] ? '✓' : '✗'
+                        puts "    #{ready} #{status['name']}: #{status['state']&.keys&.first || 'unknown'}"
+                      end
+                    end
+                  end
+
+                  # Test connectivity if endpoint is available
+                  if endpoint && phase == 'Running'
+                    puts
+                    puts 'Testing connectivity...'
+                    begin
+                      uri = URI(endpoint)
+                      response = Net::HTTP.get_response(uri)
+                      if response.code.to_i < 400
+                        Formatters::ProgressFormatter.success('Connectivity test passed')
+                      else
+                        Formatters::ProgressFormatter.warn("HTTP #{response.code}: #{response.message}")
+                      end
+                    rescue StandardError => e
+                      Formatters::ProgressFormatter.error("Connectivity test failed: #{e.message}")
+                    end
+                  end
+
+                  # Overall health
+                  puts
+                  if phase == 'Running' && ready_replicas == desired_replicas
+                    Formatters::ProgressFormatter.success("Tool '#{tool_name}' is healthy and operational")
+                  elsif phase == 'Pending'
+                    Formatters::ProgressFormatter.info("Tool '#{tool_name}' is starting up, please wait")
+                  else
+                    Formatters::ProgressFormatter.warn("Tool '#{tool_name}' has issues, check logs for details")
+                    puts
+                    puts 'View logs with:'
+                    puts "  kubectl logs -n #{ctx.namespace} -l #{Constants::KubernetesLabels::TOOL_LABEL}=#{tool_name}"
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
 require_relative '../base_command'
-require 'pastel'
 require_relative '../formatters/progress_formatter'
 require_relative '../../config/cluster_config'
+require_relative '../helpers/cluster_validator'
 
 module LanguageOperator
   module CLI
     module Commands
       # Switch cluster context command
       class Use < BaseCommand
+        include Helpers::UxHelper
+
         desc 'use CLUSTER', 'Switch to a different cluster context'
         def self.exit_on_failure?
           true
@@ -31,11 +33,32 @@ module LanguageOperator
 
             Formatters::ProgressFormatter.success("Switched to cluster '#{cluster_name}'")
 
-            pastel = Pastel.new
-            puts "\nCluster Details"
-            puts '----------------'
-            puts "Name: #{pastel.bold.white(cluster[:name])}"
-            puts "Namespace: #{pastel.bold.white(cluster[:namespace])}"
+            # Get cluster details from Kubernetes for complete information
+            begin
+              k8s = Helpers::ClusterValidator.kubernetes_client(cluster_name)
+              cluster_resource = k8s.get_resource('LanguageCluster', cluster[:name], cluster[:namespace])
+              status = cluster_resource.dig('status', 'phase') || 'Unknown'
+              domain = cluster_resource.dig('spec', 'domain')
+
+              puts
+              format_cluster_details(
+                name: cluster[:name],
+                namespace: cluster[:namespace],
+                context: cluster[:context] || 'default',
+                domain: domain,
+                status: status,
+                created: cluster[:created]
+              )
+            rescue StandardError
+              # Fallback to basic display if K8s access fails
+              puts
+              format_cluster_details(
+                name: cluster[:name],
+                namespace: cluster[:namespace],
+                context: cluster[:context] || 'default',
+                status: 'Connection Error'
+              )
+            end
           end
         end
       end

data/lib/language_operator/cli/errors/handler.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
-require 'pastel'
 require_relative 'suggestions'
+require_relative 'thor_errors'
 require_relative '../formatters/progress_formatter'
+require_relative '../helpers/ux_helper'
 
 module LanguageOperator
   module CLI
     module Errors
       # Central error handler with context-aware suggestions
       class Handler
+        extend Helpers::UxHelper
+
         class << self
           # Handle an error with context and provide helpful suggestions
           def handle(error, context = {})
@@ -51,31 +54,33 @@ module LanguageOperator
             suggestions = Suggestions.for_error(error_type, context)
             display_suggestions(suggestions) if suggestions.any?
 
-            # Re-raise if in debug mode, otherwise exit
+            # Re-raise if in debug mode, otherwise raise Thor error
             raise error if ENV['DEBUG']
 
-            exit 1
+            raise NotFoundError, message
           end
 
           # Handle generic errors
           def handle_generic(error, context)
             operation = context[:operation] || 'operation'
+            message = "Failed to #{operation}: #{error.message}"
 
-            Formatters::ProgressFormatter.error("Failed to #{operation}: #{error.message}")
+            Formatters::ProgressFormatter.error(message)
             puts
 
             # Display suggestions if provided in context
             display_suggestions(context[:suggestions]) if context[:suggestions]
 
-            # Re-raise if in debug mode, otherwise exit
+            # Re-raise if in debug mode, otherwise raise Thor error
             raise error if ENV['DEBUG']
 
-            exit 1
+            raise Thor::Error, message
           end
 
           # Handle specific error scenarios with custom suggestions
           def handle_no_cluster_selected
-            Formatters::ProgressFormatter.error('No cluster selected')
+            message = 'No cluster selected'
+            Formatters::ProgressFormatter.error(message)
             puts
 
             puts 'You must connect to a cluster first:'
@@ -84,27 +89,29 @@ module LanguageOperator
             suggestions = Suggestions.for_error(:no_cluster_selected)
             suggestions.each { |line| puts line }
 
-            exit 1
+            raise ValidationError, message
           end
 
           def handle_no_models_available(context = {})
-            Formatters::ProgressFormatter.error('No models found in cluster')
+            message = 'No models found in cluster'
+            Formatters::ProgressFormatter.error(message)
             puts
 
             suggestions = Suggestions.for_error(:no_models_available, context)
             suggestions.each { |line| puts line }
 
-            exit 1
+            raise ValidationError, message
           end
 
           def handle_synthesis_failed(message)
-            Formatters::ProgressFormatter.error("Synthesis failed: #{message}")
+            error_message = "Synthesis failed: #{message}"
+            Formatters::ProgressFormatter.error(error_message)
             puts
 
             suggestions = Suggestions.for_error(:synthesis_failed)
             suggestions.each { |line| puts line }
 
-            exit 1
+            raise SynthesisError, error_message
           end
 
           def handle_already_exists(context = {})
@@ -124,7 +131,7 @@ module LanguageOperator
             suggestions = Suggestions.for_error(:already_exists, context)
             display_suggestions(suggestions) if suggestions.any?
 
-            exit 1
+            raise ValidationError, message
           end
 
           private
@@ -169,10 +176,6 @@ module LanguageOperator
               :resource_not_found
             end
           end
-
-          def pastel
-            @pastel ||= Pastel.new
-          end
         end
       end
     end

data/lib/language_operator/cli/errors/suggestions.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 require 'did_you_mean'
-require 'pastel'
+require_relative '../helpers/ux_helper'
 
 module LanguageOperator
   module CLI
     module Errors
       # Provides helpful suggestions for error recovery
       class Suggestions
+        extend Helpers::UxHelper
+
         class << self
           # Find similar resource names using fuzzy matching
           def find_similar(input_name, available_names, limit: 3)
@@ -165,10 +167,6 @@ module LanguageOperator
               resource_type.downcase
             end
           end
-
-          def pastel
-            @pastel ||= Pastel.new
-          end
         end
       end
     end

data/lib/language_operator/cli/errors/thor_errors.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module LanguageOperator
+  module CLI
+    module Errors
+      # Base error class that integrates properly with Thor's error handling
+      # while providing specific exit codes for different error types
+      class ThorCompatibleError < Thor::Error
+        attr_reader :exit_code
+
+        def initialize(message = nil, exit_code = 1)
+          super(message)
+          @exit_code = exit_code
+        end
+      end
+
+      # Resource not found error (exit code 2)
+      class NotFoundError < ThorCompatibleError
+        def initialize(message = nil)
+          super(message, 2)
+        end
+      end
+
+      # Validation or configuration error (exit code 3)
+      class ValidationError < ThorCompatibleError
+        def initialize(message = nil)
+          super(message, 3)
+        end
+      end
+
+      # Network or connectivity error (exit code 4)
+      class NetworkError < ThorCompatibleError
+        def initialize(message = nil)
+          super(message, 4)
+        end
+      end
+
+      # Authentication or authorization error (exit code 5)
+      class AuthError < ThorCompatibleError
+        def initialize(message = nil)
+          super(message, 5)
+        end
+      end
+
+      # Synthesis or code generation error (exit code 6)
+      class SynthesisError < ThorCompatibleError
+        def initialize(message = nil)
+          super(message, 6)
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/formatters/code_formatter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require 'rouge'
-require_relative '../helpers/pastel_helper'
+require_relative '../helpers/ux_helper'
 
 module LanguageOperator
   module CLI
@@ -9,7 +8,7 @@ module LanguageOperator
       # Formatter for displaying syntax-highlighted code in the terminal
       class CodeFormatter
         class << self
-          include Helpers::PastelHelper
+          include Helpers::UxHelper
 
           # Display Ruby code with syntax highlighting
           #
@@ -17,10 +16,6 @@ module LanguageOperator
           # @param title [String, nil] Optional title to display above the code
           # @param max_lines [Integer, nil] Maximum number of lines to display (nil for all)
           def display_ruby_code(code_content, title: nil, max_lines: nil)
-            # Use Rouge to highlight the code
-            formatter = Rouge::Formatters::Terminal256.new
-            lexer = Rouge::Lexers::Ruby.new
-
             # Truncate if max_lines specified
             lines = code_content.lines
             truncated = false
@@ -33,7 +28,7 @@ module LanguageOperator
             end
 
             # Highlight and print the code
-            highlighted = formatter.format(lexer.lex(code_to_display))
+            highlighted = highlight_ruby_code(code_to_display)
             puts highlighted
 
             # Show truncation notice if applicable
@@ -53,9 +48,7 @@ module LanguageOperator
             puts pastel.dim(description) if description
             puts
 
-            formatter = Rouge::Formatters::Terminal256.new
-            lexer = Rouge::Lexers::Ruby.new
-            highlighted = formatter.format(lexer.lex(code_content))
+            highlighted = highlight_ruby_code(code_content)
 
             puts highlighted
             puts

data/lib/language_operator/cli/formatters/log_formatter.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../helpers/pastel_helper'
+require_relative '../helpers/ux_helper'
 require_relative 'log_style'
+require_relative 'value_formatter'
 require 'json'
 require 'time'
 
@@ -11,7 +12,7 @@ module LanguageOperator
       # Formatter for displaying agent execution logs with color and icons
       class LogFormatter
         class << self
-          include Helpers::PastelHelper
+          include Helpers::UxHelper
 
           # Format a single log line from kubectl output
           #
@@ -207,27 +208,19 @@ module LanguageOperator
 
           # Format timestamp from ISO8601 format
           def format_timestamp_from_iso(timestamp_str)
-            return '' unless timestamp_str
-
-            time = Time.parse(timestamp_str)
-            format_time(time)
-          rescue StandardError
-            ''
+            time_str = ValueFormatter.parse_and_format_time(timestamp_str)
+            time_str.empty? ? '' : pastel.dim(time_str)
           end
 
           # Format timestamp from text format (YYYY-MM-DD HH:MM:SS)
           def format_timestamp_from_text(timestamp_str)
-            return '' unless timestamp_str
-
-            time = Time.parse(timestamp_str)
-            format_time(time)
-          rescue StandardError
-            ''
+            time_str = ValueFormatter.parse_and_format_time(timestamp_str)
+            time_str.empty? ? '' : pastel.dim(time_str)
           end
 
           # Format Time object as HH:MM:SS
           def format_time(time)
-            pastel.dim(time.strftime('%H:%M:%S'))
+            pastel.dim(ValueFormatter.log_time(time))
           end
         end
       end

data/lib/language_operator/cli/formatters/progress_formatter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require 'tty-spinner'
-require_relative '../helpers/pastel_helper'
+require_relative '../helpers/ux_helper'
 require_relative 'log_style'
 
 module LanguageOperator
@@ -10,22 +9,21 @@ module LanguageOperator
       # Beautiful progress output for CLI operations
       class ProgressFormatter
         class << self
-          include Helpers::PastelHelper
+          include Helpers::UxHelper
 
           def with_spinner(message, success_msg: nil, &block)
-            success_icon = LogStyle.styled_icon(:success, pastel)
-            spinner = TTY::Spinner.new(":spinner #{message}...", format: :dots, success_mark: success_icon)
-            spinner.auto_spin
+            spin = spinner("#{message}...")
+            spin.auto_spin
 
             result = block.call
 
             # Determine what to show after spinner completes
             final_status = success_msg || 'done'
 
-            spinner.success(final_status)
+            spin.success(final_status)
             result
           rescue StandardError => e
-            spinner.error(e.message)
+            spin.error(e.message)
             raise
           end
 

data/lib/language_operator/cli/formatters/status_formatter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../helpers/pastel_helper'
+require_relative '../helpers/ux_helper'
 
 module LanguageOperator
   module CLI
@@ -9,7 +9,7 @@ module LanguageOperator
       #
       # Provides consistent colored status dots (●) for resource states
       class StatusFormatter
-        extend Helpers::PastelHelper
+        extend Helpers::UxHelper
 
         # Format a status string with colored indicator
         #
@@ -17,20 +17,39 @@ module LanguageOperator
         # @return [String] Formatted status with colored dot
         def self.format(status)
           status_str = status.to_s
+          color = status_color(status_str)
+          "#{pastel.send(color, '●')} #{status_str}"
+        end
 
+        # Format just the status indicator dot (without text)
+        #
+        # @param status [String, Symbol] The status to format
+        # @return [String] Just the colored dot
+        def self.dot(status)
+          color = status_color(status.to_s)
+          pastel.send(color, '●')
+        end
+
+        # Determine the appropriate color for a status
+        #
+        # @param status_str [String] The status string
+        # @return [Symbol] Color method name for pastel
+        def self.status_color(status_str)
           case status_str.downcase
           when 'ready', 'running', 'active'
-            "#{pastel.green('●')} #{status_str}"
+            :green
           when 'pending', 'creating', 'synthesizing'
-            "#{pastel.yellow('●')} #{status_str}"
+            :yellow
           when 'failed', 'error'
-            "#{pastel.red('●')} #{status_str}"
+            :red
           when 'paused', 'stopped', 'suspended'
-            "#{pastel.dim('●')} #{status_str}"
+            :dim
           else
-            "#{pastel.dim('●')} #{status_str}"
+            :dim
           end
         end
+
+        private_class_method :status_color
       end
     end
   end