ruby_raider 2.0.0 → 3.0.0

data/lib/llm/client.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require_relative 'config'
+
+module Llm
+  # Facade for LLM completion with retry logic and graceful fallback.
+  # Returns nil on any failure — callers should always have a non-AI fallback.
+  module Client
+    MAX_RETRIES = 3
+    BASE_DELAY = 1
+
+    # Only retry on transient network errors, not configuration or API errors
+    RETRYABLE_ERRORS = [
+      Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED,
+      Errno::ECONNRESET, Errno::ETIMEDOUT, SocketError
+    ].freeze
+
+    class << self
+      def complete(prompt, system_prompt: nil)
+        provider = build_provider
+        return nil unless provider
+
+        attempt = 0
+        begin
+          attempt += 1
+          provider.complete(prompt, system_prompt:)
+        rescue *RETRYABLE_ERRORS => e
+          if attempt < MAX_RETRIES
+            sleep(BASE_DELAY * (2**(attempt - 1)))
+            retry
+          end
+          warn "[Ruby Raider] LLM failed after #{MAX_RETRIES} attempts: #{e.message}"
+          nil
+        rescue StandardError => e
+          warn "[Ruby Raider] LLM error: #{e.message}"
+          nil
+        end
+      end
+
+      def available?
+        config = Config.new
+        return false unless config.configured?
+
+        provider = config.build_provider
+        provider&.available? || false
+      end
+
+      def status
+        config = Config.new
+        return { configured: false, provider: nil } unless config.configured?
+
+        provider = config.build_provider
+        {
+          configured: true,
+          provider: config.provider_name,
+          model: config.model,
+          available: provider&.available? || false
+        }
+      end
+
+      private
+
+      def build_provider
+        config = Config.new
+        unless config.configured?
+          warn '[Ruby Raider] No LLM configured. Use: raider u llm ollama'
+          return nil
+        end
+        provider = config.build_provider
+        unless provider&.available?
+          warn "[Ruby Raider] LLM provider '#{config.provider_name}' is not available"
+          return nil
+        end
+        provider
+      end
+    end
+  end
+end

data/lib/llm/config.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Llm
+  # Reads LLM configuration from env vars and config/config.yml
+  # Env vars take precedence over config file values.
+  class Config
+    PROVIDERS = %w[openai anthropic ollama].freeze
+
+    attr_reader :provider_name, :api_key, :model, :url
+
+    def initialize
+      @provider_name = env('RUBY_RAIDER_LLM_PROVIDER') || config_value('llm_provider')
+      @api_key = env('RUBY_RAIDER_LLM_API_KEY') || config_value('llm_api_key')
+      @model = env('RUBY_RAIDER_LLM_MODEL') || config_value('llm_model')
+      @url = env('RUBY_RAIDER_LLM_URL') || config_value('llm_url')
+    end
+
+    def configured?
+      return false unless @provider_name && PROVIDERS.include?(@provider_name)
+      return true if @provider_name == 'ollama'
+
+      !@api_key.nil? && !@api_key.empty?
+    end
+
+    def build_provider
+      return nil unless configured?
+
+      case @provider_name
+      when 'openai'
+        require_relative 'providers/openai_provider'
+        Providers::OpenaiProvider.new(api_key: @api_key, model: @model)
+      when 'anthropic'
+        require_relative 'providers/anthropic_provider'
+        Providers::AnthropicProvider.new(api_key: @api_key, model: @model)
+      when 'ollama'
+        require_relative 'providers/ollama_provider'
+        Providers::OllamaProvider.new(model: @model, url: @url)
+      end
+    end
+
+    private
+
+    def env(key)
+      value = ENV.fetch(key, nil)
+      value&.strip&.empty? ? nil : value&.strip
+    end
+
+    def config_value(key)
+      return nil unless File.exist?('config/config.yml')
+
+      data = YAML.load_file('config/config.yml')
+      data&.dig(key)
+    end
+  end
+end

