monadic-chat 0.3.4 → 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/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

@@ -59,6 +59,13 @@ class MonadicApp
   def prepare_params(input_role, input)
     params = @params.dup
 
+    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
       messages = +""
@@ -68,14 +75,16 @@ class MonadicApp
         content = mes["content"]
         case role
         when "system"
-          system << "#{content}\n"
+          system << "#{content}\n" if system == ""
         else
           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)
 
@@ -104,27 +113,40 @@ class MonadicApp
     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")
     when :normal
       @messages << { "role" => "assistant", "content" => res }
     end
-    remove_intermediate_messages if role == "system"
   end
 
-  def remove_intermediate_messages
-    @messages = @messages.reject { |ele| ele["role"] == "assistant" && /SEARCH\(.+\)/m =~ ele["content"] }
-    @messages = @messages.reject { |ele| ele["role"] == "system" && /^SEARCH SNIPPETS/ =~ ele["content"] }
+  ##################################################
+  # 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, role: "user", num_retry: 0)
-    @turns += 1 if role == "user"
+  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(role, input)
     research_mode = @mode == :research
@@ -132,7 +154,10 @@ class MonadicApp
     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 = ""
@@ -152,13 +177,31 @@ class MonadicApp
     print last_chunk
     print "\n"
 
-    webdata = use_tool(res)
-    update_template(res, role) unless webdata
-    if webdata && role != "system"
-      bind(webdata, role: "system", num_retry: num_retry)
-    elsif @html
-      set_html
-    end
+    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
 
   ##################################################
@@ -174,19 +217,16 @@ class MonadicApp
     end
 
     case text
-    when /\bSEARCH_WIKI\((.+?)\)/m
+    when /\bSEARCH_WIKI\("?(.+?)"?\)/m
+      @wiki_search_cache ||= {}
       search_key = Regexp.last_match(1)
-      search_keys = search_key.split(",").map do |key|
-        key.strip.sub(/^"(.+)"$/, '\1')
-      end
-      text = "SEARCH SNIPPETS\n#{wikipedia_search(*search_keys)}"
-      return text
+      wikipedia_search(search_key, @wiki_search_cache)
     when /\bSEARCH_WEB\("?(.+?)"?\)/m
+      @web_search_cache ||= {}
       search_key = Regexp.last_match(1)
-      text = "SEARCH SNIPPETS\n#{bing_search(search_key)}"
-      return text
+      bing_search(search_key, @web_searh_cache)
+    else
+      false
     end
-
-    false
   end
 end

data/lib/monadic_chat/open_ai.rb

@@ -12,7 +12,7 @@ Oj.mimic_JSON
 module OpenAI
   def self.default_model(research_mode: false)
     if research_mode
-      "text-davinci-003"
+      "gpt-3.5-turbo"
     else
       "gpt-3.5-turbo"
     end
@@ -96,10 +96,10 @@ module OpenAI
       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"
@@ -112,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, research_mode: research_mode, num_retry: num_retry - 1, &block)
+        run(params, research_mode: research_mode, timeout_sec: timeout_sec, num_retrials: num_retrials - 1, &block)
       end
     end
 
@@ -134,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)
@@ -142,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

@@ -5,24 +5,26 @@ class MonadicApp
   # method for web search
   ##################################################
 
-  def bing_search(query, retrial: 5)
-    uri = "https://www.bing.com/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([uri, q].join("?")).read)
+    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
-    return "SEARCH ENGINE NOT AVAILABLE" if retrial.zero?
-
-    sleep 1
-    retrial -= 1
-    bing_search(query, retrial: retrial)
+    num_retrial -= 1
+    if num_retrial.positive?
+      sleep 1
+      bing_search(keywords, num_retrial: num_retrial)
+    else
+      "empty"
+    end
   end
 
