ai_refactor 0.3.1 → 0.5.0

data/examples/test_helper.rb

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

data/exe/ai_refactor

@@ -3,47 +3,87 @@
 require "optparse"
 require "colorize"
 require "openai"
+require "shellwords"
 require_relative "../lib/ai_refactor"
 
-options = {}
+require "dotenv/load"
 
 supported_refactors = AIRefactor::Refactors.all
-supported_names = AIRefactor::Refactors.names
+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: #{supported_names}\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|
+    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|
+    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|
+    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|
+    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
+    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
+    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
+  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|
+    run_config.ai_max_attempts = c
   end
 
-  parser.on("-m", "--model MODEL_NAME", String, "Specify a ChatGPT model to use (default gpt-3.5-turbo).") do |m|
-    options[:ai_model] = m
+  parser.on("-m", "--model MODEL_NAME", String, "Specify a ChatGPT model to use (default gpt-4).") do |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|
+    run_config.overwrite = a
+  end
+
+  parser.on("-N", "--no", "Never overwrite existing output files, same as --overwrite=n.") do |a|
+    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
@@ -53,67 +93,114 @@ option_parser = OptionParser.new do |parser|
 
   parser.separator ""
 
+  # Example in Refactor class:
+  #
+  # class << self
+  #   def command_line_options
+  #     [
+  #       {
+  #         key: :my_option_key,
+  #         short: "-s",
+  #         long: "--long-form-cli-param [FILE]",
+  #         type: String,
+  #         help: "help text"
+  #       },
+  #       ...
+  #     ]
+  #   end
+  # end
   supported_refactors.each do |name, refactorer|
     parser.separator "For refactor type '#{name}':" if refactorer.command_line_options.size.positive?
     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
 
-option_parser.parse!
+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
 
-logger = AIRefactor::Logger.new(verbose: options[:verbose], debug: options[:debug])
+def exit_with_error(message, logger = nil)
+  logger ? logger.error(message, bold: true) : puts(message)
+  exit false
+end
 
-refactoring_type = ARGV.shift
-input_file_path = ARGV
+# 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
 
-if !AIRefactor::Refactors.supported?(refactoring_type) || input_file_path.nil? || input_file_path.empty?
-  puts option_parser.help
-  exit 1
-end
+  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]
 
-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
-end
+  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
 
-refactorer = AIRefactor::Refactors.get(refactoring_type)
+  arguments.prepend(*initial)
 
-inputs = input_file_path.map do |path|
-  File.exist?(path) ? path : Dir.glob(path)
-end.flatten
+  # Ask if template should be used - then prompt for it
 
-logger.info "AI Refactor #{inputs.size} files(s)/dir(s) '#{input_file_path}' with #{refactorer.refactor_name} refactor\n"
-logger.info "====================\n"
+  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?
 
-return_values = inputs.map do |file|
-  logger.info "Processing #{file}..."
+  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?
 
-  refactor = refactorer.new(file, options, logger)
-  refactor_returned = refactor.run
-  failed = refactor_returned == false
-  if failed
-    logger.warn "Refactor failed on #{file}\nFailed due to: #{refactor.failed_message}\n"
-  else
-    logger.success "Refactor succeeded on #{file}\n"
-    if refactor_returned.is_a?(String)
-      logger.info "Refactor #{file} output:\n\n#{refactor_returned}\n\n"
-    end
-  end
-  failed ? [file, refactor.failed_message] : true
+  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
+
+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
 
-if return_values.all?(true)
-  logger.success "All files processed successfully!"
+logger = AIRefactor::Logger.new(verbose: run_config.verbose, debug: run_config.debug)
+logger.info "Loaded config from '#{options_from_config_file}'..." if options_from_config_file
+
+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
-  files = return_values.select { |v| v != true }
-  logger.warn "Some files failed to process:\n#{files.map { |f| "#{f[0]} :\n > #{f[1]}" }.join("\n")}"
+  logger.info "Requested to run refactor '#{command_or_file}'..."
 end
 
-logger.info "Done processing all files!"
+run_config.input_file_paths = arguments
+
+job = AIRefactor::Cli.new(run_config, logger: logger)
+
+unless job.valid?
+  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 false
+end