data/lib/llm/prompts.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Llm
+  # Centralized prompt templates for LLM-enhanced code generation.
+  # All prompts instruct the model to return JSON matching specific schemas.
+  module Prompts
+    module_function
+
+    def analyze_page(html, url)
+      <<~PROMPT
+        Analyze this HTML page and extract all interactive elements that would be useful for a page object model in UI test automation.
+
+        URL: #{url}
+
+        HTML:
+        #{html[0..8000]}
+
+        Return a JSON object with this exact structure:
+        {
+          "elements": [
+            {
+              "name": "descriptive_snake_case_name",
+              "type": "input|select|textarea|button|submit|link",
+              "locator": {"type": "id|name|css|xpath", "value": "the_locator"},
+              "purpose": "brief description of what this element does",
+              "input_type": "text|email|password|etc (only for inputs)",
+              "text": "visible text (only for buttons/links)"
+            }
+          ]
+        }
+
+        Guidelines:
+        - Use semantic, descriptive names (e.g., "email_field" not "input_1", "submit_login" not "button_1")
+        - Prefer ID locators, then name, then CSS, then XPath
+        - Skip hidden inputs and purely decorative elements
+        - Include up to 5 important links
+        - The "purpose" field should be a brief, clear description
+
+        Return ONLY the JSON object, no other text.
+      PROMPT
+    end
+
+    def generate_test_scenarios(class_name, methods, automation, framework)
+      methods_desc = methods.map do |m|
+        params = m[:params].empty? ? '' : "(#{m[:params].join(', ')})"
+        "  - #{m[:name]}#{params}"
+      end.join("\n")
+
+      <<~PROMPT
+        Generate meaningful test scenarios for this page object class used in UI test automation.
+
+        Class: #{class_name}
+        Automation: #{automation}
+        Framework: #{framework}
+        Public methods:
+        #{methods_desc}
+
+        Return a JSON object with this exact structure:
+        {
+          "scenarios": [
+            {
+              "method": "method_name",
+              "description": "human-readable test description",
+              "assertion_hint": "what to assert after calling this method"
+            }
+          ]
+        }
+
+        Guidelines:
+        - Generate one scenario per method
+        - Descriptions should read naturally (e.g., "fills in the login form with valid credentials")
+        - Assertion hints should be specific (e.g., "expect page to redirect to dashboard")
+        - Consider the class name for context about what page this is
+
+        Return ONLY the JSON object, no other text.
+      PROMPT
+    end
+
+    def system_prompt
+      'You are a UI test automation expert. You generate clean, idiomatic Ruby code ' \
+        'for page object models and test specs. Always return valid JSON when asked for JSON.'
+    end
+  end
+end

data/lib/llm/provider.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Llm
+  # Abstract base class for LLM providers
+  class Provider
+    def complete(prompt, system_prompt: nil)
+      raise NotImplementedError, "#{self.class}#complete must be implemented"
+    end
+
+    def available?
+      raise NotImplementedError, "#{self.class}#available? must be implemented"
+    end
+
+    def name
+      self.class.name.split('::').last.sub('Provider', '').downcase
+    end
+
+    private
+
+    def build_messages(prompt, system_prompt)
+      messages = []
+      messages << { role: 'system', content: system_prompt } if system_prompt
+      messages << { role: 'user', content: prompt }
+      messages
+    end
+  end
+end

