ollama_chat 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c66eb0eb6290d5161516ac786036a66c381339db5ea9a91039efc0c26b069591
-  data.tar.gz: a762ad194903ce17b01d07fa44af1b2e2fc832049ae5ec665da0236291a58561
+  metadata.gz: d7e85d325cc40d5cb5dbe01e9971c22da13b4afada35fbb17f130d9430b1f508
+  data.tar.gz: 275b88f332344e7d1664e58c60540243d6cf512b2ba78547fbe784cfd02a6acc
 SHA512:
-  metadata.gz: b133ad766292019028dc584a6197d8cc84503e8260307a9fbf141a9635a1b798bffe5f24dbe2de88c6a62408b51fbed0a9826fa0a9716fafc22c0b3c63092a2a
-  data.tar.gz: d200903b0f20a6135c8603f831e454fdcdbc272bf646984ca733566e932fa2590fb89848d7776e1ae2ac7f37143966b18b489c73ec30c1b56e348dbf154435e7
+  metadata.gz: 3b3a8bbf023960e38a33f4f2c4fc1e75e7e7be4c11213144975b1ad370efd9a71e4d61c76a7de3f3340d80eaa77d53882184f1f7635d7d5f678753e2e2c0dc6f
+  data.tar.gz: 69f57301a1308f75d55842630f7902172c8b67cf37d0ea2aad7564423be0567beb9e70bdff81b6e485cf2b3700040d6039e7c170d6a6bc4ebf65e1bf32bb32f9

data/CHANGES.md

@@ -1,5 +1,15 @@
 # Changes
 
+## 2025-05-28 v0.0.10
+
+* Simplify and improve command handling logic.
+    * Update chat input handling to use a single `handle_input` method for all commands.
+    * Add tests for various chat commands, including input handling, document
+      policy selection, summarization, and more.
+    * Improve test coverage for `DocumentCache`, `Information`, and other modules.
+    * Improved handling of commands, e.g. **don't** when sending via `ollama_chat_send` by default.
+* Added support for sending content to server socket with specific type.
+
 ## 2025-05-26 v0.0.9
 
 * Improved tag parsing in OllamaChat:

data/VERSION

@@ -1 +1 @@
-0.0.9
+0.0.10

data/bin/ollama_chat_send

@@ -3,7 +3,8 @@
 require 'ollama_chat'
 
 begin
-  OllamaChat::ServerSocket.send_to_server_socket(STDIN.read)
+  type = (ARGV.shift || 'socket_input').to_sym
+  OllamaChat::ServerSocket.send_to_server_socket(STDIN.read, type:)
 rescue => e
   warn "Caught #{e.class}: #{e}"
   exit 1

data/lib/ollama_chat/chat.rb

@@ -106,229 +106,261 @@ class OllamaChat::Chat
 
   private
 
