ai_refactor 0.3.1 → 0.5.0

data/lib/ai_refactor/refactors/base_refactor.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Refactors
+    class BaseRefactor
+      # All subclasses must register themselves with the Registry
+      def self.inherited(subclass)
+        super
+        Refactors.register(subclass)
+      end
+
+      def self.description
+        "(No description provided)"
+      end
+
+      def self.takes_input_files?
+        true
+      end
+
+      attr_reader :input_file, :options, :logger
+      attr_accessor :input_content
+      attr_writer :failed_message
+
+      def initialize(input_file, options, logger)
+        @input_file = input_file
+        @options = options
+        @logger = logger
+      end
+
+      def run
+        raise NotImplementedError
+      end
+
+      def failed_message
+        @failed_message || "Reason not specified"
+      end
+
+      private
+
+      def file_processor
+        context = ::AIRefactor::Context.new(files: options[:context_file_paths], text: options[:context_text], logger: logger)
+        prompt = ::AIRefactor::Prompt.new(input_content: input_content, input_path: input_file, output_file_path: output_file_path, prompt: prompt_input, context: context, logger: logger, options: options)
+        AIRefactor::FileProcessor.new(prompt: prompt, ai_client: ai_client, output_path: output_file_path, logger: logger, options: options)
+      end
+
+      def process!(strip_ticks: true)
+        processor = file_processor
+
+        if processor.output_exists?
+          return false unless overwrite_existing_output?(output_file_path)
+        end
+
+        logger.verbose "Processing #{input_file}..."
+
+        begin
+          output_content, finished_reason, usage = processor.process! do |content|
+            if block_given?
+              yield content
+            elsif strip_ticks
+              content.gsub("```ruby", "").gsub("```", "")
+            else
+              content
+            end
+          end
+
+          logger.verbose "AI finished, with reason '#{finished_reason}'..."
+          logger.verbose "Used tokens: #{usage["total_tokens"]}".colorize(:light_black) if usage
+          if finished_reason == "length"
+            logger.warn "Translation may contain an incomplete output as the max token length was reached. You can try using the '--continue' option next time to increase the length of generated output."
+          end
+
+          if !output_content || output_content.length == 0
+            logger.warn "Skipping #{input_file}, no translated output..."
+            logger.error "Failed to translate #{input_file}, finished reason #{finished_reason}"
+            self.failed_message = "AI conversion failed, no output was generated"
+            raise NoOutputError, "No output"
+          end
+
+          output_content
+        rescue => e
+          logger.error "Request to AI failed: #{e.message}"
+          puts e.backtrace
+          logger.warn "Skipping #{input_file}..."
+          self.failed_message = "Request to OpenAI failed"
+          raise e
+        end
+      end
+
+      def overwrite_existing_output?(output_path)
+        overwrite = options && options[:overwrite]&.downcase
+        answer = if ["y", "n"].include? overwrite
+          overwrite
+        else
+          logger.info "Do you wish to overwrite #{output_path}? (y/n)"
+          $stdin.gets.chomp.downcase
+        end
+        if answer == "y"
+          logger.verbose "Overwriting #{output_path}..."
+          return true
+        end
+        logger.warn "Skipping #{input_file}..."
+        self.failed_message = "Skipped as output file already exists"
+        false
+      end
+
+      def prompt_input
+        if options && options[:prompt]&.length&.positive?
+          return options[:prompt]
+        end
+
+        file = if options && options[:prompt_file_path]&.length&.positive?
+          options[:prompt_file_path]
+        else
+          location = Module.const_source_location(::AIRefactor::Refactors::BaseRefactor.name)
+          File.join(File.dirname(location.first), "#{refactor_name}.md")
+        end
+        file.tap do |prompt|
+          raise "No prompt file '#{prompt}' found for #{refactor_name}" unless File.exist?(prompt)
+        end
+
+        File.read(file)
+      end
+
+      def output_file_path
+        @output_file_path ||= determine_output_file_path
+      end
+
+      def determine_output_file_path
+        return output_file_path_from_template if output_template_path
+
+        path = options[:output_file_path]
+        return default_output_path unless path
+
+        if path == true
+          input_file
+        else
+          path
+        end
+      end
+
+      def default_output_path
+        nil
+      end
+
+      def output_template_path
+        options[:output_template_path]
+      end
+
+      def output_file_path_from_template
+        path = output_template_path.gsub("[FILE]", File.basename(input_file))
+          .gsub("[NAME]", File.basename(input_file, ".*"))
+          .gsub("[DIR]", File.dirname(input_file))
+          .gsub("[REFACTOR]", self.class.refactor_name)
+          .gsub("[EXT]", File.extname(input_file))
+        raise "Output template could not be used" unless path.length.positive?
+        path
+      end
+
+      def ai_client
+        @ai_client ||= OpenAI::Client.new
+      end
+
+      def refactor_name
+        self.class.refactor_name
+      end
+
+      class << self
+        def command_line_options
+          []
+        end
+
+        def refactor_name
+          name.gsub("AIRefactor::Refactors::", "")
+            .gsub(/::/, "/")
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr("-", "_")
+            .downcase
+        end
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/custom.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Refactors
+    class Custom < BaseRefactor
+      def run
+        logger.verbose "Custom refactor to #{input_file}... (using user supplied prompt #{prompt_file_path})"
+        logger.verbose "Write output to #{output_file_path}..." if output_file_path
+
+        begin
+          output_content = process!(strip_ticks: false)
+        rescue => e
+          logger.error "Failed to process #{input_file}: #{e.message}"
+          return false
+        end
+
+        return false unless output_content
+
+        output_file_path ? true : output_content
+      end
+
+      def self.description
+        "Generic refactor using user supplied prompt"
+      end
+
+      private
+
+      def prompt_file_path
+        specified_prompt_path = options[:prompt_file_path]
+        if specified_prompt_path&.length&.positive?
+          if File.exist?(specified_prompt_path)
+            return specified_prompt_path
+          else
+            logger.error "No prompt file '#{specified_prompt_path}' found"
+          end
+        else
+          logger.error "No prompt file was specified!"
+        end
+        exit 1
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/minitest/write_test_for_class.md

