gpterm 0.6.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e024b6f050f77e130bee02f5a1e56df3bd510c79cd7dedb84ae26b196ae9d942
-  data.tar.gz: dcbd7637acebad7bf14de4722eeb83a9bbb57cf5c52015529b07515e573dac3f
+  metadata.gz: a5d7e207cd381258fa26f30cad19add40fef4c0b3931971e9d7c131ec16734fd
+  data.tar.gz: d3c472cf2ac8f979616f2863310aa9fd8ea083384c85ac6a78eaba5397a15899
 SHA512:
-  metadata.gz: 74f6fe4934dc5060c52085d2483a74dc98595c3208aa6917b45f2d47883c72c4b47e37670e9750745f7eb252233d636a2442afe0fa70f0b75b1970907b70780b
-  data.tar.gz: e1bad1a098380d95e1855ddfd413b2300a9224e6bca5db6aad5f4d8938d7b0356e34e6bd9fc21d7d47544dcbe5c692d67912ac5fff1f801eb239ba0c0c3dffa6
+  metadata.gz: 984be150518b40b63ba73a873d0389801c5ab45069be710c2373baa5fe324c538694a5a040c57218388ea0200a3ec38a6d5c2e04d2db803a9e9d91f543781d0e
+  data.tar.gz: 461c55256fc8f71ac54422c95022d921a172f79ec4ef4e59dd31df2d5a123c3d61fcd3013fb5d597701a37285202596342c8b47d768756fb51c8ef485639a868

data/config/prompts.yml

@@ -116,3 +116,5 @@ goal_commands: |
   - $$cannot_compute$$ - You cannot create a VALID response to this prompt. The user will be asked to provide a new prompt.
 
   COMMANDS:
+refine_commands: |
+  The last response needs some changes. Please take into account this prompt from the user, then refine the commands you provided in the last response.

data/lib/app_config.rb

@@ -0,0 +1,69 @@
+require 'colorize'
+require 'yaml'
+
+require_relative 'input'
+
+module AppConfig
+  CONFIG_FILE = File.join(Dir.home, '.gpterm', 'config.yml').freeze
+
+  def self.load
+    # Check if the directory exists, if not, create it
+    unless File.directory?(File.dirname(CONFIG_FILE))
+      Dir.mkdir(File.dirname(CONFIG_FILE))
+    end
+
+    unless File.exist?(self::CONFIG_FILE)
+      puts 'Welcome to gpterm! It looks like this is your first time using this application.'.colorize(:magenta)
+
+      new_config = {}
+      puts "Before we get started, we need to configure the application. All the info you provide will be saved in #{self::CONFIG_FILE}.".colorize(:magenta)
+
+      puts "Enter your OpenAI API key's \"SECRET KEY\" value then hit return: ".colorize(:yellow)
+      new_config['openapi_key'] = Input.non_empty
+
+      puts "Your PATH environment variable is: #{ENV['PATH']}".colorize(:magenta)
+      puts 'Are you happy for your PATH to be sent to OpenAI to help with command generation? (Y/n then hit return) '.colorize(:yellow)
+
+      input = Input.yes_or_no
+
+      if input == 'y'
+        new_config['send_path'] = true
+      else
+        new_config['send_path'] = false
+      end
+
+      default_model = 'gpt-4-turbo-preview'
+
+      puts "The default model is #{default_model}. If you would like to change it please enter the name of your preferred model:".colorize(:yellow)
+      new_config['model'] = STDIN.gets.chomp.strip || default_model
+
+      self.save_config(new_config)
+
+      puts "Configuration saved to #{self::CONFIG_FILE}".colorize(:green)
+
+      new_config
+    else
+      self.load_config_from_file
+    end
+  end
+
+  def self.load_config_from_file
+    YAML.load_file(CONFIG_FILE)
+  end
+
+  def self.save_config(config)
+    File.write(CONFIG_FILE, config.to_yaml)
+  end
+
+  def self.add_openapi_key(config, openapi_key)
+    config['openapi_key'] = openapi_key
+    save_config(config)
+  end
+
+  def self.add_preset(config, preset_name, preset_prompt)
+    # This is a YAML file so we need to make sure the presets key exists
+    config['presets'] ||= {}
+    config['presets'][preset_name] = preset_prompt
+    save_config(config)
+  end
+end