+  def handle_input(content)
+    case content
+    when %r(^/copy$)
+      copy_to_clipboard
+      :next
+    when %r(^/paste$)
+      paste_from_input
+    when %r(^/markdown$)
+      markdown.toggle
+      :next
+    when %r(^/stream$)
+      stream.toggle
+      :next
+    when %r(^/location$)
+      location.toggle
+      :next
+    when %r(^/voice(?:\s+(change))?$)
+      if $1 == 'change'
+        change_voice
+      else
+        voice.toggle
+      end
+      :next
+    when %r(^/list(?:\s+(\d*))?$)
+      last = 2 * $1.to_i if $1
+      messages.list_conversation(last)
+      :next
+    when %r(^/clear(?:\s+(messages|links|history|all))?$)
+      clean($1)
+      :next
+    when %r(^/clobber$)
+      clean('all')
+      :next
+    when %r(^/drop(?:\s+(\d*))?$)
+      messages.drop($1)
+      messages.list_conversation(2)
+      :next
+    when %r(^/model$)
+      @model = choose_model('', @model)
+      :next
+    when %r(^/system$)
+      change_system_prompt(@system)
+      info
+      :next
+    when %r(^/regenerate$)
+      if content = messages.second_last&.content
+        content.gsub!(/\nConsider these chunks for your answer.*\z/, '')
+        messages.drop(2)
+      else
+        STDOUT.puts "Not enough messages in this conversation."
+        return :redo
+      end
+      @parse_content = false
+      content
+    when %r(^/collection(?:\s+(clear|change))?$)
+      case $1 || 'change'
+      when 'clear'
+        loop do
+          tags = @documents.tags.add('[EXIT]').add('[ALL]')
+          tag = OllamaChat::Utils::Chooser.choose(tags, prompt: 'Clear? %s')
+          case tag
+          when nil, '[EXIT]'
+            STDOUT.puts "Exiting chooser."
+            break
+          when '[ALL]'
+            if ask?(prompt: 'Are you sure? (y/n) ') =~ /\Ay/i
+              @documents.clear
+              STDOUT.puts "Cleared collection #{bold{@documents.collection}}."
+              break
+            else
+              STDOUT.puts 'Cancelled.'
+              sleep 3
+            end
+          when /./
+            @documents.clear(tags: [ tag ])
+            STDOUT.puts "Cleared tag #{tag} from collection #{bold{@documents.collection}}."
+            sleep 3
+          end
+        end
+      when 'change'
+        choose_collection(@documents.collection)
+      end
+      :next
+    when %r(^/info$)
+      info
+      :next
+    when %r(^/document_policy$)
+      choose_document_policy
+      :next
+    when %r(^/import\s+(.+))
+      @parse_content = false
+      import($1) or :next
+    when %r(^/summarize\s+(?:(\d+)\s+)?(.+))
+      @parse_content = false
+      summarize($2, words: $1) or :next
+    when %r(^/embedding$)
+      embedding_paused.toggle(show: false)
+      embedding.show
+      :next
+    when %r(^/embed\s+(.+))
+      @parse_content = false
+      embed($1) or :next
+    when %r(^/web\s+(?:(\d+)\s+)?(.+))
+      @parse_content = false
+      web($1, $2)
+    when %r(^/save\s+(.+)$)
+      messages.save_conversation($1)
+      STDOUT.puts "Saved conversation to #$1."
+      :next
+    when %r(^/links(?:\s+(clear))?$)
+      manage_links($1)
+      :next
+    when %r(^/load\s+(.+)$)
+      messages.load_conversation($1)
+      if messages.size > 1
+        messages.list_conversation(2)
+      end
+      STDOUT.puts "Loaded conversation from #$1."
+      :next
+    when %r(^/config$)
+      display_config
+      :next
+    when %r(^/quit$), nil
+      STDOUT.puts "Goodbye."
+      :return
+    when %r(^/)
+      display_chat_help
+      :next
+    when /\A\s*\z/
+      STDOUT.puts "Type /quit to quit."
+      :next
+    end
+  end
+
+  def web(count, query)
+    urls            = search_web(query, count.to_i) or return :next
+    urls.each do |url|
+      fetch_source(url) { |url_io| embed_source(url_io, url) }
+    end
+    urls_summarized = urls.map { summarize(_1) }
+    query   = $2.inspect
+    results = urls.zip(urls_summarized).
+      map { |u, s| "%s as \n:%s" % [ u, s ] } * "\n\n"
+    config.prompts.web % { query:, results: }
+  end
+
+  def manage_links(command)
+    case command
+    when 'clear'
+      loop do
+        links_options = links.dup.add('[EXIT]').add('[ALL]')
+        link = OllamaChat::Utils::Chooser.choose(links_options, prompt: 'Clear? %s')
+        case link
+        when nil, '[EXIT]'
+          STDOUT.puts "Exiting chooser."
+          break
+        when '[ALL]'
+          if ask?(prompt: 'Are you sure? (y/n) ') =~ /\Ay/i
+            links.clear
+            STDOUT.puts "Cleared all links in list."
+            break
+          else
+            STDOUT.puts 'Cancelled.'
+            sleep 3
+          end
+        when /./
+          links.delete(link)
+          STDOUT.puts "Cleared link from links in list."
+          sleep 3
+        end
+      end
+    when nil
+      if links.empty?
+        STDOUT.puts "List is empty."
+      else
+        Math.log10(links.size).ceil
+        format  = "% #{}s. %s"
+        connect = -> link { hyperlink(link) { link } }
+        STDOUT.puts links.each_with_index.map { |x, i| format % [ i + 1, connect.(x) ] }
+      end
+    end
+  end
+
+  def clean(what)
+    what = 'messages' if what.nil?
+    case what
+    when 'messages'
+      messages.clear
+      STDOUT.puts "Cleared messages."
+    when 'links'
+      links.clear
+      STDOUT.puts "Cleared links."
+    when 'history'
+      clear_history
+      STDOUT.puts "Cleared history."
+    when 'all'
+      if ask?(prompt: 'Are you sure to clear messages and collection? (y/n) ') =~ /\Ay/i
+        messages.clear
+        @documents.clear
+        links.clear
+        clear_history
+        STDOUT.puts "Cleared messages and collection #{bold{@documents.collection}}."
+      else
+        STDOUT.puts 'Cancelled.'
+      end
+    end
+  end
+
+  def display_config
+    default_pager = ENV['PAGER'].full?
+    if fallback_pager = `which less`.chomp.full? || `which more`.chomp.full?
+      fallback_pager << ' -r'
+    end
+    my_pager = default_pager || fallback_pager
+    rendered = config.to_s
+    Kramdown::ANSI::Pager.pager(
+      lines: rendered.count(?\n),
+      command: my_pager
+    ) do |output|
+      output.puts rendered
+    end
+  end
+
   def interact_with_user
     loop do
