ruby_raider 3.0.1 → 3.1.0

data/lib/llm/prompts.rb

@@ -1,84 +0,0 @@
-# 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

@@ -1,27 +0,0 @@
-# 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

@@ -1,43 +0,0 @@
-# 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

@@ -1,56 +0,0 @@
-# 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

@@ -1,42 +0,0 @@
-# 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

@@ -1,67 +0,0 @@
-# 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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require_relative 'plugin_exposer'
-
-module RubyRaider
-  module Plugin
-    class << self
-      def add_plugin(plugin_name)
-        return gemfile_guard unless File.exist?('Gemfile')
-        return pp 'The plugin was not found' unless available?(plugin_name)
-        return pp 'The plugin is already installed' if installed?(plugin_name)
-
-        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"
-      end
-
-      def delete_plugin(plugin_name)
-        return gemfile_guard unless File.exist?('Gemfile')
-        return 'The plugin is not installed' unless installed_plugins.include?(plugin_name)
-
-        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"
-      end
-
-      def installed_plugins
-        return gemfile_guard unless File.exist?('Gemfile')
-
-        cached_gemfile_lines.filter_map do |line|
-          stripped = line.sub('gem ', '').strip.delete("'")
-          stripped if plugins.include?(stripped)
-        end
-      end
-
-      def installed?(plugin_name)
-        installed_plugins.include?(plugin_name)
-      end
-
-      def available?(plugin_name)
-        plugins.include?(plugin_name)
-      end
-
-      def camelize(str)
-        str.split('_').collect(&:capitalize).join
-      end
-
-      def plugins
-        ['great_axe']
-      end
-
-      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 has_comment
-          file.puts "gem '#{plugin_name}'" unless has_plugin
-        end
-      end
-
-      def remove_plugin_from_gemfile(plugin_name)
-        output_lines = remove_plugins_and_comments(plugin_name)
-        update_gemfile(output_lines)
-      end
-
-      def last_plugin?
-        installed_plugins.count == 1
-      end
-
-      def remove_plugins_and_comments(plugin_name)
-        cached_gemfile_lines.reject do |line|
-          line.include?(plugin_name) || line.include?('Ruby Raider Plugins') && last_plugin?
-        end
-      end
-
-      def update_gemfile(output_lines)
-        return gemfile_guard unless File.exist?('Gemfile')
-
-        File.open('Gemfile', 'w') do |file|
-          output_lines.each { |line| file.puts line }
-        end
-      end
-
-      def gemfile_guard
-        pp 'There is no Gemfile, please create one to install plugins'
-      end
-    end
-  end
-end

data/lib/plugin/plugin_exposer.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../plugin/plugin'
-
-module RubyRaider
-  module PluginExposer
-    class << self
-      FILE_PATH = File.expand_path('../commands/loaded_commands.rb', __dir__)
-      def expose_commands(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_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)
-        commands = read_loaded_commands
-        return pp 'The plugin is not installed' unless commands.any? { |l| l.include?(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 read_loaded_commands
-        File.readlines(FILE_PATH)
-      end
-
-      def formatted_command_without_space(plugin_name)
-        "desc '#{plugin_name}', 'Provides access to all the commands for #{plugin_name}'\n" \
-        "subcommand '#{plugin_name}', #{Plugin.camelize(plugin_name)}::PluginCommands"
-      end
-
-      def formatted_command_with_space(plugin_name)
-        "\n#{formatted_command_without_space(plugin_name)}"
-      end
-    end
-  end
-end

data/lib/scaffolding/crud_generator.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'name_normalizer'
-
-class CrudGenerator
-  ACTIONS = %w[list create detail edit].freeze
-
-  def initialize(base_name, scaffolding_class, config_loader)
-    @base_name = NameNormalizer.normalize(base_name)
-    @scaffolding_class = scaffolding_class
-    @config_loader = config_loader
-  end
-
-  def generate
-    generated = []
-    ACTIONS.each do |action|
-      name = "#{@base_name}_#{action}"
-      generate_page(name)
-      generate_test(name)
-      generated << name
-    end
-    generate_model
-    generated
-  end
-
-  def planned_files
-    files = []
-    ACTIONS.each do |action|
-      name = "#{@base_name}_#{action}"
-      files << "page_objects/pages/#{name}.rb"
-      files << test_path(name)
-    end
-    files << "models/data/#{@base_name}.yml"
-    files
-  end
-
-  private
-
-  def generate_page(name)
-    path = @config_loader.call('page')
-    @scaffolding_class.new([name, path]).generate_page
-  end
-
-  def generate_test(name)
-    if Dir.exist?('features')
-      path = @config_loader.call('feature')
-      @scaffolding_class.new([name, path]).generate_feature
-      path = @config_loader.call('steps')
-      @scaffolding_class.new([name, path]).generate_steps
-    elsif Dir.exist?('test')
-      path = @config_loader.call('spec')
-      @scaffolding_class.new([name, path]).generate_spec
-    else
-      path = @config_loader.call('spec')
-      @scaffolding_class.new([name, path]).generate_spec
-    end
-  end
-
-  def generate_model
-    model_path = "models/data/#{@base_name}.yml"
-    return if File.exist?(model_path)
-
-    FileUtils.mkdir_p(File.dirname(model_path))
-    File.write(model_path, model_content)
-  end
-
-  def model_content
-    <<~YAML
-      # Data model for #{@base_name}
-      # Used with ModelFactory for test data generation
-      default:
-        name: 'Test #{@base_name.capitalize}'
-        email: 'test@example.com'
-
-      valid:
-        name: 'Valid #{@base_name.capitalize}'
-        email: 'valid@example.com'
-
-      invalid:
-        name: ''
-        email: 'invalid'
-    YAML
-  end
-
-  def test_path(name)
-    if Dir.exist?('features')
-      "features/#{name}.feature"
-    elsif Dir.exist?('test')
-      "test/test_#{name}.rb"
-    else
-      "spec/#{name}_page_spec.rb"
-    end
-  end
-end

data/lib/scaffolding/dry_run_presenter.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module DryRunPresenter
-  module_function
-
-  def preview(planned_files)
-    return [] if planned_files.empty?
-
-    puts '[dry-run] Would create:'
-    planned_files.each do |file|
-      puts "  #{file}"
-    end
-    puts ''
-    planned_files
-  end
-end

data/lib/scaffolding/page_introspector.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'ripper'
-
-class PageIntrospector
-  SKIP_METHODS = %w[initialize url to_s inspect].freeze
-
-  attr_reader :class_name, :methods
-
-  def initialize(file_path)
-    @source = File.read(file_path)
-    @class_name = extract_class_name
-    @methods = extract_public_methods
-  end
-
-  private
-
-  def extract_class_name
-    match = @source.match(/class\s+(\w+)/)
-    match ? match[1] : 'UnknownPage'
-  end
-
-  def extract_public_methods
-    in_private = false
-    results = []
-
-    @source.each_line do |line|
-      stripped = line.strip
-      in_private = true if stripped.match?(/^\s*(private|protected)\s*$/)
-      next if in_private
-
-      match = stripped.match(/^\s*def\s+(\w+)(\(([^)]*)\))?/)
-      next unless match
-
-      method_name = match[1]
-      next if SKIP_METHODS.include?(method_name)
-      next if method_name.start_with?('_')
-
-      params = match[3]&.split(',')&.map(&:strip) || []
-      results << { name: method_name, params: }
-    end
-
-    results
-  end
-end