ai_refactor 0.4.0 → 0.5.1

data/exe/ai_refactor

@@ -8,77 +8,82 @@ require_relative "../lib/ai_refactor"
 
 require "dotenv/load"
 
-options = {}
-
 supported_refactors = AIRefactor::Refactors.all
-descriptions = AIRefactor::Refactors.descriptions
+refactors_descriptions = AIRefactor::Refactors.descriptions
+
+arguments = ARGV.dup
+
+options_from_config_file = AIRefactor::Cli.load_options_from_config_file
+arguments += options_from_config_file if options_from_config_file
+
+run_config = AIRefactor::RunConfiguration.new
 
 # General options for all refactor types
 option_parser = OptionParser.new do |parser|
-  parser.banner = "Usage: ai_refactor REFACTOR_TYPE INPUT_FILE_OR_DIR [options]\n\nWhere REFACTOR_TYPE is one of: \n- #{descriptions.to_a.map { |refactor| refactor.join(": ") }.join("\n- ")}\n\n"
+  parser.banner = "Usage: ai_refactor REFACTOR_TYPE_OR_COMMAND_FILE INPUT_FILE_OR_DIR [options]\n\nWhere REFACTOR_TYPE_OR_COMMAND_FILE is either the path to a command YML file, or one of the refactor types to run: \n- #{refactors_descriptions.to_a.map { |refactor| refactor.join(": ") }.join("\n- ")}\n\n"
 
   parser.on("-o", "--output [FILE]", String, "Write output to given file instead of stdout. If no path provided will overwrite input file (will prompt to overwrite existing files). Some refactor tasks will write out to a new file by default. This option will override the tasks default behaviour.") do |f|
-    options[:output_file_path] = f
+    run_config.output_file_path = f
   end
 
   parser.on("-O", "--output-template TEMPLATE", String, "Write outputs to files instead of stdout. The template is used to create the output name, where the it can have substitutions, '[FILE]', '[NAME]', '[DIR]', '[REFACTOR]' & '[EXT]'. Eg `[DIR]/[NAME]_[REFACTOR][EXT]` (will prompt to overwrite existing files)") do |t|
-    options[:output_template_path] = t
+    run_config.output_template_path = t
   end
 
   parser.on("-c", "--context CONTEXT_FILES", Array, "Specify one or more files to use as context for the AI. The contents of these files will be prepended to the prompt sent to the AI.") do |c|
-    options[:context_file_paths] = c
+    run_config.context_file_paths = c
   end
 
   parser.on("-x", "--extra CONTEXT_TEXT", String, "Specify some text to be prepended to the prompt sent to the AI as extra information of note.") do |c|
-    options[:context_text] = c
+    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
-    options[:review_prompt] = true
+    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|
-    options[:prompt_file_path] = f
+    run_config.prompt_file_path = f
   end
 
   parser.on("-f", "--diffs", "Request AI generate diffs of changes rather than writing out the whole file.") do
-    options[:diff] = true
+    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|
-    options[:ai_max_attempts] = c || 3
+    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|
-    options[:ai_model] = m
+    run_config.ai_model = m
   end
 
   parser.on("--temperature TEMP", Float, "Specify the temperature parameter for ChatGPT (default 0.7).") do |p|
-    options[:ai_temperature] = 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|
-    options[:ai_max_tokens] = m
+    run_config.ai_max_tokens = m
   end
 
   parser.on("-t", "--timeout SECONDS", Integer, "Specify the max wait time for ChatGPT response.") do |m|
-    options[:ai_timeout] = m
+    run_config.ai_timeout = m
   end
 
   parser.on("--overwrite ANSWER", "Always overwrite existing output files, 'y' for yes, 'n' for no, or 'a' for ask. Default to ask.") do |a|
-    options[:overwrite] = a
+    run_config.overwrite = a
   end
 
   parser.on("-N", "--no", "Never overwrite existing output files, same as --overwrite=n.") do |a|
-    options[:overwrite] = "n"
+    run_config.overwrite = "n"
   end
 
   parser.on("-v", "--verbose", "Show extra output and progress info") do
-    options[:verbose] = true
+    run_config.verbose = true
   end
 
   parser.on("-d", "--debug", "Show debugging output to help diagnose issues") do
-    options[:debug] = true
+    run_config.debug = true
   end
 
   parser.on("-h", "--help", "Prints this help") do
