ollama_chat 0.0.0

data/lib/ollama_chat/dialog.rb

@@ -0,0 +1,94 @@
+module OllamaChat::Dialog
+  def choose_model(cli_model, current_model)
+    models = ollama.tags.models.map(&:name).sort
+    model = if cli_model == ''
+              OllamaChat::Utils::Chooser.choose(models) || current_model
+            else
+              cli_model || current_model
+            end
+  ensure
+    STDOUT.puts green { "Connecting to #{model}@#{ollama.base_url} now…" }
+  end
+
+  def ask?(prompt:)
+    print prompt
+    STDIN.gets.chomp
+  end
+
+  def choose_collection(current_collection)
+    collections = [ current_collection ] + @documents.collections
+    collections = collections.compact.map(&:to_s).uniq.sort
+    collections.unshift('[EXIT]').unshift('[NEW]')
+    collection = OllamaChat::Utils::Chooser.choose(collections) || current_collection
+    case collection
+    when '[NEW]'
+      @documents.collection = ask?(prompt: "Enter name of the new collection: ")
+    when nil, '[EXIT]'
+      STDOUT.puts "Exiting chooser."
+    when /./
+      @documents.collection = collection
+    end
+  ensure
+    STDOUT.puts "Using collection #{bold{@documents.collection}}."
+    info
+  end
+
+  attr_writer :document_policy
+
+  def choose_document_policy
+    policies = %w[ importing embedding summarizing ignoring ].sort
+    current  = if policies.index(@document_policy)
+                 @document_policy
+               elsif policies.index(config.document_policy)
+                 config.document_policy
+               else
+                 policies.first
+               end
+    policies.unshift('[EXIT]')
+    policy = OllamaChat::Utils::Chooser.choose(policies)
+    case policy
+    when nil, '[EXIT]'
+      STDOUT.puts "Exiting chooser."
+      policy = current
+    end
+    self.document_policy = policy
+  ensure
+    STDOUT.puts "Using document policy #{bold{@document_policy}}."
+    info
+  end
+
+  def change_system_prompt(default, system: nil)
+    selector = Regexp.new(system.to_s[1..-1].to_s)
+    prompts  = config.system_prompts.attribute_names.compact.grep(selector)
+    if prompts.size == 1
+      system = config.system_prompts.send(prompts.first)
+    else
+      prompts.unshift('[EXIT]').unshift('[NEW]')
+      chosen = OllamaChat::Utils::Chooser.choose(prompts)
+      system =
+        case chosen
+        when '[NEW]'
+          ask?(prompt: "Enter new system prompt to use: ")
+        when '[EXIT]'
+          STDOUT.puts "Exiting chooser."
+          return
+        when nil
+          default
+        when *prompts
+          config.system_prompts.send(chosen)
+        else
+          default
+        end
+    end
+    @messages.set_system_prompt(system)
+  end
+
+  def change_voice
+    chosen  = OllamaChat::Utils::Chooser.choose(config.voice.list)
+    @current_voice = chosen.full? || config.voice.default
+  end
+
+  def message_list
+    MessageList.new(self)
+  end
+end

data/lib/ollama_chat/document_cache.rb

@@ -0,0 +1,16 @@
+module OllamaChat::DocumentCache
+  def document_cache_class
+    Object.const_get(config.cache)
+  end
+
+  def configure_cache
+    if @opts[?M]
+      Documentrix::Documents::MemoryCache
+    else
+      document_cache_class
+    end
+  rescue => e
+    STDERR.puts "Caught #{e.class}: #{e} => Falling back to MemoryCache."
+    Documentrix::Documents::MemoryCache
+  end
+end

data/lib/ollama_chat/follow_chat.rb