data/lib/ai_refactor/cli.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "readline"
+
+module AIRefactor
+  class Cli
+    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 :configuration, :logger
+
+    def refactoring_type
+      configuration.refactor
+    end
+
+    def inputs
+      configuration.input_file_paths
+    end
+
+    def valid?
+      return false unless refactorer
+      inputs_valid = refactorer.takes_input_files? ? !(inputs.nil? || inputs.empty?) : true
+      AIRefactor::Refactors.supported?(refactoring_type) && inputs_valid
+    end
+
+    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)
+        end.flatten
+
+        logger.info "AI Refactor #{expanded_inputs.size} files(s)/dir(s) '#{expanded_inputs}' with #{refactorer.refactor_name} refactor\n"
+        logger.info "====================\n"
+
+        return_values = expanded_inputs.map do |file|
+          logger.info "Processing #{file}..."
+
+          refactor = refactorer.new(file, configuration, logger)
+          refactor_returned = refactor.run
+          failed = refactor_returned == false
+          if failed
+            logger.warn "Refactor failed on #{file}\nFailed due to: #{refactor.failed_message}\n"
+          else
+            logger.success "Refactor succeeded on #{file}\n"
+            if refactor_returned.is_a?(String)
+              logger.info "Refactor #{file} output:\n\n#{refactor_returned}\n\n"
+            end
+          end
+          failed ? [file, refactor.failed_message] : true
+        end
+
+        if return_values.all?(true)
+          logger.success "All files processed successfully!"
+        else
+          files = return_values.select { |v| v != true }
+          logger.warn "Some files failed to process:\n#{files.map { |f| "#{f[0]} :\n > #{f[1]}" }.join("\n")}"
+        end
+
+        logger.info "Done processing all files!"
+      else
+        name = refactorer.refactor_name
+        logger.info "AI Refactor - #{name} refactor\n"
+        logger.info "====================\n"
+        refactor = refactorer.new(nil, configuration, logger)
+        refactor_returned = refactor.run
+        failed = refactor_returned == false
+        if failed
+          logger.warn "Refactor failed with #{name}\nFailed due to: #{refactor.failed_message}\n"
+        else
+          logger.success "Refactor succeeded with #{name}\n"
+          if refactor_returned.is_a?(String)
+            logger.info "Refactor output:\n\n#{refactor_returned}\n\n"
+          end
+        end
+      end
+    end
+
+    private
+
+    def refactorer
+      @refactorer ||= AIRefactor::Refactors.get(refactoring_type)
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  class Context
+    def initialize(files:, text:, logger:)
+      @files = files
+      @text = text
+      @logger = logger
+    end
+
+    def prepare_context
+      context = read_contexts&.compact
+      file_context = (context && context.size.positive?) ? "Here is some related files:\n\n#{context.join("\n")}" : ""
+      if @text.nil? || @text.empty?
+        file_context
+      else
+        "Also note: #{@text}\n\n#{file_context}"
+      end
+    end
+
+    private
+
+    def read_contexts
+      @files&.map do |file|
+        unless File.exist?(file)
+          @logger.warn "Context file #{file} does not exist"
+          next
+        end
+        "#---\n# File '#{file}':\n\n```#{File.read(file)}```\n"
+      end
+    end
+  end
+end

data/lib/ai_refactor/file_processor.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require "openai"
 require "json"
 
 module AIRefactor
   class FileProcessor
-    attr_reader :file_path, :output_path, :logger
+    attr_reader :input_file_path, :output_path, :logger, :options
 
-    def initialize(input_path:, prompt_file_path:, ai_client:, logger:, output_path: nil)
-      @file_path = input_path
-      @prompt_file_path = prompt_file_path
+    def initialize(prompt:, ai_client:, logger:, output_path: nil, options: {})
+      @prompt = prompt
       @ai_client = ai_client
       @logger = logger
       @output_path = output_path
+      @options = options
     end
 
     def output_exists?
@@ -20,20 +21,26 @@ module AIRefactor
       File.exist?(output_path)
     end
 
-    def process!(options)
-      logger.debug("Processing #{file_path} with prompt in #{@prompt_file_path}")
-      prompt = File.read(@prompt_file_path)
-      input = File.read(@file_path)
-      messages = [
-        {role: "system", content: prompt},
-        {role: "user", content: "Convert: ```#{input}```"}
-      ]
-      content, finished_reason, usage = generate_next_message(messages, prompt, options, options[:ai_max_attempts] || 3)
+    def process!
+      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]
+        logger.info "Review prompt:\n"
+        messages.each do |message|
+          logger.info "\n-- Start of prompt for Role #{message[:role]} --\n"
+          logger.info message[:content]
+          logger.info "\n-- End of prompt for Role #{message[:role]} --\n"
+        end
+        return [nil, "Skipped as review prompt was requested", nil]
+      end
+
+      content, finished_reason, usage = generate_next_message(messages, options, ai_max_attempts)
 
       content = if content && content.length > 0
         processed = block_given? ? yield(content) : content
         if output_path
-          File.write(output_path, processed)
+          write_output(output_path, processed)
           logger.verbose "Wrote output to #{output_path}..."
         end
         processed
