language-operator 0.0.1 → 0.1.30

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

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require 'pastel'
+require 'json'
+require 'time'
+
+module LanguageOperator
+  module CLI
+    module Formatters
+      # Formatter for displaying agent execution logs with color and icons
+      class LogFormatter
+        class << self
+          # Format a single log line from kubectl output
+          #
+          # @param line [String] Raw log line from kubectl (with [pod/container] prefix)
+          # @return [String] Formatted log line with colors and icons
+          def format_line(line)
+            return line if line.strip.empty?
+
+            # Parse kubectl prefix: [pod-name/container-name] log_content
+            prefix, content = parse_kubectl_prefix(line)
+
+            # Format the log content based on detected format
+            formatted_content = format_log_content(content)
+
+            # Combine with dimmed prefix
+            if prefix
+              "#{pastel.dim(prefix)} #{formatted_content}"
+            else
+              formatted_content
+            end
+          end
+
+          private
+
+          def pastel
+            @pastel ||= Pastel.new
+          end
+
+          # Parse the kubectl prefix from the log line
+          # Returns [prefix, content] or [nil, original_line]
+          def parse_kubectl_prefix(line)
+            if line =~ /\A\[([^\]]+)\]\s+(.*)/
+              prefix = "[#{Regexp.last_match(1)}]"
+              content = Regexp.last_match(2)
+              [prefix, content]
+            else
+              [nil, line]
+            end
+          end
+
+          # Format log content based on detected format (pretty/text/json)
+          def format_log_content(content)
+            # Try JSON first
+            if content.strip.start_with?('{')
+              format_json_log(content)
+            # Check for text format with timestamp
+            elsif content =~ /\A\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}/
+              format_text_log(content)
+            # Default to pretty format
+            else
+              format_pretty_log(content)
+            end
+          rescue StandardError
+            # Fallback to plain if parsing fails
+            content
+          end
+
+          # Format JSON log format
+          def format_json_log(content)
+            data = JSON.parse(content)
+            timestamp = format_timestamp_from_iso(data['timestamp'])
+            level = data['level']
+            message = data['message']
+
+            # Build formatted line
+            formatted = "#{timestamp} #{format_message_with_icon(message, level)}"
+
+            # Add metadata if present
+            metadata_keys = data.keys - %w[timestamp level component message]
+            if metadata_keys.any?
+              metadata_str = metadata_keys.map { |k| "#{k}=#{data[k]}" }.join(', ')
+              formatted += " #{pastel.dim("(#{metadata_str})")}"
+            end
+
+            formatted
+          rescue JSON::ParserError
+            content
+          end
+
+          # Format text log format: 2024-11-07 14:32:15 INFO [Component] message
+          def format_text_log(content)
+            if content =~ /\A(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})\s+(\w+)\s+(?:\[([^\]]+)\]\s+)?(.*)/
+              timestamp_str = Regexp.last_match(1)
+              level = Regexp.last_match(2)
+              _component = Regexp.last_match(3)
+              message = Regexp.last_match(4)
+
+              timestamp = format_timestamp_from_text(timestamp_str)
+              "#{timestamp} #{format_message_with_icon(message, level)}"
+            else
+              content
+            end
+          end
+
+          # Format pretty log format: emoji message (metadata)
+          def format_pretty_log(content)
+            # Extract emoji and message
+            if content =~ /\A([^\s]+)\s+(.*)/
+              emoji_or_text = Regexp.last_match(1)
+              rest = Regexp.last_match(2)
+
+              # Check if first part is an emoji (common log emojis)
+              if emoji_or_text =~ /[▶👤◆🤖→✓✅✗❌⚠️🔍ℹ🔄]/
+                level = emoji_to_level(emoji_or_text)
+                # Message already has emoji, just format rest without adding another icon
+                message_text, metadata = extract_metadata(rest)
+                color = determine_color_from_level(level)
+                formatted = pastel.send(color, "#{emoji_or_text} #{message_text}")
+                formatted += " #{format_metadata(metadata)}" if metadata
+                formatted
+              else
+                format_message_with_icon(content, 'INFO')
+              end
+            else
+              format_message_with_icon(content, 'INFO')
+            end
+          end
+
+          # Format a message with appropriate icon and color based on content and level
+          def format_message_with_icon(message, level)
+            # Extract metadata from message (key=value pairs in parens)
+            message_text, metadata = extract_metadata(message)
+
+            # Determine icon and color based on message content
+            icon, color = determine_icon_and_color(message_text, level)
+
+            # Format the main message
+            formatted = pastel.send(color, "#{icon} #{message_text}")
+
+            # Add metadata if present
+            formatted += " #{format_metadata(metadata)}" if metadata
+
+            formatted
+          end
+
+          # Extract metadata from message
+          # Returns [message_without_metadata, metadata_hash]
+          def extract_metadata(message)
+            if message =~ /\A(.*?)\s*\(([^)]+)\)\s*\z/
+              message_text = Regexp.last_match(1)
+              metadata_str = Regexp.last_match(2)
+
+              # Parse key=value pairs
+              metadata = {}
+              metadata_str.scan(/(\w+)=([^,]+)(?:,\s*)?/) do |key, value|
+                metadata[key] = value.strip
+              end
+
+              [message_text, metadata]
+            else
+              [message, nil]
+            end
+          end
+
+          # Determine icon and color based on message content
+          def determine_icon_and_color(message, level)
+            case message
+            when /Starting execution|Starting iteration|Starting autonomous/i
+              ['▶', :cyan]
+            when /Loading persona|Persona:/i
+              ['👤', :cyan]
+            when /Connecting to tool|Calling tool|MCP server/i
+              ['◆', :blue]
+            when /LLM request|Prompt|🤖/i
+              ['🤖', :magenta]
+            when /Tool completed|result|response|found/i
+              ['→', :yellow]
+            when /Iteration completed|completed|finished/i
+              ['✓', :green]
+            when /Execution complete|✅|workflow.*completed/i
+              ['✅', :green]
+            when /error|fail|✗|❌/i
+              ['✗', :red]
+            when /warn|⚠️/i
+              ['⚠️', :yellow]
+            else
+              # Default based on level
+              case level&.upcase
+              when 'ERROR'
+                ['✗', :red]
+              when 'WARN'
+                ['⚠️', :yellow]
+              when 'DEBUG'
+                ['🔍', :dim]
+              else
+                ['', :white]
+              end
+            end
+          end
+
+          # Format metadata hash
+          def format_metadata(metadata)
+            return '' unless metadata&.any?
+
+            parts = metadata.map do |key, value|
+              # Highlight durations
+              if key == 'duration_s' || key.include?('duration')
+                duration_val = value.to_f
+                formatted_duration = duration_val < 1 ? "#{(duration_val * 1000).round}ms" : "#{duration_val.round(1)}s"
+                "duration=#{pastel.yellow(formatted_duration)}"
+              # Highlight counts and numbers
+              elsif value =~ /^\d+$/
+                "#{key}=#{pastel.yellow(value)}"
+              # Highlight tool names
+              elsif %w[tool name].include?(key)
+                "#{key}=#{pastel.bold(value)}"
+              else
+                "#{key}=#{value}"
+              end
+            end
+
+            pastel.dim("(#{parts.join(', ')})")
+          end
+
+          # 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
+            ''
+          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
+            ''
+          end
+
+          # Format Time object as HH:MM:SS
+          def format_time(time)
+            pastel.dim(time.strftime('%H:%M:%S'))
+          end
+
+          # Convert emoji to log level
+          def emoji_to_level(emoji)
+            case emoji
+            when 'ℹ️', 'ℹ'
+              'INFO'
+            when '🔍'
+              'DEBUG'
+            when '⚠️', '⚠'
+              'WARN'
+            when '❌', '✗'
+              'ERROR'
+            when '▶', '👤', '◆'
+              'INFO'
+            when '🤖'
+              'INFO'
+            when '→', '✓', '✅'
+              'INFO'
+            else
+              'INFO'
+            end
+          end
+
+          # Determine color from log level
+          def determine_color_from_level(level)
+            case level&.upcase
+            when 'ERROR'
+              :red
+            when 'WARN'
+              :yellow
+            when 'DEBUG'
+              :dim
+            else
+              :white
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'tty-spinner'
+require 'pastel'
+
+module LanguageOperator
+  module CLI
+    module Formatters
+      # Beautiful progress output for CLI operations
+      class ProgressFormatter
+        class << self
+          def with_spinner(message, success_msg: nil, &block)
+            spinner = TTY::Spinner.new("[:spinner] #{message}...", format: :dots, success_mark: pastel.green('✔'))
+            spinner.auto_spin
+
+            result = block.call
+
+            # Determine what to show after spinner completes
+            final_status = success_msg || 'done'
+
+            spinner.success(final_status)
+            result
+          rescue StandardError => e
+            spinner.error(e.message)
+            raise
+          end
+
+          def success(message)
+            puts "[#{pastel.green('✔')}] #{message}"
+          end
+
+          def error(message)
+            puts "[#{pastel.red('✗')}] #{message}"
+          end
+
+          def info(message)
+            puts pastel.dim(message)
+          end
+
+          def warn(message)
+            puts "[#{pastel.yellow('⚠')}] #{message}"
+          end
+
+          private
+
+          def pastel
+            @pastel ||= Pastel.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'tty-table'
+require 'pastel'
+
+module LanguageOperator
+  module CLI
+    module Formatters
+      # Table output for CLI list commands
+      class TableFormatter
+        class << self
+          def clusters(clusters)
+            return ProgressFormatter.info('No clusters found') if clusters.empty?
+
+            headers = %w[NAME NAMESPACE AGENTS TOOLS MODELS STATUS]
+            rows = clusters.map do |cluster|
+              [
+                cluster[:name],
+                cluster[:namespace],
+                cluster[:agents] || 0,
+                cluster[:tools] || 0,
+                cluster[:models] || 0,
+                status_indicator(cluster[:status])
+              ]
+            end
+
+            table = TTY::Table.new(headers, rows)
+            puts table.render(:unicode, padding: [0, 1])
+          end
+
+          def agents(agents)
+            return ProgressFormatter.info('No agents found') if agents.empty?
+
+            headers = ['NAME', 'MODE', 'STATUS', 'NEXT RUN', 'EXECUTIONS']
+            rows = agents.map do |agent|
+              [
+                agent[:name],
+                agent[:mode],
+                status_indicator(agent[:status]),
+                agent[:next_run] || 'N/A',
+                agent[:executions] || 0
+              ]
+            end
+
+            table = TTY::Table.new(headers, rows)
+            puts table.render(:unicode, padding: [0, 1])
+          end
+
+          def all_agents(agents_by_cluster)
+            return ProgressFormatter.info('No agents found across any cluster') if agents_by_cluster.empty?
+
+            headers = ['CLUSTER', 'NAME', 'MODE', 'STATUS', 'NEXT RUN', 'EXECUTIONS']
+            rows = []
+
+            agents_by_cluster.each do |cluster_name, agents|
+              agents.each do |agent|
+                rows << [
+                  cluster_name,
+                  agent[:name],
+                  agent[:mode],
+                  status_indicator(agent[:status]),
+                  agent[:next_run] || 'N/A',
+                  agent[:executions] || 0
+                ]
+              end
+            end
+
+            table = TTY::Table.new(headers, rows)
+            puts table.render(:unicode, padding: [0, 1])
+          end
+
+          def tools(tools)
+            return ProgressFormatter.info('No tools found') if tools.empty?
+
+            headers = ['NAME', 'TYPE', 'STATUS', 'AGENTS USING']
+            rows = tools.map do |tool|
+              [
+                tool[:name],
+                tool[:type],
+                status_indicator(tool[:status]),
+                tool[:agents_using] || 0
+              ]
+            end
+
+            table = TTY::Table.new(headers, rows)
+            puts table.render(:unicode, padding: [0, 1])
+          end
+
+          def personas(personas)
+            return ProgressFormatter.info('No personas found') if personas.empty?
+
+            headers = ['NAME', 'TONE', 'USED BY', 'DESCRIPTION']
+            rows = personas.map do |persona|
+              [
+                persona[:name],
+                persona[:tone],
+                persona[:used_by] || 0,
+                truncate(persona[:description], 50)
+              ]
+            end
+
+            table = TTY::Table.new(headers, rows)
+            puts table.render(:unicode, padding: [0, 1])
+          end
+
+          def models(models)
+            return ProgressFormatter.info('No models found') if models.empty?
+
+            headers = %w[NAME PROVIDER MODEL STATUS]
+            rows = models.map do |model|
+              [
+                model[:name],
+                model[:provider],
+                model[:model],
+                status_indicator(model[:status])
+              ]
+            end
+
+            table = TTY::Table.new(headers, rows)
+            puts table.render(:unicode, padding: [0, 1])
+          end
+
+          def status_dashboard(cluster_summary, current_cluster: nil)
+            return ProgressFormatter.info('No clusters configured') if cluster_summary.empty?
+
+            headers = %w[CLUSTER AGENTS TOOLS MODELS STATUS]
+            rows = cluster_summary.map do |cluster|
+              name = cluster[:name].to_s
+              name += ' *' if current_cluster && cluster[:name] == current_cluster
+
+              [
+                name,
+                cluster[:agents] || 0,
+                cluster[:tools] || 0,
+                cluster[:models] || 0,
+                status_indicator(cluster[:status])
+              ]
+            end
+
+            table = TTY::Table.new(headers, rows)
+            puts table.render(:unicode, padding: [0, 1])
+
+            return unless current_cluster
+
+            puts
+            puts '* = current cluster'
+          end
+
+          private
+
+          def status_indicator(status)
+            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 || 'Unknown'}"
+            end
+          end
+
+          def truncate(text, length)
+            return text if text.nil? || text.length <= length
+
+            "#{text[0...(length - 3)]}..."
+          end
+
+          def pastel
+            @pastel ||= Pastel.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Formatters
+      # Utility module for formatting values (time, duration, file sizes, etc.)
+      # for display in CLI output. Provides consistent formatting across commands.
+      module ValueFormatter
+        SECONDS_PER_MINUTE = 60
+        SECONDS_PER_HOUR = 3600
+        SECONDS_PER_DAY = 86_400
+        SECONDS_PER_WEEK = 604_800
+        BYTES_PER_KB = 1024
+        BYTES_PER_MB = 1024 * 1024
+        BYTES_PER_GB = 1024 * 1024 * 1024
+
+        # Format time until a future event
+        #
+        # @param future_time [Time] The future time
+        # @return [String] Formatted string like "in 5m" or "in 2h 15m"
+        #
+        # @example
+        #   ValueFormatter.time_until(Time.now + 300) # => "in 5m"
+        def self.time_until(future_time)
+          diff = future_time - Time.now
+
+          if diff.negative?
+            'overdue'
+          elsif diff < SECONDS_PER_MINUTE
+            "in #{diff.to_i}s"
+          elsif diff < SECONDS_PER_HOUR
+            minutes = (diff / SECONDS_PER_MINUTE).to_i
+            "in #{minutes}m"
+          elsif diff < SECONDS_PER_DAY
+            hours = (diff / SECONDS_PER_HOUR).to_i
+            minutes = ((diff % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE).to_i
+            "in #{hours}h #{minutes}m"
+          else
+            days = (diff / SECONDS_PER_DAY).to_i
+            hours = ((diff % SECONDS_PER_DAY) / SECONDS_PER_HOUR).to_i
+            "in #{days}d #{hours}h"
+          end
+        end
+
+        # Format a duration in seconds
+        #
+        # @param seconds [Numeric] Duration in seconds
+        # @return [String] Formatted string like "1.5s" or "2m 30s"
+        #
+        # @example
+        #   ValueFormatter.duration(0.5) # => "500ms"
+        #   ValueFormatter.duration(90) # => "1m 30s"
+        def self.duration(seconds)
+          if seconds < 1
+            "#{(seconds * 1000).round}ms"
+          elsif seconds < SECONDS_PER_MINUTE
+            "#{seconds.round(1)}s"
+          else
+            minutes = (seconds / SECONDS_PER_MINUTE).floor
+            secs = (seconds % SECONDS_PER_MINUTE).round
+            "#{minutes}m #{secs}s"
+          end
+        end
+
+        # Format file size in bytes to human-readable format
+        #
+        # @param bytes [Integer] File size in bytes
+        # @return [String] Formatted string like "1.5KB" or "2.3MB"
+        #
+        # @example
+        #   ValueFormatter.file_size(1500) # => "1.5KB"
+        def self.file_size(bytes)
+          if bytes < BYTES_PER_KB
+            "#{bytes}B"
+          elsif bytes < BYTES_PER_MB
+            "#{(bytes / BYTES_PER_KB.to_f).round(1)}KB"
+          elsif bytes < BYTES_PER_GB
+            "#{(bytes / BYTES_PER_MB.to_f).round(1)}MB"
+          else
+            "#{(bytes / BYTES_PER_GB.to_f).round(1)}GB"
+          end
+        end
+
+        # Format a timestamp as relative time or absolute date
+        #
+        # @param time [Time] The timestamp to format
+        # @return [String] Formatted string like "5 minutes ago" or "2025-01-15 14:30"
+        #
+        # @example
+        #   ValueFormatter.timestamp(Time.now - 300) # => "5 minutes ago"
+        def self.timestamp(time)
+          now = Time.now
+          diff = now - time
+
+          if diff < SECONDS_PER_MINUTE
+            "#{diff.to_i} seconds ago"
+          elsif diff < SECONDS_PER_HOUR
+            minutes = (diff / SECONDS_PER_MINUTE).to_i
+            "#{minutes} minute#{'s' if minutes != 1} ago"
+          elsif diff < SECONDS_PER_DAY
+            hours = (diff / SECONDS_PER_HOUR).to_i
+            "#{hours} hour#{'s' if hours != 1} ago"
+          elsif diff < SECONDS_PER_WEEK
+            days = (diff / SECONDS_PER_DAY).to_i
+            "#{days} day#{'s' if days != 1} ago"
+          else
+            time.strftime('%Y-%m-%d %H:%M')
+          end
+        end
+      end
+    end
+  end
+end

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

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