monadic-chat 0.1.1

data/lib/monadic_app.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "./monadic_chat"
+require_relative "./monadic_chat/console"
+require_relative "./monadic_chat/formatting"
+require_relative "./monadic_chat/interaction"
+require_relative "./monadic_chat/menu"
+require_relative "./monadic_chat/parameters"
+require_relative "./monadic_chat/internals"
+
+Thread.abort_on_exception = false
+
+class MonadicApp
+  include MonadicChat
+  attr_reader :template
+
+  def initialize(params, template, placeholders, prop_accumulated, prop_newdata, update_proc)
+    @threads = Thread::Queue.new
+    @responses = Thread::Queue.new
+    @placeholders = placeholders
+    @prop_accumulated = prop_accumulated
+    @prop_newdata = prop_newdata
+    @completion = nil
+    @update_proc = update_proc
+    @params_original = params
+    @params = @params_original.dup
+    @template_original = File.read(template)
+    @method = OpenAI.model_to_method @params["model"]
+
+    case @method
+    when "completions"
+      @template = @template_original.dup
+    when "chat/completions"
+      @template = JSON.parse @template_original
+    end
+  end
+
+  ##################################################
+  # methods for running monadic app
+  ##################################################
+
+  def parse(input = nil)
+    loop do
+      case input
+      when TrueClass
+        input = user_input
+        next
+      when /\A\s*(?:help|menu|commands?|\?|h)\s*\z/i
+        return true unless show_menu
+      when /\A\s*(?:bye|exit|quit)\s*\z/i
+        break
+      when /\A\s*(?:reset)\s*\z/i
+        reset
+      when /\A\s*(?:data|context)\s*\z/i
+        show_data
+      when /\A\s*(?:html)\s*\z/i
+        set_html
+      when /\A\s*(?:save)\s*\z/i
+        save_data
+      when /\A\s*(?:load)\s*\z/i
+        load_data
+      when /\A\s*(?:clear|clean)\s*\z/i
+        clear_screen
+      when /\A\s*(?:params?|parameters?|config|configuration)\s*\z/i
+        change_parameter
+      else
+        if input && confirm_query(input)
+          begin
+            case @method
+            when "completions"
+              bind_research_mode(input, num_retry: NUM_RETRY)
+            when "chat/completions"
+              bind_normal_mode(input, num_retry: NUM_RETRY)
+            end
+          rescue StandardError => e
+            input = ask_retrial(input, e.message)
+            next
+          end
+        end
+      end
+      if input.to_s == ""
+        input = false
+        clear_screen
+      end
+      input = user_input
+    end
+  rescue MonadicError
+    false
+  end
+
+  def banner(title, desc, color)
+    screen_width = TTY::Screen.width - 2
+    width = screen_width < TITLE_WIDTH ? screen_width : TITLE_WIDTH
+    title = PASTEL.bold.send(color.to_sym, title.center(width, " "))
+    desc = desc.center(width, " ")
+    padding = "".center(width, " ")
+    banner = TTY::Box.frame "#{padding}\n#{title}\n#{desc}\n#{padding}"
+    print "\n", banner.strip, "\n"
+  end
+
+  def run
+    banner("MONADIC::CHAT / #{self.class.name}", self.class::DESC, self.class::COLOR)
+    show_greet
+
+    if @placeholders.empty?
+      parse(user_input)
+    else
+      loadfile = PROMPT_SYSTEM.select("\nLoad saved file? (Make sure the file is saved by the same app)", default: 2, show_help: :never) do |menu|
+        menu.choice "Yes", "yes"
+        menu.choice "No", "no"
+      end
+      parse(user_input) if loadfile == "yes" && load_data || fulfill_placeholders
+    end
+  end
+end

data/lib/monadic_chat/console.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class MonadicApp
+  ##################################################
+  # methods for manipulating terminal screen
+  ##################################################
+  def count_lines_below
+    screen_height = TTY::Screen.height
+    vpos = Cursor.pos[:row]
+    screen_height - vpos
+  end
+
+  def go_up_and_clear
+    print TTY::Cursor.up
+    print TTY::Cursor.clear_screen_down
+    print TTY::Cursor.up
+  end
+
+  def clear_screen
+    print "\e[2J\e[f"
+  end
+
+  def ask_clear
+    PROMPT_SYSTEM.readline(PASTEL.red("Press Enter to clear screen"))
+    print TTY::Cursor.up
+    print TTY::Cursor.clear_screen_down
+    clear_screen
+  end
+end