@@ -109,45 +114,94 @@ option_parser = OptionParser.new do |parser|
     refactorer.command_line_options.each do |option|
       args = [option[:long], option[:type], option[:help]]
       args.unshift(option[:short]) if option[:short]
+      AIRefactor::RunConfiguration.add_new_option(option[:key])
       parser.on(*args) do |o|
-        options[option[:key]] = o.nil? ? true : o
+        run_config.send("#{option[:key]}=", o.nil? ? true : o)
       end
     end
   end
 end
 
-# Load config from ~/.ai_refactor or .ai_refactor
-home_config_file_path = File.expand_path("~/.ai_refactor")
-local_config_file_path = File.join(Dir.pwd, ".ai_refactor")
-
-arguments = ARGV.dup
+def exit_with_option_error(message, option_parser = nil, logger = nil)
+  logger ? logger.error(message, bold: true) : puts(message)
+  puts option_parser if option_parser
+  exit false
+end
 
-config_file_path = if File.exist?(local_config_file_path)
-  local_config_file_path
-elsif File.exist?(home_config_file_path)
-  home_config_file_path
+def exit_with_error(message, logger = nil)
+  logger ? logger.error(message, bold: true) : puts(message)
+  exit false
 end
-if config_file_path
-  config_string = File.read(config_file_path)
-  config_lines = config_string.split(/\n+/).reject { |s| s =~ /\A\s*#/ }
-  arguments += config_lines.flat_map(&:shellsplit)
+
+# If no command was provided, prompt for one in interactive mode
+if arguments.empty? || arguments.all? { |arg| arg.start_with?("-") && !(arg == "-h" || arg == "--help") }
+  interactive_log = AIRefactor::Logger.new
+  # 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)
+  exit_with_option_error("No refactor name provided.", option_parser) if command.nil? || command.empty?
+  initial = [command]
+
+  input_path = AIRefactor::Cli.request_file_inputs("Enter input file path: ", multiple: false)
+  exit_with_option_error("No input file path provided.", option_parser) if input_path.nil? || input_path.empty?
+  initial << input_path
+
+  arguments.prepend(*initial)
+
+  # Ask if template should be used - then prompt for it
+
+  output = AIRefactor::Cli.request_file_inputs("Enter output file path (blank for refactor default): ", multiple: false)
+  arguments.concat(["-o", " #{output}"]) unless output.nil? || output.empty?
+
+  context_text = AIRefactor::Cli.request_text_input("Enter extra text to add to prompt (blank for none): ")
+  arguments.concat(["-x", context_text]) unless context_text.nil? || context_text.empty?
+
+  context_files = AIRefactor::Cli.request_file_inputs("Enter extra context file path(s) (blank for none): ")
+  arguments.concat(["-c", context_files]) unless context_files.nil? || context_files.empty?
+
+  prompt_file = AIRefactor::Cli.request_file_inputs("Enter Prompt file path (blank for refactor default): ", multiple: false)
+  arguments.concat(["-p", prompt_file]) unless prompt_file.nil? || prompt_file.empty?
+
+  review = AIRefactor::Cli.request_switch("Dry-run (review prompt only)? (y/N) (blank for 'N'): ")
+  arguments << "-r" if review
 end
 
-option_parser.parse!(arguments)
+File.write(".ai_refactor_history", arguments.join(" ") + "\n", mode: "a")
+
+begin
+  option_parser.parse!(arguments)
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument
+  exit_with_option_error($!, option_parser)
+end
 
-logger = AIRefactor::Logger.new(verbose: options[:verbose], debug: options[:debug])
+logger = AIRefactor::Logger.new(verbose: run_config.verbose, debug: run_config.debug)
+logger.info "Also loaded options from '.ai_refactor' file..." if options_from_config_file&.size&.positive?
 
-if config_file_path
-  logger.info "Loaded config from '#{config_file_path}'..."
+command_or_file = arguments.shift
+if AIRefactor::CommandFileParser.command_file?(command_or_file)
+  logger.info "Loading refactor command file '#{command_or_file}'..."
+  begin
+    run_config.set!(AIRefactor::CommandFileParser.new(command_or_file).parse)
+  rescue => e
+    exit_with_option_error(e.message, option_parser, logger)
+  end
+else
+  logger.info "Requested to run refactor '#{command_or_file}'..."
+  run_config.refactor = command_or_file
 end
 
-job = ::AIRefactor::Cli.new(refactoring_type: arguments.shift, inputs: arguments, options: options, logger: logger)
+run_config.input_file_paths = arguments
+
+job = AIRefactor::Cli.new(run_config, logger: logger)
 
 unless job.valid?
-  puts option_parser.help
-  exit 1
+  exit_with_error("Refactor job failed or was not correctly configured. Did you specify the required inputs or options?.", logger)
 end
 
 unless job.run
-  exit 1
+  exit false
 end

data/lib/ai_refactor/cli.rb

@@ -1,15 +1,67 @@
 # frozen_string_literal: true
 
+require "readline"
+
 module AIRefactor
   class Cli
-    def initialize(refactoring_type:, inputs:, options:, logger:)
-      @refactoring_type = refactoring_type
-      @inputs = inputs
-      @options = options
+    class << self
+      def load_options_from_config_file
+        # Load config from ~/.ai_refactor or .ai_refactor
+        home_config_file_path = File.expand_path("~/.ai_refactor")
+        local_config_file_path = File.join(Dir.pwd, ".ai_refactor")
+
+        config_file_path = if File.exist?(local_config_file_path)
+          local_config_file_path
+        elsif File.exist?(home_config_file_path)
+          home_config_file_path
+        end
+        return unless config_file_path
+
+        config_string = File.read(config_file_path)
+        config_lines = config_string.split(/\n+/).reject { |s| s =~ /\A\s*#/ }.map(&:strip)
+        config_lines.flat_map(&:shellsplit)
+      end
+
+      def request_text_input(prompt)
+        puts prompt
+        gets.chomp
+      end
+
+      def request_input_with_autocomplete(prompt, completion_list)
+        Readline.completion_append_character = nil
+        Readline.completion_proc = proc do |str|
+          completion_list.grep(/^#{Regexp.escape(str)}/)
+        end
+        Readline.readline(prompt, true)
+      end
+
+      def request_file_inputs(prompt, multiple: true)
+        Readline.completion_append_character = multiple ? " " : nil
+        Readline.completion_proc = Readline::FILENAME_COMPLETION_PROC
+
+        paths = Readline.readline(prompt, true)
+        multiple ? paths.gsub(/[^\\] /, ",") : paths
+      end
+
+      def request_switch(prompt)
+        (Readline.readline(prompt, true) =~ /^y/i) ? true : false
+      end
+    end
+
+    def initialize(configuration, logger:)
+      @configuration = configuration
       @logger = logger
     end
 
-    attr_reader :refactoring_type, :inputs, :options, :logger
+    attr_reader :configuration, :logger
+
+    def refactoring_type
+      configuration.refactor || raise(StandardError, "No refactor provided")
+    end
+
+    def inputs
+      configuration.input_file_paths
+    end
 
     def valid?
       return false unless refactorer
@@ -23,7 +75,7 @@ module AIRefactor
       OpenAI.configure do |config|
         config.access_token = ENV.fetch("OPENAI_API_KEY")
         config.organization_id = ENV.fetch("OPENAI_ORGANIZATION_ID", nil)
-        config.request_timeout = options[:ai_timeout] || 240
+        config.request_timeout = configuration.ai_timeout || 240
       end
 
       if refactorer.takes_input_files?
@@ -37,7 +89,7 @@ module AIRefactor
         return_values = expanded_inputs.map do |file|
           logger.info "Processing #{file}..."
 
-          refactor = refactorer.new(file, options, logger)
+          refactor = refactorer.new(file, configuration, logger)
           refactor_returned = refactor.run
           failed = refactor_returned == false
           if failed
@@ -63,7 +115,7 @@ module AIRefactor
         name = refactorer.refactor_name
         logger.info "AI Refactor - #{name} refactor\n"
         logger.info "====================\n"
-        refactor = refactorer.new(nil, options, logger)
+        refactor = refactorer.new(nil, configuration, logger)
         refactor_returned = refactor.run
         failed = refactor_returned == false
         if failed

data/lib/ai_refactor/command_file_parser.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module AIRefactor
+  class CommandFileParser
+    def self.command_file?(name)
+      name.match?(/\.ya?ml$/)
+    end
+
+    def initialize(path)
+      @path = path
+    end
+
+    def parse
+      raise StandardError, "Invalid command file:  file does not exist" unless File.exist?(@path)
+
+      options = YAML.safe_load_file(@path, permitted_classes: [Symbol], symbolize_names: true, aliases: true)
+
+      unless options && options[:refactor]
+        raise StandardError, "Invalid command file format, a 'refactor' key is required"
+      end
+
+      options
+    end
+  end
+end

data/lib/ai_refactor/context.rb

@@ -14,7 +14,7 @@ module AIRefactor
       if @text.nil? || @text.empty?
         file_context
       else
-        "Also note: #{@text}\n\n#{file_context}"
+        "\n#{file_context}\n\n#{@text}\n"
       end
     end
 

data/lib/ai_refactor/file_processor.rb

@@ -22,7 +22,7 @@ module AIRefactor
     end
 
     def process!
-      logger.debug("Processing #{@prompt.input_file_path} with prompt in #{@prompt.prompt_file_path}")
+      logger.debug("Processing #{@prompt.input_file_path} with prompt in #{options.prompt_file_path}")
       logger.debug("Options: #{options.inspect}")
       messages = @prompt.chat_messages
       if options[:review_prompt]

data/lib/ai_refactor/prompt.rb

@@ -9,18 +9,18 @@ module AIRefactor
     CONTEXT_MARKER = "__{{context}}__"
     CONTENT_MARKER = "__{{content}}__"
 
-    attr_reader :input_file_path, :prompt_file_path
+    attr_reader :input_file_path
 
-    def initialize(options:, logger:, context: nil, input_content: nil, input_path: nil, output_file_path: nil, prompt_file_path: nil, prompt_header: nil, prompt_footer: nil)
+    def initialize(options:, logger:, context: nil, input_content: nil, input_path: nil, output_file_path: nil, prompt: nil, prompt_header: nil, prompt_footer: nil)
       @input_content = input_content
       @input_file_path = input_path
       @output_file_path = output_file_path
-      @prompt_file_path = prompt_file_path
       @logger = logger
       @header = prompt_header
       @footer = prompt_footer
       @diff = options[:diff]
       @context = context
+      @prompt = prompt || raise(StandardError, "Prompt not provided")
     end
 
     def chat_messages
@@ -41,7 +41,7 @@ module AIRefactor
     end
 
     def system_prompt_template
-      File.read(@prompt_file_path)
+      @prompt
     end
 
     def system_prompt_footer

data/lib/ai_refactor/refactors/base_refactor.rb

@@ -39,7 +39,7 @@ module AIRefactor
 
       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_file_path: prompt_file_path, context: context, logger: logger, options: options)
+        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
 
@@ -102,7 +102,11 @@ module AIRefactor
         false
       end
 
-      def prompt_file_path
+      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
@@ -112,6 +116,8 @@ module AIRefactor
         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
@@ -140,11 +146,7 @@ module AIRefactor
       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))
