monadic-chat 0.3.3 → 0.3.5

data/lib/monadic_chat/commands.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module MonadicChat
+  def self.open_readme
+    url = "https://github.com/yohasebe/monadic-chat/"
+    Launchy.open(url)
+  end
+
+  def self.mdprint(str)
+    print TTY::Markdown.parse(str, indent: 0)
+  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
+
+  def self.tokenize(text)
+    BLINGFIRE.text_to_ids(text)
+  end
+
+  def self.create_app(app_name)
+    app_name = +app_name.downcase
+    user_apps_dir = File.join(HOME, "user_apps")
+    user_app_dir = File.join(user_apps_dir, app_name)
+    FileUtils.mkdir_p(user_app_dir)
+    # replace certain strings in boilerplate files (boilerplate.rb, boilerplate.json, boilerplate.md)
+    [".rb", ".json", ".md"].each do |ext|
+      file = File.join(HOME, "user_apps", "boilerplates", "boilerplate#{ext}")
+      content = File.read(file)
+      content.gsub!("{{APP_NAME}}", app_name)
+      content.gsub!("{{APP_CLASS_NAME}}", app_name.capitalize)
+      File.open(File.join(user_app_dir, "#{app_name}#{ext}"), "w") do |f|
+        f.write(content)
+      end
+    end
+    print PROMPT_SYSTEM.prefix, "Scaffolding of the app created successfully", "\n"
+    print "Edit the app files:", "\n"
+    print HOME, "\n"
+    print "user_apps", "\n"
+    print "└── #{app_name}", "\n"
+    print "    ├── #{app_name}.json", "\n"
+    print "    ├── #{app_name}.md", "\n"
+    print "    └── #{app_name}.rb", "\n"
+  end
+
+  def self.delete_app(app_name)
+    app_name = +app_name.downcase
+    user_apps_dir = File.join(HOME, "user_apps")
+    user_app_dir = File.join(user_apps_dir, app_name)
+    # confirm user wants to delete the app
+    if PROMPT_SYSTEM.yes?("Are you sure you want to delete the app #{app_name}?")
+      FileUtils.rm_rf(user_app_dir)
+      print PROMPT_SYSTEM.prefix, "App deleted successfully", "\n"
+    else
+      print PROMPT_SYSTEM.prefix, "App deletion cancelled", "\n"
+    end
+  end
+end

data/lib/monadic_chat/formatting.rb

@@ -4,6 +4,13 @@ class MonadicApp
   ##################################################
   # methods for formatting and presenting
   ##################################################
+
+  def show_template
+    puts "-----------------------------------------"
+    puts @template
+    puts "-----------------------------------------"
+  end
+
   def format_data
     contextual = []
     accumulator = []
@@ -14,7 +21,7 @@ class MonadicApp
 
         contextual << "- **#{key.split("_").map(&:capitalize).join(" ")}**: #{val.to_s.strip}"
       end
-      contextual << "- **Num of Tokens in Template**: #{count_tokens(@template)}"
+      contextual << "- **Num of Tokens in Template**: #{@template_tokens}"
     end
 
     @messages.each do |m|

data/lib/monadic_chat/interaction.rb

@@ -6,14 +6,9 @@ class MonadicApp
   ##################################################
 
   def user_input(text = "")
-    # if count_lines_below < 1
-    #   ask_clear
-    #   user_input
-    # else
     res = PROMPT_USER.readline(text)
     print TTY::Cursor.clear_line_after
     res == "" ? nil : res
-    # end
   end
 
   def show_greet
@@ -32,7 +27,7 @@ class MonadicApp
   end
 
   def confirm_query(input)
-    if input.size < MIN_LENGTH
+    if input.size < SETTINGS["min_query_size"]
       PROMPT_SYSTEM.yes?("Would you like to proceed with this (very short) prompt?")
     else
       true

data/lib/monadic_chat/internals.rb

@@ -56,10 +56,15 @@ class MonadicApp
     end
   end
 
-  def prepare_params(input)
+  def prepare_params(input_role, input)
     params = @params.dup
 
-    @update_proc.call
+    delimited_input = case input_role
+                      when "user"
+                        "NEW PROMPT: ###\n#{input}\n###"
+                      when "system" # i.e. search engine
+                        "SEARCH SNIPPETS: ###\n#{input}\n###"
+                      end
 
     case @mode
     when :research
