ollama_chat 0.0.134 → 0.0.136

data/lib/ollama_chat/model_handling.rb

@@ -1,3 +1,5 @@
+require 'ollama_chat/model_handling/model_cache'
+
 # A module that provides functionality for managing Ollama models, including
 # checking model availability, pulling models from remote servers, and handling
 # model presence verification.
@@ -416,16 +418,20 @@ module OllamaChat::ModelHandling
   # @return [ ModelMetadata, NilClass ] if the model is present,
   #   nil otherwise
   def model_present?(model, ollama:)
+    name           = model.full? or return
+    model_metadata = @model_cache.cached?(ollama, name) and return model_metadata
     ollama.show(model:) do |md|
-      return ModelMetadata.new(
-        name:         model,
+      model_metadata = ModelMetadata.new(
+        name:         ,
         system:       md.system,
         capabilities: md.capabilities,
         families:     md.details.families,
         thinking:     md.thinking,
       )
     end
-  rescue Ollama::Errors::NotFoundError
+    model_metadata or return
+    @model_cache.cache(ollama, name, model_metadata)
+  rescue Ollama::Errors::NotFoundError, Ollama::Errors::BadRequestError
     nil
   end
 
@@ -467,16 +473,15 @@ module OllamaChat::ModelHandling
   # by creating a formatted string that includes the model name and its size
   # in a human-readable format with appropriate units.
   #
-  # @param model [ Object ] the model object that has name and size attributes
+  # @param model [ String ] the model name
+  # @param size  [ Integer ] the size of the model in bytes
   #
-  # @return [ Object ] a result object with an overridden to_s method
-  #                     that combines the model name and formatted size
-  def model_with_size(model, favourited: false)
-    formatted_size = Term::ANSIColor.bold {
-      format_bytes(model.size)
-    }
-    display = prefix_favourite("#{model.name} #{formatted_size}", favourited)
-    SearchUI::Wrapper.new(model.name, display:)
+  # @return [ SearchUI::Wrapper ] a result object with an overridden to_s
+  #   method that combines the model name and formatted size
+  def model_with_size(model, size, favourited: false)
+    formatted_size = Term::ANSIColor.bold { format_bytes(size) }
+    display        = prefix_favourite("#{model} #{formatted_size}", favourited)
+    SearchUI::Wrapper.new(model, display:)
   end
 
   # Ensures the specified model is available locally and synchronizes the
@@ -625,8 +630,13 @@ module OllamaChat::ModelHandling
   #   metadata
   def all_models
     favs = all_favourited('model')
-    ollama.tags.models.sort_by(&:name).
-      map { |m| model_with_size(m, favourited: favs[m.name]) }
+    @model_cache.models(ollama).sort.map { |name|
+      model_with_size(
+        name,
+        @model_cache.model_size(ollama, name),
+        favourited: favs[name]
+      )
+    }
   end
 
   # The choose_model method selects a model from the available list based on
@@ -641,22 +651,24 @@ module OllamaChat::ModelHandling
   # @param current_model [String] the fallback model if selection fails
   # @return [String] the selected model name
   def choose_model(cli_model, current_model)
+    if model_present?(cli_model, ollama:)
+      return cli_model
+    end
     selector = if cli_model =~ /\A\?+(.*)\z/
                  cli_model = ''
                  Regexp.new($1)
                end
     models = all_models
     selector and models = models.select { _1.value =~ selector }
-    model =
-      if models.size == 1
-        models.first.value
-      elsif cli_model == ''
-        choose_entry(
-          models,
-          prompt: "Which digital oracle shall we consult? %s"
-        )&.value || current_model
-      else
-        cli_model || current_model
-      end
+    if models.size == 1
+      models.first.value
+    elsif cli_model == ''
+      choose_entry(
+        models,
+        prompt: "Which digital oracle shall we consult? %s"
+      )&.value || current_model
+    else
+      cli_model || current_model
+    end
   end
 end

data/lib/ollama_chat/oc.rb

@@ -89,6 +89,14 @@ module OC
     end
   end
 
+  FASTFETCH = set do
+    description 'Path to fastfetch executable for system information'
+
+    default do
+      `which 2>/dev/null fastfetch`.full?(:chomp)
+    end
+  end
+
   KRAMDOWN_ANSI_OLLAMA_CHAT_STYLES = set do
     description 'Styles to use for kramdown-ansi markdown'
 

data/lib/ollama_chat/ollama_chat_config/default_config.yml

@@ -56,6 +56,7 @@ prompts:
       - Location: %{location}
       - Current directory is "%{current_directory}"
       - Client is %{client}.
+      - Machine: %{machine}
     dynamic_runtime_info: |
       There is usually no reason to mention this information to the user unless
       asked about it.
@@ -174,7 +175,7 @@ prompts:
 
       Create a title with a length of **less than %{length}** characters for
       the conversation above. Output only the title and nothing else.
-  session:
+  report:
     coding_brief: |
       %{content}
 

data/lib/ollama_chat/ollama_chat_config/fastfetch-profile.jsonc

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+  "display": {
+    "showErrors": false,
+    "noBuffer": true
+  },
+  "logo": null,
+  "modules": [
+    "os", "kernel", "cpu", "gpu", "de", "wm",
+    "terminal", "memory", "editor",
+    "packages", "chassis", "board", "bios"
+  ]
+}