data/lib/llm/providers/anthropic_provider.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../provider'
+
+module Llm
+  module Providers
+    class AnthropicProvider < Provider
+      DEFAULT_MODEL = 'claude-sonnet-4-20250514'
+
+      def initialize(api_key:, model: nil)
+        super()
+        @api_key = api_key
+        @model = model || DEFAULT_MODEL
+      end
+
+      def complete(prompt, system_prompt: nil)
+        client = build_client
+        params = { model: @model, max_tokens: 4096, messages: [{ role: 'user', content: prompt }] }
+        params[:system] = system_prompt if system_prompt
+        response = client.messages(parameters: params)
+        response.dig('content', 0, 'text')
+      rescue StandardError => e
+        warn "[Ruby Raider] Anthropic error: #{e.message}"
+        nil
+      end
+
+      def available?
+        require 'anthropic'
+        !@api_key.nil? && !@api_key.empty?
+      rescue LoadError
+        warn '[Ruby Raider] Install anthropic gem: gem install anthropic-rb'
+        false
+      end
+
+      private
+
+      def build_client
+        require 'anthropic'
+        Anthropic::Client.new(access_token: @api_key)
+      end
+    end
+  end
+end

data/lib/llm/providers/ollama_provider.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require_relative '../provider'
+
+module Llm
+  module Providers
+    class OllamaProvider < Provider
+      DEFAULT_MODEL = 'llama3.2'
+      DEFAULT_URL = 'http://localhost:11434'
+      TIMEOUT = 60
+
+      def initialize(model: nil, url: nil)
+        super()
+        @model = model || DEFAULT_MODEL
+        @base_url = url || DEFAULT_URL
+      end
+
+      def complete(prompt, system_prompt: nil)
+        uri = URI("#{@base_url}/api/generate")
+        body = { model: @model, prompt:, stream: false }
+        body[:system] = system_prompt if system_prompt
+
+        response = post_request(uri, body)
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body)['response']
+      rescue StandardError => e
+        warn "[Ruby Raider] Ollama error: #{e.message}"
+        nil
+      end
+
+      def available?
+        uri = URI("#{@base_url}/api/tags")
+        response = Net::HTTP.get_response(uri)
+        response.is_a?(Net::HTTPSuccess)
+      rescue StandardError
+        warn '[Ruby Raider] Ollama not reachable. Start it with: ollama serve'
+        false
+      end
+
+      private
+
+      def post_request(uri, body)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.read_timeout = TIMEOUT
+        http.open_timeout = 10
+        request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
+        request.body = JSON.generate(body)
+        http.request(request)
+      end
+    end
+  end
+end

data/lib/llm/providers/openai_provider.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../provider'
+
+module Llm
+  module Providers
+    class OpenaiProvider < Provider
+      DEFAULT_MODEL = 'gpt-4o-mini'
+
+      def initialize(api_key:, model: nil)
+        super()
+        @api_key = api_key
+        @model = model || DEFAULT_MODEL
+      end
+
+      def complete(prompt, system_prompt: nil)
+        client = build_client
+        messages = build_messages(prompt, system_prompt)
+        response = client.chat(parameters: { model: @model, messages:, temperature: 0.2 })
+        response.dig('choices', 0, 'message', 'content')
+      rescue StandardError => e
+        warn "[Ruby Raider] OpenAI error: #{e.message}"
+        nil
+      end
+
+      def available?
+        require 'openai'
+        !@api_key.nil? && !@api_key.empty?
+      rescue LoadError
+        warn '[Ruby Raider] Install ruby-openai gem: gem install ruby-openai'
+        false
+      end
+
+      private
+
+      def build_client
+        require 'openai'
+        OpenAI::Client.new(access_token: @api_key)
+      end
+    end
+  end
+end