-      parse_content = true
-      input_prompt = bold { color(172) { message_type(@images) + " user" } } + bold { "> " }
+      @parse_content = true
+      type           = :terminal_input
+      input_prompt   = bold { color(172) { message_type(@images) + " user" } } + bold { "> " }
 
       begin
         content = Reline.readline(input_prompt, true)&.chomp
       rescue Interrupt
         if message = server_socket_message
           self.server_socket_message = nil
+          type    = message.fetch('type', 'socket_input').to_sym
           content = message['content']
         else
           raise
         end
       end
 
-      case content
-      when %r(^/copy$)
-        copy_to_clipboard
-        next
-      when %r(^/paste$)
-        content = paste_from_input
-      when %r(^/markdown$)
-        markdown.toggle
-        next
-      when %r(^/stream$)
-        stream.toggle
-        next
-      when %r(^/location$)
-        location.toggle
-        next
-      when %r(^/voice(?:\s+(change))?$)
-        if $1 == 'change'
-          change_voice
-        else
-          voice.toggle
-        end
-        next
-      when %r(^/list(?:\s+(\d*))?$)
-        last = 2 * $1.to_i if $1
-        messages.list_conversation(last)
-        next
-      when %r(^/clear(?:\s+(messages|links|history))?$)
-        what = $1.nil? ? 'messages' : $1
-        case what
-        when 'messages'
-          messages.clear
-          STDOUT.puts "Cleared messages."
-        when 'links'
-          links.clear
-          STDOUT.puts "Cleared links."
-        when 'history'
-          clear_history
-          STDOUT.puts "Cleared history."
-        end
-        next
-      when %r(^/clobber$)
-        if ask?(prompt: 'Are you sure to clear messages and collection? (y/n) ') =~ /\Ay/i
-          messages.clear
-          @documents.clear
-          links.clear
-          clear_history
-          STDOUT.puts "Cleared messages and collection #{bold{@documents.collection}}."
-        else
-          STDOUT.puts 'Cancelled.'
-        end
-        next
-      when %r(^/drop(?:\s+(\d*))?$)
-        messages.drop($1)
-        messages.list_conversation(2)
-        next
-      when %r(^/model$)
-        @model = choose_model('', @model)
-        next
-      when %r(^/system$)
-        change_system_prompt(@system)
-        info
-        next
-      when %r(^/regenerate$)
-        if content = messages.second_last&.content
-          content.gsub!(/\nConsider these chunks for your answer.*\z/, '')
-          messages.drop(2)
-        else
-          STDOUT.puts "Not enough messages in this conversation."
+      unless type == :socket_input
+        case next_action = handle_input(content)
+        when :next
+          next
+        when :redo
           redo
