ai_refactor 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f916993ff53967b44cbbc81138c87d518518618d3edc932cefa6aea9f0a4c4c
-  data.tar.gz: 5d3bd3b9cea6d7bd39e0028caa5ccf24527dd03fcd98d643498a65743a2cac5e
+  metadata.gz: ca299458e2af2bc7ba495ce6473e1e6b1824e679893815616a209697178aefbd
+  data.tar.gz: b13da64462ef3f5572a9afebb0020ecdb5adc538b92e7c80b3b6bbd756473f9d
 SHA512:
-  metadata.gz: 41cb1f31ceb6e503cdbeeb972f17a91e1826eccb4fb66e8a73b3b54bb3899ff9572d9cb4783c67fe7e7fee8999f7f25f2b19ae7ab9fde6c766e895e4fb4a1b32
-  data.tar.gz: 57626f38b266521d820bb411dbf517dd3273ed6e4bd44412d4c4e4b0306a3347252a1b87d0214c148f5f5e35c20cd81c6325648f878dd34d67fe58226156118d
+  metadata.gz: 5714f5535a9a6436beba5a6b33a79a0eb02c095f4ca93a5cdfd794fc231cdcab6341a87565fc8c9f32ef24e1edf35957d5268b48f259c2046f867d722520760a
+  data.tar.gz: d986828235c4f26ba78a443ca267455be12d2b9647b672f7cb8a4f4ce53eed5f02c426f626531a9d567058ad8f3e4a34f0c43072529820ca803719542ea0c9e0

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # AI Refactor Changelog
 
+
+## [0.5.4] - 2024-02-07
+
+### Added
+- Support for built-in command YML files to make it easy to add new refactors
+- Support for specifying context files from gems with `context_file_paths_from_gems:` key in command templates
+- Command to convert Minitest tests to Quickdraw tests
+
+### Changes
+- Default openAI model is now `gpt-4-turbo-preview`
+
+## [0.5.3] - 2024-02-06
+
+### Added
+- Add runner to run steep on inputs after generating RBS
+- Add refactor to write RBS
+
+### Fixed
+- Removed dependency on `dotenv` gems
+- Update openai dependency
+- Improve prompt handling to allow having custom text prompts from commands that can append to build in prompt templates
+- Custom refactor should allow prompt to come from prompt text option
+
+## [0.5.2] - 2023-09-21
+
+### Added
+
+### Fixed
+- Removed `puts`
+
 ## [0.5.1] - 2023-09-21
 
 ### Added

data/README.md

@@ -49,8 +49,7 @@ And find the file `examples/ex1_input_test.rb` has been created. Note the proces
 
 If you see an error, then try to run it again, or use a different GPT model.
 
-
-## Available refactors
+## Available refactors & commands
 
 Write your own prompt:
 
@@ -107,6 +106,14 @@ For example, if the input file is `app/stuff/my_thing.rb` the output will be wri
 This refactor can benefit from being passed related files as context, for example, if the class under test inherits from another class,
 then context can be used to provide the parent class.
 
