ai_refactor 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f916993ff53967b44cbbc81138c87d518518618d3edc932cefa6aea9f0a4c4c
-  data.tar.gz: 5d3bd3b9cea6d7bd39e0028caa5ccf24527dd03fcd98d643498a65743a2cac5e
+  metadata.gz: 8bd5fdbe52b59e22f97921422925d317e01e05355bc4af0baa9ae17952e5f4d1
+  data.tar.gz: ee025ff41eaf40421288c66b737336f61d24a9951f80f48d968a72b0c4f99554
 SHA512:
-  metadata.gz: 41cb1f31ceb6e503cdbeeb972f17a91e1826eccb4fb66e8a73b3b54bb3899ff9572d9cb4783c67fe7e7fee8999f7f25f2b19ae7ab9fde6c766e895e4fb4a1b32
-  data.tar.gz: 57626f38b266521d820bb411dbf517dd3273ed6e4bd44412d4c4e4b0306a3347252a1b87d0214c148f5f5e35c20cd81c6325648f878dd34d67fe58226156118d
+  metadata.gz: fe1321b14189e4043ceea64457126cdf0f39a387a3568aca51a9ff0e8a5e76837ae551b20f83363ad97699b69e5c5a0823b71a0d40aedcceec7ef19a9cf2b5bf
+  data.tar.gz: 910dba4e7bccf116a1122d0e06a1b2d92406288c6200dac5f3bdbd943c66ae5696b73e88abb75ce02ce46eaad06d5d0529015a6042e28ac63af26525b5b2ac9f

data/CHANGELOG.md

@@ -1,5 +1,52 @@
 # AI Refactor Changelog
 
+## [Unreleased]
+
+### Changes
+
+
+## [0.6.0] - 2024-06-19
+
+### Added
+
+- Now supports Anthropic AI models. Eg pass `-m claude-3-opus-20240229` to use the current Claude Opus model.
+
+### Changes
+- Default openAI model is now `gpt-4-turbo`
+
+### Fixed
+
+- example test run should use `bundle exec` to ensure the correct version of the gem is used.
+
+## [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

@@ -2,20 +2,25 @@
 
 __The goal for AIRefactor is to use LLMs to apply repetitive refactoring tasks to code.__
 
-First the human decides what refactoring is needed and builds up a prompt to describe the task, or uses one of AIRefactors provided prompts.
+## The workflow
 
-AIRefactor then helps to apply the refactoring to one or more files.
+1) the human decides what refactoring is needed
+2) the human selects an existing built-in refactoring command, and/or builds up a prompt to describe the task
+3) the human selects some source files to act as context (eg examples of the code post-refactor, or related classes etc)
+4) the human runs the tool with the command, source files and context files
+5) the AI generates the refactored code and outputs it either to a file or stdout.
+6) In some cases, the tool can then check the generated code by running tests and comparing test outputs.
 
-In some cases, the tool can then check the generated code by running tests and comparing test outputs.
+AIRefactor can apply the refactoring to multiple files, allowing batch processing.
 
 #### Notes
 
 AI Refactor is an experimental tool and under active development as I explore the idea myself. It may not work as expected, or
 change in ways that break existing functionality.
 
-The focus of the tool is work with the Ruby programming language ecosystem, but it can be used with any language.
+The focus of the tool is work with the **Ruby programming language ecosystem**, but it can be used with any language.
 