-  def wikipedia_search(keywords, base_url = nil)
-    base_url ||= "https://en.wikipedia.org/w/api.php"
+  def wikipedia_search(keywords, cache = {}, num_retrial: 10)
+    base_url = "https://en.wikipedia.org/w/api.php"
     search_params = {
       action: "query",
       list: "search",
@@ -41,6 +43,8 @@ class MonadicApp
 
     title = search_data["query"]["search"][0]["title"]
 
+    return cache[title] if cache.keys.include?(title)
+
     content_params = {
       action: "query",
       prop: "extracts",
@@ -56,8 +60,28 @@ class MonadicApp
     content_response = Net::HTTP.get(content_uri)
     content_data = JSON.parse(content_response)
 
-    content_data["query"]["pages"][0]["extract"][0..1000]
+    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
-    "SEARCH RESULTS EMPTY"
+    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.4"
+  VERSION = "0.3.5"
 end

data/lib/monadic_chat.rb

@@ -16,29 +16,43 @@ require "io/console"
 require "readline"
 require "nokogiri"
 require "open-uri"
-require "wikipedia"
 
 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 = {}
-  MAX_CHARS_WIKI = 1000
+  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, ".*")
@@ -89,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;
@@ -102,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|
@@ -110,162 +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.mdprint(str)
-    print TTY::Markdown.parse(str, indent: 0)
-  end
-
-  def self.authenticate(overwrite: false, message: true)
-    check = lambda do |token|
-      if message
-        print TTY::Cursor.restore
-        print TTY::Cursor.clear_screen_down
-        print "\n"
-        SPINNER.auto_spin
-      end
-
-      if !token || token.strip == ""
-        if message
-          SPINNER.stop
-          print TTY::Cursor.restore
-          print "\n"
-          mdprint "- Authentication: #{PASTEL.bold.red("Failure")}\n" if message
-        end
-        return false
-      end
-
-      begin
-        models = OpenAI.models(token)
-        raise if models.empty?
-
-        if message
-          SPINNER.stop
-          print TTY::Cursor.restore, "\n"
-          mdprint "#{PASTEL.on_green(" System ")} Config file: `#{CONFIG}`\n"
-          print "\n"
-          mdprint "- Authentication: #{PASTEL.bold.green("Success")}\n"
-        end
-
-        if SETTINGS["normal_model"] && !models.map { |m| m["id"] }.index(SETTINGS["normal_model"])
-          if message
-            SPINNER.stop
-            mdprint "- Normal mode model specified in config file not available\n"
-            mdprint "- Fallback to the default model (`#{OpenAI.default_model(research_mode: false)}`)\n"
-          end
-          SETTINGS["normal_model"] = false
-        end
-        SETTINGS["normal_model"] ||= OpenAI.default_model(research_mode: false)
-        mdprint "- Normal mode model: `#{SETTINGS["normal_model"]}`\n" if message
-
-        if SETTINGS["research_model"] && !models.map { |m| m["id"] }.index(SETTINGS["research_model"])
-          if message
-            SPINNER.stop
-            mdprint "- Research mode model specified in config file not available\n"
-            mdprint "- Fallback to the default model (`#{OpenAI.default_model(research_mode: true)}`)\n"
-          end
-          SETTINGS["research_model"] = false
-        end
-        SETTINGS["research_model"] ||= OpenAI.default_model(research_mode: true)
-        mdprint "- Research mode model: `#{SETTINGS["research_model"]}`\n" if message
-
-        OpenAI::Completion.new(token)
-      rescue StandardError
-        if message
-          SPINNER.stop
-          print TTY::Cursor.restore
-          print "\n"
-          mdprint "- Authentication: #{PASTEL.bold.red("Failure")}\n" if message
-        end
-        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)
-
-      if completion
-        File.open(CONFIG, "w") do |f|
-          config = {
-            "access_token" => access_token,
-            "normal_model" => SETTINGS["normal_model"],
-            "research_model" => SETTINGS["research_model"]
-          }
-          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
-      SETTINGS["normal_model"] = config["normal_model"] if config["normal_model"]
-      SETTINGS["research_model"] = config["research_model"] if config["research_model"]
-      access_token = config["access_token"]
-      completion = check.call(access_token)
-    else
-      access_token ||= PROMPT_SYSTEM.ask("Input your OpenAI access token:")
-      return false if access_token.to_s == ""
-
-      completion = check.call(access_token)
-      if completion
-        File.open(CONFIG, "w") do |f|
-          config = {
-            "access_token" => access_token,
-            "normal_model" => SETTINGS["normal_model"],
-            "research_model" => SETTINGS["research_model"]
-          }
-          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/monadic_chat.gemspec

@@ -51,5 +51,4 @@ Gem::Specification.new do |spec|
   spec.add_dependency "tty-prompt"
   spec.add_dependency "tty-screen"
   spec.add_dependency "tty-spinner"
-  spec.add_dependency "wikipedia-client"
 end

data/user_apps/boilerplates/boilerplate.json

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