monadic-chat 0.1.1

data/lib/monadic_chat/menu.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+class MonadicApp
+  ##################################################
+  # methods for showing menu and menu items
+  ##################################################
+
+  def show_menu
+    clear_screen
+    print TTY::Cursor.save
+    parameter = PROMPT_SYSTEM.select("Select function:", per_page: 10, cycle: true, filter: true, default: 1, show_help: :never) do |menu|
+      menu.choice "#{BULLET} #{PASTEL.bold("cancel/return/escape")}   cancel this menu", "cancel"
+      menu.choice "#{BULLET} #{PASTEL.bold("params/settings/config")} show and change values of parameters", "params"
+      menu.choice "#{BULLET} #{PASTEL.bold("data/context")}           show currrent contextual info", "data"
+      menu.choice "#{BULLET} #{PASTEL.bold("html")}                   view contextual info on the web browser", "html"
+      menu.choice "#{BULLET} #{PASTEL.bold("reset")}                  reset context to original state", "reset"
+      menu.choice "#{BULLET} #{PASTEL.bold("save")}                   save current contextual info to file", "save"
+      menu.choice "#{BULLET} #{PASTEL.bold("load")}                   load current contextual info from file", "load"
+      menu.choice "#{BULLET} #{PASTEL.bold("clear/clean")}            clear screen", "clear"
+      menu.choice "#{BULLET} #{PASTEL.bold("readme/documentation")}   open readme/documentation", "readme"
+      menu.choice "#{BULLET} #{PASTEL.bold("exit/bye/quit")}          go back to main menu", "exit"
+    end
+
+    print TTY::Cursor.restore
+    print TTY::Cursor.clear_screen_down
+    print TTY::Cursor.restore
+
+    case parameter
+    when "cancel"
+      return true
+    when "params"
+      change_parameter
+    when "data"
+      show_data
+    when "html"
+      set_html
+    when "reset"
+      reset
+    when "save"
+      save_data
+    when "load"
+      load_data
+    when "clear"
+      clear_screen
+      print TTY::Cursor.clear_screen_down
+    when "readme"
+      MonadicChat.open_readme
+    when "exit"
+      return false
+    end
+    true
+  end
+
+  def reset
+    @params = @params_original.dup
+
+    case @method
+    when "completions"
+      @template = @template_original.dup
+    when "chat/completions"
+      @template = JSON.parse @template_original
+    end
+
+    if @placeholders.empty?
+      print PROMPT_SYSTEM.prefix
+      print "Context and parameters have been reset.\n"
+    else
+      fulfill_placeholders
+    end
+  end
+
+  def ask_retrial(input, message = nil)
+    print PROMPT_SYSTEM.prefix
+    print " Error: #{message.capitalize}\n" if message
+    retrial = PROMPT_USER.select("Do you want to try again?",
+                                 show_help: :never) do |menu|
+                                   menu.choice "Yes", "yes"
+                                   menu.choice "No", "no"
+                                   menu.choice "Show current contextual data", "show"
+                                 end
+    case retrial
+    when "yes"
+      input
+    when "no"
+      user_input
+    when "show"
+      show_data
+      ask_retrial(input)
+    end
+  end
+
+  def check_file(path)
+    dirname = File.dirname(File.expand_path(path))
+    path == "" || (/\.json\z/ =~ path.strip && Dir.exist?(dirname)) ? true : false
+  end
+
+  def save_data
+    input = ""
+    loop do
+      print TTY::Cursor.save
+      path = PROMPT_SYSTEM.readline("Enter the file path for the JSON file (including the file name and .json extension): ")
+      if check_file(path)
+        input = path
+        break
+      else
+        print TTY::Cursor.restore
+        print TTY::Cursor.clear_screen_down
+      end
+    end
+    print TTY::Cursor.save
+
+    return if input.to_s == ""
+
+    filepath = File.expand_path(input.strip)
+
+    if File.exist? filepath
+      overwrite = PROMPT_SYSTEM.select("#{filepath} already exists.\nOverwrite?",
+                                       show_help: :never) do |menu|
+                                         menu.choice "Yes", "yes"
+                                         menu.choice "No", "no"
+                                       end
+      return if overwrite == "no"
+    end
+
+    FileUtils.touch(filepath)
+    unless File.exist? filepath
+      print "File cannot be created\n"
+      save_data
+    end
+
+    begin
+      File.open(filepath, "w") do |f|
+        case @method
+        when "completions"
+          m = /\n\n```json\s*(\{.+\})\s*```\n\n/m.match(@template)
+          f.write JSON.pretty_generate(JSON.parse(m[1]))
+        when "chat/completions"
+          f.write JSON.pretty_generate(@template)
+        end
+
+        print "Data has been saved successfully\n"
+      end
+      true
+    rescue StandardError
+      print "Error: Something went wrong"
+      false
+    end
+  end
+
+  def load_data
+    input = ""
+    loop do
+      print TTY::Cursor.save
+      path = PROMPT_SYSTEM.readline("Enter the file path for the JSON file (press Enter to cancel): ")
+      if check_file(path)
+        input = path
+        break
+      else
+        print TTY::Cursor.restore
+        print TTY::Cursor.clear_screen_down
+      end
+    end
+    print TTY::Cursor.save
+
+    return if input.to_s == ""
+
+    begin
+      filepath = File.expand_path(input.strip)
+      json = File.read(filepath)
+      data = JSON.parse(json)
+      case @method
+      when "completions"
+        raise unless data["mode"] == self.class.name.downcase.split("::")[-1]
+
+        new_template = @template.sub(/\n\n```json\s*\{.+\}\s*```\n\n/m, "\n\n```json\n#{JSON.pretty_generate(data).strip}\n```\n\n")
+        @template = new_template
+      when "chat/completions"
+        raise unless data["messages"] && data["messages"][0]["role"]
+
+        @template["messages"] = data["messages"]
+      end
+      print "Data has been loaded successfully\n"
+      true
+    rescue StandardError
+      print "The data structure is not valid for this app\n"
+      false
+    end
+  end
+end