@@ -70,20 +75,22 @@ class MonadicApp
         content = mes["content"]
         case role
         when "system"
-          system << "#{content}\n"
-        when "assistant", "gpt"
-          messages << "- #{mes["role"].strip}: #{content}\n"
+          system << "#{content}\n" if system == ""
         else
-          messages << "- #{mes["role"].strip}: #{mes["content"]}\n"
+          messages << "- #{mes["role"].strip}: #{content}\n"
         end
       end
+
+      delimited_messages = "MESSAGES: ###\n#{messages}\n###"
       template = @template.dup.sub("{{SYSTEM}}", system)
-                          .sub("{{PROMPT}}", input)
-                          .sub("{{MESSAGES}}", messages.strip)
+                          .sub("{{PROMPT}}", delimited_input)
+                          .sub("{{MESSAGES}}", delimited_messages.strip)
+
+      @template_tokens = count_tokens(template)
 
       File.open(TEMP_MD, "w") { |f| f.write template }
 
-      @messages << { "role" => "user", "content" => input }
+      @messages << { "role" => input_role, "content" => input }
 
       case @method
       when "completions"
@@ -93,18 +100,20 @@ class MonadicApp
       end
 
     when :normal
-      @messages << { "role" => "user", "content" => input }
+      @messages << { "role" => input_role, "content" => input }
       params["messages"] = @messages
     end
 
+    @update_proc.call unless input_role == "system"
+
     params
   end
 
-  def update_template(res)
+  def update_template(res, role)
     case @mode
     when :research
       @metadata = res
-      @messages << { "role" => "assistant", "content" => @metadata["response"] }
+      @messages << { "role" => role, "content" => @metadata["response"] }
       json = @metadata.to_json.strip
       File.open(TEMP_JSON, "w") { |f| f.write json }
       @template.sub!(/JSON:\n+```json.+```\n\n/m, "JSON:\n\n```json\n#{json}\n```\n\n")
@@ -113,19 +122,42 @@ class MonadicApp
     end
   end
 
+  ##################################################
+  # function to package plain text into a unit
+  ##################################################
+
+  def unit(input)
+    if input.instance_of?(Hash)
+      input
+    else
+      @metadata["response"] = input
+      @metadata
+    end
+  end
+
   ##################################################
   # function to bind data
   ##################################################
 
-  def bind(input, num_retry: 0)
+  def bind(input, role: "user", num_retrials: 0)
+    case role
+    when "user"
+      @turns += 1
+    when "system" # i.e. search engine
+      input = "\n\n#{input}"
+    end
+
     print PROMPT_ASSISTANT.prefix, "\n"
-    params = prepare_params(input)
+    params = prepare_params(role, input)
     research_mode = @mode == :research
 
     escaping = +""
     last_chunk = +""
 
-    res = @completion.run(params, research_mode: research_mode, num_retry: num_retry) do |chunk|
+    res = @completion.run(params,
+                          research_mode: research_mode,
+                          timeout_sec: SETTINGS["timeout_sec"],
+                          num_retrials: num_retrials) do |chunk|
       if escaping
         chunk = escaping + chunk
         escaping = ""
@@ -145,7 +177,56 @@ class MonadicApp
     print last_chunk
     print "\n"
 
-    update_template(res)
+    message = case role
+              when "system" # i.e. search engine; the response given above should be by "assistant"
+                { role: "assistant", content: @mode == :research ? unit(res) : res }
+              when "user" # the response give above should be either "assistant"
+                searched = use_tool(res)
+                # but if the response is a search query, it should be by "system" (search engine)
+                if searched
+                  @messages << { "role" => "assistant",
+                                 "content" => @mode == :research ? unit(res)["response"] : res }
+                  if searched == "empty"
+                    print PROMPT_SYSTEM.prefix, "Search results are empty", "\n"
+                    return
+                  else
+                    bind(searched, role: "system")
+                    return
+                  end
+                # otherwise, it should be by "assistant"
+                else
+                  { role: "assistant", content: @mode == :researh ? unit(res) : res }
+                end
+              end
+
+    update_template(message[:content], message[:role])
+
     set_html if @html
   end