+        when :return
+          return
+        when String
+          content = next_action
         end
-        parse_content = false
-        content
-      when %r(^/collection(?:\s+(clear|change))?$)
-        case $1 || 'change'
-        when 'clear'
-          loop do
-            tags = @documents.tags.add('[EXIT]').add('[ALL]')
-            tag = OllamaChat::Utils::Chooser.choose(tags, prompt: 'Clear? %s')
-            case tag
-            when nil, '[EXIT]'
-              STDOUT.puts "Exiting chooser."
-              break
-            when '[ALL]'
-              if ask?(prompt: 'Are you sure? (y/n) ') =~ /\Ay/i
-                @documents.clear
-                STDOUT.puts "Cleared collection #{bold{@documents.collection}}."
-                break
-              else
-                STDOUT.puts 'Cancelled.'
-                sleep 3
-              end
-            when /./
-              @documents.clear(tags: [ tag ])
-              STDOUT.puts "Cleared tag #{tag} from collection #{bold{@documents.collection}}."
-              sleep 3
-            end
-          end
-        when 'change'
-          choose_collection(@documents.collection)
-        end
-        next
-      when %r(^/info$)
-        info
-        next
-      when %r(^/document_policy$)
-        choose_document_policy
-        next
-      when %r(^/import\s+(.+))
-        parse_content = false
-        content       = import($1) or next
-      when %r(^/summarize\s+(?:(\d+)\s+)?(.+))
-        parse_content = false
-        content       = summarize($2, words: $1) or next
-      when %r(^/embedding$)
-        embedding_paused.toggle(show: false)
-        embedding.show
-        next
-      when %r(^/embed\s+(.+))
-        parse_content = false
-        content       = embed($1) or next
-      when %r(^/web\s+(?:(\d+)\s+)?(.+))
-        parse_content   = false
-        urls            = search_web($2, $1.to_i) or next
-        urls.each do |url|
-          fetch_source(url) { |url_io| embed_source(url_io, url) }
-        end
-        urls_summarized = urls.map { summarize(_1) }
-        query   = $2.inspect
-        results = urls.zip(urls_summarized).
-          map { |u, s| "%s as \n:%s" % [ u, s ] } * "\n\n"
-        content = config.prompts.web % { query:, results: }
-      when %r(^/save\s+(.+)$)
-        messages.save_conversation($1)
-        STDOUT.puts "Saved conversation to #$1."
-        next
-      when %r(^/links(?:\s+(clear))?$)
-        case $1
-        when 'clear'
-          loop do
-            links_options = links.dup.add('[EXIT]').add('[ALL]')
-            link = OllamaChat::Utils::Chooser.choose(links_options, prompt: 'Clear? %s')
-            case link
-            when nil, '[EXIT]'
-              STDOUT.puts "Exiting chooser."
-              break
-            when '[ALL]'
-              if ask?(prompt: 'Are you sure? (y/n) ') =~ /\Ay/i
-                links.clear
-                STDOUT.puts "Cleared all links in list."
-                break
-              else
-                STDOUT.puts 'Cancelled.'
-                sleep 3
-              end
-            when /./
-              links.delete(link)
-              STDOUT.puts "Cleared link from links in list."
-              sleep 3
-            end
-          end
-        when nil
-          if links.empty?
-            STDOUT.puts "List is empty."
-          else
-            Math.log10(links.size).ceil
-            format  = "% #{}s. %s"
-            connect = -> link { hyperlink(link) { link } }
-            STDOUT.puts links.each_with_index.map { |x, i| format % [ i + 1, connect.(x) ] }
-          end
-        end
-        next
-      when %r(^/load\s+(.+)$)
-        messages.load_conversation($1)
-        if messages.size > 1
-          messages.list_conversation(2)
-        end
-        STDOUT.puts "Loaded conversation from #$1."
-        next
-      when %r(^/config$)
-        default_pager = ENV['PAGER'].full?
-        if fallback_pager = `which less`.chomp.full? || `which more`.chomp.full?
-          fallback_pager << ' -r'
-        end
-        my_pager = default_pager || fallback_pager
-        rendered = config.to_s
-        Kramdown::ANSI::Pager.pager(
-          lines: rendered.count(?\n),
-          command: my_pager
-        ) do |output|
-          output.puts rendered
-        end
-        next
-      when %r(^/quit$)
-        STDOUT.puts "Goodbye."
-        return
-      when %r(^/)
-        display_chat_help
-        next
-      when ''
-        STDOUT.puts "Type /quit to quit."
-        next
-      when nil
-        STDOUT.puts "Goodbye."
-        return
       end
 
