gpterm 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dc7687047e7d6b18c984706991d29e2b3fea168159c3688aac9c039b98f63974
+  data.tar.gz: 0ded9b23d8ca54f53b46639b3854b2f2cd5fd17521c417be045611be409f8140
+SHA512:
+  metadata.gz: ecb6f33683c67a269e43f24cf13ba1022b22fb37b2e0b01955706dff1cc19bba36b13d32d51cd05d75450ec952d5e9a2c88caa6b699faf7ec1fcd82dd1610faa
+  data.tar.gz: de4343ac31ecd56c910f83ee6390996f88beabcaf3f4fd4e0dfbb3c0a3a79e4fda682f467b943f32436365ec0d572cb61cf8091d96c30b61253cefcbb57f493c

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2024 Daniel Hough
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,55 @@
+# gpterm
+
+**WARNING:** `gpterm` has very few guardrails. If used indiscriminately, it can wipe your entire system or leak information.
+
+`gpterm` is a powerful, flexible and dangerous command-line tool designed to help you generate commands for your terminal using OpenAI's Chat Completions. It will not execute commands without your consent, but please do check which commands it is presenting before you let it execute them. Like so:
+
+```bash
+$ gpterm "Using git diff to gather info, commit all the latest changes with a descriptive commit message, then push the changes"
+$ # It gathers info, asks for consent, and does the thing
+$ [main 94a9292] Update README with gpterm usage example
+$  1 file changed, 4 insertions(+)
+```
+
+## Getting Started
+
+You can install it from RubyGems using `gem install gpterm`, or you can clone it and run it straight from the source.
+
+Ensure you have Ruby installed on your system. Then, follow these steps:
+
+- Clone the repository or download the source code.
+- Navigate to the gpterm directory and run `bundle install` to install dependencies.
+- Start the application by running `./bin/gpterm`
+
+## Configuration
+
+On first run, you'll be prompted to enter your OpenAI API key. This is required for the application to interact with OpenAI's API. You will also be asked to specify whether you'd like your `PATH` variable to be sent in the prompt, which can help with command generation.
+
+## Usage
+
+`gpterm <prompt> [options] [subcommand [options]]`
+
+**Subcommands:**
+
+- `preset` - `gpterm preset <name> <prompt>`
+- `config` - `gpterm config [--openapi_key <value>|--send_path <true|false>]`
+
+**Options:**
+`-v`, `--verbose` Run verbosely
+
+## Presets
+
+You can save and reuse preset prompts for common or repeated tasks. To create a preset, use the `-s` option followed by a name and the prompt, separated by a comma.
+To use a preset, simply pass its name as an argument when starting gpterm.
+
+## Contributing
+
+Contributions are welcome! Feel free to open an issue or pull request.
+
+## License
+
+gpterm is open-source software licensed under the MIT license.
+
+## Author
+
+[Dan Hough](https://danhough.com)

data/bin/gpterm

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/gpterm'
+
+GPTerm.new.run

data/lib/client.rb

@@ -0,0 +1,165 @@
+require "openai"
+
+class Client
+  attr_reader :openapi_client
+  attr_reader :config
+
+  def initialize(config)
+    @config = config
+    @openapi_client = OpenAI::Client.new(access_token: config["openapi_key"])
+  end
+
+  def first_prompt(prompt)
+    system_prompt = <<~PROMPT
+      You are a command-line application being executed inside of a directory in a macOS environment, on the user's terminal command line.
+
+      You are executed by running `gpterm` in the terminal, and you are provided with a prompt to respond to with the -p flag.
+
+      Users can add a preset prompt by running `gpterm -s <name>,<prompt>`.
+
+      The eventual output to the user would be a list of commands that they can run in their terminal to accomplish a task.
+
+      You have the ability to run any command that this system can run, and you can read the output of those commands.
+
+      The user is trying to accomplish a task using the terminal, but they are not sure how to do it.
+    PROMPT
+
+    if @config["send_path"]
+      system_prompt += <<~PROMPT
+        The user's PATH environment variable is:
+        #{ENV["PATH"]}
+      PROMPT
+    end
+
+    full_prompt = <<~PROMPT
+      Your FIRST response should be a list of commands that will be automatically executed to gather more information about the user's system.
+      - The commands MUST NOT make any changes to the user's system.
+      - The commands MUST NOT make any changes to any files on the user's system.
+      - The commands MUST NOT write to any files using the > or >> operators.
+      - The commands MUST NOT use the touch command.
+      - The commands MUST NOT use echo or any other command to write into files using the > or >> operators.
+      - The commands MUST NOT send any data to any external servers.
+      - The commands MUST NOT contain any placeholders in angle brackets like <this>.
+      - The commands MUST NOT contain any plain language instructions, or backticks indicating where the commands begin or end.
+      - The commands MAY gather information about the user's system, such as the version of a software package, or the contents of a file.
+      - The commands CAN pipe their output into other commands.
+      - The commands SHOULD tend to gather more verbose information INSTEAD OF more concise information.
+      This will help you to provide a more accurate response to the user's goal.
+      Therefore your FIRST response MUST contain ONLY a list of commands and nothing else.
+
+      VALID example response. These commands are examples of commands which CAN be included in your FIRST response:
+
+        for file in *; do cat "$file"; done
+        which ls
+        which git
+        which brew
+        git diff
+        git status
+
+      INVALID example response. These commands are examples of commands which MUST NOT be included in your FIRST response:
+
+        touch file.txt
+        git add .
+        git push
+
+      If you cannot create a VALID response, simply return the string "$$cannot_compute$$" and the user will be asked to provide a new prompt.
+      If you do not need to gather more information, simply return the string "$$no_gathering_needed$$" and the next step will be executed.
+      You probably will need to gather information.
+      If you need to gather information directly from the user, you will be able to do so in the next step.
+
+      The user's goal prompt is:
+      "#{prompt}"
+      Commands to execute to gather more information about the user's system before providing the response which will accomplish the user's goal:
+    PROMPT
+
+    @messages = [
+      { role: "system", content: system_prompt },
+      { role: "user", content: full_prompt }
+    ]
+
+    response = openapi_client.chat(
+      parameters: {
+        model: "gpt-4-turbo-preview",
+        messages: @messages,
+        temperature: 0.6,
+      }
+    )
+    content = response.dig("choices", 0, "message", "content")
+
+    @messages << { role: "assistant", content: content }
+
+    content
+  end
+
+  def offer_information_prompt(prompt)
+    full_prompt = <<~PROMPT
+      This is the output of the command you provided to the user in the previous step.
+
+      #{prompt}
+
+      Before you provide the user with the next command, you have the opportunity to ask the user to provide more information so you can better tailor your response to their needs.
+
+      If you would like to ask the user for more information, please provide a prompt that asks the user for the information you need.
+      - Your prompt MUST ONLY contain one question. You will be able to ask another question in the next step.
+      If you have all the information you need, simply return the string "$$no_more_information_needed$$" and the next step will be executed.
+    PROMPT
+
+    @messages << { role: "user", content: full_prompt }
+
+    response = openapi_client.chat(
+      parameters: {
+        model: "gpt-4-turbo-preview",
+        messages: @messages,
+        temperature: 0.6,
+      }
+    )
+
+    content = response.dig("choices", 0, "message", "content")
+
+    @messages << { role: "assistant", content: content }
+
+    content
+  end
+
+  def final_prompt(prompt)
+    full_prompt = <<~PROMPT
+      This is the output of the command you provided to the user in the previous step.
+
+      #{prompt}
+
+      Your NEXT response should be a list of commands that will be automatically executed to fulfill the user's goal.
+      - The commands may make changes to the user's system.
+      - The commands may install new software using package managers like Homebrew
+      - The commands MUST all start with a valid command that you would run in the terminal
+      - The commands MUST NOT contain any placeholders in angle brackets like <this>.
+      - The response MUST NOT contain any plain language instructions, or backticks indicating where the commands begin or end.
+      - THe response MUST NOT start or end with backticks.
+      - The response MUST NOT end with a newline character.
+      Therefore your NEXT response MUST contain ONLY a list of commands and nothing else.
+
+      VALID example response. These commands are examples of commands which CAN be included in your FINAL response:
+
+        ls
+        mkdir new_directory
+        brew install git
+        git commit -m "This is a great commit message"
+
+      If you cannot keep to this restriction, simply return the string "$$cannot_compute$$" and the user will be asked to provide a new prompt.
+    PROMPT
+
+    @messages << { role: "user", content: full_prompt }
+
+    response = openapi_client.chat(
+      parameters: {
+        model: "gpt-4-turbo-preview",
+        messages: @messages,
+        temperature: 0.6,
+      }
+    )
+    content = response.dig("choices", 0, "message", "content")
+
+    @messages << { role: "assistant", content: content }
+
+    content
+  end
+end

data/lib/config.rb

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

data/lib/gpterm.rb

@@ -0,0 +1,188 @@
+require 'optparse'
+require 'colorize'
+
+require_relative 'config'
+require_relative 'client'
+
+class GPTerm
+  def initialize
+    @config = load_config
+    @options = parse_options
+    @client = Client.new(@config)
+  end
+
+  def run
+    if @options[:preset_prompt]
+      name = @options[:preset_prompt][0]
+      prompt = @options[:preset_prompt][1]
+      AppConfig.add_preset(@config, name, prompt)
+      puts "Preset prompt '#{name}' saved with prompt '#{prompt}'".colorize(:green)
+      exit
+    elsif @options[:prompt]
+      start_prompt(@options[:prompt])
+    end
+  end
+
+  private
+
+  def start_prompt(prompt)
+    message = @client.first_prompt(prompt)
+
+    if message.downcase == '$$cannot_compute$$'
+      puts 'Sorry, a command could not be generated for that prompt. Try another.'.colorize(:red)
+      exit
+    end
+
+    if message.downcase == '$$no_gathering_needed$$'
+      puts 'No information gathering needed'.colorize(:magenta)
+      output = "No information gathering was needed."
+    else
+      puts 'Information gathering command:'.colorize(:magenta)
+      puts message.gsub(/^/, "#{"  $".colorize(:blue)} ")
+      puts 'Do you want to execute this command? (Y/n)'.colorize(:yellow)
+      continue = STDIN.gets.chomp
+
+      unless continue.downcase == 'y'
+        exit
+      end
+
+      puts 'Running command...'
+      output = `#{message}`
+
+      puts 'Output:'
+      puts output
+    end
+
+    output = offer_more_information(output)
+
+    while output.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 "What is your response? (Type 'skip' to skip this step and force the final command to be generated)".colorize(:yellow)
+
+      response = STDIN.gets.chomp
+
+      if response.downcase == 'skip'
+        output = '$$no_more_information_needed$$'
+      else
+        output = offer_more_information(response)
+      end
+    end
+
+    puts 'Requesting the next command...'.colorize(:magenta)
+
+    message = @client.final_prompt(output)
+
+    puts 'Generated command to accomplish your goal:'.colorize(:magenta)
+    puts message.gsub(/^/, "#{"  $".colorize(:green)} ")
+
+    puts 'Do you want to execute this command? (Y/n)'.colorize(:yellow)
+
+    continue = STDIN.gets.chomp
+
+    unless continue.downcase == 'y'
+      exit
+    end
+
+    output = `#{message}`
+
+    puts 'Output:'
+    puts output
+  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)
+
+      puts "Enter your OpenAI API key's \"SECRET KEY\" value: ".colorize(:yellow)
+      new_config['openapi_key'] = STDIN.gets.chomp
+
+      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) '.colorize(:yellow)
+
+      if STDIN.gets.chomp.downcase == 'y'
+        new_config['send_path'] = true
+      else
+        new_config['send_path'] = false
+      end
+
+      AppConfig.save_config(new_config)
+
+      new_config
+    else
+      AppConfig.load_config
+    end
+  end
+
+  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)
+            puts "OpenAI API key saved"
+            exit
+          end
+          opts.on("--send_path", "Send the PATH environment variable to OpenAI") do
+            @config['send_path'] = true
+            AppConfig.save_config(@config)
+            puts "Your PATH environment variable will be sent to OpenAI to help with command generation"
+            exit
+          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'
+      puts main
+      exit
+    elsif command
+      options[:prompt] = command
+    else
+      puts 'Enter a prompt to generate text from:'.colorize(:yellow)
+      options[:prompt] = STDIN.gets.chomp
+    end
+
+    options
+  end
+
+  def offer_more_information(output)
+    output = @client.offer_information_prompt(output)
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: gpterm
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Dan Hough
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-02-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+description: gpterm is a powerful, flexible and dangerous command-line tool designed
+  to help you generate commands for your terminal using OpenAI's Chat Completions
+email:
+- daniel.hough@gmail.com
+executables:
+- gpterm
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/gpterm
+- lib/client.rb
+- lib/config.rb
+- lib/gpterm.rb
+homepage: https://github.com/basicallydan/gpterm
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/basicallydan/gpterm
+  source_code_uri: https://github.com/basicallydan/gpterm
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: A CLI for generating CLI commands with OpenAI's help.
+test_files: []