data/lib/ollama_chat/personae_management.rb

@@ -95,15 +95,33 @@ module OllamaChat::PersonaeManagement
   def set_default_persona_name(persona_name)
     if persona_name.present? && persona_name != :none
       @default_persona_name = Pathname.new(persona_name).basename.sub_ext('').to_path
-      @session.update(default_persona_name:)
     else
-      @session.update(default_persona_name: nil)
       @default_persona_name = nil
     end
+    @session.update(default_persona_name:)
+    sync_trigger
     messages.set_system_prompt(session&.current_system_prompt.full?)
     default_persona_name
   end
 
+  # Synchronizes the session's trigger collection to match the current
+  # default persona.
+  #
+  # When a persona is set, the trigger is re-keyed (or seeded) to
+  # `memory-<persona>`, preserving any existing trigger configuration.
+  # When no persona is active, the trigger is set to nil.
+  def sync_trigger
+    unless @default_persona_name
+      session.update(trigger: nil) unless session.trigger.nil?
+      return
+    end
+    collection = create_memory_collection(@default_persona_name)
+    return if session.trigger&.keys&.first == collection
+    cfg = session.trigger&.values&.first or
+      cfg = chat.config.trigger.to_h.stringify_keys_recursive
+    session.update(trigger: { collection => cfg })
+  end
+
   # Interactively selects a persona and sets it as the default for the session.
   #
   # This method prompts the user to choose a persona from the available list

data/lib/ollama_chat/prompt_management.rb

@@ -381,7 +381,7 @@ module OllamaChat::PromptManagement
       start   = '%s %s' % [ default, bold { p.name } ]
       start   = prefix_favourite(start, favs[p.name])
       content = p.to_s.inspect[1..-2]