data/lib/llm/response_parser.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Llm
+  # Extracts JSON from LLM responses, handling markdown wrapping and malformed output.
+  # Returns nil on parse failure — callers should fall back to non-AI path.
+  module ResponseParser
+    module_function
+
+    def parse_json(response)
+      return nil if response.nil? || response.strip.empty?
+
+      json_str = extract_json(response)
+      result = JSON.parse(json_str, symbolize_names: true)
+      result.is_a?(Hash) ? result : nil
+    rescue JSON::ParserError
+      nil
+    end
+
+    def extract_elements(response)
+      parsed = parse_json(response)
+      return nil unless parsed && parsed[:elements].is_a?(Array)
+
+      parsed[:elements].map { |el| normalize_element(el) }.compact
+    end
+
+    def extract_scenarios(response)
+      parsed = parse_json(response)
+      return nil unless parsed && parsed[:scenarios].is_a?(Array)
+
+      parsed[:scenarios]
+    end
+
+    def normalize_element(element)
+      return nil unless element[:name] && element[:type] && element[:locator]
+
+      locator = element[:locator]
+      locator = { type: locator[:type]&.to_sym, value: locator[:value] } if locator.is_a?(Hash)
+
+      {
+        name: element[:name].to_s.gsub(/[^a-z0-9_]/i, '_').downcase,
+        type: element[:type].to_sym,
+        locator:,
+        purpose: element[:purpose],
+        input_type: element[:input_type],
+        text: element[:text]
+      }.compact
+    end
+
+    def extract_json(text)
+      # Try raw JSON first
+      stripped = text.strip
+      return stripped if stripped.start_with?('{')
+
+      # Try markdown code block
+      match = text.match(/```(?:json)?\s*\n?(.*?)\n?\s*```/m)
+      return match[1].strip if match
+
+      # Try finding first { ... } block
+      brace_match = text.match(/(\{.*\})/m)
+      return brace_match[1] if brace_match
+
+      text
+    end
+  end
+end

data/lib/plugin/plugin.rb

@@ -13,6 +13,7 @@ module RubyRaider
 
         pp "Adding #{plugin_name}..."
         add_plugin_to_gemfile(plugin_name)
+        invalidate_gemfile_cache
         system('bundle install')
         PluginExposer.expose_commands(plugin_name)
         pp "The plugin #{plugin_name} is added"
@@ -24,6 +25,7 @@ module RubyRaider
 
         pp "Deleting #{plugin_name}..."
         remove_plugin_from_gemfile(plugin_name)
+        invalidate_gemfile_cache
         PluginExposer.remove_command(plugin_name)
         system('bundle install')
         pp "The plugin #{plugin_name} is deleted"
@@ -32,8 +34,10 @@ module RubyRaider
       def installed_plugins
         return gemfile_guard unless File.exist?('Gemfile')
 
-        parsed_gemfile = File.readlines('Gemfile').map { |line| line.sub('gem ', '').strip.delete("'") }
-        parsed_gemfile.select { |line| plugins.include?(line) }
+        cached_gemfile_lines.filter_map do |line|
+          stripped = line.sub('gem ', '').strip.delete("'")
+          stripped if plugins.include?(stripped)
+        end
       end
 
       def installed?(plugin_name)
@@ -54,12 +58,25 @@ module RubyRaider
 
       private
 
+      # Read Gemfile once and cache until explicitly invalidated
+      def cached_gemfile_lines
+        @cached_gemfile_lines ||= File.readlines('Gemfile')
+      end
+
+      def invalidate_gemfile_cache
+        @cached_gemfile_lines = nil
+      end
+
       def add_plugin_to_gemfile(plugin_name)
         return gemfile_guard unless File.exist?('Gemfile')
 
+        lines = cached_gemfile_lines
+        has_comment = lines.any? { |l| l.include?('Ruby Raider Plugins') }
+        has_plugin = lines.any? { |l| l.include?(plugin_name) }
+
         File.open('Gemfile', 'a') do |file|
-          file.puts "\n# Ruby Raider Plugins\n" unless comment_present?
-          file.puts "gem '#{plugin_name}'" unless plugin_present?(plugin_name)
+          file.puts "\n# Ruby Raider Plugins\n" unless has_comment
+          file.puts "gem '#{plugin_name}'" unless has_plugin
         end
       end
 
@@ -72,27 +89,12 @@ module RubyRaider
         installed_plugins.count == 1
       end
 