+        path = AIRefactor::TemplatedPath.new(input_file, refactor_name, output_template_path).generate
         raise "Output template could not be used" unless path.length.positive?
         path
       end

data/lib/ai_refactor/refactors/{generic.rb → custom.rb}

@@ -2,9 +2,9 @@
 
 module AIRefactor
   module Refactors
-    class Generic < BaseRefactor
+    class Custom < BaseRefactor
       def run
-        logger.verbose "Generic refactor to #{input_file}... (using user supplied prompt #{prompt_file_path})"
+        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

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

@@ -4,8 +4,12 @@ Test 100% of the code.
 The path to the file to test is: __{{input_file_path}}__
 The output file path is: __{{output_file_path}}__
 
-Only show me the test file code. Do NOT provide any other description of your work. Always enclose the output code in triple backticks (```).
+__{{prompt_header}}__
 
 __{{context}}__
 
+Only show me the test file code. Do NOT provide any other description of your work. Always enclose the output code in triple backticks (```).
+
+__{{prompt_footer}}__
+
 The class to test is:

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

@@ -19,9 +19,9 @@ module AIRefactor
 
           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__")
+          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})..."
+          logger.verbose "Run generated test file #{output_file_path} (`#{minitest_runner.command}`)..."
           test_run = minitest_runner.run
 
           if test_run.failed?

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

@@ -6,7 +6,7 @@ module AIRefactor
       module Minitest
         class RspecToMinitest < BaseRefactor
           def run
-            spec_runner = AIRefactor::TestRunners::RSpecRunner.new(input_file)
+            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
@@ -32,7 +32,7 @@ module AIRefactor
 
             logger.verbose "Converted #{input_file} to #{output_file_path}..." if result
 
-            minitest_runner = AIRefactor::TestRunners::MinitestRunner.new(output_file_path)
+            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

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