data/lib/monadic_chat/open_ai.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "http"
+require "oj"
+require "net/http"
+require "uri"
+require "strscan"
+require "parallel"
+require "tty-progressbar"
+
+Oj.mimic_JSON
+
+module OpenAI
+  def self.model_name(research_mode: false)
+    research_mode ? "text-davinci-003" : "gpt-3.5-turbo"
+  end
+
+  def self.model_to_method(model)
+    {
+      "text-davinci-003" => "completions",
+      "gpt-3.5-turbo" => "chat/completions",
+      "gpt-3.5-turbo-0301" => "chat/completions"
+    }[model]
+  end
+
+  def self.query(access_token, mode, method, timeout_sec = 60, query = {}, &block)
+    target_uri = "https://api.openai.com/v1/#{method}"
+    headers = {
+      "Content-Type" => "application/json",
+      "Authorization" => "Bearer #{access_token}"
+    }
+    headers["Accept"] = "text/event-stream" if query["stream"]
+    http = HTTP.headers(headers)
+
+    case mode
+    when "post"
+      res = http.timeout(timeout_sec).post(target_uri, json: query)
+    when "get"
+      res = http.timeout(timeout_sec).get(target_uri)
+    end
+
+    if query["stream"]
+      json = nil
+      res.body.each do |chunk|
+        chunk.split("\n\n").each do |data|
+          content = data.strip[6..]
+          break if content == "[DONE]"
+
+          stream = JSON.parse(content)
+          fragment = case method
+                     when "completions"
+                       stream["choices"][0]["text"]
+                     when "chat/completions"
+                       stream["choices"][0]["delta"]["content"] || ""
+                     end
+          block&.call fragment
+          if !json
+            json = stream
+          else
+            case method
+            when "completions"
+              json["choices"][0]["text"] << fragment
+            when "chat/completions"
+              json["choices"][0]["text"] ||= +""
+              json["choices"][0]["text"] << fragment
+            end
+          end
+        end
+      end
+      json
+    else
+      JSON.parse res.body
+    end
+  end
+
+  def self.models(access_token)
+    res = query(access_token, "get", "models")
+    res.fetch("data", []).sort_by { |m| -m["created"] }
+  end
+
+  class Completion
+    attr_reader :access_token
+
+    def initialize(access_token, tmp_file: nil)
+      @access_token = access_token
+      @tmp_file = tmp_file
+    end
+
+    def models
+      OpenAI.models(@access_token)
+    end
+
+    def run(params, num_retry: 1, &block)
+      method = OpenAI.model_to_method(params["model"])
+
+      response = OpenAI.query(@access_token, "post", method, 60, params, &block)
+      if response["error"]
+        raise response["error"]["message"]
+      elsif response["choices"][0]["finish_reason"] == "length"
+        raise "finished because of length"
+      end
+
+      case method
+      when "completions"
+        get_json response ["choices"][0]["text"]
+      when "chat/completions"
+        response ["choices"][0]["text"]
+      end
+    rescue StandardError => e
+      case num_retry
+      when 0
+        raise e
+      else
+        run(params, num_retry: num_retry - 1, &block)
+      end
+    end
+
+    def get_json(data)
+      case data
+      when %r{<JSON>\n*(\{.+\})\n*</JSON>}m
+        json = Regexp.last_match(1).gsub(/\r\n?/, "\n").gsub(/\r\n/) { "\n" }
+        res = JSON.parse(json)
+      when /(\{.+\})/m
+        json = Regexp.last_match(1).gsub(/\r\n?/, "\n").gsub(/\r\n/) { "\n" }
+        res = JSON.parse(json)
+      else
+        res = data
+      end
+      File.open(@tmp_file, "w") { |f| f.write json } if @tmp_file
+      res
+    end
+
+    def run_iteration(params, prompts, template, replace_key = "{{PROMPT}}", num_retry: 0)
+      bar = TTY::ProgressBar.new("[:bar] :current/:total :total_byte :percent ET::elapsed ETA::eta",
+                                 total: prompts.size,
+                                 bar_format: :box)
+      bar.start
+      json = ""
+      prompts.each do |prompt|
+        params["prompt"] = template.sub(replace_key, prompt)
+        res = run(params, num_retry: num_retry)
+        json = JSON.pretty_generate(res)
+        bar.advance(1)
+        template = template.sub(/\n\n```json.+?```\n\n/m, "\n\n```json\n#{json}\n```\n\n")
+      end
+      bar.finish
+      JSON.parse(json)
+    end
+  end
+end

