monadic-chat 0.2.2 → 0.3.1

data/lib/monadic_chat/internals.rb

@@ -39,35 +39,15 @@ class MonadicApp
     end
   end
 
-  def wait
-    return self if @threads.empty?
-
-    print TTY::Cursor.save
-    message = PASTEL.red "Processing contextual data #{SPINNER} "
-    print message
-
-    TIMEOUT_SEC.times do |i|
-      raise MonadicError, "Error: something went wrong" if i + 1 == TIMEOUT_SEC
-
-      break if @threads.empty?
-
-      sleep 1
-    end
-    print TTY::Cursor.restore
-    print TTY::Cursor.clear_char(message.size)
-
-    self
-  end
-
   def objectify
-    case @method
-    when RESEARCH_MODE
-      m = /\n\n```json\s*(\{.+\})\s*```\n\n/m.match(@template)
+    case @mode
+    when :research
+      m = /JSON:\n+```json\s*(\{.+\})\s*```\n\n/m.match(@template)
       json = m[1].gsub(/(?!\\\\\\)\\\\"/) { '\\\"' }
       res = JSON.parse(json)
       res["messages"] = @messages
       res
-    when NORMAL_MODE
+    when :normal
       @messages
     end
   end
@@ -76,8 +56,9 @@ class MonadicApp
     params = @params.dup
 
     @update_proc.call
-    case @method
-    when RESEARCH_MODE
+
+    case @mode
+    when :research
       messages = +""
       system = +""
       @messages.each do |mes|
@@ -87,20 +68,28 @@ class MonadicApp
         when "system"
           system << "#{content}\n"
         when "assistant", "gpt"
-          system << "- #{mes["role"].strip}: #{content.sub("\n\n###\n\n", "")}\n\n###\n\n"
+          messages << "- #{mes["role"].strip}: #{content}\n"
         else
-          messages << "- #{mes["role"].strip}: #{mes["content"]}"
+          messages << "- #{mes["role"].strip}: #{mes["content"]}\n"
         end
       end
       template = @template.dup.sub("{{SYSTEM}}", system)
                           .sub("{{PROMPT}}", input)
                           .sub("{{MESSAGES}}", messages.strip)
 
-      params["prompt"] = template
+      File.open(TEMP_MD, "w") { |f| f.write template }
+
       @messages << { "role" => "user", "content" => input }
-    when NORMAL_MODE
+
+      case @method
+      when "completions"
+        params["prompt"] = template
+      when "chat/completions"
+        params["messages"] = [{ "role" => "system", "content" => template }]
+      end
+
+    when :normal
       @messages << { "role" => "user", "content" => input }
-      @update_proc.call
       params["messages"] = @messages
     end
 
@@ -108,36 +97,31 @@ class MonadicApp
   end
 
   def update_template(res)
-    case @method
-    when RESEARCH_MODE
+    case @mode
+    when :research
       @metadata = res
-      @messages << { "role" => "assistant", "content" => res["response"] }
-      json = res.to_json.strip
-      @template.sub!(/\n\n```json.+```\n\n/m, "\n\n```json\n#{json}\n```\n\n")
-    when NORMAL_MODE
+      @messages << { "role" => "assistant", "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
   end
 
   ##################################################
-  # functions for binding data
+  # function to bind data
   ##################################################
 
-  def bind_normal_mode(input, num_retry: 0)
+  def bind(input, num_retry: 0)
     print PROMPT_ASSISTANT.prefix, "\n"
-    print TTY::Cursor.save
-
-    wait
-
     params = prepare_params(input)
-
-    print TTY::Cursor.save
+    research_mode = @mode == :research
 
     escaping = +""
     last_chunk = +""
-    response = +""
-    spinning = false
-    res = @completion.run(params, num_retry: num_retry) do |chunk|
+
+    res = @completion.run(params, research_mode: research_mode, num_retry: num_retry) do |chunk|
       if escaping
         chunk = escaping + chunk
         escaping = ""
@@ -147,147 +131,17 @@ class MonadicApp
         escaping += chunk
         next
       else
-        chunk = chunk.gsub('\\n', "\n")
-        response << chunk
-      end
-
-      if count_lines_below > 1
-        print PASTEL.magenta(last_chunk)
-      elsif !spinning
-        print PASTEL.red SPINNER
-        spinning = true
+        chunk = chunk.gsub('\\n') { "\n" }
       end
 
+      print last_chunk
       last_chunk = chunk
     end
 
-    print TTY::Cursor.restore
-    print TTY::Cursor.clear_screen_down
-
-    text = response.gsub(/(?<![\\>\s])(?!\n[\n<])\n/m) { "{{NEWLINE}}\n" }
-    text = text.gsub(/```(.+?)```/m) do
-      m = Regexp.last_match
-      "```#{m[1].gsub("{{NEWLINE}}\n") { "\n" }}```"
-    end
-    text = text.gsub(/`(.+?)`/) do
-      m = Regexp.last_match
-      "`#{m[1].gsub("{{NEWLINE}}\n") { "\n" }}`"
-    end
-
-    text = text.gsub(/(?!\\\\)\\/) { "" }
-    print TTY::Markdown.parse(text).gsub("{{NEWLINE}}") { "\n" }.strip
+    print last_chunk
     print "\n"
 
     update_template(res)
     set_html if @html
   end
-
-  def bind_research_mode(input, num_retry: 0)
-    print PROMPT_ASSISTANT.prefix, "\n"
-
-    wait
-
-    params = prepare_params(input)
-
-    print TTY::Cursor.save
-
-    @threads << true
-    Thread.new do
-      response_all_shown = false
-      key_start = /"#{@prop_newdata}":\s*"/
-      key_finish = /\s+###\s*"/m
-      started = false
-      escaping = +""
-      last_chunk = +""
-      finished = false
-      response = +""
-      spinning = false
-      res = @completion.run(params, num_retry: num_retry, tmp_json_file: TEMP_JSON, tmp_md_file: TEMP_MD) do |chunk|
-        if finished && !response_all_shown
-          response_all_shown = true
-          @responses << response.sub(/\s+###\s*".*/m, "")
-          if spinning
-            TTY::Cursor.backword(" ▹▹▹▹▹ ".size)
-            TTY::Cursor.clear_char(" ▹▹▹▹▹ ".size)
-          end
-        end
-
-        unless finished
-          if escaping
-            chunk = escaping + chunk
-            escaping = ""
-          end
-
-          if /(?:\\\z)/ =~ chunk
-            escaping += chunk
-            next
-          else
-            chunk = chunk.gsub('\\n', "\n")
-            response << chunk
-          end
-
-          if started && !finished
-            if key_finish =~ response
-              finished = true
-            else
-              if count_lines_below > 1
-                print PASTEL.magenta(last_chunk)
-              elsif !spinning
-                print PASTEL.red SPINNER
-                spinning = true
-              end
-              last_chunk = chunk
-            end
-          elsif !started && !finished && key_start =~ response
-            started = true
-            response = +""
-          end
-        end
-      end
-
-      unless response_all_shown
-        if spinning
-          TTY::Cursor.backword(SPINNER.size)
-          TTY::Cursor.clear_char(SPINNER.size)
-        end
-        @responses << response.sub(/\s+###\s*".*/m, "")
-      end
-
-      update_template(res)
-      @threads.clear
-    rescue StandardError => e
-      @threads.clear
-      @responses << <<~ERROR
-        Error: something went wrong in a thread"
-        #{e.message}
-        #{e.backtrace}
-      ERROR
-    end
-
-    loop do
-      if @responses.empty?
-        sleep 1
-      else
-        print TTY::Cursor.restore
-        print TTY::Cursor.clear_screen_down
-        text = @responses.pop
-
-        text = text.gsub(/(?<![\\>\s])(?!\n[\n<])\n/m) { "{{NEWLINE}}\n" }
-        text = text.gsub(/```(.+?)```/m) do
-          m = Regexp.last_match
-          "```#{m[1].gsub("{{NEWLINE}}\n") { "\n" }}```"
-        end
-        text = text.gsub(/`(.+?)`/) do
-          m = Regexp.last_match
-          "`#{m[1].gsub("{{NEWLINE}}\n") { "\n" }}`"
-        end
-
-        text = text.gsub(/(?!\\\\)\\/) { "" }
-        print TTY::Markdown.parse(text).gsub("{{NEWLINE}}") { "\n" }.strip
-        print "\n"
-        break
-      end
-    end
-    set_html if @html
-  end
 end

data/lib/monadic_chat/menu.rb

@@ -127,13 +127,13 @@ class MonadicApp
 
     begin
       File.open(filepath, "w") do |f|
-        case @method
-        when RESEARCH_MODE
-          m = /\n\n```json\s*(\{.+\})\s*```\n\n/m.match(@template)
+        case @mode
+        when :research
+          m = /JSON:\n+```json\s*(\{.+\})\s*```\n\n/m.match(@template)
           data = JSON.parse(m[1])
           data["messages"] = @messages
           f.write JSON.pretty_generate(data)
-        when NORMAL_MODE
+        when :normal
           f.write JSON.pretty_generate({ "messages" => @messages })
         end
 
@@ -167,15 +167,15 @@ class MonadicApp
       filepath = File.expand_path(input.strip)
       json = File.read(filepath)
       data = JSON.parse(json)
-      case @method
-      when RESEARCH_MODE
+      case @mode
+      when :research
         self.class.name.downcase.split("::")[-1]
 
         raise unless data["mode"] == self.class.name.downcase.split("::")[-1]
 
         @messages = data.delete "messages"
-        @template = @template.sub(/\n\n```json\s*\{.+\}\s*```\n\n/m, "\n\n```json\n#{JSON.pretty_generate(data).strip}\n```\n\n")
-      when NORMAL_MODE
+        @template = @template.sub(/JSON:\n+```json\s*\{.+\}\s*```\n\n/m, "JSON:\n\n```json\n#{JSON.pretty_generate(data).strip}\n```\n\n")
+      when :normal
         raise unless data["messages"] && data["messages"][0]["role"]
 
         @messages = data["messages"]

data/lib/monadic_chat/open_ai.rb

@@ -12,7 +12,11 @@ Oj.mimic_JSON
 
 module OpenAI
   def self.model_name(research_mode: false)
-    research_mode ? "text-davinci-003" : "gpt-3.5-turbo"
+    if research_mode
+      "text-davinci-003"
+    else
+      "gpt-3.5-turbo"
+    end
   end
 
   def self.model_to_method(model)
@@ -85,15 +89,25 @@ module OpenAI
   class Completion
     attr_reader :access_token
 
-    def initialize(access_token)
+    def initialize(access_token, normal_mode_model = nil, research_mode_model = nil)
       @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, num_retry: 1, tmp_json_file: nil, tmp_md_file: nil, &block)
+    def run(params, research_mode: false, num_retry: 1, &block)
       method = OpenAI.model_to_method(params["model"])
 
       response = OpenAI.query(@access_token, "post", method, 60, params, &block)
@@ -103,12 +117,10 @@ module OpenAI
         raise "finished because of length"
       end
 
-      case method
-      when "completions"
-        File.open(tmp_md_file, "w") { |f| f.write params["prompt"] } if tmp_md_file
-        get_json(response["choices"][0]["text"], tmp_json_file: tmp_json_file)
-      when "chat/completions"
-        response ["choices"][0]["text"]
+      if research_mode
+        get_json response["choices"][0]["text"]
+      else
+        response["choices"][0]["text"]
       end
     rescue StandardError => e
       case num_retry
@@ -119,9 +131,9 @@ module OpenAI
       end
     end
 
-    def get_json(data, tmp_json_file: nil)
+    def get_json(data)
       case data
-      when %r{<JSON>\n*(\{.+\})\n*</JSON>}m
+      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
@@ -130,7 +142,6 @@ module OpenAI
       else
         res = data
       end
-      File.open(tmp_json_file, "w") { |f| f.write json } if tmp_json_file
       res
     end
 
@@ -143,9 +154,9 @@ module OpenAI
       prompts.each do |prompt|
         params["prompt"] = template.sub(replace_key, prompt)
         res = run(params, num_retry: num_retry)
-        json = JSON.pretty_generate(res)
+        json = JSON.pretty_generate(get_json(res))
         bar.advance(1)
-        template = template.sub(/\n\n```json.+?```\n\n/m, "\n\n```json\n#{json}\n```\n\n")
+        template = template.sub(/JSON:\n+```json.+?```\n\n/m, "JSON:\n\n```json\n#{json}\n```\n\n")
       end
       bar.finish
       JSON.parse(json)

data/lib/monadic_chat/parameters.rb

@@ -20,11 +20,7 @@ class MonadicApp
     case parameter
     when "model"
       value = change_model
-      @messages = @messages_initial.dup
-      case @method
-      when RESEARCH_MODE
-        @template = @template_initial.dup
-      end
+      @method = OpenAI.model_to_method(value)
     when "max_tokens"
       value = change_max_tokens
     when "temperature"
@@ -79,13 +75,19 @@ class MonadicApp
     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
+      SPINNER.auto_spin
       models = @completion.models
-      go_up_and_clear
-      TTY::Cursor.restore
+      SPINNER.stop
       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"]
+      case @mode
+      when :research
+        models.filter { |m| ["completions", "chat/completions"].include? OpenAI.model_to_method(m["id"]) }.sort_by { |m| -m["created"] }.each do |m|
+          menu.choice "#{BULLET} #{m["id"]}", m["id"]
+        end
+      when :normal
+        models.filter { |m| OpenAI.model_to_method(m["id"]) == "chat/completions" }.sort_by { |m| -m["created"] }.each do |m|
+          menu.choice "#{BULLET} #{m["id"]}", m["id"]
+        end
       end
     end
     if model == "cancel"

data/lib/monadic_chat/version.rb

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

data/lib/monadic_chat.rb

@@ -3,6 +3,7 @@
 require "tty-cursor"
 require "tty-screen"
 require "tty-markdown"
+require "tty-spinner"
 require "tty-prompt"
 require "tty-box"
 require "pastel"
@@ -25,8 +26,6 @@ module MonadicChat
   MIN_LENGTH = 5
   TIMEOUT_SEC = 120
   TITLE_WIDTH = 72
-  NORMAL_MODE = "chat/completions"
-  RESEARCH_MODE = "completions"
 
   APPS_DIR = File.absolute_path(File.join(__dir__, "..", "apps"))
   APPS_DIR_LIST = Dir.entries(APPS_DIR)
@@ -123,15 +122,37 @@ module MonadicChat
   end
 
   def self.authenticate(overwrite: false)
-    check = lambda do |token|
-      print "Checking configuration #{SPINNER} "
+    check = lambda do |token, normal_mode_model, research_mode_model|
+      print "Checking configuration\n"
+      SPINNER.auto_spin
       begin
-        raise if OpenAI.models(token).empty?
+        models = OpenAI.models(token)
+        raise if models.empty?
 
-        print "success\n"
-        OpenAI::Completion.new(token)
+        SPINNER.stop
+
+        print "Success\n"
+
+        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"
+          normal_mode_model = false
+        end
+        normal_mode_model ||= OpenAI.model_name(research_mode: false)
+        print "Normal mode model: #{normal_mode_model}\n"
+
+        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"
+          print "Fallback to the default model (#{OpenAI.model_name(research_mode: true)}).\n"
+        end
+        research_mode_model ||= OpenAI.model_name(research_mode: true)
+        print "Research mode model: #{research_mode_model}\n"
+
+        OpenAI::Completion.new(token, normal_mode_model, research_mode_model)
       rescue StandardError
-        print "failure.\n"
+        SPINNER.stop
+        print "Authentication: failure.\n"
         false
       end
     end
@@ -142,7 +163,7 @@ module MonadicChat
       access_token = PROMPT_SYSTEM.ask(" Input your OpenAI access token:")
       return false if access_token.to_s == ""
 
-      completion = check.call(access_token)
+      completion = check.call(access_token, nil, nil)
 
       if completion
         File.open(CONFIG, "w") do |f|
@@ -153,12 +174,19 @@ module MonadicChat
       end
     elsif File.exist?(CONFIG)
       json = File.read(CONFIG)
-      config = JSON.parse(json)
+      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"]
-      completion = check.call(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)
+      completion = check.call(access_token, nil, nil)
       if completion
         File.open(CONFIG, "w") do |f|
           config = { "access_token" => access_token }
@@ -194,6 +222,8 @@ module MonadicChat
   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 = "▹▹▹▹"
+
+  SPINNER = TTY::Spinner.new(format: :arrow_pulse, clear: true)
+
   BULLET = "\e[33m●\e[0m"
 end

data/monadic_chat.gemspec

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monadic-chat
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.1
 platform: ruby
 authors:
 - yohasebe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-21 00:00:00.000000000 Z
+date: 2023-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -234,6 +234,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: '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.
@@ -275,10 +289,8 @@ files:
 - doc/img/code-example-time-html.png
 - doc/img/code-example-time.png
 - doc/img/example-translation.png
-- doc/img/extra-template-json.png
 - doc/img/how-research-mode-works.svg
 - doc/img/input-acess-token.png
-- doc/img/langacker-2001.svg
 - doc/img/linguistic-html.png
 - doc/img/monadic-chat.svg
 - doc/img/readme-example-beatles-html.png