data/lib/{client.rb → command_generator.rb}

@@ -1,13 +1,12 @@
-require "openai"
 require 'yaml'
 
-class Client
+class CommandGenerator
   attr_reader :openai_client
   attr_reader :config
 
-  def initialize(config)
+  def initialize(config, openai_client)
     @config = config
-    @openai_client = OpenAI::Client.new(access_token: config["openapi_key"])
+    @openai_client = openai_client
     @prompts = YAML.load_file(File.join(__dir__, '..', 'config', 'prompts.yml'))
   end
 
@@ -74,6 +73,19 @@ class Client
     continue_conversation(goal_commands_prompt)
   end
 
+  def refine_last_response(prompt)
+    refinement_prompt = @prompts["refine_commands"]
+
+    refinement_prompt += <<~PROMPT
+
+      #{prompt}
+
+      COMMANDS:
+    PROMPT
+
+    continue_conversation(refinement_prompt)
+  end
+
   private
 
   def continue_conversation(prompt)

data/lib/gpterm.rb

@@ -1,9 +1,11 @@
-require 'optparse'
 require 'colorize'
 require 'open3'
+require "openai"
 
-require_relative 'config'
-require_relative 'client'
+require_relative 'app_config'
+require_relative 'command_generator'
+require_relative 'parse_options'
+require_relative 'input'
 
 # The colours work like this:
 # - Output from STDOUT or STDERR is default
@@ -14,9 +16,10 @@ require_relative 'client'
 
 class GPTerm
   def initialize
-    @config = load_config
-    @options = parse_options
-    @client = Client.new(@config)
+    @config = AppConfig.load
+    @options = ParseOptions.call(@config)
+    @openai_client = OpenAI::Client.new(access_token: @config["openapi_key"])
+    @command_generator = CommandGenerator.new(@config, @openai_client)
   end
 
   def run
@@ -47,93 +50,35 @@ class GPTerm
     exit
   end
 
-  # Ensures the user enters "y" or "n"
-  def get_yes_or_no
-    input = STDIN.gets.chomp.downcase
-    while ['y', 'n'].include?(input) == false
-      puts 'Please enter "y/Y" or "n/N":'.colorize(:yellow)
-      input = STDIN.gets.chomp.downcase
-    end
-    input
-  end
-
-  # Ensures the user enters a non-empty value
-  def get_non_empty_input
-    input = STDIN.gets.chomp.strip
-    while input.length == 0
-      puts 'Please enter a non-empty value:'.colorize(:yellow)
-      input = STDIN.gets.chomp.strip
-    end
-    input
-  end
-
   def start_conversation(prompt)
-    message = @client.first_prompt(prompt)
+    shell_output = gather_information_from_shell(prompt)
 
-    if message.downcase == '$$cannot_compute$$'
-      exit_with_message('Sorry, a command could not be generated for that prompt. Try another.', :red)
-    end
-
-    if message.downcase == '$$no_gathering_needed$$'
-      puts 'No information gathering needed'.colorize(:magenta)
-      output = "No information gathering was needed."
-    elsif message.downcase == '$$cannot_compute$$'
-      exit_with_message('Sorry, a command could not be generated for that prompt. Try another.', :red)
-    else
-      puts 'Information gathering command:'.colorize(:magenta)
-      puts message.gsub(/^/, "#{"  $".colorize(:blue)} ")
-      puts 'Do you want to execute this command? (Y/n then hit return)'.colorize(:yellow)
-      continue = get_yes_or_no
+    offer_prompt_response = @command_generator.offer_information_prompt(shell_output, :shell_output_response)
 
-      unless continue.downcase == 'y'
-        exit
-      end
-
-      puts 'Running command...'
-      output = `#{message}`
-
-      if @config[:verbose]
-        puts 'Output:'
-        puts output
-      end
-    end
-
-    output = @client.offer_information_prompt(output, :shell_output_response)
-
-    while output.downcase != '$$no_more_information_needed$$'
+    while offer_prompt_response.downcase != '$$no_more_information_needed$$'
       puts "You have been asked to provide more information with this command:".colorize(:magenta)