data/lib/monadic_chat/parameters.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+class MonadicApp
+  ##################################################
+  # methods for parametter setting
+  ##################################################
+
+  def change_parameter
+    parameter = PROMPT_SYSTEM.select("Select the parmeter to be set:", per_page: 7, cycle: true, show_help: :never, filter: true, default: 1) do |menu|
+      menu.choice "#{BULLET} Cancel", "cancel"
+      menu.choice "#{BULLET} model: #{@params["model"]}", "model"
+      menu.choice "#{BULLET} max_tokens: #{@params["max_tokens"]}", "max_tokens"
+      menu.choice "#{BULLET} temperature: #{@params["temperature"]}", "temperature"
+      menu.choice "#{BULLET} top_p: #{@params["top_p"]}", "top_p"
+      menu.choice "#{BULLET} frequency_penalty: #{@params["frequency_penalty"]}", "frequency_penalty"
+      menu.choice "#{BULLET} presence_penalty: #{@params["presence_penalty"]}", "presence_penalty"
+    end
+    return if parameter == "cancel"
+
+    case parameter
+    when "model"
+      value = change_model
+      case @method
+      when "completions"
+        @template = @template_original.dup
+      when "chat/completions"
+        @template = JSON.parse @template_original
+      end
+    when "max_tokens"
+      value = change_max_tokens
+    when "temperature"
+      value = change_temperature
+    when "top_p"
+      value = change_top_p
+    when "frequency_penalty"
+      value = change_frequency_penalty
+    when "presence_penalty"
+      value = change_presence_penalty
+    end
+    @params[parameter] = value if value
+    print "Parameter #{parameter} has been set to #{PASTEL.green(value)}\n" if value
+  end
+
+  def change_max_tokens
+    PROMPT_SYSTEM.ask("Set value of max tokens [1000 to 8000]:", convert: :int) do |q|
+      q.in "1000-8000"
+      q.messages[:range?] = "Value out of expected range [1000 to 2048]"
+    end
+  end
+
+  def change_temperature
+    PROMPT_SYSTEM.ask("Set value of temperature [0.0 to 1.0]:", convert: :float) do |q|
+      q.in "0.0-1.0"
+      q.messages[:range?] = "Value out of expected range [0.0 to 1.0]"
+    end
+  end
+
+  def change_top_p
+    PROMPT_SYSTEM.ask("Set value of top_p [0.0 to 1.0]:", convert: :float) do |q|
+      q.in "0.0-1.0"
+      q.messages[:range?] = "Value out of expected range [0.0 to 1.0]"
+    end
+  end
+
+  def change_frequency_penalty
+    PROMPT_SYSTEM.ask("Set value of frequency penalty [-2.0 to 2.0]:", convert: :float) do |q|
+      q.in "-2.0-2.0"
+      q.messages[:range?] = "Value out of expected range [-2.0 to 2.0]"
+    end
+  end
+
+  def change_presence_penalty
+    PROMPT_SYSTEM.ask("Set value of presence penalty [-2.0 to 2.0]:", convert: :float) do |q|
+      q.in "-2.0-2.0"
+      q.messages[:range?] = "Value out of expected range [-2.0 to 2.0]"
+    end
+  end
+
+  def change_model
+    model = PROMPT_SYSTEM.select("Select a model:", per_page: 10, cycle: false, show_help: :never, filter: true, default: 1) do |menu|
+      menu.choice "#{BULLET} Cancel", "cancel"
+      TTY::Cursor.save
+      print SPINNER
+      models = @completion.models
+      go_up_and_clear
+      TTY::Cursor.restore
+      TTY::Cursor.restore
+      models.filter { |m| OpenAI.model_to_method(m["id"]) == @method }.sort_by { |m| -m["created"] }.each do |m|
+        menu.choice "#{BULLET} #{m["id"]}", m["id"]
+      end
+    end
+    if model == "cancel"
+      nil
+    else
+      model
+    end
+  end
+
+  def show_params
+    params_md = "# Current Parameter Values\n\n"
+    @params.each do |key, val|
+      next if /\A(?:prompt|stream|logprobs|echo|stop)\z/ =~ key
+
+      params_md += "- #{key}: #{val}\n"
+    end
+    print prompt_system, "\n"
+    print "#{TTY::Markdown.parse(params_md, indent: 0).strip}\n\n"
+  end
+end