data/lib/monadic_chat/formatting.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+class MonadicApp
+  ##################################################
+  # methods for formatting and presenting
+  ##################################################
+  def format_data
+    contextual = []
+    accumulated = []
+
+    objectify.each do |key, val|
+      next if %w[prompt response].include? key
+
+      if (@method == "completions" && key == @prop_accumulated) ||
+         (@method == "chat/completions" && key == "messages")
+        val = val.map do |v|
+          case @method
+          when "completions"
+            if v.instance_of?(String)
+              v.sub(/\s+###\s*$/m, "")
+            else
+              v.map { |role, text| "#{role.strip.capitalize}: #{text.sub(/\s+###\s*$/m, "")}" }
+            end
+          when "chat/completions"
+            "#{v["role"].capitalize}: #{v["content"]}"
+          end
+        end
+        accumulated << val.join("\n\n")
+      else
+        contextual << "- **#{key.split("_").map(&:capitalize).join(" ")}**: #{val.to_s.strip}"
+      end
+    end
+
+    h1 = "# Monadic :: Chat / #{self.class.name}"
+    contextual.map!(&:strip).unshift "## Contextual Data\n" unless contextual.empty?
+    accum_label = @prop_accumulated.split("_").map(&:capitalize).join(" ")
+    accumulated.map!(&:strip).unshift "## #{accum_label}\n" unless accumulated.empty?
+    "#{h1}\n\n#{contextual.join("\n")}\n\n#{accumulated.join("\n")}"
+  end
+
+  def show_data
+    print PROMPT_SYSTEM.prefix
+
+    wait
+
+    res = format_data
+    print "\n#{TTY::Markdown.parse(res, indent: 0)}"
+  end
+
+  def set_html
+    print PROMPT_SYSTEM.prefix
+
+    wait
+
+    print "HTML is ready\n"
+    show_html
+  end
+
+  def add_to_html(text, filepath)
+    text = text.gsub(/(?<![\\>\s])(?!\n[\n<])\n/m) { "<br/>\n" }
+    text = text.gsub(/~~~(.+?)~~~/m) do
+      m = Regexp.last_match
+      "~~~#{m[1].gsub("<br/>\n") { "\n" }}~~~"
+    end
+    text = text.gsub(/`(.+?)`/) do
+      m = Regexp.last_match
+      "`#{m[1].gsub("<br/>\n") { "\n" }}`"
+    end
+
+    `touch #{filepath}` unless File.exist?(filepath)
+    File.open(filepath, "w") do |f|
+      html = <<~HTML
+        <!doctype html>
+          <html lang="en">
+            <head>
+              <meta charset="utf-8">
+              <meta name="viewport" content="width=device-width, initial-scale=1">
+              <style type="text/css">
+                #{GITHUB_STYLE}
+              </style>
+              <title>Monadic Chat</title>
+            </head>
+            <body>
+                #{Kramdown::Document.new(text, syntax_highlighter: :rouge, syntax_highlighter_ops: {}).to_html}
+            </body>
+            <script src="https://code.jquery.com/jquery-3.6.3.min.js"></script>
+            <script src="https://code.jquery.com/ui/1.13.2/jquery-ui.min.js"></script>
+            <script>
+              $(window).on("load", function() {
+                $("html, body").animate({ scrollTop: $(document).height() }, 500);
+              });
+            </script>
+          </html>
+      HTML
+      f.write html
+    end
+    Launchy.open(filepath)
+  end
+
+  def show_html
+    res = format_data.sub(%r{::(.+?)/(.+?)\b}) do
+      " <span class='monadic_gray'>::</span> <span class='monadic_app'>#{Regexp.last_match(1)}</span> <span class='monadic_gray'>/</span> #{Regexp.last_match(2)}"
+    end
+    res = res.gsub("```") { "~~~" }
+             .gsub(/^(system):/i) { "<span class='monadic_system'> #{Regexp.last_match(1)} </span><br />" }
+             .gsub(/^(user):/i) { "<span class='monadic_user'> #{Regexp.last_match(1)} </span><br />" }
+             .gsub(/^(assistant|gpt):/i) { "<span class='monadic_chat'> #{Regexp.last_match(1)} </span><br />" }
+    add_to_html(res, TEMP_HTML)
+  end
+end

data/lib/monadic_chat/helper.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+class Cursor
+  class << self
+    def pos
+      res = +""
+      $stdin.raw do |stdin|
+        $stdout << "\e[6n"
+        $stdout.flush
+        while (c = stdin.getc) != "R"
+          res << c if c
+        end
+      end
+      m = res.match(/(?<row>\d+);(?<column>\d+)/)
+      { row: Integer(m[:row]), column: Integer(m[:column]) }
+    end
+  end
+end
+
+module TTY
+  class PromptX < Prompt
+    attr_reader :prefix
+
+    def initialize(active_color:, prefix:, history: true)
+      @interrupt = lambda do
+        print TTY::Cursor.clear_screen_down
+        print "\e[2J\e[f"
+        res = TTY::Prompt.new.yes?("Quit the app?")
+        exit if res
+      end
+
+      super(active_color: active_color, prefix: prefix, interrupt: @interrupt)
+      @history = history
+      @prefix = prefix
+    end
+
+    def readline(text = "")
+      puts @prefix
+      begin
+        Readline.readline(text, @history)
+      rescue Interrupt
+        @interrupt.call
+      end
+    end
+  end
+
+  module Markdown
+    # Converts a Kramdown::Document tree to a terminal friendly output
+    class Converter < ::Kramdown::Converter::Base
+      def convert_p(ell, opts)
+        indent = SPACE * @current_indent
+        result = []
+
+        result << indent unless %i[blockquote li].include?(opts[:parent].type)
+
+        opts[:indent] = @current_indent
+        opts[:indent] = 0 if opts[:parent].type == :blockquote
+
+        content = inner(ell, opts)
+
+        symbols = %q{[-!$%^&*()_+|~=`{}\[\]:";'<>?,.\/]}
+        # result << content.join.gsub(/(?<!#{symbols})\n(?!#{symbols})/m) { " " }.gsub(/ +/) { " " }
+        result << content.join.gsub(/(?<!#{symbols})\n(?!#{symbols})/m) { "" }
+        result << NEWLINE unless result.last.to_s.end_with?(NEWLINE)
+        result
+      end
+    end
+  end
+end
+
+class MonadicError < StandardError
+end

data/lib/monadic_chat/interaction.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class MonadicApp
+  ##################################################
+  # methods for user interaction
+  ##################################################
+
+  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
+    current_mode = case @method
+                   when "completions"
+                     PASTEL.red("Research")
+                   when "chat/completions"
+                     PASTEL.green("Normal")
+                   end
+    greet_md = <<~GREET
+      - You are currently in **#{current_mode}** mode
+      - Type **help** or **menu** to see available commands
+    GREET
+    print PROMPT_SYSTEM.prefix
+    print "\n#{TTY::Markdown.parse(greet_md, indent: 0).strip}\n"
+  end
+
+  def confirm_query(input)
+    if input.size < MIN_LENGTH
+      PROMPT_SYSTEM.yes?("Would you like to proceed with this (very short) prompt?")
+    else
+      true
+    end
+  end
+end

data/lib/monadic_chat/internals.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+class MonadicApp
+  ##################################################
+  # methods for preparation and updating
+  ##################################################
+
+  def fulfill_placeholders
+    input = nil
+    replacements = []
+    mode = :replace
+
+    @placeholders.each do |key, val|
+      if key == "mode"
+        mode = val
+        next
+      end
+
+      input = if mode == :replace
+                val
+              else
+                PROMPT_SYSTEM.readline("#{val}: ")
+              end
+
+      unless input
+        replacements.clear
+        break
+      end
+      replacements << [key, input]
+    end
+    if replacements.empty?
+      false
+    else
+      replacements.each do |key, value|
+        case @method
+        when "completions"
+          @template.gsub!(key, value)
+        when "chat/completions"
+          @template["messages"][0]["content"].gsub!(key, value)
+        end
+      end
+      true
+    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 "completions"
+      m = /\n\n```json\s*(\{.+\})\s*```\n\n/m.match(@template)
+      json = m[1].gsub(/(?!\\\\\\)\\\\"/) { '\\\"' }
+      JSON.parse(json)
+    when "chat/completions"
+      @template
+    end
+  end
+
+  def prepare_params(input)
+    params = @params.dup
+    case @method
+    when "completions"
+      template = @template.dup.sub("{{PROMPT}}", input).sub("{{MAX_TOKENS}}", (@params["max_tokens"] / 2).to_s)
+      params["prompt"] = template
+    when "chat/completions"
+      @template["messages"] << { "role" => "user", "content" => input }
+      params["messages"] = @template["messages"]
+    end
+    params
+  end
+
+  def update_template(res)
+    case @method
+    when "completions"
+      updated = @update_proc.call(res)
+      json = updated.to_json.strip
+      @template.sub!(/\n\n```json.+```\n\n/m, "\n\n```json\n#{json}\n```\n\n")
+    when "chat/completions"
+      @template["messages"] << { "role" => "assistant", "content" => res }
+      @template["messages"] = @update_proc.call(@template["messages"])
+    end
+  end
+
+  ##################################################
+  # functions for binding data
+  ##################################################
+
+  def bind_normal_mode(input, num_retry: 0)
+    print PROMPT_ASSISTANT.prefix, "\n"
+    print TTY::Cursor.save
+
+    wait
+
+    params = prepare_params(input)
+    print TTY::Cursor.save
+
+    escaping = +""
+    last_chunk = +""
+    response = +""
+    spinning = false
+    res = @completion.run(params, num_retry: num_retry) do |chunk|
+      if escaping
+        chunk = escaping + chunk
+        escaping = ""
+      end
+
+      if /(?:\\\z)/ =~ chunk
+        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
+      end
+
+      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 "\n"
+
+    update_template(res)
+  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) 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
+  end
+end