-      puts output.gsub(/^/, "#{"  >".colorize(:blue)} ")
+      puts offer_prompt_response.gsub(/^/, "#{"  >".colorize(:blue)} ")
       puts "What is your response? (Type 'skip' to skip this step and force the final command to be generated)".colorize(:yellow)
 
-      response = get_non_empty_input
+      user_question_response = Input.non_empty
 
-      if response.downcase == 'skip'
-        output = '$$no_more_information_needed$$'
+      if user_question_response.downcase == 'skip'
+        offer_prompt_response = '$$no_more_information_needed$$'
+        puts 'Thanks, one moment please...'.colorize(:magenta)
       else
-        output = @client.offer_information_prompt(response, :question_response)
+        offer_prompt_response = @command_generator.offer_information_prompt(user_question_response, :question_response)
       end
     end
 
-    puts 'Requesting the next command...'.colorize(:magenta)
-
-    message = @client.final_prompt(output)
-
-    if message.downcase == '$$cannot_compute$$'
-      exit_with_message('Sorry, a command could not be generated for that prompt. Try another.', :red)
-    end
-
-    puts 'Generated command to accomplish your goal:'.colorize(:magenta)
-    puts message.gsub(/^/, "#{"  $".colorize(:green)} ")
-
-    puts 'Do you want to execute this command? (Y/n then hit return)'.colorize(:yellow)
+    puts 'Requesting the next command...'.colorize(:magenta) if @config[:verbose]
 
-    continue = get_yes_or_no
+    # TODO: Some redundant info being passed here in the case of
+    # the user answering a question
+    goal_prompt_response = @command_generator.final_prompt(offer_prompt_response)
 
-    unless continue.downcase == 'y'
-      exit
-    end
+    goal_prompt_response = run_refinement_loop(goal_prompt_response)
 
-    commands = message.split("\n")
+    commands = goal_prompt_response.split("\n")
 
     commands.each do |command|
       stdout, stderr, exit_status = execute_shell_command(command)
@@ -149,101 +94,58 @@ class GPTerm
     end
   end
 
-  def load_config
-    unless File.exist?(AppConfig::CONFIG_FILE)
-      puts 'Welcome to gpterm! It looks like this is your first time using this application.'.colorize(:magenta)
-
-      new_config = {}
-      puts "Before we get started, we need to configure the application. All the info you provide will be saved in #{AppConfig::CONFIG_FILE}.".colorize(:magenta)
+  def gather_information_from_shell(prompt)
+    info_prompt_response = @command_generator.first_prompt(prompt)
 
-      puts "Enter your OpenAI API key's \"SECRET KEY\" value then hit return: ".colorize(:yellow)
-      new_config['openapi_key'] = get_non_empty_input
-
-      puts "Your PATH environment variable is: #{ENV['PATH']}".colorize(:magenta)
-      puts 'Are you happy for your PATH to be sent to OpenAI to help with command generation? (Y/n then hit return) '.colorize(:yellow)
+    if info_prompt_response.downcase == '$$no_gathering_needed$$'
+      puts 'No information gathering needed'.colorize(:magenta) if @config[:verbose]
+      shell_output = nil
+    else
+      info_prompt_response = run_refinement_loop(info_prompt_response, 'gather more information for your request')
 
-      input = get_yes_or_no
+      puts 'Running command...' if @config[:verbose]
+      shell_output = `#{info_prompt_response}`
 
-      if input == 'y'
-        new_config['send_path'] = true
-      else
-        new_config['send_path'] = false
+      if @config[:verbose]
+        puts 'Shell output:'
+        puts shell_output
       end
 
-      default_model = 'gpt-4-turbo-preview'
+    end
+    shell_output
+  end
 
-      puts "The default model is #{default_model}. If you would like to change it please enter the name of your preferred model:".colorize(:yellow)
-      new_config['model'] = STDIN.gets.chomp.strip || default_model
+  def run_refinement_loop(original_response, purpose = 'accomplish your goal')
+    if original_response.downcase == '$$cannot_compute$$'
+      exit_with_message('Sorry, a command could not be generated for that prompt. Try another.', :red)
+    end
 
-      AppConfig.save_config(new_config)
+    refined_response = original_response.dup
 