+
+  ##################################################
+  # function to have GPT use tools
+  ##################################################
+
+  def use_tool(res)
+    case @mode
+    when :normal
+      text = res
+    when :research
+      text = res.is_a?(Hash) ? res["response"] : res
+    end
+
+    case text
+    when /\bSEARCH_WIKI\("?(.+?)"?\)/m
+      @wiki_search_cache ||= {}
+      search_key = Regexp.last_match(1)
+      wikipedia_search(search_key, @wiki_search_cache)
+    when /\bSEARCH_WEB\("?(.+?)"?\)/m
+      @web_search_cache ||= {}
+      search_key = Regexp.last_match(1)
+      bing_search(search_key, @web_searh_cache)
+    else
+      false
+    end
+  end
 end

data/lib/monadic_chat/menu.rb

@@ -57,6 +57,7 @@ class MonadicApp
     @params = @params_initial.dup
     @messages = @messages_initial.dup
     @template = @template_initial.dup
+    @template_tokens = 0
 
     if @placeholders.empty?
       print PROMPT_SYSTEM.prefix
@@ -68,7 +69,7 @@ class MonadicApp
 
   def ask_retrial(input, message = nil)
     print PROMPT_SYSTEM.prefix
-    print " Error: #{message.capitalize}\n" if message
+    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"

data/lib/monadic_chat/open_ai.rb

@@ -10,9 +10,9 @@ require "tty-progressbar"
 Oj.mimic_JSON
 
 module OpenAI
-  def self.model_name(research_mode: false)
+  def self.default_model(research_mode: false)
     if research_mode
-      "text-davinci-003"
+      "gpt-3.5-turbo"
     else
       "gpt-3.5-turbo"
     end
@@ -88,28 +88,18 @@ module OpenAI
   class Completion
     attr_reader :access_token
 
-    def initialize(access_token, normal_mode_model = nil, research_mode_model = nil)
+    def initialize(access_token)
       @access_token = access_token
-      @normal_mode_model = normal_mode_model || OpenAI.model_name(research_mode: false)
-      @research_mode_model = research_mode_model || OpenAI.model_name(research_mode: true)
-    end
-
-    def model_name(research_mode: false)
-      if research_mode
-        @research_mode_model
-      else
-        @normal_mode_model
-      end
     end
 
     def models
       OpenAI.models(@access_token)
     end
 
-    def run(params, research_mode: false, num_retry: 1, &block)
+    def run(params, research_mode: false, timeout_sec: 60, num_retrials: 1, &block)
       method = OpenAI.model_to_method(params["model"])
 
-      response = OpenAI.query(@access_token, "post", method, 60, params, &block)
+      response = OpenAI.query(@access_token, "post", method, timeout_sec, params, &block)
       if response["error"]
         raise response["error"]["message"]
       elsif response["choices"][0]["finish_reason"] == "length"
@@ -122,11 +112,11 @@ module OpenAI
         response["choices"][0]["text"]
       end
     rescue StandardError => e
-      case num_retry
+      case num_retrials
       when 0
         raise e
       else
-        run(params, num_retry: num_retry - 1, &block)
+        run(params, research_mode: research_mode, timeout_sec: timeout_sec, num_retrials: num_retrials - 1, &block)
       end
     end
 
@@ -144,7 +134,7 @@ module OpenAI
       res
     end
 
-    def run_iteration(params, prompts, template, replace_key = "{{PROMPT}}", num_retry: 0)
+    def run_iteration(params, prompts, template, replace_key = "{{PROMPT}}", timeout_sec: 60, num_retrials: 0)
       bar = TTY::ProgressBar.new("[:bar] :current/:total :total_byte :percent ET::elapsed ETA::eta",
                                  total: prompts.size,
                                  bar_format: :box)
@@ -152,7 +142,7 @@ module OpenAI
       json = ""
       prompts.each do |prompt|
         params["prompt"] = template.sub(replace_key, prompt)
-        res = run(params, num_retry: num_retry)
+        res = run(params, timeout_sec: timeout_sec, num_retrials: num_retrials)
         json = JSON.pretty_generate(get_json(res))
         bar.advance(1)
         template = template.sub(/JSON:\n+```json.+?```\n\n/m, "JSON:\n\n```json\n#{json}\n```\n\n")

