language-operator 0.1.61 → 0.1.62

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require 'tty-table'
-require_relative '../helpers/pastel_helper'
+require_relative '../helpers/ux_helper'
 require_relative 'status_formatter'
 
 module LanguageOperator
@@ -10,43 +9,57 @@ module LanguageOperator
       # Table output for CLI list commands
       class TableFormatter
         class << self
-          include Helpers::PastelHelper
+          include Helpers::UxHelper
 
           def clusters(clusters)
             return ProgressFormatter.info('No clusters found') if clusters.empty?
 
-            headers = %w[NAME NAMESPACE AGENTS TOOLS MODELS STATUS]
+            headers = ['', 'NAME', 'NAMESPACE', 'STATUS', 'DOMAIN']
             rows = clusters.map do |cluster|
+              # Extract asterisk for selected cluster
+              name = cluster[:name].to_s.gsub(' *', '')
+              is_current = cluster[:name].to_s.include?(' *')
+
+              # Apply bold yellow formatting if current cluster
+              formatted_name = is_current ? pastel.bold.yellow(name) : name
+
+              # Format domain - show empty cell if nil or empty, handle error states
+              domain_display = case cluster[:domain]
+                               when nil, ''
+                                 ''
+                               when '?', '-'
+                                 cluster[:domain]
+                               else
+                                 cluster[:domain]
+                               end
+
               [
-                cluster[:name],
+                StatusFormatter.dot(cluster[:status] || 'Unknown'),
+                formatted_name,
                 cluster[:namespace],
-                cluster[:agents] || 0,
-                cluster[:tools] || 0,
-                cluster[:models] || 0,
-                StatusFormatter.format(cluster[:status] || 'Unknown')
+                cluster[:status] || 'Unknown',
+                domain_display
               ]
             end
 
-            table = TTY::Table.new(headers, rows)
-            puts table.render(:unicode, padding: [0, 1])
+            puts table(headers, rows)
           end
 
           def agents(agents)
             return ProgressFormatter.info('No agents found') if agents.empty?
 
-            headers = ['NAME', 'MODE', 'STATUS', 'NEXT RUN', 'EXECUTIONS']
+            headers = ['', 'NAME', 'NAMESPACE', 'STATUS', 'MODE']
             rows = agents.map do |agent|
               [
+                StatusFormatter.dot(agent[:status]),
                 agent[:name],
-                agent[:mode],
-                StatusFormatter.format(agent[:status]),
-                agent[:next_run] || 'N/A',
-                agent[:executions] || 0
+                agent[:namespace],
+                agent[:status] || 'Unknown',
+                agent[:mode]
               ]
             end
 
-            table = TTY::Table.new(headers, rows)
-            puts table.render(:unicode, padding: [0, 1])
+            puts table(headers, rows)
           end
 
           def all_agents(agents_by_cluster)
@@ -68,25 +81,23 @@ module LanguageOperator
               end
             end
 
-            table = TTY::Table.new(headers, rows)
-            puts table.render(:unicode, padding: [0, 1])
+            puts table(headers, rows)
           end
 
           def tools(tools)
             return ProgressFormatter.info('No tools found') if tools.empty?
 
-            headers = ['NAME', 'TYPE', 'STATUS', 'AGENTS USING']
+            headers = ['', 'NAME', 'NAMESPACE', 'STATUS']
             rows = tools.map do |tool|
               [
+                StatusFormatter.dot(tool[:status]),
                 tool[:name],
-                tool[:type],
-                StatusFormatter.format(tool[:status]),
-                tool[:agents_using] || 0
+                tool[:namespace],
+                tool[:status] || 'Unknown'
               ]
             end
 
-            table = TTY::Table.new(headers, rows)
-            puts table.render(:unicode, padding: [0, 1])
+            puts table(headers, rows)
           end
 
           def personas(personas)
@@ -102,25 +113,26 @@ module LanguageOperator
               ]
             end
 
-            table = TTY::Table.new(headers, rows)
-            puts table.render(:unicode, padding: [0, 1])
+            puts table(headers, rows)
           end
 
           def models(models)
             return ProgressFormatter.info('No models found') if models.empty?
 
-            headers = %w[NAME PROVIDER MODEL STATUS]
+            headers = ['', 'NAME', 'NAMESPACE', 'STATUS', 'PROVIDER/MODEL']
             rows = models.map do |model|