-      puts "Configuration saved to #{AppConfig::CONFIG_FILE}".colorize(:green)
+    puts "The following command(s) were generated to #{purpose}:".colorize(:magenta)
+    puts refined_response.gsub(/^/, "#{"  $".colorize(:green)} ")
+    puts 'Do you want to execute this/these command(s), or refine them with another prompt? (Y/n/r then hit return)'.colorize(:yellow)
+    continue = Input.yes_no_or_refine
 
-      new_config
-    else
-      AppConfig.load_config
-    end
-  end
+    while continue.downcase == 'r'
+      puts 'Please enter a new prompt:'.colorize(:yellow)
+      new_prompt = Input.non_empty
+      refined_response = @command_generator.refine_last_response(new_prompt)
 
-  def parse_options
-    options = {}
-    subcommands = {
-      'preset' => {
-        option_parser: OptionParser.new do |opts|
-          opts.banner = "gpterm preset <name> <prompt>"
-        end,
-        argument_parser: ->(args) {
-          if args.length < 2
-            options[:prompt] = @config['presets'][args[0]]
-          else
-            options[:preset_prompt] = [args[0], args[1]]
-          end
-        }
-      },
-      'config' => {
-        option_parser: OptionParser.new do |opts|
-          opts.banner = "gpterm config [--openapi_key <value>|--send_path <true|false>]"
-          opts.on("--openapi_key VALUE", "Set the OpenAI API key") do |v|
-            AppConfig.add_openapi_key(@config, v)
-            exit_with_message("OpenAI API key saved")
-          end
-          opts.on("--send_path", "Send the PATH environment variable to OpenAI") do
-            @config['send_path'] = true
-            AppConfig.save_config(@config)
-            exit_with_message("Your PATH environment variable will be sent to OpenAI to help with command generation")
-          end
-        end
-      }
-    }
-
-    main = OptionParser.new do |opts|
-      opts.banner = "Usage:"
-      opts.banner += "\n\ngpterm <prompt> [options] [subcommand [options]]"
-      opts.banner += "\n\nSubcommands:"
-      subcommands.each do |name, subcommand|
-        opts.banner += "\n  #{name} - #{subcommand[:option_parser].banner}"
-      end
-      opts.banner += "\n\nOptions:"
-      opts.on("-v", "--verbose", "Run verbosely") do |v|
-        options[:verbose] = true
+      if refined_response.downcase == '$$cannot_compute$$'
+        exit_with_message('Sorry, a command could not be generated for that prompt. Try another.', :red)
       end
-    end
 
-    command = ARGV.shift
+      puts "The following command(s) were generated to #{purpose}:".colorize(:magenta)
+      puts refined_response.gsub(/^/, "#{"  $".colorize(:blue)} ")
+      puts 'Do you want to execute this/these command(s), or refine them with another prompt? (Y/n/r then hit return)'.colorize(:yellow)
+      continue = Input.yes_no_or_refine
+    end
 
-    main.order!
-    if subcommands.key?(command)
-      subcommands[command][:option_parser].parse!
-      subcommands[command][:argument_parser].call(ARGV) if subcommands[command][:argument_parser]
-    elsif command == 'help'
-      exit_with_message(main)
-    elsif command
-      options[:prompt] = command
-    else
-      puts 'Enter a prompt to generate text from:'.colorize(:yellow)
-      options[:prompt] = get_non_empty_input
+    unless continue.downcase == 'y'
+      exit
     end
 
-    options
+    refined_response
   end
 end

data/lib/input.rb

@@ -0,0 +1,31 @@
+module Input
+  # Ensures the user enters a non-empty value
+  def self.non_empty
+    input = STDIN.gets.chomp.strip
+    while input.length == 0
+      puts 'Please enter a non-empty value:'.colorize(:yellow)
+      input = STDIN.gets.chomp.strip
+    end
+    input
+  end
+
+  # Ensures the user enters "y" or "n"
+  def self.yes_or_no
+    input = STDIN.gets.chomp.downcase
+    while ['y', 'n'].include?(input) == false
+      puts 'Please enter "y/Y" or "n/N":'.colorize(:yellow)
+      input = STDIN.gets.chomp.downcase
+    end
+    input
+  end
+
+  # Ensures the user enters "y" or "n"
+  def self.yes_no_or_refine
+    input = STDIN.gets.chomp.downcase
+    while ['y', 'n', 'r'].include?(input) == false
+      puts 'Please enter "y/Y", "n/N" or "r/R":'.colorize(:yellow)
+      input = STDIN.gets.chomp.downcase
+    end
+    input
+  end
+end