-      content, tags = if parse_content
+      content, tags = if @parse_content
                         parse_content(content, @images)
                       else
                         [ content, Documentrix::Utils::Tags.new(valid_tag: /\A#*([\w\]\[]+)/) ]

data/lib/ollama_chat/server_socket.rb

@@ -8,9 +8,9 @@ module OllamaChat::ServerSocket
       File.join(runtime_dir, 'ollama_chat.sock')
     end
 
-    def send_to_server_socket(content)
+    def send_to_server_socket(content, type: :socket_input)
       FileUtils.mkdir_p runtime_dir
-      message = { content: }
+      message = { content:, type: }
       socket = UNIXSocket.new(server_socket_path)
       socket.puts JSON(message)
       socket.close

data/lib/ollama_chat/version.rb

@@ -1,6 +1,6 @@
 module OllamaChat
   # OllamaChat version
-  VERSION         = '0.0.9'
+  VERSION         = '0.0.10'
   VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/ollama_chat.gemspec

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
-# stub: ollama_chat 0.0.9 ruby lib
+# stub: ollama_chat 0.0.10 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "ollama_chat".freeze
-  s.version = "0.0.9".freeze
+  s.version = "0.0.10".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]

data/spec/ollama_chat/chat_spec.rb

@@ -6,43 +6,211 @@ RSpec.describe OllamaChat::Chat do
   end
 
   let :chat do
-    OllamaChat::Chat.new argv: argv
+    OllamaChat::Chat.new(argv: argv).expose
   end
 
-  connect_to_ollama_server(instantiate: false)
+  describe 'instantiation' do
+    connect_to_ollama_server(instantiate: false)
 
-  it 'can be instantiated' do
-    expect(chat).to be_a described_class
+    it 'can be instantiated' do
+      expect(chat).to be_a described_class
+    end
+  end
+
+  describe 'handle_input' do
+    connect_to_ollama_server
+
+    it 'returns :next when input is "/copy"' do
+      expect(chat).to receive(:copy_to_clipboard)
+      expect(chat.handle_input("/copy")).to eq :next
+    end
+
+    it 'returns :next when input is "/paste"' do
+      expect(chat).to receive(:paste_from_input).and_return "pasted this"
+      expect(chat.handle_input("/paste")).to eq "pasted this"
+    end
+
+    it 'returns :next when input is "/markdown"' do
+      expect(chat.markdown).to receive(:toggle)
+      expect(chat.handle_input("/markdown")).to eq :next
+    end
+
+    it 'returns :next when input is "/stream"' do
+      expect(chat.stream).to receive(:toggle)
+      expect(chat.handle_input("/stream")).to eq :next
+    end
+
+    it 'returns :next when input is "/location"' do
+      expect(chat.location).to receive(:toggle)
+      expect(chat.handle_input("/location")).to eq :next
+    end
+
+    it 'returns :next when input is "/voice(?:\s+(change))? "' do
+      expect(chat.voice).to receive(:toggle)
+      expect(chat.handle_input("/voice")).to eq :next
+      expect(chat).to receive(:change_voice)
+      expect(chat.handle_input("/voice change")).to eq :next
+    end
+
+    it 'returns :next when input is "/list(?:\s+(\d*))? "' do
+      expect(chat.messages).to receive(:list_conversation).with(4)
+      expect(chat.handle_input("/list 2")).to eq :next
+    end
+
+    it 'returns :next when input is "/clear(messages|links|history|all)"' do
+      expect(chat).to receive(:clean).with('messages')
+      expect(chat.handle_input("/clear messages")).to eq :next
+      expect(chat).to receive(:clean).with('links')
+      expect(chat.handle_input("/clear links")).to eq :next
+      expect(chat).to receive(:clean).with('history')
+      expect(chat.handle_input("/clear history")).to eq :next
+      expect(chat).to receive(:clean).with('all')
+      expect(chat.handle_input("/clear all")).to eq :next
+    end
+
+    it 'returns :next when input is "/clobber"' do
+      expect(chat).to receive(:clean).with('all')
+      expect(chat.handle_input("/clobber")).to eq :next
+    end
+
+    it 'returns :next when input is "/drop(?:\s+(\d*))?"' do
+      expect(chat.messages).to receive(:drop).with(?2)
+      expect(chat.messages).to receive(:list_conversation).with(2)
+      expect(chat.handle_input("/drop 2")).to eq :next
+    end
+
+    it 'returns :next when input is "/model"' do
+      expect(chat).to receive(:choose_model).with('', 'llama3.1')
+      expect(chat.handle_input("/model")).to eq :next
+    end
+
+    it 'returns :next when input is "/system"' do
+      expect(chat).to receive(:change_system_prompt).with(nil)
+      expect(chat).to receive(:info)
+      expect(chat.handle_input("/system")).to eq :next
+    end
+
+    it 'returns :next when input is "/regenerate"' do
+      expect(STDOUT).to receive(:puts).with(/Not enough messages/)
+      expect(chat.handle_input("/regenerate")).to eq :redo
+    end
+
+    it 'returns :next when input is "/collection(clear|change)"' do
+      expect(OllamaChat::Utils::Chooser).to receive(:choose)
+      expect(STDOUT).to receive(:puts).with(/Exiting/)
+      expect(chat.handle_input("/collection clear")).to eq :next
+      expect(OllamaChat::Utils::Chooser).to receive(:choose)
+      expect(chat).to receive(:info)
+      expect(STDOUT).to receive(:puts).with(/./)
+      expect(chat.handle_input("/collection change")).to eq :next
+    end
+
+    it 'returns :next when input is "/info"' do
+      expect(chat).to receive(:info)
+      expect(chat.handle_input("/info")).to eq :next
+    end
+
+    it 'returns :next when input is "/document_policy"' do
+      expect(chat).to receive(:choose_document_policy)
+      expect(chat.handle_input("/document_policy")).to eq :next
+    end
+
+    it 'returns :next when input is "/import\s+(.+)"' do
+      expect(chat).to receive(:import).with('./some_file')
+      expect(chat.handle_input("/import ./some_file")).to eq :next
+    end
+
+    it 'returns :next when input is "/summarize\s+(?:(\d+)\s+)?(.+)"' do
+      expect(chat).to receive(:summarize).with('./some_file', words: '23')
+      expect(chat.handle_input("/summarize 23 ./some_file")).to eq :next
+    end
+
+    it 'returns :next when input is "/embedding"' do
+      expect(chat.embedding_paused).to receive(:toggle)
+      expect(chat.embedding).to receive(:show)
+      expect(chat.handle_input("/embedding")).to eq :next
+    end
+
+    it 'returns :next when input is "/embed\s+(.+)"' do
+      expect(chat).to receive(:embed).with('./some_file')
+      expect(chat.handle_input("/embed ./some_file")).to eq :next
+    end
+
+    it 'returns :next when input is "/web\s+(?:(\d+)\s+)?(.+)"' do
+      expect(chat).to receive(:web).with('23', 'query').and_return 'the response'
+      expect(chat.handle_input("/web 23 query")).to eq 'the response'
+    end
+
+    it 'returns :next when input is "/save\s+(.+)$"' do
+      expect(chat.messages).to receive(:save_conversation).with('./some_file')
+      expect(chat.handle_input("/save ./some_file")).to eq :next
+    end
+
+    it 'returns :next when input is "/links(?:\s+(clear))?$" ' do
+      expect(chat).to receive(:manage_links).with(nil)
+      expect(chat.handle_input("/links")).to eq :next
+      expect(chat).to receive(:manage_links).with('clear')
+      expect(chat.handle_input("/links clear")).to eq :next
+    end
+
+    it 'returns :next when input is "/load\s+(.+)$"' do
+      expect(chat.messages).to receive(:load_conversation).with('./some_file')
+      expect(chat.handle_input("/load ./some_file")).to eq :next
+    end
+
+    it 'returns :next when input is "/config"' do
+      expect(chat).to receive(:display_config)
+      expect(chat.handle_input("/config")).to eq :next
+    end
+
+    it 'returns :next when input is "/quit"' do
+      expect(STDOUT).to receive(:puts).with(/Goodbye/)
+      expect(chat.handle_input("/quit")).to eq :return
+    end
+
+    it 'returns :next when input is "/nixda"' do
+      expect(chat).to receive(:display_chat_help)
+      expect(chat.handle_input("/nixda")).to eq :next
+    end
+
+    it 'returns :next when input is "   "' do
+      expect(STDOUT).to receive(:puts).with(/to quit/)
+      expect(chat.handle_input("   ")).to eq :next
+    end
   end
 
   describe 'chat history' do
+    connect_to_ollama_server(instantiate: false)
+
     it 'derives chat_history_filename' do
-      expect(chat.send(:chat_history_filename)).to_not be_nil
+      expect(chat.chat_history_filename).to_not be_nil
     end
 
     it 'can save chat history' do
       expect(File).to receive(:secure_write).with(
-        chat.send(:chat_history_filename),
+        chat.chat_history_filename,
         kind_of(String)
       )
-      chat.send(:save_history)
+      chat.save_history
     end
 
     it 'can initialize chat history' do
-      expect(File).to receive(:exist?).with(chat.send(:chat_history_filename)).
+      expect(File).to receive(:exist?).with(chat.chat_history_filename).
         and_return true
-      expect(File).to receive(:open).with(chat.send(:chat_history_filename), ?r)
-      chat.send(:init_chat_history)
+      expect(File).to receive(:open).with(chat.chat_history_filename, ?r)
+      chat.init_chat_history
     end
 
     it 'can clear history' do
       chat
       expect(Readline::HISTORY).to receive(:clear)
-      chat.send(:clear_history)
+      chat.clear_history
     end
   end
 
   context 'loading conversations' do
+    connect_to_ollama_server(instantiate: false)
+
     let :argv do
       %w[ -C test -c ] << asset('conversation.json')
     end
@@ -56,7 +224,10 @@ RSpec.describe OllamaChat::Chat do
   end
 
   describe OllamaChat::DocumentCache do
+    connect_to_ollama_server(instantiate: false)
+
     context 'with MemoryCache' do
+
       let :argv do
         %w[ -M ]
       end
@@ -77,6 +248,8 @@ RSpec.describe OllamaChat::Chat do
 
   describe Documentrix::Documents do
     context 'with documents' do
+    connect_to_ollama_server(instantiate: false)
+
       let :argv do
         %w[ -C test -D ] << asset('example.html')
       end
@@ -90,6 +263,8 @@ RSpec.describe OllamaChat::Chat do
   end
 
   describe OllamaChat::Information do
+    connect_to_ollama_server(instantiate: false)
+
     it 'has progname' do
       expect(chat.progname).to eq 'ollama_chat'
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ollama_chat
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Florian Frank