@@ -44,14 +51,18 @@ module AIRefactor
 
     private
 
-    def generate_next_message(messages, prompt, options, attempts_left)
+    def ai_max_attempts
+      options[:ai_max_attempts] || 1
+    end
+
+    def generate_next_message(messages, options, attempts_left)
       logger.verbose "Generate AI output. Generation attempts left: #{attempts_left}"
       logger.debug "Options: #{options.inspect}"
       logger.debug "Messages: #{messages.inspect}"
 
       response = @ai_client.chat(
         parameters: {
-          model: options[:ai_model] || "gpt-3.5-turbo",
+          model: options[:ai_model] || "gpt-4",
           messages: messages,
           temperature: options[:ai_temperature] || 0.7,
           max_tokens: options[:ai_max_tokens] || 1500
@@ -69,7 +80,7 @@ module AIRefactor
         generate_next_message(messages + [
           {role: "assistant", content: content},
           {role: "user", content: "Continue"}
-        ], prompt, options, attempts_left - 1)
+        ], options, attempts_left - 1)
       else
         previous_messages = messages.filter { |m| m[:role] == "assistant" }.map { |m| m[:content] }.join
         content = if previous_messages.length > 0
@@ -80,5 +91,11 @@ module AIRefactor
         [content, finished_reason, response["usage"]]
       end
     end
+
+    def write_output(output_path, processed)
+      dir = File.dirname(output_path)
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      File.write(output_path, processed)
+    end
   end
 end

data/lib/ai_refactor/prompt.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module AIRefactor
+  class Prompt
+    INPUT_FILE_PATH_MARKER = "__{{input_file_path}}__"
+    OUTPUT_FILE_PATH_MARKER = "__{{output_file_path}}__"
+    HEADER_MARKER = "__{{prompt_header}}__"
+    FOOTER_MARKER = "__{{prompt_footer}}__"
+    CONTEXT_MARKER = "__{{context}}__"
+    CONTENT_MARKER = "__{{content}}__"
+
+    attr_reader :input_file_path
+
+    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
+      @logger = logger
+      @header = prompt_header
+      @footer = prompt_footer
+      @diff = options[:diff]
+      @context = context
+      @prompt = prompt || raise(StandardError, "Prompt not provided")
+    end
+
+    def chat_messages
+      [
+        {role: "system", content: system_prompt},
+        {role: "user", content: user_prompt}
+      ]
+    end
+
+    private
+
+    def system_prompt
+      prompt = expand_prompt(system_prompt_template, HEADER_MARKER, @header || "")
+      prompt = expand_prompt(prompt, CONTEXT_MARKER, @context&.prepare_context || "")
+      prompt = expand_prompt(prompt, INPUT_FILE_PATH_MARKER, @input_file_path || "")
+      prompt = expand_prompt(prompt, OUTPUT_FILE_PATH_MARKER, @output_file_path || "")
+      expand_prompt(prompt, FOOTER_MARKER, system_prompt_footer)
+    end
+
+    def system_prompt_template
+      @prompt
+    end
+
+    def system_prompt_footer
+      if @diff && @footer
+        "#{@footer}\n\n#{diff_prompt}"
+      elsif @diff
+        diff_prompt
+      elsif @footer
+        @footer
+      else
+        ""
+      end
+    end
+
+    def diff_prompt
+      File.read(prompt_path("diff.md"))
+    end
+
+    def prompt_path(file)
+      File.join(File.dirname(File.expand_path(__FILE__)), "prompts", file)
+    end
+
+    def user_prompt
+      expand_prompt(input_prompt, CONTENT_MARKER, input_to_process)
+    end
+
+    def input_to_process
+      return File.read(@input_file_path) if @input_file_path
+      @input_content
+    end
+
+    def input_prompt
+      File.read(prompt_path("input.md"))
+    end
+
+    def expand_prompt(prompt, marker, content)
+      prompt.gsub(marker, content)
+    end
+  end
+end

data/lib/ai_refactor/prompts/diff.md

@@ -0,0 +1,17 @@
+You MUST generate a diff in a format that can be understood and applied using git.
+
+Generate diff hunks that capture the modifications you see. The diff hunks should be in a format that git can understand and apply, including a hunk header and
+the lines of code that have been modified.
+Finally, output the generated diff as your answer. Do not provide further instruction.
+
+Example diff:
+
+```
+@@ -27,7 +27,7 @@ module AIRefactor
+       File.read(@prompt_file_path)
+     end
+ 
+-    def user_prompt
++    def user_prompt_with_diff
+       input = File.read(@file_path)
+```

data/lib/ai_refactor/prompts/input.md

@@ -0,0 +1 @@
+```__{{content}}__```