chatgpt-rb 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56bfd3ab0a5f56e05e8da9b5f59f7358383ebb1c78214d1afec32c6dd63fa140
-  data.tar.gz: 3361ca43ea603a5634e95793cfff46215751a855e2836a92ba6161c4eb07d3fc
+  metadata.gz: 2dcefe52467b8bae3bc12c17e1f36a20b7a5a8a207f21c20d3db413b19f0a15e
+  data.tar.gz: 0cde2181779a22b431d8afd59dc89a80a1a5c58634fd02f7795cc31a9ee874be
 SHA512:
-  metadata.gz: '09ab2d88f40d4b00eed86b3fbab7ab8fcc9b454f98c6f1ab0ac3b7461f97324f9151563540c9700d6e24d2ba47491ada4e611394453bd9b093ed2c026254f4cb'
-  data.tar.gz: ff8ba450b24f98564a455c5994e8e19a3ad8cc0e85e4e3f14530a65a669e2a964ae8484815c14098fa6160c48e61b24a69f8cb46de4da4b5874d8a191881bb60
+  metadata.gz: 5ba3dd8cf78ef49ca4df7ed0521c309b8cc44bc837a0fd14aed5a7f346cced3a5204c56581514b19761d0f081b82edae25298a871eba7dfc409a226819f3a1b5
+  data.tar.gz: 73f97ff7857d9947cfd60036eb8c0b455e603fe73b84d02624ff693f969cfcdef47c8e078c3e7a95cb78fde9ca70fccffc3d2b52c36c9465220adfa4e3e8aa95

data/bin/chatgpt-rb

@@ -3,6 +3,7 @@
 require "dotenv/load"
 require "colorize"
 require "reline"
+require "optparse"
 require_relative "./../lib/chatgpt_rb"
 
 begin
@@ -10,17 +11,83 @@ begin
 rescue
 end
 