data/lib/monadic_chat/tools.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class MonadicApp
+  ##################################################
+  # method for web search
+  ##################################################
+
+  def bing_search(query, num_retrial: 3)
+    base_uri = "https://www.bing.com/search?setlang=en"
+    css_selector = "#b_results"
+
+    q = URI.encode_www_form(q: query)
+    doc = Nokogiri::HTML(URI.parse([base_uri, q].join("&")).read)
+    doc.css("script, link").each(&:remove)
+    doc.css(css_selector).text.squeeze(" \n")
+  rescue StandardError
+    num_retrial -= 1
+    if num_retrial.positive?
+      sleep 1
+      bing_search(keywords, num_retrial: num_retrial)
+    else
+      "empty"
+    end
+  end
+
+  def wikipedia_search(keywords, cache = {}, num_retrial: 10)
+    base_url = "https://en.wikipedia.org/w/api.php"
+    search_params = {
+      action: "query",
+      list: "search",
+      format: "json",
+      srsearch: keywords,
+      utf8: 1,
+      formatversion: 2
+    }
+
+    search_uri = URI(base_url)
+    search_uri.query = URI.encode_www_form(search_params)
+    search_response = Net::HTTP.get(search_uri)
+    search_data = JSON.parse(search_response)
+
+    raise if search_data["query"]["search"].empty?
+
+    title = search_data["query"]["search"][0]["title"]
+
+    return cache[title] if cache.keys.include?(title)
+
+    content_params = {
+      action: "query",
+      prop: "extracts",
+      format: "json",
+      titles: title,
+      explaintext: 1,
+      utf8: 1,
+      formatversion: 2
+    }
+
+    content_uri = URI(base_url)
+    content_uri.query = URI.encode_www_form(content_params)
+    content_response = Net::HTTP.get(content_uri)
+    content_data = JSON.parse(content_response)
+
+    result_data = content_data["query"]["pages"][0]["extract"]
+    tokenized = BLINGFIRE.text_to_ids(result_data)
+    if tokenized.size > SETTINGS["max_tokens_wiki"].to_i
+      ratio = SETTINGS["max_tokens_wiki"].to_f / tokenized.size
+      result_data = result_data[0..(result_data.size * ratio).to_i]
+    end
+
+    text = <<~TEXT
+      ```MediaWiki
+      #{result_data}
+      ```
+    TEXT
+    cache[title] = text
+
+    text
+  rescue StandardError
+    num_retrial -= 1
+    if num_retrial.positive?
+      sleep 1
+      wikipedia_search(keywords, num_retrial: num_retrial)
+    else
+      "empty"
+    end
+  end
+end

data/lib/monadic_chat/version.rb

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

data/lib/monadic_chat.rb

@@ -14,26 +14,45 @@ require "rouge"
 require "launchy"
 require "io/console"
 require "readline"
+require "nokogiri"
+require "open-uri"
 
 require_relative "./monadic_chat/version"
 require_relative "./monadic_chat/open_ai"
+require_relative "./monadic_chat/authenticate"
+require_relative "./monadic_chat/commands"
 require_relative "./monadic_chat/helper"
 
 Oj.mimic_JSON
 
 module MonadicChat
+  SETTINGS = {
+    "normal_model" => "gpt-3.5-turbo",
+    "research_model" => "gpt-3.5-turbo",
+    "max_tokens_wiki" => 1000,
+    "num_retrials" => 2,
+    "min_query_size" => 5,
+    "timeout_sec" => 120
+  }
   gpt2model_path = File.absolute_path(File.join(__dir__, "..", "assets", "gpt2.bin"))
+
   BLINGFIRE = BlingFire.load_model(gpt2model_path)
   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)
+  USER_APPS_DIR = File.absolute_path(File.join(__dir__, "..", "user_apps"))
+
+  apps_dir_list = Dir.entries(APPS_DIR)
                      .reject { |entry| /\A\./ =~ entry || /\A_/ =~ entry.split("/").last }
                      .map { |entry| File.join(APPS_DIR, entry) }
+
+  user_apps_dir_list = Dir.entries(USER_APPS_DIR)
+                          .reject { |entry| /\A\./ =~ entry || /\A_/ =~ entry.split("/").last }
+                          .reject { |entry| /\Aboilerplates/ =~ entry }
+                          .map { |entry| File.join(USER_APPS_DIR, entry) }
+
+  APPS_DIR_LIST = apps_dir_list + user_apps_dir_list
+
   templates = {}
   APPS_DIR_LIST.each do |app|
     basename = File.basename(app, ".*")