@@ -0,0 +1,60 @@
+class OllamaChat::FollowChat
+  include Ollama
+  include Ollama::Handlers::Concern
+  include Term::ANSIColor
+  include OllamaChat::MessageType
+
+  def initialize(messages:, markdown: false, voice: nil, output: STDOUT)
+    super(output:)
+    @output.sync = true
+    @markdown    = markdown
+    @say         = voice ? Handlers::Say.new(voice:) : NOP
+    @messages    = messages
+    @user        = nil
+  end
+
+  def call(response)
+    OllamaChat::Chat.config.debug and jj response
+    if response&.message&.role == 'assistant'
+      if @messages&.last&.role != 'assistant'
+        @messages << Message.new(role: 'assistant', content: '')
+        @user = message_type(@messages.last.images) + " " +
+          bold { color(111) { 'assistant:' } }
+        @output.puts @user unless @markdown
+      end
+      if content = response.message&.content
+        content = content.gsub(%r(<think>), "💭\n").gsub(%r(</think>), "\n💬")
+      end
+      @messages.last.content << content
+      if @markdown and content = @messages.last.content.full?
+        markdown_content = Kramdown::ANSI.parse(content)
+        @output.print clear_screen, move_home, @user, ?\n, markdown_content
+      else
+        @output.print content
+      end
+      @say.call(response)
+    end
+    if response.done
+      @output.puts "", eval_stats(response)
+    end
+    self
+  end
+
+  def eval_stats(response)
+    eval_duration = response.eval_duration / 1e9
+    prompt_eval_duration = response.prompt_eval_duration / 1e9
+    stats_text = {
+      eval_duration:        Tins::Duration.new(eval_duration),
+      eval_count:           response.eval_count.to_i,
+      eval_rate:            bold { "%.2f c/s" % (response.eval_count.to_i / eval_duration) } + color(111),
+      prompt_eval_duration: Tins::Duration.new(prompt_eval_duration),
+      prompt_eval_count:    response.prompt_eval_count.to_i,
+      prompt_eval_rate:     bold { "%.2f c/s" % (response.prompt_eval_count.to_i / prompt_eval_duration) } + color(111),
+      total_duration:       Tins::Duration.new(response.total_duration / 1e9),
+      load_duration:        Tins::Duration.new(response.load_duration / 1e9),
+    }.map { _1 * '=' } * ' '
+    '📊 ' + color(111) {
+      Kramdown::ANSI::Width.wrap(stats_text, percentage: 90).gsub(/(?<!\A)^/, '   ')
+    }
+  end
+end

data/lib/ollama_chat/information.rb