-AI Refactor currently uses [OpenAI's ChatGPT](https://platform.openai.com/).
+AI Refactor currently uses [OpenAI's ChatGPT](https://platform.openai.com/) or [Anthropic Claude](https://docs.anthropic.com/en/docs/about-claude/models) to generate code.
 
 ## Examples
 
@@ -49,8 +54,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:
 
@@ -65,7 +69,9 @@ Use a pre-built prompt:
 
 ### User supplied prompts, eg `custom`, `ruby/write_ruby` and `ruby/refactor_ruby`
 
-Applies the refactor specified by prompting the AI with the user supplied prompt. You must supply a prompt file with the `-p` option.
+You can use these commands in conjunction with a user supplied prompt. 
+
+You must supply a prompt file with the `-p` option.
 
 The output is written to `stdout`, or to a file with the `--output` option.
 
@@ -107,6 +113,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 +148,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).
         --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.
@@ -171,19 +185,26 @@ output_file_path: output file or directory
 output_template_path: output file template (see docs)
 prompt_file_path: path
 prompt: |
-  A custom prompt to send to ChatGPT if the command needs it (otherwise read from file)
+  A custom prompt to send to AI if the command needs it (otherwise read from file)
 context_file_paths: 
     - file1.rb
     - file2.rb
+context_file_paths_from_gems:
+  gem_name: 
+    - path/from/gem_root/file1.rb
+    - lib/gem_name/file2.rb
+  gem_name2: 
+    - lib/gem_name2/file1.rb
+    - app/controllers/file2.rb
 # Other configuration options:
 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_temperature: ChatGPT temperature (default 0.7)
-ai_max_tokens: ChatGPT max tokens (default 1500)
-ai_timeout: ChatGPT timeout (default 60)
+ai_model: AI model name, OpenAI GPT or Anthropic Claude (default gpt-4-turbo)
+ai_temperature: AI temperature (default 0.7)
+ai_max_tokens: AI max tokens (default 1500)
+ai_timeout: AI timeout (default 60)
 overwrite: y/n/a (default a)
 verbose: true/false (default false)
 debug: true/false (default false)
@@ -247,12 +268,6 @@ This file provides default CLI switches to add to any `ai_refactor` command.
 
 The tool keeps a history of commands run in the `.ai_refactor_history` file in the current working directory.
 
-## Note on performance and ChatGPT version
-
-_The quality of results depend very much on the version of ChatGPT being used._
-
-I have tested with both 3.5 and 4 and see **significantly** better performance with version 4.
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/ai_refactor.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description = "Use OpenAI's ChatGPT to automate converting Rails RSpec tests to minitest (ActiveSupport::TestCase)."
   spec.homepage = "https://github.com/stevegeek/ai_refactor"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.7.0"
+  spec.required_ruby_version = ">= 3.3.0"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/stevegeek/ai_refactor"
@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(__dir__) do
     `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ examples/ .github/ .git .circleci appveyor])
     end
   end
   spec.bindir = "exe"
@@ -32,5 +32,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency "colorize", "< 2.0"
   spec.add_dependency "open3", "< 2.0"
   spec.add_dependency "ruby-openai", ">= 3.4.0", "< 6.0"
+  spec.add_dependency "anthropic", ">= 0.1.0", "< 1.0"
   spec.add_dependency "zeitwerk", "~> 2.6"
 end

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

@@ -3,11 +3,13 @@
 require "optparse"
 require "colorize"
 require "openai"
+require "anthropic"
 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
 
@@ -36,11 +38,11 @@ option_parser = OptionParser.new do |parser|
     run_config.context_text = c
   end
 
-  parser.on("-r", "--review-prompt", "Show the prompt that will be sent to ChatGPT but do not actually call ChatGPT or make changes to files.") do
+  parser.on("-r", "--review-prompt", "Show the prompt that will be sent to the AI but do not actually call the AI or make changes to files.") do
     run_config.review_prompt = true
   end
 
-  parser.on("-p", "--prompt PROMPT_FILE", String, "Specify path to a text file that contains the ChatGPT 'system' prompt.") do |f|
+  parser.on("-p", "--prompt PROMPT_FILE", String, "Specify path to a text file that contains the AI 'system' prompt.") do |f|
     run_config.prompt_file_path = f
   end
 
@@ -48,23 +50,23 @@ option_parser = OptionParser.new do |parser|
     run_config.diff = true
   end
 
-  parser.on("-C", "--continue [MAX_MESSAGES]", Integer, "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") do |c|
+  parser.on("-C", "--continue [MAX_MESSAGES]", Integer, "If AI 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") do |c|
     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 AI model to use (default 'gpt-4-turbo'). OpenAI and Anthropic models supported (eg 'gpt-4o', 'claude-3-opus-20240229')") do |m|
     run_config.ai_model = m
   end
 
-  parser.on("--temperature TEMP", Float, "Specify the temperature parameter for ChatGPT (default 0.7).") do |p|
+  parser.on("--temperature TEMP", Float, "Specify the temperature parameter for generation (default 0.7).") do |p|
     run_config.ai_temperature = p
   end
 
-  parser.on("--max-tokens MAX_TOKENS", Integer, "Specify the max number of tokens of output ChatGPT can generate. Max will depend on the size of the prompt (default 1500)") do |m|
+  parser.on("--max-tokens MAX_TOKENS", Integer, "Specify the max number of tokens of output the AI can generate. Max will depend on the size of the prompt (default 1500)") do |m|
     run_config.ai_max_tokens = m
   end
 
-  parser.on("-t", "--timeout SECONDS", Integer, "Specify the max wait time for ChatGPT response.") do |m|
+  parser.on("-t", "--timeout SECONDS", Integer, "Specify the max wait time for an AI response.") do |m|
     run_config.ai_timeout = m
   end
 
@@ -137,10 +139,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 +181,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/ai_client.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  class AIClient
+    def initialize(platform: "openai", model: "gpt-4-turbo", temperature: 0.7, max_tokens: 1500, timeout: 60, verbose: false)
+      @platform = platform
+      @model = model
+      @temperature = temperature
+      @max_tokens = max_tokens
+      @timeout = timeout
+      @verbose = verbose
+      @client = configure
+    end
+
+    def generate!(messages)
+      finished_reason, content, response = case @platform
+      when "openai"
+        openai_parse_response(
+          @client.chat(
+            parameters: {
+              messages: messages,
+              model: @model,
+              temperature: @temperature,
+              max_tokens: @max_tokens
+            }
+          )
+        )
+      when "anthropic"
+        anthropic_parse_response(
+          @client.messages(
+            parameters: {
+              system: messages.find { |m| m[:role] == "system" }&.fetch(:content, nil),
+              messages: messages.select { |m| m[:role] != "system" },
+              model: @model,
+              max_tokens: @max_tokens
+            }
+          )
+        )
+      else
+        raise "Invalid platform: #{@platform}"
+      end
+      yield finished_reason, content, response
+    end
+
+    private
+
+    def configure
+      case @platform
+      when "openai"
+        ::OpenAI::Client.new(
+          access_token: ENV.fetch("OPENAI_API_KEY"),
+          organization_id: ENV.fetch("OPENAI_ORGANIZATION_ID", nil),
+          request_timeout: @timeout,
+          log_errors: @verbose
+        )
+      when "anthropic"
+        ::Anthropic::Client.new(
+          access_token: ENV.fetch("ANTHROPIC_API_KEY"),
+          request_timeout: @timeout
+        )
+      else
+        raise "Invalid platform: #{@platform}"
+      end
+    end
+
+    def openai_parse_response(response)
+      if response["error"]
+        raise StandardError.new("OpenAI error: #{response["error"]["type"]}: #{response["error"]["message"]} (#{response["error"]["code"]})")
+      end
+
+      content = response.dig("choices", 0, "message", "content")
+      finished_reason = response.dig("choices", 0, "finish_reason")
+      [finished_reason, content, response]
+    end
+
+    def anthropic_parse_response(response)
+      if response["error"]
+        raise StandardError.new("Anthropic error: #{response["error"]["type"]}: #{response["error"]["message"]}")
+      end
+
+      content = response.dig("content", 0, "text")
+      finished_reason = response["stop_reason"] == "max_tokens" ? "length" : response["stop_reason"]
+      [finished_reason, content, response]
+    end
+  end
+end

data/lib/ai_refactor/cli.rb

@@ -63,6 +63,17 @@ module AIRefactor
       configuration.input_file_paths
     end
 
+    def ai_client
+      @ai_client ||= AIRefactor::AIClient.new(
+        platform: configuration.ai_platform,
+        model: configuration.ai_model,
+        temperature: configuration.ai_temperature,
+        max_tokens: configuration.ai_max_tokens,
+        timeout: configuration.ai_timeout,
+        verbose: configuration.verbose
+      )
+    end
+
     def valid?
       return false unless refactorer
       inputs_valid = refactorer.takes_input_files? ? !(inputs.nil? || inputs.empty?) : true
@@ -72,12 +83,6 @@ module AIRefactor
     def run
       return false unless valid?
 
-      OpenAI.configure do |config|
-        config.access_token = ENV.fetch("OPENAI_API_KEY")
-        config.organization_id = ENV.fetch("OPENAI_ORGANIZATION_ID", nil)
-        config.request_timeout = configuration.ai_timeout || 240
-      end
-
       if refactorer.takes_input_files?
         expanded_inputs = inputs.map do |path|
           File.exist?(path) ? path : Dir.glob(path)
@@ -85,11 +90,14 @@ 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}..."
 
-          refactor = refactorer.new(file, configuration, logger)
+          refactor = refactorer.new(ai_client, file, configuration, logger)
           refactor_returned = refactor.run
           failed = refactor_returned == false
           if failed
@@ -115,7 +123,7 @@ module AIRefactor
         name = refactorer.refactor_name
         logger.info "AI Refactor - #{name} refactor\n"
         logger.info "====================\n"
-        refactor = refactorer.new(nil, configuration, logger)
+        refactor = refactorer.new(ai_client, nil, configuration, logger)
         refactor_returned = refactor.run
         failed = refactor_returned == false
         if failed

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

@@ -60,35 +60,21 @@ module AIRefactor
       logger.debug "Options: #{options.inspect}"
       logger.debug "Messages: #{messages.inspect}"
 
-      response = @ai_client.chat(
-        parameters: {
-          model: options[:ai_model] || "gpt-4",
-          messages: messages,
-          temperature: options[:ai_temperature] || 0.7,
-          max_tokens: options[:ai_max_tokens] || 1500
-        }
-      )
-
-      if response["error"]
-        raise StandardError.new("OpenAI error: #{response["error"]["type"]}: #{response["error"]["message"]} (#{response["error"]["code"]})")
-      end
-
-      content = response.dig("choices", 0, "message", "content")
-      finished_reason = response.dig("choices", 0, "finish_reason")
-
-      if finished_reason == "length" && attempts_left > 0
-        generate_next_message(messages + [
-          {role: "assistant", content: content},
-          {role: "user", content: "Continue"}
-        ], options, attempts_left - 1)
-      else
-        previous_messages = messages.filter { |m| m[:role] == "assistant" }.map { |m| m[:content] }.join
-        content = if previous_messages.length > 0
-          content ? previous_messages + content : previous_messages
+      @ai_client.generate!(messages) do |finished_reason, content, response|
+        if finished_reason == "length" && attempts_left > 0
+          generate_next_message(messages + [
+            {role: "assistant", content: content},
+            {role: "user", content: "Continue"}
+          ], options, attempts_left - 1)
         else
-          content
+          previous_messages = messages.filter { |m| m[:role] == "assistant" }.map { |m| m[:content] }.join
+          content = if previous_messages.length > 0
+            content ? previous_messages + content : previous_messages
+          else
+            content
+          end
+          [content, finished_reason, response["usage"]]
         end
-        [content, finished_reason, response["usage"]]
       end
     end
 

data/lib/ai_refactor/refactors/base_refactor.rb

@@ -17,11 +17,12 @@ module AIRefactor
         true
       end
 
-      attr_reader :input_file, :options, :logger
+      attr_reader :ai_client, :input_file, :options, :logger
       attr_accessor :input_content
       attr_writer :failed_message
 
-      def initialize(input_file, options, logger)
+      def initialize(ai_client, input_file, options, logger)
+        @ai_client = ai_client
         @input_file = input_file
         @options = options
         @logger = logger
@@ -79,8 +80,11 @@ module AIRefactor
           output_content
         rescue => e
           logger.error "Request to AI failed: #{e.message}"
+          if e.respond_to?(:response) && e.response
+            logger.error "Response: #{e.response[:body]}"
+          end
           logger.warn "Skipping #{input_file}..."
-          self.failed_message = "Request to OpenAI failed"
+          self.failed_message = "Request to AI API failed"
           raise e
         end
       end
@@ -175,10 +179,6 @@ module AIRefactor
         path
       end
 
-      def ai_client
-        @ai_client ||= OpenAI::Client.new
-      end
-
       def refactor_name
         self.class.refactor_name
       end

data/lib/ai_refactor/run_configuration.rb

@@ -8,19 +8,16 @@ 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,
       :prompt_file_path,
-      :ai_max_attempts,
-      :ai_model,
-      :ai_temperature,
-      :ai_max_tokens,
-      :ai_timeout,
       :overwrite,
       :diff,
       :verbose,
@@ -33,7 +30,7 @@ module AIRefactor
       end
     end
 
-    attr_writer :refactor
+    attr_writer :refactor, :description
 
     # @deprecated
     def [](key)
@@ -56,6 +53,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
@@ -76,30 +92,54 @@ module AIRefactor
     attr_writer :rspec_run_command
     attr_writer :minitest_run_command
 
+    def ai_max_attempts
+      @ai_max_attempts || 3
+    end
+
     def ai_max_attempts=(value)
-      @ai_max_attempts = value || 3
+      @ai_max_attempts = value
+    end
+
+    def ai_model
+      @ai_model || "gpt-4-turbo"
     end
 
     def ai_model=(value)
-      @ai_model = value || "gpt-4"
+      @ai_model = value
     end
 
-    def ai_temperature=(value)
-      @ai_temperature = value || 0.7
+    def ai_platform
+      if ai_model&.start_with?("claude")
+        "anthropic"
+      else
+        "openai"
+      end
     end
 
-    def ai_max_tokens=(value)
-      @ai_max_tokens = value || 1500
+    def ai_temperature
+      @ai_temperature || 0.7
     end
 
-    def ai_timeout=(value)
-      @ai_timeout = value || 60
+    attr_writer :ai_temperature
+
+    def ai_max_tokens
+      @ai_max_tokens || 1500
     end
 
-    def overwrite=(value)
-      @overwrite = value || "a"
+    attr_writer :ai_max_tokens
+
+    def ai_timeout
+      @ai_timeout || 60
     end
 
+    attr_writer :ai_timeout
+
+    def overwrite
+      @overwrite || "a"
+    end
+
+    attr_writer :overwrite
+
     attr_writer :diff
 
     attr_writer :verbose

data/lib/ai_refactor/version.rb

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

data/lib/ai_refactor.rb

@@ -4,6 +4,7 @@ require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem
 loader.inflector.inflect(
   "ai_refactor" => "AIRefactor",
+  "ai_client" => "AIClient",
   "rspec_runner" => "RSpecRunner"
 )
 loader.setup # ready!

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ai_refactor
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Stephen Ierodiaconou
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-06 00:00:00.000000000 Z
+date: 2024-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -58,6 +58,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: anthropic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -89,16 +109,13 @@ files:
 - Rakefile
 - Steepfile
 - ai_refactor.gemspec
-- examples/ex1_convert_a_rspec_test_to_minitest.yml
-- examples/ex1_input_spec.rb
-- examples/ex2_input.rb
-- examples/ex2_write_rbs.yml
-- examples/rails_helper.rb
-- examples/test_helper.rb
+- commands/quickdraw/0.1.0/convert_minitest.yml
 - exe/ai_refactor
 - lib/ai_refactor.rb
+- lib/ai_refactor/ai_client.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
@@ -144,14 +161,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.20
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Use AI to convert a Rails RSpec test suite to minitest.

data/examples/ex1_convert_a_rspec_test_to_minitest.yml

@@ -1,8 +0,0 @@
-refactor: rails/minitest/rspec_to_minitest
-input_file_paths:
-  - examples/ex1_input_spec.rb
-# We need to add context here as otherwise to tell the AI to require our local test_helper.rb file so that we can run the tests after
-context_text: "In the output test use `require_relative '../test_helper'` to include 'test_helper'."
-# By default, ai_refactor runs "bundle exec rails test" but this isn't going to work here as we are not actually in a Rails app context in the examples
-minitest_run_command: ruby __FILE__
-output_file_path: examples/outputs/ex1_input_test.rb

data/examples/ex1_input_spec.rb

@@ -1,32 +0,0 @@
-require_relative "rails_helper"
-
-RSpec.describe MyModel, type: :model do
-  subject(:model) { described_class.new }
-
-  it { is_expected.to validate_presence_of(:name) }
-
-  it "should allow integer values for age" do
-    model.age = 1
-    expect(model.age).to eq 1
-  end
-
-  it "should allow string values for name" do
-    model.name = "test"
-    expect(model.name).to eq "test"
-  end
-
-  it "should be invalid with invalid name" do
-    model.name = nil
-    expect(model).to be_invalid
-  end
-
-  it "should convert integer values for name" do
-    model.name = 1
-    expect(model.name).to eq "1"
-  end
-
-  it "should not allow string values for age" do
-    model.age = "test"
-    expect(model.age).to eq 0
-  end
-end

data/examples/ex2_input.rb

@@ -1,17 +0,0 @@
-# example from https://blog.kiprosh.com/type-checking-in-ruby-3-using-rbs/
-# basic_math.rb
-
-class BasicMath
-  def initialize(num1, num2)
-    @num1 = num1
-    @num2 = num2
-  end
-
-  def first_less_than_second?
-    @num1 < @num2
-  end
-
-  def add
-    @num1 + @num2
-  end
-end

data/examples/ex2_write_rbs.yml

@@ -1,7 +0,0 @@
-refactor: ruby/write_rbs
-input_file_paths:
-  - examples/ex2_input.rb
-# We need to add context here as our class doesnt actually give any context.
-context_text: "Assume that the inputs can be any numeric type."
-# By default this refactor writes to `sig/...` but here we just put the result in `examples/...`
-output_file_path: examples/outputs/ex2_input.rbs

data/examples/rails_helper.rb

@@ -1,21 +0,0 @@
-require "rails/all"
-require "shoulda-matchers"
-
-Shoulda::Matchers.configure do |config|
-  config.integrate do |with|
-    with.test_framework :rspec
-    with.library :rails
-  end
-end
-
-class MyModel
-  include ActiveModel::Model
-  include ActiveModel::Attributes
-  include ActiveModel::Validations
-  include ActiveModel::Validations::Callbacks
-
-  validates :name, presence: true
-
-  attribute :name, :string
-  attribute :age, :integer
-end

data/examples/test_helper.rb

@@ -1,14 +0,0 @@
-require "rails/all"
-require "active_support/testing/autorun"
-
-class MyModel
-  include ActiveModel::Model
-  include ActiveModel::Attributes
-  include ActiveModel::Validations
-  include ActiveModel::Validations::Callbacks
-
-  validates :name, presence: true
-
-  attribute :name, :string
-  attribute :age, :integer
-end