@@ -84,6 +103,14 @@ module MonadicChat
       background-color: #c4ffcb;
       margin-bottom: 0.5em;
     }
+    .monadic_search_engine {
+      display:inline-block;
+      padding-left: 0.5em;
+      padding-right: 0.5em;
+      font-weight: bold;
+      background-color: #ffe9c4;
+      margin-bottom: 0.5em;
+    }
     .monadic_gray {
       display:inline-block;
       font-weight: bold;
@@ -97,7 +124,14 @@ module MonadicChat
       margin-bottom: 0.5em;
     }
   CSS
+
   GITHUB_STYLE = style
+  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 = TTY::Spinner.new(format: :arrow_pulse, clear: true)
+  BULLET = "\e[33m●\e[0m"
+  HOME = File.expand_path(File.join(__dir__, ".."))
 
   def self.require_apps
     MonadicChat::APPS_DIR_LIST.each do |app_dir|
@@ -105,119 +139,4 @@ module MonadicChat
       require "#{app_dir}/#{basename}"
     end
   end
-
-  def self.open_readme
-    url = "https://github.com/yohasebe/monadic-chat/"
-    Launchy.open(url)
-  end
-
-  def self.authenticate(overwrite: false, message: true)
-    check = lambda do |token, normal_mode_model, research_mode_model|
-      print "Checking configuration\n" if message
-      SPINNER.auto_spin
-      begin
-        models = OpenAI.models(token)
-        raise if models.empty?
-
-        SPINNER.stop
-
-        print "Success\n" if message
-
-        if normal_mode_model && !models.map { |m| m["id"] }.index(normal_mode_model)
-          SPINNER.stop
-          print "Normal mode model set in config file not available.\n" if message
-          normal_mode_model = false
-        end
-        normal_mode_model ||= OpenAI.model_name(research_mode: false)
-        print "Normal mode model: #{normal_mode_model}\n" if message
-
-        if research_mode_model && !models.map { |m| m["id"] }.index(research_mode_model)
-          SPINNER.stop
-          print "Normal mode model set in config file not available.\n" if message
-          print "Fallback to the default model (#{OpenAI.model_name(research_mode: true)}).\n" if message
-        end
-        research_mode_model ||= OpenAI.model_name(research_mode: true)
-        print "Research mode model: #{research_mode_model}\n" if message
-
-        OpenAI::Completion.new(token, normal_mode_model, research_mode_model)
-      rescue StandardError
-        SPINNER.stop
-        print "Authentication: failure.\n" if message
-        false
-      end
-    end
-
-    completion = nil
-
-    if overwrite
-      access_token = PROMPT_SYSTEM.ask(" Input your OpenAI access token:")
-      return false if access_token.to_s == ""
-
-      completion = check.call(access_token, nil, nil)
-
-      if completion
-        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" if message
-        end
-      end
-    elsif File.exist?(CONFIG)
-      json = File.read(CONFIG)
-      begin
-        config = JSON.parse(json)
-      rescue JSON::ParserError
-        puts "Error: config file does not contain a valid JSON object."
-        exit
-      end
-      access_token = config["access_token"]
-      normal_mode_model = config["normal_mode_model"]
-      research_mode_model = config["research_mode_model"]
-      completion = check.call(access_token, normal_mode_model, research_mode_model)
-    else
-      access_token ||= PROMPT_SYSTEM.ask(" Input your OpenAI access token:")
-      completion = check.call(access_token, nil, nil)
-      if completion
-        File.open(CONFIG, "w") do |f|
-          config = { "access_token" => access_token }
-          f.write(JSON.pretty_generate(config))
-        end
-        print "Access token has been saved to #{CONFIG}\n" if message
-      end
-    end
-    completion || authenticate(overwrite: true)
-  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
-
-  def self.tokenize(text)
-    BLINGFIRE.text_to_ids(text)
-  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 = TTY::Spinner.new(format: :arrow_pulse, clear: true)
-
-  BULLET = "\e[33m●\e[0m"
 end

data/user_apps/boilerplates/boilerplate.json

@@ -0,0 +1,5 @@
+{"messages": [
+  {"role": "system", "content": ""},
+   {"role": "user", "content": ""},
+   {"role": "assistant", "content": ""}
+]}