@@ -0,0 +1,15 @@
+You are an expert Ruby senior software developer. Write a unit test for the class show below, using minitest and minitest/mock if necessary.
+Test 100% of the code. 
+
+The path to the file to test is: __{{input_file_path}}__
+The output file path is: __{{output_file_path}}__
+
+__{{prompt_header}}__
+
+Only show me the test file code. Do NOT provide any other description of your work. Always enclose the output code in triple backticks (```).
+
+__{{context}}__
+
+__{{prompt_footer}}__
+
+The class to test is:

data/lib/ai_refactor/refactors/minitest/write_test_for_class.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Refactors
+    module Minitest
+      class WriteTestForClass < BaseRefactor
+        def run
+          logger.verbose "'Write minitest test' refactor for #{input_file}..."
+          logger.verbose "Write output to #{output_file_path}..." if output_file_path
+
+          begin
+            output_content = process!
+          rescue => e
+            logger.error "Failed to process #{input_file}: #{e.message}"
+            return false
+          end
+
+          return false unless output_file_path
+
+          logger.verbose "Generated #{output_file_path} from #{input_file} ..." if output_content
+
+          minitest_runner = AIRefactor::TestRunners::MinitestRunner.new(output_file_path, command_template: "bundle exec ruby __FILE__")
+
+          logger.verbose "Run generated test file #{output_file_path} (#{minitest_runner.command})..."
+          test_run = minitest_runner.run
+
+          if test_run.failed?
+            logger.warn "#{input_file} was translated to #{output_file_path} but the resulting test is failing..."
+            logger.error "Failed to run test, exited with status #{test_run.exitstatus}. Stdout: #{test_run.stdout}\n\nStderr: #{test_run.stderr}\n\n"
+            logger.error "New test failed!", bold: true
+            self.failed_message = "Generated test file failed to run correctly"
+            return false
+          end
+
+          logger.verbose "\nNew test file ran and returned the following results:"
+          logger.verbose ">> Runs: #{test_run.example_count}, Failures: #{test_run.failure_count}, Skips: #{test_run.pending_count}\n"
+
+          output_file_path ? true : output_content
+        end
+
+        def self.description
+          "Write a minitest test for a class"
+        end
+
+        def default_output_path
+          File.join("test", input_file.gsub(/\.rb$/, "_test.rb"))
+        end
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/project/write_changelog_from_history.md

@@ -0,0 +1,35 @@
+You are a senior Ruby software developer. You are diligent about writing clear changelogs for your users.
+
+You have a git history of changes to your project. You want to write a changelog from this history.
+
+The format of the changelog you will create entries for is from keepachangelog.com version 1.0.0.
+
+Here is an example of a set of changelog entries:
+
+```
+## [0.2.0] - 2015-10-06
+
+### Changed
+
+- Remove exclusionary mentions of "open source" since this project can
+  benefit both "open" and "closed" source projects equally.
+
+## [0.1.0] - 2015-10-06
+
+### Added
+
+- Answer "Should you ever rewrite a change log?".
+
+### Changed
+
+- Improve argument against commit logs.
+- Start following [SemVer](https://semver.org) properly.
+
+### Fixed
+
+- Fix typos in recent CHANGELOG entries.
+```
+
+If the history contains any mention of changes of version (such as "Bump version to 1.0.0"), then you should use that version number in a new changelog entry.
+
+Now write changelog entries from the following git history.

data/lib/ai_refactor/refactors/project/write_changelog_from_history.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Refactors
+    module Project
+      class WriteChangelogFromHistory < BaseRefactor
+        def self.description
+          "Write changelog entries from the git history"
+        end
+
+        def self.takes_input_files?
+          false
+        end
+
+        def run
+          logger.verbose "Creating changelog entries for project from #{options[:git_commit_count] || 3} commits..."
+          logger.verbose "Write output to #{output_file_path}..." if output_file_path
+
+          self.input_content = `git log -#{options[:git_commit_count] || 3} --pretty=format:"%ci %d %s"`.split("\n").map { |line| "- #{line}" }.join("\n")
+          logger.debug "\nInput messages: \n#{input_content}\n\n"
+          begin
+            output_content = process!(strip_ticks: false)
+          rescue => e
+            logger.error "Failed to process: #{e.message}"
+            return false
+          end
+
+          return false unless output_content
+
+          output_file_path ? true : output_content
+        end
+
+        def default_output_path
+          nil
+        end
+
+        def self.command_line_options
+          [
+            {
+              key: :git_commit_count,
+              long: "--commits N",
+              type: Integer,
+              help: "The number of commits to analyse when creating the changelog entries (defaults to 3)"
+            }
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/{prompts/rspec_to_minitest_rails.md → rails/minitest/rspec_to_minitest.md}

@@ -1,8 +1,8 @@
+You are an expert software developer. 
 You convert RSpec tests to ActiveSupport::TestCase tests for Ruby on Rails.
 ActiveSupport::TestCase uses MiniTest under the hood.
 Remember that MiniTest does not support `context` blocks, instead these should be removed and the context
 specified in them should be moved directly into the relevant tests.
-Always enclose the output code in triple backticks (```).
 
 Here are some examples to use as a guide:
 
@@ -42,6 +42,10 @@ subject(:model) { create(:order_state) }
 context "when rejected" do
   before { model.rejected_at = 1.day.ago }
 
+  it "should be not valid" do
+    expect(model).not_to be_valid
+  end
+
   context "with reason and message" do
     before do
       model.rejected_message = reason
@@ -68,6 +72,11 @@ setup do
   @reason = "my reason"
 end
 
+test "when rejected, model should be not valid" do
+  @model.rejected_at = 1.day.ago
+  refute @model.valid?
+end
+
 test "when rejected, with reason and message, model should be valid" do
   @model.rejected_at = 1.day.ago
   @model.rejected_message = @reason
@@ -231,3 +240,33 @@ test "stubs any instance" do
   end
 end
 ```
+
+Example 9) RSpec:
+```
+assert_association @model, :message_thread, :belongs_to
+```
+
+Result 9) minitest:
+
+```
+assert_instance_of MessageThread, @model.message_thread
+```
+
+Example 10) RSpec:
+```
+assert_association @model, :message_thread, :belongs_to, optional: true
+```
+
+Result 10) minitest:
+```
+assoc = @model.reflect_on_association(:message_thread)
+refute assoc.nil?, "no association :message_thread"
+assert_equal :belongs_to, assoc.macro
+assert assoc.options[:optional]
+```
+
+__{{context}}__
+
+Only output the refactored class. Do NOT provide any other description of your work. Always enclose the output code in triple backticks (```).
+
+Convert this Rspec file to minitest:

data/lib/ai_refactor/refactors/rails/minitest/rspec_to_minitest.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Refactors
+    module Rails
+      module Minitest
+        class RspecToMinitest < BaseRefactor
+          def run
+            spec_runner = AIRefactor::TestRunners::RSpecRunner.new(input_file, command_template: options.rspec_run_command)
+            logger.verbose "Run spec #{input_file}... (#{spec_runner.command})"
+
+            spec_run = spec_runner.run
+
+            if spec_run.failed?
+              logger.warn "Skipping #{input_file}..."
+              logger.error "Failed to run #{input_file}, exited with status #{spec_run.exitstatus}. Stdout: #{spec_run.stdout}\n\nStderr: #{spec_run.stderr}\n\n"
+              self.failed_message = "Failed to run RSpec file, has errors"
+              return false
+            end
+
+            logger.debug "\nOriginal test run results:"
+            logger.debug ">> Examples: #{spec_run.example_count}, Failures: #{spec_run.failure_count}, Pendings: #{spec_run.pending_count}\n"
+
+            begin
+              result = process!
+            rescue AIRefactor::NoOutputError => _e
+              return false
+            rescue => e
+              logger.error "Failed to convert #{input_file} to Minitest, error: #{e.message}"
+              return false
+            end
+
+            logger.verbose "Converted #{input_file} to #{output_file_path}..." if result
+
+            minitest_runner = AIRefactor::TestRunners::MinitestRunner.new(output_file_path, command_template: options.minitest_run_command)
+
+            logger.verbose "Run generated test file #{output_file_path} (#{minitest_runner.command})..."
+            test_run = minitest_runner.run
+
+            if test_run.failed?
+              logger.warn "Skipping #{input_file}..."
+              logger.error "Failed to run translated #{output_file_path}, exited with status #{test_run.exitstatus}. Stdout: #{test_run.stdout}\n\nStderr: #{test_run.stderr}\n\n"
+              logger.error "Conversion failed!", bold: true
+              self.failed_message = "Generated test file failed to run correctly"
+              return false
+            end
+
+            logger.debug "\nTranslated test file results:"
+            logger.debug ">> Runs: #{test_run.example_count}, Failures: #{test_run.failure_count}, Skips: #{test_run.pending_count}\n"
+
+            report = AIRefactor::TestRunners::TestRunDiffReport.new(spec_run, test_run)
+
+            if report.no_differences?
+              logger.verbose "Done converting #{input_file} to #{output_file_path}..."
+              logger.success "\nNo differences found! Conversion worked!"
+              true
+            else
+              logger.warn report.diff.colorize(:yellow)
+              logger.verbose "Done converting #{input_file} to #{output_file_path}..."
+              logger.error "\nDifferences found! Conversion failed!", bold: true
+              self.failed_message = "Generated test file run output did not match original RSpec spec run output"
+              false
+            end
+          end
+
+          def self.description
+            "Convert RSpec file to Minitest (for Rails apps)"
+          end
+
+          def default_output_path
+            input_file.gsub("_spec.rb", "_test.rb").gsub("spec/", "test/")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/rspec/minitest_to_rspec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Refactors
+    module Rspec
+      class MinitestToRspec < BaseRefactor
+        def run
+          raise "Not implemented"
+        end
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/ruby/refactor_ruby.md

@@ -0,0 +1,10 @@
+__{{context}}__
+
+__{{prompt_header}}__
+
+The input file is: __{{input_file_path}}__
+The output file path is: __{{output_file_path}}__
+
+__{{content}}__
+
+__{{prompt_footer}}__

data/lib/ai_refactor/refactors/ruby/refactor_ruby.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Refactors
+    module Ruby
+      class RefactorRuby < Custom
+        def run
+          logger.verbose "Custom refactor to #{input_file}... (using user supplied prompt #{prompt_file_path})"
+          logger.verbose "Write output to #{output_file_path}..." if output_file_path
+
+          begin
+            output_content = process!(strip_ticks: true)
+          rescue => e
+            logger.error "Failed to process #{input_file}: #{e.message}"
+            return false
+          end
+
+          return false unless output_content
+
+          output_file_path ? true : output_content
+        end
+
+        def self.description
+          "Generic refactor using user supplied prompt (assumes Ruby code generation)"
+        end
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors/ruby/write_ruby.md

@@ -0,0 +1,7 @@
+__{{context}}__
+
+__{{prompt_header}}__
+
+__{{content}}__
+
+__{{prompt_footer}}__

data/lib/ai_refactor/refactors/ruby/write_ruby.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Refactors
+    module Ruby
+      class WriteRuby < Custom
+        def run
+          logger.verbose "Write some ruby code... (using user supplied prompt #{prompt_file_path})"
+          logger.verbose "Write output to #{output_file_path}..." if output_file_path
+
+          begin
+            output_content = process!(strip_ticks: true)
+          rescue => e
+            logger.error "Failed to process #{input_file}: #{e.message}"
+            return false
+          end
+
+          return false unless output_content
+
+          output_file_path ? true : output_content
+        end
+
+        def self.takes_input_files?
+          false
+        end
+
+        def self.description
+          "User supplied prompt to write Ruby code"
+        end
+      end
+    end
+  end
+end

data/lib/ai_refactor/refactors.rb

@@ -2,6 +2,11 @@
 
 module AIRefactor
   module Refactors
+    def register(klass)
+      all[klass.refactor_name] = klass
+    end
+    module_function :register
+
     def get(name)
       all[name]
     end
@@ -12,16 +17,19 @@ module AIRefactor
     end
     module_function :names
 
-    def all
-      @all ||= constants.map { |n| const_get(n) }.select { |c| c.is_a? Class }.each_with_object({}) do |klass, hash|
-        hash[klass.refactor_name] = klass
-      end
+    def descriptions
+      names.map { |n| "\"#{n}\"" }.zip(all.values.map(&:description)).to_h
     end
-    module_function :all
+    module_function :descriptions
 
     def supported?(name)
       names.include?(name)
     end
     module_function :supported?
+
+    def all
+      @all ||= {}
+    end
+    module_function :all
   end
 end