+              provider_model = "#{model[:provider]}/#{model[:model]}"
+
               [
+                StatusFormatter.dot(model[:status]),
                 model[:name],
-                model[:provider],
-                model[:model],
-                StatusFormatter.format(model[:status])
+                model[:namespace],
+                model[:status] || 'Unknown',
+                provider_model
               ]
             end
 
-            table = TTY::Table.new(headers, rows)
-            puts table.render(:unicode, padding: [0, 1])
+            puts table(headers, rows)
           end
 
           def status_dashboard(cluster_summary, current_cluster: nil)
@@ -140,8 +152,7 @@ module LanguageOperator
               ]
             end
 
-            table = TTY::Table.new(headers, rows)
-            puts table.render(:unicode, padding: [0, 1])
+            puts table(headers, rows)
 
             return unless current_cluster
 

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

@@ -42,6 +42,42 @@ module LanguageOperator
           end
         end
 
+        # Format time elapsed since past time (opposite of time_until)
+        #
+        # @param past_time [Time] Past timestamp
+        # @return [String] Formatted string like "5m ago" or "2h 15m ago"
+        #
+        # @example
+        #   ValueFormatter.time_ago(Time.now - 300) # => "5m ago"
+        def self.time_ago(past_time)
+          diff = Time.now - past_time
+          
+          if diff < 0
+            'in the future' # Edge case for clock skew
+          elsif diff < SECONDS_PER_MINUTE
+            "#{diff.to_i}s ago"
+          elsif diff < SECONDS_PER_HOUR
+            minutes = (diff / SECONDS_PER_MINUTE).to_i
+            "#{minutes}m ago"
+          elsif diff < SECONDS_PER_DAY
+            hours = (diff / SECONDS_PER_HOUR).to_i
+            minutes = ((diff % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE).to_i
+            if minutes > 0
+              "#{hours}h #{minutes}m ago"
+            else
+              "#{hours}h ago"
+            end
+          else
+            days = (diff / SECONDS_PER_DAY).to_i
+            hours = ((diff % SECONDS_PER_DAY) / SECONDS_PER_HOUR).to_i
+            if hours > 0
+              "#{days}d #{hours}h ago"
+            else
+              "#{days}d ago"
+            end
+          end
+        end
+
         # Format a duration in seconds
         #
         # @param seconds [Numeric] Duration in seconds
@@ -107,6 +143,45 @@ module LanguageOperator
             time.strftime('%Y-%m-%d %H:%M')
           end
         end
+
+        # Format Time object as HH:MM:SS for logs
+        #
+        # @param time [Time] The time to format
+        # @return [String] Formatted string like "14:30:25"
+        #
+        # @example
+        #   ValueFormatter.log_time(Time.now) # => "14:30:25"
+        def self.log_time(time)
+          time.strftime('%H:%M:%S')
+        end
+
+        # Parse timestamp string and format as HH:MM:SS
+        #
+        # @param timestamp_str [String] ISO or text format timestamp
+        # @return [String] Formatted time or empty string on parse error
+        #
+        # @example
+        #   ValueFormatter.parse_and_format_time("2025-01-15T14:30:25Z") # => "14:30:25"
+        def self.parse_and_format_time(timestamp_str)
+          return '' unless timestamp_str
+
+          time = Time.parse(timestamp_str)
+          log_time(time)
+        rescue StandardError
+          ''
+        end
+
+        # Format time components as HH:MM for schedules
+        #
+        # @param hours [Integer] Hours (0-23)
+        # @param minutes [Integer] Minutes (0-59)
+        # @return [String] Formatted string like "14:30"
+        #
+        # @example
+        #   ValueFormatter.schedule_time(14, 30) # => "14:30"
+        def self.schedule_time(hours, minutes)
+          format('%<hours>02d:%<minutes>02d', hours: hours, minutes: minutes)
+        end
       end
     end
   end

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'shellwords'
 require_relative 'cluster_validator'
 
 module LanguageOperator
@@ -41,12 +42,13 @@ module LanguageOperator
         end
 
         # Build kubectl command args for this cluster context
+        # All user-controlled inputs are properly escaped to prevent command injection
         # @return [Hash] kubectl arguments
         def kubectl_args
           {
-            kubeconfig: config[:kubeconfig] ? "--kubeconfig=#{config[:kubeconfig]}" : '',
-            context: config[:context] ? "--context=#{config[:context]}" : '',
-            namespace: "-n #{namespace}"
+            kubeconfig: config[:kubeconfig] ? "--kubeconfig=#{Shellwords.escape(config[:kubeconfig])}" : '',
+            context: config[:context] ? "--context=#{Shellwords.escape(config[:context])}" : '',
+            namespace: "-n #{Shellwords.escape(namespace)}"
           }
         end
 

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

@@ -2,6 +2,7 @@
 
 require_relative '../formatters/progress_formatter'
 require_relative '../../kubernetes/client'
+require_relative '../../utils/secure_path'
 
 module LanguageOperator
   module CLI
@@ -59,7 +60,7 @@ module LanguageOperator
           private
 
           def default_kubeconfig_path
-            File.expand_path('~/.kube/config')
+            LanguageOperator::Utils::SecurePath.expand_home_path('.kube/config')
           end
 
           def kubeconfig_missing_message(path)

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative '../../constants/kubernetes_labels'
+
+module LanguageOperator
+  module CLI
+    module Helpers
+      # Utilities for working with Kubernetes labels
+      module LabelUtils
+        # Normalize an agent name for use as a Kubernetes label value
+        #
+        # Kubernetes label values must follow DNS-1123 subdomain format:
+        # - contain only lowercase alphanumeric characters, '-' or '.'
+        # - start and end with an alphanumeric character
+        # - be at most 63 characters
+        #
+        # @param agent_name [String] The agent name to normalize
+        # @return [String] A valid label value
+        def self.normalize_agent_name(agent_name)
+          # Agent names should already be valid Kubernetes resource names,
+          # which are compatible with label values. Just ensure lowercase.
+          agent_name.to_s.downcase
+        end
+
+        # Build a label selector for finding agent pods
+        #
+        # @param agent_name [String] The agent name
+        # @return [String] A label selector string
+        def self.agent_pod_selector(agent_name)
+          normalized_name = normalize_agent_name(agent_name)
+          Constants::KubernetesLabels.agent_selector(normalized_name)
+        end
+
+        # Validate that an agent name will work as a label value
+        #
+        # @param agent_name [String] The agent name to validate
+        # @return [Boolean] true if valid, false otherwise
+        def self.valid_label_value?(agent_name)
+          return false if agent_name.nil? || agent_name.empty?
+
+          # Check original string first (before normalization)
+          agent_str = agent_name.to_s
+
+          # Check DNS-1123 subdomain requirements:
+          # - 63 characters or less
+          # - lowercase letters, numbers, hyphens, and dots only
+          # - start and end with alphanumeric character
+          return false if agent_str.length > 63
+          return false unless agent_str.match?(/\A[a-z0-9]([a-z0-9\-.]*[a-z0-9])?\z/)
+
+          true
+        end
+
+        # Get debugging information about label selector matching
+        #
+        # @param ctx [ClusterContext] Kubernetes context
+        # @param agent_name [String] Agent name being searched
+        # @return [Hash] Debug information about the search
+        def self.debug_pod_search(ctx, agent_name)
+          selector = agent_pod_selector(agent_name)
+
+          {
+            agent_name: agent_name,
+            normalized_name: normalize_agent_name(agent_name),
+            label_selector: selector,
+            namespace: ctx.namespace,
+            valid_label_value: valid_label_value?(agent_name)
+          }
+        end
+
+        # Convert deployment labels to pod selector and find matching pods
+        #
+        # This method handles the common pattern of extracting selector labels from a deployment,
+        # converting them to a label selector string, and finding matching pods.
+        #
+        # @param ctx [ClusterContext] Kubernetes context with client and namespace
+        # @param deployment_name [String] Name of the deployment (for error messages)
+        # @param labels [Hash, Object] Deployment selector labels (may be K8s::Resource or Hash)
+        # @return [Array] Array of pod resources matching the labels
+        # @raise [RuntimeError] If labels are nil, empty, or no pods found
+        def self.find_pods_by_deployment_labels(ctx, deployment_name, labels)
+          raise "Deployment '#{deployment_name}' has no selector labels" if labels.nil?
+
+          # Convert to hash if needed (K8s API may return K8s::Resource objects)
+          labels_hash = labels.respond_to?(:to_h) ? labels.to_h : labels
+          raise "Deployment '#{deployment_name}' has empty selector labels" if labels_hash.empty?
+
+          # Convert labels to Kubernetes label selector format
+          label_selector = labels_hash.map { |k, v| "#{k}=#{v}" }.join(',')
+
+          # Find matching pods
+          ctx.client.list_resources('Pod', namespace: ctx.namespace, label_selector: label_selector)
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/{ux/concerns/provider_helpers.rb → cli/helpers/provider_helper.rb}

@@ -5,23 +5,21 @@ require 'json'
 require 'uri'
 
 module LanguageOperator
-  module Ux
-    module Concerns
-      # Mixin for common LLM provider operations
+  module CLI
+    module Helpers
+      # LLM provider operations for CLI wizards
       #
-      # Provides helpers for testing provider connections, fetching available models,
-      # and handling provider-specific configuration.
+      # Provides helpers for testing provider connections and fetching available models.
       #
       # @example
-      #   class MyFlow < Base
-      #     include Concerns::ProviderHelpers
+      #   class ModelWizard
+      #     include Helpers::ProviderHelper
       #
-      #     def setup
-      #       result = test_provider_connection(:anthropic, api_key: 'sk-...')
-      #       models = fetch_provider_models(:openai, api_key: 'sk-...')
+      #     def test_anthropic_connection(api_key)
+      #       test_provider_connection(:anthropic, api_key: api_key)
       #     end
       #   end
-      module ProviderHelpers
+      module ProviderHelper
         # Test connection to an LLM provider
         #
         # @param provider [Symbol] Provider type (:anthropic, :openai, :openai_compatible)
@@ -65,27 +63,10 @@ module LanguageOperator
             fetch_openai_compatible_models(endpoint, api_key)
           end
         rescue StandardError => e
-          CLI::Formatters::ProgressFormatter.warn("Could not fetch models: #{e.message}")
+          Formatters::ProgressFormatter.warn("Could not fetch models: #{e.message}")
           nil
         end
 
-        # Get provider display information
-        #
-        # @param provider [Symbol] Provider type
-        # @return [Hash] Hash with :name, :docs_url keys
-        def provider_info(provider)
-          case provider
-          when :anthropic
-            { name: 'Anthropic', docs_url: 'https://console.anthropic.com' }
-          when :openai
-            { name: 'OpenAI', docs_url: 'https://platform.openai.com/api-keys' }
-          when :openai_compatible
-            { name: 'OpenAI-Compatible', docs_url: nil }
-          else
-            { name: provider.to_s.capitalize, docs_url: nil }
-          end
-        end
-
         private
 
         def test_anthropic(api_key)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../formatters/value_formatter'
+
 module LanguageOperator
   module CLI
     module Helpers
@@ -45,6 +47,8 @@ module LanguageOperator
 
           # Build a cron expression for interval-based execution
           def interval_cron(interval, unit)
+            validate_interval(interval, unit)
+
             case unit.downcase
             when 'minutes', 'minute'
               "*/#{interval} * * * *"
@@ -99,7 +103,23 @@ module LanguageOperator
           end
 
           def format_time(hours, minutes)
-            format('%<hours>02d:%<minutes>02d', hours: hours, minutes: minutes)
+            Formatters::ValueFormatter.schedule_time(hours, minutes)
+          end
+
+          def validate_interval(interval, unit)
+            raise ArgumentError, "Interval must be a positive integer, got: #{interval}" unless interval.is_a?(Integer) && interval.positive?
+
+            case unit.downcase
+            when 'minutes', 'minute'
+              raise ArgumentError, "Minutes interval must be between 1-59, got: #{interval}" if interval >= 60
+            when 'hours', 'hour'
+              raise ArgumentError, "Hours interval must be between 1-23, got: #{interval}" if interval >= 24
+            when 'days', 'day'
+              raise ArgumentError, "Days interval must be between 1-31, got: #{interval}" if interval >= 32
+            else
+              # Will be caught by the existing case statement
+              nil
+            end
           end
         end
       end

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

@@ -49,18 +49,26 @@ module LanguageOperator
         # @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}): "
+          loop do
+            puts prompt
+            options.each_with_index do |option, index|
+              puts "  #{index + 1}. #{option}"
+            end
+            print "\nSelect (1-#{options.length}): "
+
+            input = $stdin.gets&.chomp || ''
+
+            # Allow user to quit/cancel
+            if input.downcase.match?(/^q(uit)?$/)
+              puts 'Selection cancelled'
+              exit 0
+            end
+
+            selection = input.to_i
+            return options[selection - 1] if selection.between?(1, options.length)
 
-          selection = $stdin.gets&.chomp.to_i
-          if selection.between?(1, options.length)
-            options[selection - 1]
-          else
-            puts 'Invalid selection'
-            exit 1
+            puts 'Invalid selection. Please try again.'
+            puts
           end
         end
       end