data/lib/monadic_chat/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MonadicChat
+  VERSION = "0.1.1"
+end

data/lib/monadic_chat.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "tty-cursor"
+require "tty-screen"
+require "tty-markdown"
+require "tty-prompt"
+require "tty-box"
+require "pastel"
+require "oj"
+require "kramdown"
+require "rouge"
+require "launchy"
+require "io/console"
+require "readline"
+
+require_relative "./monadic_chat/version"
+require_relative "./monadic_chat/open_ai"
+require_relative "./monadic_chat/helper"
+
+Oj.mimic_JSON
+
+module MonadicChat
+  CONFIG = File.join(Dir.home, "monadic_chat.conf")
+  NUM_RETRY = 2
+  MIN_LENGTH = 5
+  TIMEOUT_SEC = 120
+  TITLE_WIDTH = 72
+
+  APPS_DIR = File.absolute_path(File.join(__dir__, "..", "apps"))
+  APPS_DIR_LIST = Dir.entries(APPS_DIR)
+                     .reject { |entry| /\A\./ =~ entry || /\A_/ =~ entry.split("/").last }
+                     .map { |entry| File.join(APPS_DIR, entry) }
+  templates = {}
+  APPS_DIR_LIST.each do |app|
+    basename = File.basename(app, ".*")
+    normal_mode_template = File.absolute_path(File.join(app, "#{basename}.json"))
+    templates["normal/#{basename}"] = normal_mode_template if File.exist? normal_mode_template
+    research_mode_template = File.absolute_path(File.join(app, "#{basename}.md"))
+    templates["research/#{basename}"] = research_mode_template if File.exist? research_mode_template
+  end
+  APPS = APPS_DIR_LIST.map { |dir| File.basename(dir, ".*") }
+
+  TEMPLATES = templates
+
+  PASTEL = Pastel.new
+
+  TEMP_HTML = File.join(Dir.home, "monadic_chat.html")
+  TEMP_JSON = File.join(Dir.home, "monadic_chat.json")
+
+  style = +File.read(File.join(__dir__, "..", "assets", "github.css")).gsub(".markdown-") { "" }
+  style << File.read(File.join(__dir__, "..", "assets", "pigments-default.css"))
+  style << <<~CSS
+    body {
+      margin: 50px;
+      font-family: "Helvetica Neue", Arial, "Hiragino Kaku Gothic ProN", "Hiragino Sans", Meiryo, sans-serif;
+      color: #333
+    }
+    .monadic_user{
+      display:inline-block;
+      padding-left: 0.5em;
+      padding-right: 0.5em;
+      font-weight: bold;
+      background-color: #c8e5ff;
+      margin-bottom: 0.5em;
+    }
+    .monadic_chat {
+      display:inline-block;
+      padding-left: 0.5em;
+      padding-right: 0.5em;
+      font-weight: bold;
+      background-color: #ffcaca;
+      margin-bottom: 0.5em;
+    }
+    .monadic_system {
+      display:inline-block;
+      padding-left: 0.5em;
+      padding-right: 0.5em;
+      font-weight: bold;
+      background-color: #c4ffcb;
+      margin-bottom: 0.5em;
+    }
+    .monadic_gray {
+      display:inline-block;
+      font-weight: bold;
+      color: #999;
+      margin-bottom: 0.5em;
+    }
+    .monadic_app {
+      display:inline-block;
+      font-weight: bold;
+      color: #EB742B;
+      margin-bottom: 0.5em;
+    }
+  CSS
+  GITHUB_STYLE = style
+
+  def self.require_apps
+    MonadicChat::APPS_DIR_LIST.each do |app_dir|
+      basename = app_dir.split("/").last
+      require "#{app_dir}/#{basename}"
+    end
+  end
+
+  def self.open_readme
+    url = "https://github.com/yohasebe/monadic-chat/"
+    shellscript = <<~SHELL
+      if [[ "$OSTYPE" == "darwin"* ]]; then
+        open "#{url}"
+      elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+        if command -v xdg-open >/dev/null 2>&1; then
+          xdg-open "#{url}"
+        else
+          echo "#{url}"
+        fi
+      else
+        echo "#{url}"
+      fi
+    SHELL
+    `#{shellscript}`
+  end
+
+  def self.authenticate(overwrite: false)
+    check = lambda do |token|
+      print "Checking configuration #{SPINNER} "
+      begin
+        raise if OpenAI.models(token).empty?
+
+        print "success\n"
+        OpenAI::Completion.new(token, tmp_file: TEMP_JSON)
+      rescue StandardError
+        print "failure.\n"
+        authenticate(overwrite: true)
+      end
+    end
+
+    access_token = ENV["OPENAI_API_KEY"]
+    if overwrite
+      access_token = nil
+      access_token ||= PROMPT_SYSTEM.ask(" Input your OpenAI access token:")
+
+      check.call(access_token)
+
+      File.open(CONFIG, "w") do |f|
+        config = { "access_token" => access_token }
+        f.write(JSON.pretty_generate(config))
+        print "New access token has been saved to #{CONFIG}\n"
+      end
+    elsif File.exist?(CONFIG)
+      json = File.read(CONFIG)
+      config = JSON.parse(json)
+      access_token = config["access_token"]
+      check.call(access_token)
+    else
+      access_token ||= PROMPT_SYSTEM.ask(" Input your OpenAI access token:")
+      check.call(access_token)
+      File.open(CONFIG, "w") do |f|
+        config = { "access_token" => access_token }
+        f.write(JSON.pretty_generate(config))
+        print "Access token has been saved to #{CONFIG}\n"
+      end
+    end
+  end
+
+  def self.prompt_system
+    box_width = 8
+    name = "System".center(box_width, " ")
+    color = "green"
+    "\n#{PASTEL.send(:"on_#{color}", name)}"
+  end
+
+  def self.prompt_user
+    box_width = 6
+    color = "blue"
+    name = "User".center(box_width, " ")
+    "\n#{PASTEL.send(:"on_#{color}", name)}"
+  end
+
+  def self.prompt_assistant
+    box_width = 5
+    color = "red"
+    name = "GPT".center(box_width, " ")
+    "\n#{PASTEL.send(:"on_#{color}", name)}"
+  end
+
+  PROMPT_USER = TTY::PromptX.new(active_color: :blue, prefix: prompt_user)
+  PROMPT_SYSTEM = TTY::PromptX.new(active_color: :blue, prefix: "#{prompt_system} ")
+  PROMPT_ASSISTANT = TTY::PromptX.new(active_color: :red, prefix: "#{prompt_assistant} ")
+  SPINNER = "▹▹▹▹"
+  BULLET = "\e[33m●\e[0m"
+end