-      def read_gemfile
-        return gemfile_guard unless File.exist?('Gemfile')
-
-        File.readlines('Gemfile')
-      end
-
-      def comment_present?
-        read_gemfile.grep(/Ruby Raider Plugins/).any?
-      end
-
-      def plugin_present?(plugin_name)
-        read_gemfile.grep(/#{plugin_name}/).any?
-      end
-
       def remove_plugins_and_comments(plugin_name)
-        read_gemfile.reject do |line|
+        cached_gemfile_lines.reject do |line|
           line.include?(plugin_name) || line.include?('Ruby Raider Plugins') && last_plugin?
         end
       end
 
-      # :reek:NestedIterators { enabled: false }
       def update_gemfile(output_lines)
         return gemfile_guard unless File.exist?('Gemfile')
 

data/lib/plugin/plugin_exposer.rb

@@ -6,33 +6,38 @@ module RubyRaider
   module PluginExposer
     class << self
       FILE_PATH = File.expand_path('../commands/loaded_commands.rb', __dir__)
-      # :reek:NestedIterators { enabled: false }
       def expose_commands(plugin_name)
-        return pp 'The plugin is already installed' if plugin_present?(plugin_name)
-
         commands = read_loaded_commands
+        return pp 'The plugin is already installed' if commands.any? { |l| l.include?(plugin_name) }
+
+        has_subcommands = commands.any? { |l| l.include?('subcommand') }
 
         File.open(FILE_PATH, 'w') do |file|
           commands.each do |line|
             file.puts line
-            file.puts require_plugin(plugin_name, line)
-            file.puts select_command_formatting(plugin_name, line)
+            file.puts "require '#{plugin_name}'" if line.include?("require 'thor'")
+            if line.strip == 'class LoadedCommands < Thor' && !has_subcommands
+              file.puts formatted_command_without_space(plugin_name)
+            elsif line.strip == 'class LoadedCommands < Thor' && has_subcommands
+              file.puts formatted_command_with_space(plugin_name)
+            end
           end
         end
       end
 
       def remove_command(plugin_name)
-        return pp 'The plugin is not installed' unless plugin_present?(plugin_name)
+        commands = read_loaded_commands
+        return pp 'The plugin is not installed' unless commands.any? { |l| l.include?(plugin_name) }
 
-        delete_plugin_command(plugin_name)
+        output_lines = commands.reject { |line| line.include?(plugin_name) }
+
+        File.open(FILE_PATH, 'w') do |file|
+          output_lines.each { |line| file.puts line }
+        end
       end
 
       private
 
-      def any_commands?
-        read_loaded_commands.any? { |line| line.include?('subcommand') }
-      end
-
       def read_loaded_commands
         File.readlines(FILE_PATH)
       end
@@ -45,33 +50,6 @@ module RubyRaider
       def formatted_command_with_space(plugin_name)
         "\n#{formatted_command_without_space(plugin_name)}"
       end
-
-      def plugin_present?(plugin_name)
-        read_loaded_commands.grep(/#{plugin_name}/).any?
-      end
-
-      def select_command_formatting(plugin_name, line)
-        if line.strip == 'class LoadedCommands < Thor' && !any_commands?
-          formatted_command_without_space(plugin_name)
-        elsif any_commands?
-          formatted_command_with_space(plugin_name)
-        end
-      end
-
-      def require_plugin(plugin_name, line)
-        "require '#{plugin_name}'" if line.include?("require 'thor'") && !plugin_present?(plugin_name)
-      end
-
-      # :reek:NestedIterators { enabled: false }
-      def delete_plugin_command(plugin_name)
-        output_lines = read_loaded_commands.reject do |line|
-          line.include?(plugin_name) if plugin_present?(plugin_name)
-        end
-
-        File.open(FILE_PATH, 'w') do |file|
-          output_lines.each { |line| file.puts line }
-        end
-      end
     end
   end
 end