+### `quickdraw/0.1.0/convert_minitest`
+
+Convert Minitest or Test::Unit test suite files to [Quickdraw](https://github.com/joeldrapper/quickdraw) test suite files.
+
+Files, by default, are output to the same directory as the input file but with .test.rb extension (and _test removed).
+
+Note: Quickdraw is still missing some features, so some minitest methods are not converted, for example, Quickdraw does not support setup/teardown just yet.
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -134,7 +141,7 @@ Where REFACTOR_TYPE_OR_COMMAND_FILE is either the path to a command YML file, or
     -p, --prompt PROMPT_FILE         Specify path to a text file that contains the ChatGPT 'system' prompt.
     -f, --diffs                      Request AI generate diffs of changes rather than writing out the whole file.
     -C, --continue [MAX_MESSAGES]    If ChatGPT stops generating due to the maximum token count being reached, continue to generate more messages, until a stop condition or MAX_MESSAGES. MAX_MESSAGES defaults to 3
-    -m, --model MODEL_NAME           Specify a ChatGPT model to use (default gpt-4).
+    -m, --model MODEL_NAME           Specify a ChatGPT model to use (default gpt-4-turbo-preview).
         --temperature TEMP           Specify the temperature parameter for ChatGPT (default 0.7).
         --max-tokens MAX_TOKENS      Specify the max number of tokens of output ChatGPT can generate. Max will depend on the size of the prompt (default 1500)
     -t, --timeout SECONDS            Specify the max wait time for ChatGPT response.
@@ -180,7 +187,7 @@ context_text: |
     Some extra info to prepend to the prompt
 diff: true/false (default false)
 ai_max_attempts: max times to generate more if AI does not complete generating (default 3)
-ai_model: ChatGPT model name (default gpt-4)
+ai_model: ChatGPT model name (default gpt-4-turbo-preview)
 ai_temperature: ChatGPT temperature (default 0.7)
 ai_max_tokens: ChatGPT max tokens (default 1500)
 ai_timeout: ChatGPT timeout (default 60)

data/commands/quickdraw/0.1.0/convert_minitest.yml

@@ -0,0 +1,194 @@
+# Convert Minitest or Test::Unit test suite files to Quickdraw test suite files.
+#
+# Files are output to the same directory as the input file but with .test.rb extension (and _test removed).
+# Quickdraw is still missing some features, so some minitest methods are not converted. Also
+# Quickdraw does not support setup/teardown just yet.
+
+refactor: ruby/refactor_ruby
+description: Convert Minitest or Test::Unit test suite files to Quickdraw test suite files.
+output_template_path: "[DIR]/[NAME|_test|].test[EXT]"
+context_file_paths_from_gems:
+  quickdraw:
+    - "lib/quickdraw/matchers/boolean.rb"
+    - "lib/quickdraw/matchers/case_equality.rb"
+    - "lib/quickdraw/matchers/change.rb"
+    - "lib/quickdraw/matchers/equality.rb"
+    - "lib/quickdraw/matchers/include.rb"
+    - "lib/quickdraw/matchers/predicate.rb"
+    - "lib/quickdraw/matchers/respond_to.rb"
+    - "lib/quickdraw/matchers/to_be_a.rb"
+    - "lib/quickdraw/matchers/to_have_attributes.rb"
+prompt: |
+  You are an expert Ruby senior software developer. You convert minitest or Test::Unit test suite files to Quickdraw test suite files.
+
+  Quickdraw is a new test framework for Ruby:
+  
+  - Spec-like DSL, but with just five methods: `describe`, `test` and `expect`, `assert`, `refute`. No `context`, `let`, `subject`, `to`, `it`, `is_expected` or `specify`, and you’ll never need to guess whether the next symbol should be a space, a colon, a dot or an underscore.
+  - No chaining on matchers. Rather than chain, the matcher can yield if it wants to allow for more complex matching.
+  - Auto-loaded configuration, so you never need to `require "test_helper"`.
+  - Scoped execution, so you can define methods and constants at the top level without worrying about collisions.
+  - You can define your own matchers, which can be scoped to a specific type of object and they can be overloaded for different types.
+  - Designed to take advantage of all your CPU cores — by default it runs one process per CPU core and two threads per process.
+  - Optional test names — sometimes the code is so clear, you don’t need names.
+  - Make as many expectations as you want in a test. You’ll get a dot for each one to make you feel good about youtself.
+  
+  > [!TIP]
+  > Your test files are executed in an anonymous class, so you can define methods and constants at the top level without worrying about collisions. If you’re testing something that references `Class#name`, you may have to define those classes as fixtures somewhere else.
+  
+  ### `.test`
+  Use the `test` method to define a test. The description is optional — sometimes you don’t need it.
+  
+  ```ruby
+  test { assert true }
+  ```
+  
+  You can pass `skip: true` to skip the test. Skipped tests are still run; they pass if they fail and fail they pass.
+  
+  ```ruby
+  test(skip: true) { assert false }
+  ```
+  
+  ### `.describe`
+  You can optionally wrap tests in any number of `describe` blocks, which can take a description as a string or module/class.
+  
+  ```ruby
+  describe Thing do
+    # your Thing tests here
+  end
+  ```
+  
+  ### `#assert`
+  `assert` takes a value and passes if it’s truthy.
+  
+  ```ruby
+  test "something" do
+    assert true
+  end
+  ```
+  
+  You can pass a custom failure message as a block. Using blocks for the failure messages means we don’t waste time constructing them unless the test fails. You don’t need to worry about expensive failure messages slowing down your tests.
+  
+  ```ruby
+  test "something" do
+    assert(false) { "This is a custom failure message" }
+  end
+  ```
+  
+  ### `#refute`
+  `refute` is just like `assert`, but it passes if the value is falsy.
+  
+  ```ruby
+  test "something" do
+    refute false
+  end
+  ```
+  
+  ### `expect` matchers
+  `expect` takes either a value or a block and returns an expectation object, which you can call matchers on.
+  
+  #### `==` and `!=`
+  
+  ```ruby
+  test "equality" do
+    expect(Thing.foo) == "foo"
+    expect(Thing.bar) != "foo"
+  end
+  ```
+  
+  #### `to_raise`
+  
+  ```ruby
+  test "raises" do
+    expect { Thing.bar! }.to_raise(ArgumentError) do |error|
+      expect(error.message) == "Foo bar"
+    end
+  end
+  ```
+  
+  #### `to_receive`
+  
+  ```ruby
+  test "mocks and spies" do
+    expect(Thing).to_receive(:foo) do |a, b, c|
+      # The block receives arguments and can make assertions about them.
+      expect(a) == 1
+      expect(b) != 1
+      assert(c)
+  
+      # Either return a mock response or call the original via `@super`
+      @super.call
+    end
+  
+    Thing.foo(1, 2, 3)
+  end
+  ```
+  
+  ### Mappings of minitest assertions/expectations to quickdraw
+  
+  The minitest test class (which inherits from Test::Unit or Minitest::Test) should be removed from the output, as the
+  quickdraw test class is anonymous and implicit.
+  eg 
+  ```ruby
+  class MyTest < Minitest::Test
+    def test_something
+      assert true
+    end
+  end
+  ```
+  becomes
+  ```ruby
+  test "something" do
+      assert true
+  end
+  ```
+  
+  `should` in Test::Unit is the same as `describe` in Quickdraw.
+  
+  minitest "assert" and "refute" methods are mapped to quickdraw `assert` and `refute` methods.
+  
+  minitest "expect" methods are mapped to quickdraw `expect` methods.
+  
+  below are the mappings of minitest methods to quickdraw methods:
+
+  `_(x).must_be`, `expect(x).must_be :==, 0` or `assert_operator x, :==, 0` becomes `expect(x) == 0`
+  `_(x).must_be`, `expect(x).must_be :>, 0` or `assert_operator x, :>, 0`  becomes `assert(x > 0)`
+  `_(x).must_be`, `expect(x).must_be :empty?` `expect(x).must_be_empty` `assert_empty` becomes `assert(x.empty?)`
+  `_(x).must_equal`, `expect(x).must_equal b` or `assert_equal b, x` becomes `expect(x) == b`
+  `_(x).must_be_close_to`, `expect(x).must_be_close_to 2.99999`, `assert_in_epsilon` or `assert_in_delta` becomes `raise "Not implemented in Quickdraw yet"`
+  `_(x).must_be_same_as`, `expect(x).must_be_same_as b`  and `assert_same` becomes `expect(x).to_equal(b)` 
+  `_(x).must_include`, `expect(x).must_include needle`, `assert_includes x, needle` becomes `expect(x).to_include(needle)`  
+  `_(x).must_be_kind_of`, `expect(x).must_be_kind_of Enumerable` or `assert_kind_of Enumerable, x` becomes `assert(x.kind_of? Enumerable)` 
+  `_(x).must_be_instance_of`, `expect(x).must_be_instance_of Array` or `assert_instance_of Array, x` becomes `assert(x.instance_of? Array)` 
+  `_(x).must_be_nil`, `expect(x).must_be_nil` or `assert_nil` becomes `assert(x == nil)` 
+  `_(x).must_match`, `expect(x).must_match /regex/` , `assert_match x, /regex/` becomes `assert(/regex/ === x)`
+  `_(x).must_respond_to`, `expect(x).must_respond_to msg` or `assert_respond_to x, msg` becomes `expect(x).to_respond_to(msg)` 
+  `_(x).wont_respond_to`, `expect(x).wont_respond_to msg` or `refute_respond_to x, msg` becomes `expect(x).not_to_respond_to(msg)` 
+  `proc { "no stdout or stderr" }.must_output` or `assert_output {}`, proc { "no stdout or stderr" }.must_be_silent` or `assert_silent {}`  becomes `raise "Not implemented in Quickdraw yet"` 
+  `proc { ... }.must_raise exception`  or `assert_raises(exp) {}` becomes `expect {}.to_raise(exp)`
+  `proc { ... }.must_throw sym` or `assert_throws(sym) {}`   becomes `raise "Not implemented in Quickdraw yet"`
+
+  note: there are also `refute_*` methods in minitest, which are mapped to either a `refute(...)` or a #not_to* methods in quickdraw.
+
+  Converting `MiniTest::Spec` to `Quickdraw` as follows (like converting from Spec syntax to Test syntax):
+  
+  `subject {}` becomes
+  ```ruby
+  def subject
+    @subject ||= Thing.new
+  end
+  ```
+  
+  `let(:x) { 1 }` becomes
+  ```ruby
+  def x
+      @x ||= 1
+  end
+  ```
+
+  If any modules are included in the minitest class, then take the contents of the module and add it to the output but remove the wrapping `module`
+  Also remove the `include Module` statement from the output.
+  Also remove the def self.included(base) method from the output.
+  
+  Only show me the test file code. Do NOT provide any other description of your work. Always enclose the output code in triple backticks (```).
+
+  The minitest test to convert is as follows:

data/exe/ai_refactor

@@ -6,8 +6,9 @@ require "openai"
 require "shellwords"
 require_relative "../lib/ai_refactor"
 
-supported_refactors = AIRefactor::Refactors.all
-refactors_descriptions = AIRefactor::Refactors.descriptions
+supported_refactors = AIRefactor::Refactors.all.merge(AIRefactor::Commands.all)
+supported_refactors_names = supported_refactors.keys
+refactors_descriptions = AIRefactor::Refactors.descriptions.merge(AIRefactor::Commands.descriptions)
 
 arguments = ARGV.dup
 
@@ -52,7 +53,7 @@ option_parser = OptionParser.new do |parser|
     run_config.ai_max_attempts = c
   end
 
-  parser.on("-m", "--model MODEL_NAME", String, "Specify a ChatGPT model to use (default gpt-4).") do |m|
+  parser.on("-m", "--model MODEL_NAME", String, "Specify a ChatGPT model to use (default gpt-4-turbo-preview).") do |m|
     run_config.ai_model = m
   end
 
@@ -137,10 +138,9 @@ if arguments.empty? || arguments.all? { |arg| arg.start_with?("-") && !(arg == "
   # For each option that is required but not provided, prompt for it
   # Put the option in arguments to parse with option_parser
   interactive_log.info "Interactive mode started. You can use tab to autocomplete:"
-  predefined_commands = AIRefactor::Refactors.names
 
-  interactive_log.info "Available refactors: #{predefined_commands.join(", ")}\n"
-  command = AIRefactor::Cli.request_input_with_autocomplete("Enter refactor name: ", predefined_commands)
+  interactive_log.info "Available refactors: #{supported_refactors_names.join(", ")}\n"
+  command = AIRefactor::Cli.request_input_with_autocomplete("Enter refactor name: ", supported_refactors_names)
   exit_with_option_error("No refactor name provided.", option_parser) if command.nil? || command.empty?
   initial = [command]
 
@@ -180,10 +180,12 @@ logger = AIRefactor::Logger.new(verbose: run_config.verbose, debug: run_config.d
 logger.info "Also loaded options from '.ai_refactor' file..." if options_from_config_file&.size&.positive?
 
 command_or_file = arguments.shift
-if AIRefactor::CommandFileParser.command_file?(command_or_file)
-  logger.info "Loading refactor command file '#{command_or_file}'..."
+is_built_in_command = AIRefactor::Commands.supported?(command_or_file)
+if is_built_in_command || AIRefactor::CommandFileParser.command_file?(command_or_file)
+  logger.info "Loading #{is_built_in_command ? "built-in" : "custom"} refactor command file '#{command_or_file}'..."
   begin
-    run_config.set!(AIRefactor::CommandFileParser.new(command_or_file).parse)
+    command_file_path = is_built_in_command ? Commands.get(command_name).path : command_or_file
+    run_config.set!(AIRefactor::CommandFileParser.new(command_file_path).parse)
   rescue => e
     exit_with_option_error(e.message, option_parser, logger)
   end

data/lib/ai_refactor/cli.rb

@@ -85,6 +85,9 @@ module AIRefactor
 
         logger.info "AI Refactor #{expanded_inputs.size} files(s)/dir(s) '#{expanded_inputs}' with #{refactorer.refactor_name} refactor\n"
         logger.info "====================\n"
+        if configuration.description
+          logger.info "Description: #{configuration.description}\n"
+        end
 
         return_values = expanded_inputs.map do |file|
           logger.info "Processing #{file}..."

data/lib/ai_refactor/commands.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  module Commands
+    # TODO: support command_line_options
+    BuiltInCommand = Data.define(:name, :description, :path, :command_line_options, :config)
+
+    def get(name)
+      all[name]
+    end
+    module_function :get
+
+    def names
+      all.keys
+    end
+    module_function :names
+
+    def descriptions
+      names.map { |n| "\"#{n}\"" }.zip(all.values.map(&:description)).to_h
+    end
+    module_function :descriptions
+
+    def supported?(name)
+      names.include?(name)
+    end
+    module_function :supported?
+
+    def all
+      @all ||= begin
+        commands = Dir.glob(File.join(__dir__, "../../commands", "**/*.yml")).map do |path|
+          path_to_commands = File.join(__dir__, "../../commands/")
+          name = File.join(File.dirname(path.gsub(path_to_commands, "")), File.basename(path, ".yml")).to_sym
+          config = YAML.safe_load_file(path, permitted_classes: [Symbol], symbolize_names: true, aliases: true)
+          BuiltInCommand.new(name: name, path: path, description: config[:description], config: config, command_line_options: [])
+        end
+        commands.map { |c| [c.name, c] }.to_h
+      end
+    end
+    module_function :all
+  end
+end

data/lib/ai_refactor/file_processor.rb

@@ -62,7 +62,7 @@ module AIRefactor
 
       response = @ai_client.chat(
         parameters: {
-          model: options[:ai_model] || "gpt-4",
+          model: options[:ai_model] || "gpt-4-turbo-preview",
           messages: messages,
           temperature: options[:ai_temperature] || 0.7,
           max_tokens: options[:ai_max_tokens] || 1500

data/lib/ai_refactor/run_configuration.rb

@@ -8,10 +8,12 @@ module AIRefactor
     end
 
     attr_reader :refactor,
+      :description,
       :input_file_paths,
       :output_file_path,
       :output_template_path,
       :context_file_paths,
+      :context_file_paths_from_gems,
       :context_text,
       :review_prompt,
       :prompt,
@@ -33,7 +35,7 @@ module AIRefactor
       end
     end
 
-    attr_writer :refactor
+    attr_writer :refactor, :description
 
     # @deprecated
     def [](key)
@@ -56,6 +58,25 @@ module AIRefactor
       @context_file_paths.concat(paths)
     end
 
+    # A hash is passed in, where the keys are gem names that should be in the bundle and the path is a path inside the gem
+    # install location. We resolve the absolute path of each and then add to @context_file_paths
+    def context_file_paths_from_gems=(paths)
+      @context_file_paths ||= []
+      @context_file_paths_from_gems ||= {}
+      @context_file_paths_from_gems.merge!(paths)
+
+      paths.each do |gem_name, paths|
+        paths = [paths] unless paths.is_a?(Array)
+        paths.each do |path|
+          gem_spec = Gem::Specification.find_by_name(gem_name.to_s)
+          raise "Gem #{gem_name} not found" unless gem_spec
+          gem_path = gem_spec.gem_dir
+          full_path = File.join(gem_path, path)
+          @context_file_paths << full_path
+        end
+      end
+    end
+
     def context_text=(text)
       @context_text ||= ""
       @context_text += text
@@ -81,7 +102,7 @@ module AIRefactor
     end
 
     def ai_model=(value)
-      @ai_model = value || "gpt-4"
+      @ai_model = value || "gpt-4-turbo-preview"
     end
 
     def ai_temperature=(value)

data/lib/ai_refactor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AIRefactor
-  VERSION = "0.5.3"
+  VERSION = "0.5.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ai_refactor
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - Stephen Ierodiaconou
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-06 00:00:00.000000000 Z
+date: 2024-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -89,6 +89,7 @@ files:
 - Rakefile
 - Steepfile
 - ai_refactor.gemspec
+- commands/quickdraw/0.1.0/convert_minitest.yml
 - examples/ex1_convert_a_rspec_test_to_minitest.yml
 - examples/ex1_input_spec.rb
 - examples/ex2_input.rb
@@ -99,6 +100,7 @@ files:
 - lib/ai_refactor.rb
 - lib/ai_refactor/cli.rb
 - lib/ai_refactor/command_file_parser.rb
+- lib/ai_refactor/commands.rb
 - lib/ai_refactor/context.rb
 - lib/ai_refactor/file_processor.rb
 - lib/ai_refactor/logger.rb