data/monadic_chat.gemspec

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "lib/monadic_chat/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "monadic-chat"
+  spec.version = MonadicChat::VERSION
+  spec.authors = ["yohasebe"]
+  spec.email = ["yohasebe@gmail.com"]
+
+  spec.summary = "Highly configurable CLI client app for OpenAI chat/text-completion API"
+  spec.description = <<~DESC
+    Monadic Chat is a command-line client application program that uses OpenAI's Text Completion API and Chat API to enable chat-style conversations with OpenAI's artificial intelligence system in a ChatGPT-like style.
+  DESC
+  spec.homepage = "https://github.com/yohasebe/monadic-chat"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/yohasebe/monadic-chat"
+  spec.metadata["changelog_uri"] = "https://github.com/yohasebe/monadic-chat/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "bin"
+  spec.executables = ["monadic-chat"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "solargraph"
+
+  spec.add_dependency "http"
+  spec.add_dependency "kramdown"
+  spec.add_dependency "launchy"
+  spec.add_dependency "oj"
+  spec.add_dependency "parallel"
+  spec.add_dependency "pastel"
+  spec.add_dependency "rouge"
+  spec.add_dependency "tty-box"
+  spec.add_dependency "tty-cursor"
+  spec.add_dependency "tty-markdown"
+  spec.add_dependency "tty-progressbar"
+  spec.add_dependency "tty-prompt"
+  spec.add_dependency "tty-screen"
+end