data/lib/parse_options.rb

@@ -0,0 +1,65 @@
+require 'optparse'
+
+class ParseOptions
+  def self.call(config)
+    options = {}
+    subcommands = {
+      'preset' => {
+        option_parser: OptionParser.new do |opts|
+          opts.banner = "gpterm preset <name> <prompt>"
+        end,
+        argument_parser: ->(args) {
+          if args.length < 2
+            options[:prompt] = config['presets'][args[0]]
+          else
+            options[:preset_prompt] = [args[0], args[1]]
+          end
+        }
+      },
+      'config' => {
+        option_parser: OptionParser.new do |opts|
+          opts.banner = "gpterm config [--openapi_key <value>|--send_path <true|false>]"
+          opts.on("--openapi_key VALUE", "Set the OpenAI API key") do |v|
+            AppConfig.add_openapi_key(config, v)
+            exit_with_message("OpenAI API key saved")
+          end
+          opts.on("--send_path", "Send the PATH environment variable to OpenAI") do
+            config['send_path'] = true
+            AppConfig.save_config(config)
+            exit_with_message("Your PATH environment variable will be sent to OpenAI to help with command generation")
+          end
+        end
+      }
+    }
+
+    main = OptionParser.new do |opts|
+      opts.banner = "Usage:"
+      opts.banner += "\n\ngpterm <prompt> [options] [subcommand [options]]"
+      opts.banner += "\n\nSubcommands:"
+      subcommands.each do |name, subcommand|
+        opts.banner += "\n  #{name} - #{subcommand[:option_parser].banner}"
+      end
+      opts.banner += "\n\nOptions:"
+      opts.on("-v", "--verbose", "Run verbosely") do |v|
+        options[:verbose] = true
+      end
+    end
+
+    command = ARGV.shift
+
+    main.order!
+    if subcommands.key?(command)
+      subcommands[command][:option_parser].parse!
+      subcommands[command][:argument_parser].call(ARGV) if subcommands[command][:argument_parser]
+    elsif command == 'help'
+      exit_with_message(main)
+    elsif command
+      options[:prompt] = command
+    else
+      puts 'Enter a prompt to generate text from:'.colorize(:yellow)
+      options[:prompt] = Input.non_empty
+    end
+
+    options
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gpterm
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.0
 platform: ruby
 authors:
 - Dan Hough
@@ -51,9 +51,11 @@ files:
 - README.md
 - bin/gpterm
 - config/prompts.yml
-- lib/client.rb
-- lib/config.rb
+- lib/app_config.rb
+- lib/command_generator.rb
 - lib/gpterm.rb
+- lib/input.rb
+- lib/parse_options.rb
 homepage: https://github.com/basicallydan/gpterm
 licenses:
 - MIT

data/lib/config.rb

@@ -1,38 +0,0 @@
-require 'yaml'
-
-module AppConfig
-  CONFIG_FILE = File.join(Dir.home, '.gpterm', 'config.yml').freeze
-
-  # Check if the directory exists, if not, create it
-  unless File.directory?(File.dirname(CONFIG_FILE))
-    Dir.mkdir(File.dirname(CONFIG_FILE))
-  end
-
-  def self.load_config
-    YAML.load_file(CONFIG_FILE)
-  rescue Errno::ENOENT
-    default_config
-  end
-
-  def self.save_config(config)
-    File.write(CONFIG_FILE, config.to_yaml)
-  end
-
-  def self.add_openapi_key(config, openapi_key)
-    config['openapi_key'] = openapi_key
-    save_config(config)
-  end
-
-  def self.add_preset(config, preset_name, preset_prompt)
-    # This is a YAML file so we need to make sure the presets key exists
-    config['presets'] ||= {}
-    config['presets'][preset_name] = preset_prompt
-    save_config(config)
-  end
-
-  def self.default_config
-    {
-      'openapi_key' => ''
-    }
-  end
-end