+options = {
+  key: ENV["OPEN_AI_KEY"],
+  model: "gpt-3.5-turbo",
+  base_uri: "https://api.openai.com/v1",
+  functions_files: [],
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: chatgpt-rb [options]"
+
+  opts.on("-f", "--file FILE", "Load a previous conversation from FILE") do |file|
+    options[:file] = file
+  end
+
+  opts.on("-k", "--api-key KEY", "Use the provided API key for authentication") do |key|
+    options[:key] = key
+  end
+
+  opts.on("-m", "--model MODEL", "Use the provided MODEL (Default: #{options[:model]})") do |model|
+    options[:model] = model
+  end
+
+  opts.on("-b", "--base-uri URI", "Use the provided base URI (Default: #{options[:base_uri]})") do |uri|
+    options[:base_uri] = uri
+  end
+
+  opts.on("-u", "--functions-file FILE", "Add functions defined in FILE to your conversation") do |functions_file|
+    options[:functions_files] << functions_file
+  end
+
+  opts.on("-p", "--prompt PROMPT", "Declare the PROMPT for your conversation") do |prompt|
+    options[:prompt] = prompt
+  end
+end.parse!
+
 begin
-  conversation = ChatgptRb::Conversation.new(api_key: ENV.fetch("OPEN_AI_KEY"), model: ENV.fetch("OPEN_AI_MODEL", "gpt-3.5-turbo"))
+  puts "Type any message to talk with ChatGPT. Type '\\help' for a list of commands."
+
+  functions = options[:functions_files].map do |function_file|
+              puts "Loading functions from #{function_file}"
+
+              ChatgptRb::DSL::Conversation.new(ChatgptRb::Conversation.new).instance_eval(File.read(function_file))
+            end
+
+  messages = if options[:file]
+               JSON.parse(File.read(options[:file])).map { |hash| hash.transform_keys(&:to_sym) }
+             else
+               []
+             end
+
+  if options[:prompt]
+    puts "prompt> ".colorize(:blue) + options[:prompt]
+  end
 
-  puts "Type any message to talk with ChatGPT. Type 'exit' to quit. Type 'dump' to dump this conversation to JSON."
+  conversation = ChatgptRb::Conversation.new(api_key: options.fetch(:key), model: options.fetch(:model), base_uri: options.fetch(:base_uri), messages:, functions:, prompt: options[:prompt])
 
   while message = Reline.readline("me> ".colorize(:red), true) do
     case message.chomp
-    when "exit", "quit", "q", "\\q"
+    when "\\help", "\\h"
+      puts <<~COMMANDS.colorize(:blue)
+        - `\\quit` Exit
+        - `\\save <filename>` Save this conversation to a JSON file that can be reloaded later with the `-f` argument
+        - `\\functions` Get a list of configured functions
+      COMMANDS
+    when "\\q", "\\quit", "\\exit"
       exit
-    when "dump"
+    when "\\dump"
       puts "dump> ".colorize(:blue) + conversation.messages.to_json
+    when "\\functions"
+      puts "available functions:".colorize(:blue)
+      functions.each do |function|
+        puts "- `#{function.name}` #{function.description}".colorize(:blue)
+      end
+    when /^\\save .+/
+      filename = /^\\save (.+)/.match(message)[1]
+      File.open(filename, "w") { |f| f.write(conversation.messages.to_json) }
+      puts "saved to #{filename} ".colorize(:blue)
     else
       print("ai> ".colorize(:yellow))
       conversation.ask(message) { |fragment| print(fragment) }

data/bin/watcher

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require "listen"
+
+directory_to_watch = Dir.pwd
+
+listener = Listen.to(directory_to_watch) do |modified, added, removed|
+  system("rspec")
+end
+
+listener.start
+puts "Watching #{directory_to_watch} for changes..."
+
+# Stop the listener when the process is terminated
+Signal.trap("INT") { listener.stop }
+Signal.trap("TERM") { listener.stop }
+sleep

data/lib/chatgpt_rb/conversation.rb

@@ -1,12 +1,16 @@
 require "httparty"
+require "json-schema"
+require_relative "./function"
+require_relative "./dsl/conversation"
 
 module ChatgptRb
   class Conversation
-    attr_reader :api_key, :model, :functions, :temperature, :max_tokens, :top_p, :frequency_penalty, :presence_penalty, :messages
+    attr_accessor :api_key, :model, :functions, :temperature, :max_tokens, :top_p, :frequency_penalty, :presence_penalty, :prompt, :base_uri
+    attr_reader :messages
 
     # @param api_key [String]
     # @param model [String]
-    # @param functions [Array<Hash>]
+    # @param functions [Array<Hash>, Array<ChatgptRb::Function>]
     # @param temperature [Float]
     # @param max_tokens [Integer]
     # @param top_p [Float]
@@ -14,63 +18,101 @@ module ChatgptRb
     # @param presence_penalty [Float]
     # @param messages [Array<Hash>]
     # @param prompt [String, nil] instructions that the model can use to inform its responses, for example: "Act like a sullen teenager."
-    def initialize(api_key:, model: "gpt-3.5-turbo", functions: [], temperature: 0.7, max_tokens: 1024, top_p: 1.0, frequency_penalty: 0.0, presence_penalty: 0.0, messages: [], prompt: nil)
+    # @param base_uri [String]
+    def initialize(api_key: nil, model: "gpt-3.5-turbo", functions: [], temperature: 0.7, max_tokens: 1024, top_p: 1.0, frequency_penalty: 0.0, presence_penalty: 0.0, messages: [], prompt: nil, base_uri: "https://api.openai.com/v1", &configuration)
       @api_key = api_key
       @model = model
-      @functions = functions
+      @functions = functions.each_with_object({}) do |function, hash|
+        func = function.is_a?(ChatgptRb::Function) ? function : ChatgptRb::Function.new(**function)
+        hash[func.name] = func
+      end
       @temperature = temperature
       @max_tokens = max_tokens
       @top_p = top_p
       @frequency_penalty = frequency_penalty
       @presence_penalty = presence_penalty
-      @messages = messages
+      @messages = messages.map { |message| message.transform_keys(&:to_sym) }
+      @prompt = prompt
+      @base_uri = base_uri
+      ChatgptRb::DSL::Conversation.configure(self, &configuration) if block_given?
       @messages << { role: "system", content: prompt } if prompt
     end
 
     # @param content [String]
+    # @yieldparam [String] the response, but streamed
+    # @return [String] the response
     def ask(content, &block)
       @messages << { role: "user", content: }
       get_next_response(&block)
     end
 
+    # @param content [String]
+    # @param function [ChatgptRb::Function] temporarily enhance the next response with the provided function
+    # @yieldparam [String] the response, but streamed
+    # @return [String] the response
+    def ask_with_function(content, function, &block)
+      function_was = functions[function.name]
+      functions[function.name] = function
+      get_next_response(content, &block)
+      functions[function.name] = function_was
+    end
+
     private
 
     def <<(message)
       @messages << message
     end
 
+    # Ensure that each function's argument declarations conform to the JSON Schema
+    # See https://github.com/voxpupuli/json-schema/
+    def validate_functions!
+      metaschema = JSON::Validator.validator_for_name("draft4").metaschema
+      functions.values.each do |function|
+        raise ArgumentError, "Invalid function declaration for #{function.name}: #{function.as_json}" unless JSON::Validator.validate(metaschema, function.as_json)
+      end
+    end
+
     def get_next_response(&block)
+      validate_functions!
+
       streamed_content = ""
       streamed_arguments = ""
       streamed_role = ""
       streamed_function = ""
       error_buffer = []
 
+      body = {
+        model:,
+        messages: @messages,
+        temperature:,
+        max_tokens:,
+        top_p:,
+        frequency_penalty:,
+        presence_penalty:,
+        stream: block_given?,
+      }.tap do |hash|
+        hash[:functions] = functions.values.map(&:as_json) unless functions.empty?
+      end
+
       response = HTTParty.post(
-        "https://api.openai.com/v1/chat/completions",
+        "#{base_uri}/chat/completions",
         steam_body: block_given?,
         headers: {
-          "Content-Type": "application/json",
-          "Authorization": "Bearer #{api_key}",
+          "Content-Type" => "application/json",
+          "Authorization" => "Bearer #{api_key}",
+          "Accept" => "application/json",
+          "User-Agent" => "Ruby/chatgpt-rb",
         },
-        body: {
-          model:,
-          messages: @messages,
-          temperature:,
-          max_tokens:,
-          top_p:,
-          frequency_penalty:,
-          presence_penalty:,
-          stream: block_given?,
-        }.tap { |hash| hash[:functions] = functions.map { |hash| hash.except(:implementation) } unless functions.empty? }.to_json,
+        body: body.to_json,
       ) do |fragment|
         if block_given?
           fragment.each_line do |line|
-            next if line.nil?
-            next if line == "\n"
             break if line == "data: [DONE]\n"
 
-            line_without_prefix = line.gsub(/^data: /, "")
+            line_without_prefix = line.gsub(/^data: /, "").rstrip
+
+            next if line_without_prefix.empty?
+
             json = JSON.parse(line_without_prefix)
 
             break if json.dig("choices", 0, "finish_reason")
@@ -100,26 +142,25 @@ module ChatgptRb
       error_buffer.each { |e| $stderr.puts("Error: #{e}") }
 
       @messages << if block_given? && streamed_content != ""
-                     { "content" => streamed_content, "role" => streamed_role }
+                     { content: streamed_content, role: streamed_role }
                    elsif block_given? && streamed_arguments != ""
-                     { "role" => "assistant", "content" => nil, "function_call" => { "name" => streamed_function, "arguments" => streamed_arguments } }
+                     { role: "assistant", content: nil, function_call: { "name" => streamed_function, "arguments" => streamed_arguments } }
                    else
-                     response.dig("choices", 0, "message")
+                     response.dig("choices", 0, "message").transform_keys(&:to_sym)
                    end
 
-      if @messages.last["content"]
-        @messages.last["content"]
-      elsif @messages.last["function_call"]
-        function_args = @messages.last["function_call"]
+      if @messages.last[:content]
+        @messages.last[:content]
+      elsif @messages.last[:function_call]
+        function_args = @messages.last[:function_call]
         function_name = function_args.fetch("name")
         arguments = JSON.parse(function_args.fetch("arguments"))
-
-        function = functions.find { |function| function[:name] == function_name }
-        content = function.fetch(:implementation).call(**arguments.transform_keys(&:to_sym))
+        function = functions[function_name]
+        content = function.implementation.call(**arguments.transform_keys(&:to_sym))
 
         @messages << { role: "function", name: function_name, content: content.to_json }
 
-        get_next_response(functions:, api_key:, model:, temperature:, max_tokens:, top_p:, frequency_penalty:, presence_penalty:, &block)
+        get_next_response(&block)
       end
     end
   end

data/lib/chatgpt_rb/dsl/base.rb

@@ -0,0 +1,29 @@
+module ChatgptRb
+  module DSL
+    class Base
+      # @param object [Chatgpt::Conversation, ChatgptRb::Function, ChatgptRb::Parameter]
+      # @param configuration [Block]
+      # @return [Chatgpt::Conversation, ChatgptRb::Function, ChatgptRb::Parameter]
+      def self.configure(object, &configuration)
+        new(object).instance_eval(&configuration)
+        object
+      end
+
+      attr_reader :object
+
+      # @param object [Chatgpt::Conversation, ChatgptRb::Function, ChatgptRb::Parameter]
+      def initialize(object)
+        @object = object
+      end
+
+      # @param [Array<Symbol>] shorthand for allowing the DSL to set iVars
+      def self.supported_fields(fields)
+        fields.each do |method_name|
+          define_method method_name do |value|
+            object.public_send("#{method_name}=", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chatgpt_rb/dsl/conversation.rb

@@ -0,0 +1,17 @@
+require_relative "./base"
+require_relative "./function"
+require_relative "../function"
+
+module ChatgptRb
+  module DSL
+    class Conversation < Base
+      supported_fields %i[api_key model functions temperature max_tokens top_p frequency_penalty presence_penalty prompt]
+
+      # @param name [String] the name of the function
+      # @param configuration [Block]
+      def function(name, &configuration)
+        object.functions[name] = ChatgptRb::DSL::Function.configure(ChatgptRb::Function.new(name:), &configuration)
+      end
+    end
+  end
+end

data/lib/chatgpt_rb/dsl/function.rb

@@ -0,0 +1,14 @@
+require_relative "../parameter"
+require_relative "./parameter"
+
+module ChatgptRb
+  module DSL
+    class Function < Base
+      supported_fields %i[description implementation parameters]
+
+      def parameter(name, &configuration)
+        object.parameters << ChatgptRb::DSL::Parameter.configure(ChatgptRb::Parameter.new(name:), &configuration)
+      end
+    end
+  end
+end

data/lib/chatgpt_rb/dsl/parameter.rb

@@ -0,0 +1,9 @@
+require_relative "./base"
+
+module ChatgptRb
+  module DSL
+    class Parameter < Base
+      supported_fields %i[description type enum required]
+    end
+  end
+end

data/lib/chatgpt_rb/function.rb

@@ -0,0 +1,31 @@
+module ChatgptRb
+  class Function
+    attr_accessor :name, :description, :parameters, :implementation
+
+    # @param name [String, nil]
+    # @param description [String, nil]
+    # @param parameters [Array<ChatgptRb::Parameter>]
+    # @param implementation [Lambda, nil]
+    def initialize(name: nil, description: nil, parameters: [], implementation: nil)
+      @name = name
+      @description = description
+      @parameters = parameters
+      @implementation = implementation
+    end
+
+    # @return [Hash]
+    def as_json
+      {
+        name:,
+        description:,
+        parameters: {
+          type: "object",
+          properties: parameters.each_with_object({}) do |parameter, hash|
+            hash[parameter.name] = parameter.as_json
+          end,
+        },
+        required: parameters.select(&:required?).map(&:name),
+      }.compact
+    end
+  end
+end

data/lib/chatgpt_rb/parameter.rb

@@ -0,0 +1,31 @@
+module ChatgptRb
+  class Parameter
+    attr_accessor :name, :enum, :type, :description, :required
+
+    # @param name [String]
+    # @param enum
+    # @param type
+    # @param description
+    # @param required [true, false] whether or not this parameter is required
+    def initialize(name:, enum: nil, type: nil, description: nil, required: false)
+      @name = name
+      @enum = enum
+      @type = type
+      @description = description
+      @required = required
+    end
+
+    def required?
+      !!required
+    end
+
+    # @return Hash
+    def as_json
+      {
+        enum:,
+        type:,
+        description:,
+      }.compact
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chatgpt-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Aaron Breckenridge
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-07 00:00:00.000000000 Z
+date: 2023-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -66,6 +66,62 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Provides libraries for interacting with the ChatGPT API and a CLI program
   `chatgpt-rb` for live conversations.
 email:
@@ -76,8 +132,15 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/chatgpt-rb
+- bin/watcher
 - lib/chatgpt_rb.rb
 - lib/chatgpt_rb/conversation.rb
+- lib/chatgpt_rb/dsl/base.rb
+- lib/chatgpt_rb/dsl/conversation.rb
+- lib/chatgpt_rb/dsl/function.rb
+- lib/chatgpt_rb/dsl/parameter.rb
+- lib/chatgpt_rb/function.rb
+- lib/chatgpt_rb/parameter.rb
 homepage: https://github.com/breckenedge/chatgpt-rb
 licenses:
 - MIT