-      content = Kramdown::ANSI::Width.truncate(
+      content = truncate(
         content, length: 0.9 * (Tins::Terminal.columns - start.size)
       )
       feedback '%s %s' % [ start, italic { content } ]

data/lib/ollama_chat/rag_handling.rb

@@ -336,7 +336,7 @@ module OllamaChat::RAGHandling
         output.puts kramdown_ansi_parse(<<~EOT)
           **#{record.source}**
           ```
-          #{Kramdown::ANSI::Width.wrap(record.text.sub(/\n+\z/, ''), percentage: 90)}
+          #{wrap(record.text.sub(/\n+\z/, ''), percentage: 90)}
           ```
           ---
         EOT
@@ -406,7 +406,7 @@ module OllamaChat::RAGHandling
                 output.puts kramdown_ansi_parse(<<~EOT)
                   **[#{record.tags.join(', ')}]**
                   ```
-                  #{Kramdown::ANSI::Width.wrap(record.text.sub(/\n+\z/, ''), percentage: 90)}
+                  #{wrap(record.text.sub(/\n+\z/, ''), percentage: 90)}
                   ```
                   ---
                 EOT

data/lib/ollama_chat/session_management.rb

@@ -110,7 +110,7 @@ module OllamaChat::SessionManagement
       table.headings = %w[ ID NAME SIZE #TOK COUNT UPDATED ].map { |header| bold { header } }
       now = Time.now
       models::Session.order(Sequel.desc(:updated_at)).each do |s|
-        name        = Kramdown::ANSI::Width.truncate(s.name, length: 32)
+        name        = truncate(s.name, length: 32)
         name        = session.id == s.id ? bold { name } : name
         name        = if pid = s.locked?
                         if pid == $$
@@ -197,8 +197,15 @@ module OllamaChat::SessionManagement
     previous_session_id = @session.id
     @session = new_session(name:)
     set_previous_session_on_change(previous_session_id)
-    session.lock?(chat: self) or raise OllamaChat::OllamaChatError,
-      "Could not lock session #{session.id} #{session.errors.full?(:inspect)}"
+    unless session.lock?
+      feedback(
+        "session #{session.id} locked by running process #{session.locked?}",
+        type: :warn
+      )
+      raise OllamaChat::OllamaChatError,
+        "Could not lock session #{session.id} #{session.errors.full?(:inspect)}"
+    end
+    @default_persona_name = session.default_persona_name
     session_apply
     messages.clear
     session.current_model.full? {
@@ -255,10 +262,15 @@ module OllamaChat::SessionManagement
                  preferred_session
                end
     session or abort "No session named #{bold{session_name.inspect}} found."
-    if session.lock?(chat: self)
+    if session.lock?
       messages.read_conversation_jsonl(session.messages.to_s)
+      @default_persona_name = session.default_persona_name || nil
       session_apply
     else
+      feedback(
+        "session #{session.id} locked by running process #{session.locked?}",
+        type: :warn
+      )
       raise OllamaChat::OllamaChatError,
         "Could not lock session #{session.id} #{session.errors.full?(:inspect)}"
     end
@@ -279,13 +291,7 @@ module OllamaChat::SessionManagement
   # @return [OllamaChat::Database::Models::Session] the applied session
   #   instance.
   def session_apply
-    initial_persona_name.full? do |persona_name|
-      collection        = create_memory_collection(persona_name)
-      session.trigger.present? or
-        session.trigger = {
-          collection => chat.config.trigger.to_h.stringify_keys_recursive
-        }
-    end
+    sync_trigger
     session.update(working_directory: Dir.pwd)
     init_history
     repair_group_uuids
@@ -442,7 +448,7 @@ module OllamaChat::SessionManagement
 
   # Generates a report document for the current session's conversation.
   #
-  # Uses a user-selected prompt template from the 'session' context
+  # Uses a user-selected prompt template from the 'report' context
   # (e.g. coding_brief, roleplay_story) to produce a single cohesive
   # document describing the session. Uses `compacted_messages` (summary +
   # recent tail) rather than `each_message` so the interpolated content
@@ -459,10 +465,10 @@ module OllamaChat::SessionManagement
     content.empty? and return
 
     template = if name
-                 prompt(name, context: 'session')
+                 prompt(name, context: 'report')
                else
                  choose_prompt(
-                   context: 'session',
+                   context: 'report',
                    prompt: 'Which report template? %s'
                  )
                end
@@ -601,7 +607,7 @@ module OllamaChat::SessionManagement
         name = name.
           gsub(/(\A(\s|[^A-Za-z])+|(\s|[^A-Za-z])+\z)/m, '').
           gsub(/\s+/, ' ')
-        Kramdown::ANSI::Width.truncate(name, length:)
+        truncate(name, length:)
       end
     end
   end
@@ -649,7 +655,7 @@ module OllamaChat::SessionManagement
         session_close
         previous_session = session
         @session = chosen_session
-        if session.lock?(chat: self)
+        if session.lock?
           messages.read_conversation_jsonl(session.messages.to_s)
           if current_collection = session.current_collection.full? and
               database_collection?(current_collection)
@@ -666,6 +672,10 @@ module OllamaChat::SessionManagement
           info_session
           break
         else
+          feedback(
+            "session #{session.id} locked by running process #{session.locked?}",
+            type: :warn
+          )
           @session = previous_session
           @session.lock
           name = ??
@@ -737,16 +747,13 @@ module OllamaChat::SessionManagement
                    else
                      ' '
                    end
-        display     = <<~EOT.strip
-          #{session.name} 🆔#{session.id}#{locked}📨#{count} 🧩#{es.tokens_formatted} ⏳#{duration}
-        EOT
-        SearchUI::Wrapper.new(
-          session.name,
-          display:
-        )
+        suffix               = " 🆔#{session.id}#{locked}📨#{count} 🧩#{es.tokens_formatted} ⏳#{duration}"
+        display_session_name = truncate(session.name, length: (0.8 * (width - suffix.length)).floor.clamp(1..))
+        display              = "#{display_session_name}#{suffix}"
+        SearchUI::Wrapper.new([ session.id, session.name ] * ?-, display:)
       }
       selector and sessions = sessions.select { _1 =~ selector }
-      session_name =
+      session_selected =
         if sessions.size == 1
           sessions.first.value
         else
@@ -766,8 +773,8 @@ module OllamaChat::SessionManagement
           end
           value
         end
-      if session_name
-        session_query.first(name: session_name)
+      if session_selected
+        session_query.first(id: session_selected.split(?-, 2).first)
       end
     end
   end

data/lib/ollama_chat/source_fetching.rb

@@ -244,7 +244,7 @@ module OllamaChat::SourceFetching
     command = false
     inputs  = inputs.map { |chunk| "Source: #{source}\n#{chunk}" }
     if source.start_with?(?!)
-      source = Kramdown::ANSI::Width.truncate(
+      source = truncate(
         source[1..-1].gsub(/\W+/, ?_),
         length: 10
       )

data/lib/ollama_chat/tool_call_processor.rb

@@ -0,0 +1,176 @@
+# Processes tool calls from Ollama responses: executes registered tools,
+# collects results, and provides a drain interface for the chat loop to
+# consume them as follow-up messages.
+#
+# This class encapsulates the full tool-call lifecycle that was previously
+# split between {OllamaChat::FollowChat#handle_tool_calls} (execution)
+# and {OllamaChat::ToolCalling#handle_tool_call_results?} (consumption).
+class OllamaChat::ToolCallProcessor
+  include Ollama::Handlers::Concern
+  include Term::ANSIColor
+  include OllamaChat::Feedback
+
+  # @return [OllamaChat::Chat] the chat context
+  attr_reader :chat
+
+  # The accumulated tool results, keyed by tool name.
+  #
+  # @return [Hash{String => Array<String>}]
+  attr_reader :results
+
+  # @param chat [OllamaChat::Chat] the chat context
+  # @param output [IO] the output stream for feedback (default: STDOUT)
+  def initialize(chat:, output: STDOUT)
+    super(output:)
+    @chat = chat
+    @results = Hash.new { |h, name| h[name] = [] }
+  end
+
+  # Processes tool calls from a response, executing each tool and
+  # storing the result in the internal results hash.
+  #
+  # @param response [Ollama::Response] the parsed response
+  def handle(response)
+    return unless response.message.ask_and_send(:tool_calls)
+
+    tools_used = {}
+
+    response.message.tool_calls.each do |tool_call|
+      name = tool_call.function.name
+      if %r(.*[/:](?<new_name>.+)) =~ name
+        msg = "Received namespaced tool call for #{name}, correcting to #{new_name}"
+        chat.log(:warn, msg, data: { tool: name, new_name: })
+        name = new_name
+      end
+      unless chat.tool_configured?(name)
+        msg = "Error: Unconfigured tool named %s ignored => Skip.\n" % name
+        @results[name] << msg
+        chat.log(:error, msg, data: { tool: name, reason: :unconfigured })
+        next
+      end
+      unless chat.tool_registered?(name)
+        msg = "Error: Unregistered tool named %s ignored => Skip.\n" % name
+        @results[name] << msg
+        chat.log(:error, msg, data: { tool: name, reason: :unregistered })
+        next
+      end
+      unless chat.tool_enabled?(name)
+        msg = "Error: Disabled tool named %s ignored => Skip.\n" % name
+        @results[name] << msg
+        chat.log(:error, msg, data: { tool: name, reason: :disabled })
+        next
+      end
+      feedback(?\n, output:)
+      confirmed = :implicit
+      resolve   = nil
+      function  = JSON.pretty_generate(tool_call.function)
+      chat.log(:info, "Tool call received", data: { tool: name, function: })
+      if chat.tool_function(name).require_confirmation?
+        feedback(
+          ("I want to execute tool %s\n%s\n" % [ bold { name }, italic { function }, ]),
+          type: :alarm
+        )
+        prompt  = '❓ Allow ✅[y]es / ⛔️[n]o / 📝[i]nstruct? '
+        answer  = chat.confirm?(prompt:)&.to_s&.downcase
+        resolve = 'You **MUST** ask the user for instructions on how to proceed!!!'
+        case answer
+        when 'y'
+          confirmed = :explicit
+        when 'n'
+          confirmed = :denied
+        else
+          confirmed = :denied
+          instr     = chat.ask?(prompt: '📝 Instructions: ')&.strip
+          resolve   = instr.full? ||  resolve
+        end
+      else
+        feedback(
+          "Executing tool %s\n%s" % [ bold { name }, italic { function }, ]
+        )
+      end
+      start  = Time.now
+      result = nil
+      case confirmed
+      when :denied
+        result = JSON(message: 'User denied confirmation!', resolve:)
+        feedback(?\n)
+        feedback(
+          ("Execution of tool %s denied by user.\n\n" % [ bold { name } ]),
+          type: :denied
+        )
+        chat.log(:warn, "Tool execution denied", data: { tool: name, reason: :denied })
+      else
+        symbol = confirmed == :implicit ? '☑️ ' : '✅'
+        feedback(
+          ("\n%s Execution of tool %s confirmed.\n\n" % [ symbol, bold { name } ])
+        )
+        result = OllamaChat::Tools.registered_tool(name, chat:).execute(tool_call)
+        chat.log(:info, "Tool execution confirmed", data: { tool: name, confirmed: })
+      end
+
+      @results[name] << result
+      data    = nil
+      message = begin
+                  data = JSON.parse(result)
+                  chat.log(:info, "Tool result", data: { result: data })
+                  data.to_hash['message'] if data.respond_to?(:to_hash)
+                rescue
+                  chat.log(:info, "Tool result", data: { result: })
+                  nil
+                end
+      warn =
+        begin
+          !!data.ask_and_send(:[], 'error') || data.ask_and_send(:[], 'success') == false
+        rescue
+          false
+        end
+
+      es = OllamaChat::TokenEstimator.estimate(result.to_s)
+
+      tools_used[name] = {
+        message:,
+        warn:     ,
+        size:     es.bytes_formatted,
+        tokens:   es.tokens_formatted,
+        duration: Tins::Duration.new(Time.now - start).to_s,
+      }
+    end
+
+    if tools_used.full?
+      infobar.reset
+      tools_used.each do |name, info|
+        feedback_message =
+          if info[:message]
+            "\n%s %s\n\n" % [ info[:warn] ? '⚠️' : '💡', info[:message] ]
+          end
+        feedback(<<~EOT.strip)
+          🔧 Tool functions #{name} returned result (#{info[:size]}/#{info[:tokens]} in #{info[:duration]}).
+          #{feedback_message}
+        EOT
+        feedback(?\n)
+        timeout = chat.tool_function(name).result_display_timeout?
+        chat.confirm?(prompt: '⏎  Press any key to continue (%s). ', timeout:)
+      end
+    end
+  end
+
+  # Drains all accumulated results, yielding each entry to the block,
+  # then clears the internal storage.
+  #
+  # @yield [index, tool_name, content] each result entry
+  # @return [true, false] whether any results were present
+  def drain(&block)
+    @results.each do |tool_name, results|
+      results.each_with_index { |content, index|
+        block.(index, tool_name, content)
+      }
+    end.present?
+  ensure
+    @results.clear
+  end
+
+  # Clears all accumulated results without yielding them.
+  def clear!
+    @results.clear
+  end
+end

data/lib/ollama_chat/tool_calling.rb

@@ -94,11 +94,6 @@ module OllamaChat::ToolCalling
     Array(config.tools&.functions&.attribute_names&.map(&:to_s)).sort
   end
 
-  # The tool_call_results reader returns the tools' results for the
-  # chat session if any.
-  #
-  # @return [ Hash ] a hash containing the registered tool results
-  attr_reader :tool_call_results
 
   # The list_tools method displays the sorted list of enabled tools.
   #
@@ -183,15 +178,4 @@ module OllamaChat::ToolCalling
     end
   end
 
-  private
-
-  def handle_tool_call_results?(&block)
-    @tool_call_results.each do |tool_name, results|
-      results.each_with_index { |content, index|
-        block.(index, tool_name, content)
-      }
-    end.present?
-  ensure
-    @tool_call_results.clear
-  end
 end