@@ -0,0 +1,113 @@
+module OllamaChat::Information
+  extend Tins::Concern
+
+  included do
+    include UserAgent
+    extend UserAgent
+  end
+
+  module UserAgent
+    def progname
+      'ollama_chat'
+    end
+
+    def user_agent
+      [ progname, OllamaChat::VERSION ] * ?/
+    end
+  end
+
+  def collection_stats
+    STDOUT.puts <<~EOT
+      Current Collection
+        Name: #{bold{@documents.collection}}
+        #Embeddings: #{@documents.size}
+        #Tags: #{@documents.tags.size}
+        Tags: #{@documents.tags}
+    EOT
+    nil
+  end
+
+  def info
+    STDOUT.puts "Current model is #{bold{@model}}."
+    if @model_options.present?
+      STDOUT.puts "  Options: #{JSON.pretty_generate(@model_options).gsub(/(?<!\A)^/, '  ')}"
+    end
+    @embedding.show
+    if @embedding.on?
+      STDOUT.puts "Embedding model is #{bold{@embedding_model}}"
+      if @embedding_model_options.present?
+        STDOUT.puts "  Options: #{JSON.pretty_generate(@embedding_model_options).gsub(/(?<!\A)^/, '  ')}"
+      end
+      STDOUT.puts "Text splitter is #{bold{config.embedding.splitter.name}}."
+      collection_stats
+    end
+    STDOUT.puts "Documents database cache is #{@documents.nil? ? 'n/a' : bold{@documents.cache.class}}"
+    @markdown.show
+    @stream.show
+    @location.show
+    STDOUT.puts "Document policy for references in user text: #{bold{@document_policy}}"
+    if @voice.on?
+      STDOUT.puts "Using voice #{bold{@current_voice}} to speak."
+    end
+    @messages.show_system_prompt
+    nil
+  end
+
+  def display_chat_help
+    STDOUT.puts <<~EOT
+      /copy                           to copy last response to clipboard
+      /paste                          to paste content
+      /markdown                       toggle markdown output
+      /stream                         toggle stream output
+      /location                       toggle location submission
+      /voice( change)                 toggle voice output or change the voice
+      /list [n]                       list the last n / all conversation exchanges
+      /clear                          clear the whole conversation
+      /clobber                        clear the conversation, links, and collection
+      /drop [n]                       drop the last n exchanges, defaults to 1
+      /model                          change the model
+      /system                         change system prompt (clears conversation)
+      /regenerate                     the last answer message
+      /collection( clear|change)      change (default) collection or clear
+      /info                           show information for current session
+      /config                         output current configuration (#{@ollama_chat_config.filename.to_s.inspect})
+      /document_policy                pick a scan policy for document references
+      /import source                  import the source's content
+      /summarize [n] source           summarize the source's content in n words
+      /embedding                      toggle embedding paused or not
+      /embed source                   embed the source's content
+      /web [n] query                  query web search & return n or 1 results
+      /links( clear)                  display (or clear) links used in the chat
+      /save filename                  store conversation messages
+      /load filename                  load conversation messages
+      /quit                           to quit
+      /help                           to view this help
+    EOT
+    nil
+  end
+
+  def usage
+    STDOUT.puts <<~EOT
+      Usage: #{progname} [OPTIONS]
+
+        -f CONFIG      config file to read
+        -u URL         the ollama base url, OLLAMA_URL
+        -m MODEL       the ollama model to chat with, OLLAMA_CHAT_MODEL
+        -s SYSTEM      the system prompt to use as a file, OLLAMA_CHAT_SYSTEM
+        -c CHAT        a saved chat conversation to load
+        -C COLLECTION  name of the collection used in this conversation
+        -D DOCUMENT    load document and add to embeddings collection (multiple)
+        -M             use (empty) MemoryCache for this chat session
+        -E             disable embeddings for this chat session
+        -V             display the current version number and quit
+        -h             this help
+
+    EOT
+    0
+  end
+
+  def version
+    STDOUT.puts "%s %s" % [ progname, OllamaChat::VERSION ]
+    0
+  end
+end

data/lib/ollama_chat/message_list.rb

@@ -0,0 +1,216 @@
+class OllamaChat::MessageList
+  include Term::ANSIColor
+  include OllamaChat::MessageType
+
+  # The initialize method sets up the message list for an OllamaChat session.
+  #
+  # @param chat [ OllamaChat::Chat ] the chat object that this message list
+  # belongs to
+  def initialize(chat)
+    @chat     = chat
+    @messages = []
+  end
+
+  attr_reader :system
+
+  attr_reader :messages
+
+  # Returns the number of messages stored in the message list.
+  #
+  # @return [ Integer ] The size of the message list.
+  def size
+    @messages.size
+  end
+
+  # The clear method removes all non-system messages from the message list.
+  #
+  # @return [ OllamaChat::MessageList ] self
+  def clear
+    @messages.delete_if { _1.role != 'system' }
+    self
+  end
+
+  # The << operator appends a message to the list of messages and returns self.
+  #
+  # @param message [ Ollama::Message ] the message to append
+  #
+  # @return [ OllamaChat::MessageList ] self
+  def <<(message)
+    @messages << message
+    self
+  end
+
+  # Returns the last message from the conversation.
+  #
+  # @return [ Ollama::Message ] The last message in the conversation, or nil if
+  #         there are no messages.
+  def last
+    @messages.last
+  end
+
+  # The second_last method returns the second-to-last message from the
+  # conversation if there are more than one non-system messages.
+  #
+  # @return [ Ollama::Message ] the second-to-last message
+  def second_last
+    if @messages.reject { _1.role == 'system' }.size > 1
+      @messages[-2]
+    end
+  end
+
+  # The load_conversation method loads a conversation from a file and populates
+  # the message list.
+  #
+  # @param filename [ String ] the path to the file containing the conversation
+  #
+  # @return [ OllamaChat::MessageList ] self
+  def load_conversation(filename)
+    unless File.exist?(filename)
+      STDOUT.puts "File #{filename} doesn't exist. Choose another filename."
+      return
+    end
+    @messages =
+      File.open(filename, 'r') do |output|
+        JSON(output.read).map { Ollama::Message.from_hash(_1) }
+      end
+    self
+  end
+
+  # The save_conversation method saves the current conversation to a file.
+  #
+  # @param filename [ String ] the path where the conversation will be saved
+  #
+  # @return [ OllamaChat::MessageList ] self
+  def save_conversation(filename)
+    if File.exist?(filename)
+      STDOUT.puts "File #{filename} already exists. Choose another filename."
+      return
+    end
+    File.open(filename, 'w') do |output|
+      output.puts JSON(@messages)
+    end
+    self
+  end
+
+  # The list_conversation method displays the last n messages from the conversation.
+  #
+  # @param last [ Integer ] the number of messages to display (default: nil)
+  #
+  # @return [ OllamaChat::MessageList ]
+  def list_conversation(last = nil)
+    last = (last || @messages.size).clamp(0, @messages.size)
+    @messages[-last..-1].to_a.each do |m|
+      role_color = case m.role
+                   when 'user' then 172
+                   when 'assistant' then 111
+                   when 'system' then 213
+                   else 210
+                   end
+      content = m.content.full? { @chat.markdown.on? ? Kramdown::ANSI.parse(_1) : _1 }
+      message_text = message_type(m.images) + " "
+      message_text += bold { color(role_color) { m.role } }
+      message_text += ":\n#{content}"
+      m.images.full? { |images|
+        message_text += "\nImages: " + italic { images.map(&:path) * ', ' }
+      }
+      STDOUT.puts message_text
+    end
+    self
+  end
+
+  # The drop method removes the last n exchanges from the message list and returns the number of removed exchanges.
+  #
+  # @param n [ Integer ] the number of exchanges to remove
+  #
+  # @return [ Integer ] the number of removed exchanges, or 0 if there are no more exchanges to pop
+  def drop(n)
+    if @messages.reject { _1.role == 'system' }.size > 1
+      n = n.to_i.clamp(1, Float::INFINITY)
+      r = @messages.pop(2 * n)
+      m = r.size / 2
+      STDOUT.puts "Popped the last #{m} exchanges."
+      m
+    else
+      STDOUT.puts "No more exchanges you can pop."
+      0
+    end
+  end
+
+  # The set_system_prompt method sets the system prompt for the chat session.
+  # This implies deleting all of the messages in the message list, so it only
+  # contains the system prompt at the end.
+  #
+  # @param system [ String ] the new system prompt
+  #
+  # @return [ OllamaChat::MessageList ] the message list instance itself, allowing for chaining.
+  def set_system_prompt(system)
+    @system = system.to_s
+    @messages.clear
+    @messages << Ollama::Message.new(role: 'system', content: self.system)
+    self
+  end
+
+  # The show_system_prompt method displays the system prompt configured for the
+  # chat session.
+  #
+  # It retrieves the system prompt from the @system instance variable, parses
+  # it using Kramdown::ANSI, and removes any trailing newlines. If the
+  # resulting string is empty, the method returns immediately.
+  #
+  # Otherwise, it prints a formatted message to the console, including the
+  # configured system prompt and its length in characters.
+  #
+  # @return [self, NilClass] nil if the system prompt is empty, otherwise self.
+  def show_system_prompt
+    system_prompt = Kramdown::ANSI.parse(system.to_s).gsub(/\n+\z/, '').full?
+    system_prompt or return
+    STDOUT.puts <<~EOT
+      Configured system prompt is:
+      #{system_prompt}
+
+      System prompt length: #{bold{system_prompt.size}} characters.
+    EOT
+    self
+  end
+
+  # The to_ary method converts the message list into an array of
+  # Ollama::Message objects. If location support was enabled and the message
+  # list contains a system message, the system messages is decorated with the
+  # curent location, time, and unit preferences.
+  #
+  # @return [Array] An array of Ollama::Message objects representing the
+  # messages in the list.
+  def to_ary
+    location = at_location.full?
+    @messages.map do |message|
+      if message.role == 'system' && location
+        content = message.content + "\n\n#{location}"
+        Ollama::Message.new(role: message.role, content:)
+      else
+        message
+      end
+    end
+  end
+
+  # The at_location method returns the location/time/units information as a
+  # string if location is enabled.
+  #
+  # @return [ String ] the location information
+  def at_location
+    if @chat.location.on?
+      location_name            = config.location.name
+      location_decimal_degrees = config.location.decimal_degrees * ', '
+      localtime                = Time.now.iso8601
+      units                    = config.location.units
+      config.prompts.location % {
+        location_name:, location_decimal_degrees:, localtime:, units:,
+      }
+    end.to_s
+  end
+
+  private
+
+  def config
+    @chat.config
+  end
+end

data/lib/ollama_chat/message_type.rb

@@ -0,0 +1,5 @@
+module OllamaChat::MessageType
+  def message_type(images)
+    images.present? ? ?📸 : ?📨
+  end
+end

data/lib/ollama_chat/model_handling.rb

@@ -0,0 +1,29 @@
+module OllamaChat::ModelHandling
+  def model_present?(model)
+    ollama.show(name: model) { return _1.system.to_s }
+  rescue Ollama::Errors::NotFoundError
+    false
+  end
+
+  def pull_model_from_remote(model)
+    STDOUT.puts "Model #{bold{model}} not found locally, attempting to pull it from remote now…"
+    ollama.pull(name: model)
+  end
+
+  def pull_model_unless_present(model, options)
+    if system = model_present?(model)
+      return system.full?
+    else
+      pull_model_from_remote(model)
+      if system = model_present?(model)
+        return system.full?
+      else
+        STDOUT.puts "Model #{bold{model}} not found remotely. => Exiting."
+        exit 1
+      end
+    end
+  rescue Ollama::Errors::Error => e
+    warn "Caught #{e.class} while pulling model: #{e} => Exiting."
+    exit 1
+  end
+end

data/lib/ollama_chat/ollama_chat_config.rb

@@ -0,0 +1,103 @@
+class OllamaChat::OllamaChatConfig
+  include ComplexConfig
+  include FileUtils
+
+  DEFAULT_CONFIG = <<~EOT
+      ---
+      url: <%= ENV['OLLAMA_URL'] || 'http://%s' % ENV.fetch('OLLAMA_HOST') %>
+      proxy: null # http://localhost:8080
+      model:
+        name: <%= ENV.fetch('OLLAMA_CHAT_MODEL', 'llama3.1') %>
+        options:
+          num_ctx: 8192
+      location:
+        enabled: false
+        name: Berlin
+        decimal_degrees: [ 52.514127, 13.475211 ]
+        units: SI (International System of Units) # or USCS (United States Customary System)
+      prompts:
+        embed: "This source was now embedded: %{source}"
+        summarize: |
+          Generate an abstract summary of the content in this document using
+          %{words} words:
+
+          %{source_content}
+        web: |
+          Answer the the query %{query} using these sources and summaries:
+
+          %{results}
+      system_prompts:
+        default: <%= ENV.fetch('OLLAMA_CHAT_SYSTEM', 'null') %>
+      voice:
+        enabled: false
+        default: Samantha
+        list: <%= `say -v ? 2>/dev/null`.lines.map { _1[/^(.+?)\s+[a-z]{2}_[a-zA-Z0-9]{2,}/, 1] }.uniq.sort.to_s.force_encoding('ASCII-8BIT') %>
+      markdown: true
+      stream: true
+      document_policy: importing
+      embedding:
+        enabled: true
+        model:
+          name: mxbai-embed-large
+          embedding_length: 1024
+          options: {}
+          # Retrieval prompt template:
+          prompt: 'Represent this sentence for searching relevant passages: %s'
+        batch_size: 10
+        database_filename: null # ':memory:'
+        collection: <%= ENV['OLLAMA_CHAT_COLLECTION'] %>
+        found_texts_size: 4096
+        found_texts_count: 10
+        splitter:
+          name: RecursiveCharacter
+          chunk_size: 1024
+      cache: Documentrix::Documents::SQLiteCache
+      redis:
+        documents:
+          url: <%= ENV.fetch('REDIS_URL', 'null') %>
+        expiring:
+          url: <%= ENV.fetch('REDIS_EXPIRING_URL', 'null') %>
+          ex: 86400
+      debug: <%= ENV['OLLAMA_CHAT_DEBUG'].to_i == 1 ? true : false %>
+      ssl_no_verify: []
+      copy: pbcopy
+  EOT
+
+  def initialize(filename = nil)
+    @filename = filename || default_path
+    unless File.directory?(cache_dir_path)
+      mkdir_p cache_dir_path.to_s
+    end
+    @config = Provider.config(@filename, '⚙️')
+    retried = false
+  rescue ConfigurationFileMissing
+    if @filename == default_path && !retried
+      retried = true
+      mkdir_p config_dir_path.to_s
+      File.secure_write(default_path, DEFAULT_CONFIG)
+      retry
+    else
+      raise
+    end
+  end
+
+  attr_reader :filename
+
+  attr_reader :config
+
+  def default_path
+    config_dir_path + 'config.yml'
+  end
+
+  def config_dir_path
+    XDG.new.config_home + 'ollama_chat'
+  end
+
+  def cache_dir_path
+    XDG.new.cache_home + 'ollama_chat'
+  end
+
+  def database_path
+    cache_dir_path + 'documents.db'
+  end
+end