language-operator 0.0.1 → 0.1.31

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'pastel'
+require_relative 'suggestions'
+require_relative '../formatters/progress_formatter'
+
+module LanguageOperator
+  module CLI
+    module Errors
+      # Central error handler with context-aware suggestions
+      class Handler
+        class << self
+          # Handle an error with context and provide helpful suggestions
+          def handle(error, context = {})
+            case error
+            when K8s::Error::NotFound
+              handle_not_found(error, context)
+            else
+              handle_generic(error, context)
+            end
+          end
+
+          # Handle resource not found errors with fuzzy matching
+          def handle_not_found(error, context)
+            resource_type = context[:resource_type] || 'Resource'
+            resource_name = context[:resource_name] || 'unknown'
+            cluster = context[:cluster]
+
+            # Display main error message
+            message = if cluster
+                        "#{format_resource_type(resource_type)} '#{resource_name}' not found in cluster '#{cluster}'"
+                      else
+                        "#{format_resource_type(resource_type)} '#{resource_name}' not found"
+                      end
+
+            Formatters::ProgressFormatter.error(message)
+            puts
+
+            # Find and display similar resources
+            if context[:available_resources]
+              similar = Suggestions.find_similar(resource_name, context[:available_resources])
+              if similar.any?
+                puts pastel.yellow('Did you mean?')
+                similar.each { |name| puts "  #{pastel.cyan('•')} #{name}" }
+                puts
+              end
+            end
+
+            # Display recovery suggestions
+            error_type = error_type_for_resource(resource_type)
+            suggestions = Suggestions.for_error(error_type, context)
+            display_suggestions(suggestions) if suggestions.any?
+
+            # Re-raise if in debug mode, otherwise exit
+            raise error if ENV['DEBUG']
+
+            exit 1
+          end
+
+          # Handle generic errors
+          def handle_generic(error, context)
+            operation = context[:operation] || 'operation'
+
+            Formatters::ProgressFormatter.error("Failed to #{operation}: #{error.message}")
+            puts
+
+            # Display suggestions if provided in context
+            display_suggestions(context[:suggestions]) if context[:suggestions]
+
+            # Re-raise if in debug mode, otherwise exit
+            raise error if ENV['DEBUG']
+
+            exit 1
+          end
+
+          # Handle specific error scenarios with custom suggestions
+          def handle_no_cluster_selected
+            Formatters::ProgressFormatter.error('No cluster selected')
+            puts
+
+            puts 'You must connect to a cluster first:'
+            puts
+
+            suggestions = Suggestions.for_error(:no_cluster_selected)
+            suggestions.each { |line| puts line }
+
+            exit 1
+          end
+
+          def handle_no_models_available(context = {})
+            Formatters::ProgressFormatter.error('No models found in cluster')
+            puts
+
+            suggestions = Suggestions.for_error(:no_models_available, context)
+            suggestions.each { |line| puts line }
+
+            exit 1
+          end
+
+          def handle_synthesis_failed(message)
+            Formatters::ProgressFormatter.error("Synthesis failed: #{message}")
+            puts
+
+            suggestions = Suggestions.for_error(:synthesis_failed)
+            suggestions.each { |line| puts line }
+
+            exit 1
+          end
+
+          def handle_already_exists(context = {})
+            resource_type = context[:resource_type] || 'Resource'
+            resource_name = context[:resource_name] || 'unknown'
+            cluster = context[:cluster]
+
+            message = if cluster
+                        "#{format_resource_type(resource_type)} '#{resource_name}' already exists in cluster '#{cluster}'"
+                      else
+                        "#{format_resource_type(resource_type)} '#{resource_name}' already exists"
+                      end
+
+            Formatters::ProgressFormatter.error(message)
+            puts
+
+            suggestions = Suggestions.for_error(:already_exists, context)
+            display_suggestions(suggestions) if suggestions.any?
+
+            exit 1
+          end
+
+          private
+
+          def display_suggestions(suggestions)
+            return if suggestions.empty?
+
+            suggestions.each do |suggestion|
+              puts suggestion
+            end
+            puts
+          end
+
+          def format_resource_type(resource_type)
+            case resource_type
+            when 'LanguageAgent'
+              'Agent'
+            when 'LanguageTool'
+              'Tool'
+            when 'LanguageModel'
+              'Model'
+            when 'LanguagePersona'
+              'Persona'
+            else
+              resource_type
+            end
+          end
+
+          def error_type_for_resource(resource_type)
+            case resource_type
+            when 'LanguageAgent', 'agent'
+              :agent_not_found
+            when 'LanguageTool', 'tool'
+              :tool_not_found
+            when 'LanguageModel', 'model'
+              :model_not_found
+            when 'LanguagePersona', 'persona'
+              :persona_not_found
+            when 'cluster'
+              :cluster_not_found
+            else
+              :resource_not_found
+            end
+          end
+
+          def pastel
+            @pastel ||= Pastel.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'did_you_mean'
+require 'pastel'
+
+module LanguageOperator
+  module CLI
+    module Errors
+      # Provides helpful suggestions for error recovery
+      class Suggestions
+        class << self
+          # Find similar resource names using fuzzy matching
+          def find_similar(input_name, available_names, limit: 3)
+            return [] if available_names.empty?
+
+            spell_checker = DidYouMean::SpellChecker.new(dictionary: available_names)
+            corrections = spell_checker.correct(input_name)
+            corrections.first(limit)
+          end
+
+          # Generate context-aware suggestions based on error type
+          def for_error(error_type, context = {})
+            case error_type
+            when :agent_not_found
+              agent_not_found_suggestions(context)
+            when :tool_not_found
+              tool_not_found_suggestions(context)
+            when :model_not_found
+              model_not_found_suggestions(context)
+            when :persona_not_found
+              persona_not_found_suggestions(context)
+            when :cluster_not_found
+              cluster_not_found_suggestions(context)
+            when :no_cluster_selected
+              no_cluster_selected_suggestions
+            when :no_models_available
+              no_models_available_suggestions(context)
+            when :synthesis_failed
+              synthesis_failed_suggestions
+            when :already_exists
+              already_exists_suggestions(context)
+            else
+              []
+            end
+          end
+
+          private
+
+          def agent_not_found_suggestions(context)
+            suggestions = []
+            suggestions << "List all agents: #{pastel.dim('aictl agent list')}"
+            suggestions << "Create a new agent: #{pastel.dim('aictl agent create \"description\"')}"
+            suggestions << "Use the wizard: #{pastel.dim('aictl agent create --wizard')}" if context[:suggest_wizard]
+            suggestions
+          end
+
+          def tool_not_found_suggestions(context)
+            suggestions = []
+            tool_name = context[:tool_name]
+
+            if tool_name
+              suggestions << "Install from registry: #{pastel.dim("aictl tool install #{tool_name}")}"
+              suggestions << "Search for tools: #{pastel.dim('aictl tool search')}"
+            end
+
+            suggestions << "List installed tools: #{pastel.dim('aictl tool list')}"
+            suggestions
+          end
+
+          def model_not_found_suggestions(_context)
+            suggestions = []
+            suggestions << "List all models: #{pastel.dim('aictl model list')}"
+            suggestions << "Create a new model: #{pastel.dim('aictl model create <name> --provider <provider>')}"
+            suggestions
+          end
+
+          def persona_not_found_suggestions(_context)
+            suggestions = []
+            suggestions << "List all personas: #{pastel.dim('aictl persona list')}"
+            suggestions << "Create a new persona: #{pastel.dim('aictl persona create <name>')}"
+            suggestions
+          end
+
+          def cluster_not_found_suggestions(_context)
+            suggestions = []
+            suggestions << "List available clusters: #{pastel.dim('aictl cluster list')}"
+            suggestions << "Create a new cluster: #{pastel.dim('aictl cluster create <name>')}"
+            suggestions
+          end
+
+          def no_cluster_selected_suggestions
+            [
+              'Create a new cluster:',
+              "  #{pastel.dim('aictl cluster create my-cluster')}",
+              '',
+              'Or select an existing cluster:',
+              "  #{pastel.dim('aictl use my-cluster')}",
+              '',
+              'List available clusters:',
+              "  #{pastel.dim('aictl cluster list')}"
+            ]
+          end
+
+          def no_models_available_suggestions(context)
+            cluster = context[:cluster]
+            suggestions = []
+
+            if cluster
+              suggestions << "Create a model in cluster '#{cluster}':"
+              suggestions << "  #{pastel.dim('aictl model create <name> --provider anthropic --model claude-3-5-sonnet')}"
+            else
+              suggestions << "Create a model: #{pastel.dim('aictl model create <name> --provider <provider>')}"
+            end
+
+            suggestions << ''
+            suggestions << "List available models: #{pastel.dim('aictl model list')}"
+            suggestions
+          end
+
+          def synthesis_failed_suggestions
+            [
+              'The description may be too vague. Try the interactive wizard:',
+              "  #{pastel.dim('aictl agent create --wizard')}",
+              '',
+              'Or provide a more detailed description with:',
+              '  • What the agent should do specifically',
+              '  • When it should run (schedule)',
+              '  • What tools or resources it needs',
+              '',
+              'Examples:',
+              "  #{pastel.green('✓')} #{pastel.dim('\"Check my email every hour and notify me of urgent messages\"')}",
+              "  #{pastel.green('✓')} #{pastel.dim('\"Review my spreadsheet at 4pm daily and email me errors\"')}",
+              "  #{pastel.red('✗')} #{pastel.dim('\"do the thing\"')} (too vague)"
+            ]
+          end
+
+          def already_exists_suggestions(context)
+            resource_type = context[:resource_type]
+            resource_name = context[:resource_name]
+
+            suggestions = []
+
+            if resource_name
+              suggestions << "View existing #{resource_type}: #{pastel.dim("aictl #{command_for_resource(resource_type)} inspect #{resource_name}")}"
+              suggestions << "Delete and recreate: #{pastel.dim("aictl #{command_for_resource(resource_type)} delete #{resource_name}")}"
+            end
+
+            suggestions << 'Choose a different name'
+            suggestions
+          end
+
+          def command_for_resource(resource_type)
+            case resource_type
+            when 'LanguageAgent', 'agent'
+              'agent'
+            when 'LanguageTool', 'tool'
+              'tool'
+            when 'LanguageModel', 'model'
+              'model'
+            when 'LanguagePersona', 'persona'
+              'persona'
+            when 'cluster'
+              'cluster'
+            else
+              resource_type.downcase
+            end
+          end
+
+          def pastel
+            @pastel ||= Pastel.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'rouge'
+require_relative '../helpers/pastel_helper'
+
+module LanguageOperator
+  module CLI
+    module Formatters
+      # Formatter for displaying syntax-highlighted code in the terminal
+      class CodeFormatter
+        class << self
+          include Helpers::PastelHelper
+
+          # Display Ruby code with syntax highlighting
+          #
+          # @param code_content [String] The Ruby code to display
+          # @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
+            if max_lines && lines.length > max_lines
+              code_to_display = lines[0...max_lines].join
+              truncated = true
+              remaining_lines = lines.length - max_lines
+            else
+              code_to_display = code_content
+            end
+
+            # Print header
+            puts
+            puts pastel.cyan(title) if title
+            puts pastel.dim('─' * 80)
+            puts
+
+            # Highlight and print the code
+            highlighted = formatter.format(lexer.lex(code_to_display))
+            puts highlighted
+
+            # Show truncation notice if applicable
+            if truncated
+              puts
+              puts pastel.dim("... #{remaining_lines} more lines ...")
+            end
+
+            # Print footer
+            puts
+            puts pastel.dim('─' * 80)
+          end
+
+          # Display a code snippet with context
+          #
+          # @param code_content [String] The Ruby code
+          # @param description [String] Description of what the code does
+          def display_snippet(code_content, description: nil)
+            puts
+            puts pastel.cyan('Generated Code Preview:') if description.nil?
+            puts pastel.dim(description) if description
+            puts
+
+            formatter = Rouge::Formatters::Terminal256.new
+            lexer = Rouge::Lexers::Ruby.new
+            highlighted = formatter.format(lexer.lex(code_content))
+
+            puts highlighted
+            puts
+          end
+        end
+      end
+    end
+  end
+end