ollama_chat 0.0.95 → 0.0.97

data/lib/ollama_chat/personae_management.rb

@@ -262,13 +262,14 @@ module OllamaChat::PersonaeManagement
   # Prompts the user to select a persona, copies its filesystem path to the
   # clipboard, and sets it as the prefill prompt for the next interaction.
   #
+  # @param [Boolean] no_prefill Whether to skip updating the prefill prompt.
   # @return [String, nil] the filesystem path of the selected persona,
   #   or nil if the selection was cancelled.
-  def select_persona_path
+  def select_persona_path(no_prefill: false)
     persona = choose_persona(prompt: "Which persona's path do you need? %s") or return
     path = persona_name_to_pathname(persona).to_s
     perform_copy_to_clipboard(text: path, edit: false)
-    @prefill_prompt = path
+    no_prefill or @prefill_prompt = path
     path
   end
 
@@ -351,14 +352,11 @@ module OllamaChat::PersonaeManagement
         [ pathname, pathname.size ]
       end.compact.sort_by(&:last).reverse_each do |pathname, size_bytes|
         persona_name = pathname.basename.sub_ext('').to_s
-        size_bytes   = pathname.size
-        size         = format_bytes(size_bytes)
-        tokens       = OllamaChat::Utils::TokenEstimator.estimate(size_bytes)
-        tokens_size  = format_tokens(tokens)
+        es           = OllamaChat::TokenEstimator.estimate(size_bytes)
         is_default   = default_persona_name == persona_name
         display_name = prefix_favourite(is_default ? bold { persona_name } : persona_name, favs[persona_name])
 
-        table << [ display_name, size, tokens_size, ]
+        table << [ display_name, es.bytes_formatted, es.tokens_formatted, ]
       end
 
       table.align_column 1, :right
@@ -554,24 +552,40 @@ module OllamaChat::PersonaeManagement
     persona_name
   end
 
+  # Imports a character persona from JSON data, prompts for a name,
+  # and saves the resulting Markdown profile to disk.
+  #
+  # @param json_data [String] The raw character data in JSON format.
+  # @return [String, nil] The name of the created persona if successful,
+  #   or nil if the process was cancelled or failed.
+  def import_persona_from_json(json_data)
+    persona_name = determine_valid_new_name_for_persona('to import from JSON/PNG') or return
+    markdown = convert_json_character_to_markdown(json_data, persona_name)
+    persona_pathname = persona_name_to_pathname(persona_name)
+    persona_pathname.write(markdown)
+    persona_name
+  end
+
   # Transforms raw character data (JSON or YAML) into a high-fidelity,
   # structured Markdown persona profile using the persona architect prompt and
   # the current persona template.
   #
   # This method leverages the LLM to interpret raw attributes and expand them
   # into evocative prose, ensuring the final output conforms to the system's
-  # standard persona structure. It also normalizes placeholder syntax to ensure
-  # compatibility with the internal persona system.
+  # standard persona structure. It also normalizes placeholders: {{user}} is
+  # converted to %{user} for runtime personalization, and {{char}} is replaced
+  # with the actual character name provided.
   #
   # @param character [String] the raw character data in JSON format
+  # @param persona_name [String] the name of the character to replace {{char}} with
   # @return [String] the resulting structured Markdown persona profile
-  def convert_json_character_to_markdown(character)
+  def convert_json_character_to_markdown(character, persona_name)
     generate(
       prompt:  prompt(:persona_architect).to_s % {
         character:,
         persona_template: prompt(:persona).to_s
       }
-    ).response.gsub('{{user}}', '%{user}')
+    ).gsub(/{{user}}/i, '%{user}').gsub(/{{char}}/i, persona_name)
   end
 
   # Interactively exports a persona profile to a specified file.

data/lib/ollama_chat/prompt_management.rb

@@ -232,24 +232,38 @@ module OllamaChat::PromptManagement
   # Interactively generates follow-up prompt suggestions based on the current
   # session.
   #
-  # This method prompts the user to select a suggestion strategy (e.g., coding
-  # or roleplaying), constructs a prompt containing the conversation history,
-  # and requests a generation from the AI model. The resulting suggestions
-  # are then opened in the editor for final refinement before being returned.
+  # This method constructs a prompt containing the conversation history and an
+  # instruction (either selected from a template or provided manually) and
+  # requests a generation from the AI model. The resulting suggestions are then
+  # opened in the editor for final refinement before being returned.
+  #
+  # @param edit [Boolean] If true, allows the user to write a custom suggestion
+  #   instruction on the fly; otherwise, prompts the user to pick a template.
   #
   # @return [String, nil] The refined suggestion text, or nil if the process
   #   was cancelled.
-  def suggest_prompts
-    # Let the user pick a prompt template (e.g., suggest_coding, suggest_roleplaying)
-    instruction = choose_prompt(prompt: 'Which suggestion strategy shall we employ? %s') or return
+  def suggest_prompts(edit: false)
+    instruction = nil
+    if edit
+      # Let the user write a suggestion instruction on the fly
+      instruction = edit_text('')
+    else
+      # Let the user pick a prompt template (e.g., suggest_coding, suggest_roleplaying)
+      instruction = choose_prompt(prompt: 'Which suggestion strategy shall we employ? %s') or return
+    end
 
     # Build the context by gathering all current conversation messages
     history     = prepare_conversation_history
-    full_prompt = "Conversation History:\n#{history}\n\n#{instruction}"
+    full_prompt = <<~EOT
+      Conversation History:
+      #{history}
+
+      Instruction:
+      #{instruction}
+    EOT
 
-    # Execute a silent generation call (doesn't add to history)
-    response = generate(prompt: full_prompt)
-    suggestions = response.response
+    # Execute a silent chat oneshot call (doesn't add to history)
+    suggestions  = generate(prompt: full_prompt)
 
     # Pass the AI's suggestions through the editor for final refinement
     edit_text(suggestions)

data/lib/ollama_chat/session_management.rb

@@ -104,15 +104,12 @@ module OllamaChat::SessionManagement
                       else
                         name
                       end
-        size_bytes  = s.messages.to_s.size
-        size        = format_bytes(size_bytes)
-        tokens      = OllamaChat::Utils::TokenEstimator.estimate(size_bytes)
-        tokens_size = format_tokens(tokens)
+        es = OllamaChat::TokenEstimator.estimate(s.messages.to_s)
         table << [
           s.id.to_s,
           name,
-          size,
-          tokens_size,
+          es.bytes_formatted,
+          es.tokens_formatted,
           s.messages.to_s.count(?\n),
           s.age(now:),
         ]
@@ -130,12 +127,10 @@ module OllamaChat::SessionManagement
   #
   # @param output [IO] the output stream to write the information to (default: STDOUT)
   def show_session(output: STDOUT)
-    size_bytes = session.messages.to_s.size
-    messages_size  = format_bytes(size_bytes)
-    tokens         = OllamaChat::Utils::TokenEstimator.estimate(size_bytes)
-    tokens_size    = format_tokens(tokens)
+    size_bytes     = session.messages.to_s.size
+    es             = OllamaChat::TokenEstimator.estimate(size_bytes)
     messages_count = session.messages.to_s.count(?\n)
-    output.puts "#{bold{session.name}} (#{italic{session.id}}), #{messages_size}/#{tokens_size}, #{messages_count} messages"
+    output.puts "#{bold{session.name}} (#{italic{session.id}}), #{es.bytes_formatted}/#{es.tokens_formatted}, #{messages_count} messages"
   end
 
   # Interactively prompts the user for a unique session name.
@@ -227,7 +222,7 @@ module OllamaChat::SessionManagement
   # @return [OllamaChat::Database::Models::Session] the initialized session
   def setup_session
     @session = if session_name = @opts[?l]
-                 choose_session(session_name)
+                 choose_session(session_name,  offer_new_session: true)
                elsif @opts[?n]
                  new_session
                else
@@ -258,7 +253,8 @@ module OllamaChat::SessionManagement
       will be deleted, pick a new session to switch to.
     EOT
     confirm?(prompt: "\n⏎  Press any key to continue (%s). ", timeout: 3)
-    if chosen_session = choose_session(??, except_id: current_session_id)
+    if chosen_session = choose_session(??, except_id: current_session_id, offer_new_session: true)
+      chosen_session.save
       confirm?(
         prompt: "🔔 Delete session #{current_session_name.inspect} (#{current_session_id})? (y/n) ",
         yes: /\Ay/i
@@ -353,7 +349,7 @@ module OllamaChat::SessionManagement
         prompt:  prompt(:session_summarize).to_s % {
           sender_name:, unit:, message_content:, message_thinking:, context:
         }
-      ).response
+      )
       content = if pretty
                   '**%s**: %s' % [ sender_name_output, summary ]
                 else
@@ -384,7 +380,7 @@ module OllamaChat::SessionManagement
       c << "%s: %s\n\n" % [ sender_name, message.content ]
     end
     prompt = prompt(:session_title).to_s % { length:, content: }
-    generate(prompt:).response.full? do |name|
+    generate(prompt:).full? do |name|
       name = name.
         gsub(/(\A(\s|[^A-Za-z])+|(\s|[^A-Za-z])+\z)/m, '').
         gsub(/\s+/, ' ')
@@ -476,22 +472,20 @@ module OllamaChat::SessionManagement
     elsif selector
       now = Time.now
       sessions = session_query.order(Sequel.desc(:updated_at)).map { |session|
-        duration    = session.age(now:)
-        size_bytes  = session.messages.to_s.size
-        tokens      = OllamaChat::Utils::TokenEstimator.estimate(size_bytes)
-        tokens_size = format_tokens(tokens)
-        count       = session.messages.to_s.count(?\n)
-        locked      = if pid = session.locked?
-                        if pid == $$
-                          " 🔓#{pid} "
-                        else
-                          " 🔐#{pid} "
-                        end
-                      else
-                        ' '
-                      end
+        duration = session.age(now:)
+        es       = OllamaChat::TokenEstimator.estimate(session.messages.to_s)
+        count    = session.messages.to_s.count(?\n)
+        locked   = if pid = session.locked?
+                     if pid == $$
+                       " 🔓#{pid} "
+                     else
+                       " 🔐#{pid} "
+                     end
+                   else
+                     ' '
+                   end
         display     = <<~EOT.strip
-          #{session.name} 🆔#{session.id}#{locked}📨#{count} 🧩#{tokens_size} ⏳#{duration}
+          #{session.name} 🆔#{session.id}#{locked}📨#{count} 🧩#{es.tokens_formatted} ⏳#{duration}
         EOT
         SearchUI::Wrapper.new(
           session.name,

data/lib/ollama_chat/source_fetching.rb

@@ -246,7 +246,7 @@ module OllamaChat::SourceFetching
       source_io.rewind
       embed_source(source_io, source, tags:) or return
     end
-    prompt(:embed).to_s % { collection: collection }
+    prompt(:embed).to_s % { source:, collection: }
   end
 
   private

data/lib/ollama_chat/state_selectors.rb

@@ -241,6 +241,14 @@ module OllamaChat::StateSelectors
   #   that manages the currently selected voice for the chat session
   attr_reader :voices
 
+  # The context_format reader returns the context format selector for the
+  # chat session.
+  #
+  # @return [ OllamaChat::StateSelector ] the context format selector object
+  #   that manages the format used for project context generation
+  #   (e.g., 'JSON', 'TOON')
+  attr_reader :context_format
+
   # Sets up state selectors for document policy and think mode based on the
   # provided configuration.
   #
@@ -268,5 +276,11 @@ module OllamaChat::StateSelectors
       states:      config.voice.list,
       allow_empty: true
     )
+    @context_format = DatabaseStateSelector.new(
+      chat:      self,
+      attribute: :context_format,
+      name:      'Context format',
+      states:    %w[ JSON TOON ],
+    )
   end
 end

data/lib/ollama_chat/system_prompt_management.rb

@@ -41,6 +41,27 @@ module OllamaChat::SystemPromptManagement
     messages.system_name
   end
 
+  # Resolves the currently active system prompt name to its raw text content.
+  #
+  # If the current system prompt is set to 'model_default', this method
+  # retrieves the default prompt associated with the loaded model. Otherwise,
+  # it fetches the content of the specifically named system prompt from the
+  # database.
+  #
+  # The returned string represents the base template; any dynamic placeholders
+  # (e.g., %{persona} and %{runtime_info}) are nullified to ensure only the raw
+  # structure is returned.
+  #
+  # @return [String] The raw text content of the active system prompt.
+  def raw_system_prompt
+    system_name =  current_system_prompt_name
+    if system_name == 'model_default'
+      model_default_system_prompt.to_s
+    else
+      system_prompt(system_name).to_s
+    end % { persona: nil, runtime_info: nil }
+  end
+
   # Retrieves the content of the system prompt currently active in the chat
   # session.
   #

data/lib/ollama_chat/think_control.rb

@@ -5,7 +5,6 @@
 # thinking modes, checking the current state, and displaying the current
 # think mode status.
 module OllamaChat::ThinkControl
-
   # An array of strings representing the valid configuration states for the
   # thinking mode.
   #

data/lib/ollama_chat/token_estimator/crude.rb

@@ -0,0 +1,25 @@
+# Provides a "best-effort" estimation of token counts based on the
+# character count or byte size of the input content.
+class OllamaChat::TokenEstimator::Crude
+  # Initializes a new crude estimator with the provided source.
+  #
+  # @param arg [String, Integer] The content to estimate (string or raw byte count).
+  # @raise [ArgumentError] if the input is not a string or an integer.
+  def initialize(arg)
+    if text = arg.ask_and_send(:to_str)
+      @bytes = text.size
+    elsif bytes = arg.ask_and_send(:to_int)
+      @bytes = bytes
+    else
+      raise ArgumentError, "#{arg.inspect} cannot be used to estimate"
+    end
+  end
+
+  # Performs the estimation calculation and returns an Estimate object.
+  #
+  # @return [OllamaChat::TokenEstimator::Estimate]
+  def perform
+    tokens = (@bytes.to_f / 3.5).ceil
+    OllamaChat::TokenEstimator::Estimate.new(bytes: @bytes, tokens:)
+  end
+end

data/lib/ollama_chat/token_estimator.rb

@@ -0,0 +1,36 @@
+# Provides tools for estimating token counts across different models and contexts.
+module OllamaChat::TokenEstimator
+end
+
+# Requires the core estimation implementations.
+require 'ollama_chat/token_estimator/crude'
+
+# A data structure that holds the results of a token estimation,
+# providing convenient formatting methods for both byte size and token count.
+module OllamaChat::TokenEstimator
+  # Represents the result of a calculation including raw values
+  # and their human-readable formatted strings.
+  class Estimate < Struct.new(:bytes, :tokens)
+    include OllamaChat::Utils::ValueFormatter
+
+    # Returns the byte count in a formatted string (e.g., "1.2 KB").
+    # @return [String] The formatted byte size.
+    def tokens_formatted
+      format_tokens(tokens)
+    end
+
+    # Returns the byte count as a formatted string.
+    # @return [String] The formatted byte size.
+    def bytes_formatted
+      format_bytes(bytes)
+    end
+  end
+
+  # Estimates token count for a given piece of content.
+  #
+  # @param text [String, Integer] The content to estimate (string or raw byte count).
+  # @return [OllamaChat::TokenEstimator::Estimate] An object containing the results.
+  def self.estimate(text)
+    OllamaChat::TokenEstimator::Crude.new(text).perform
+  end
+end

data/lib/ollama_chat/tool_calling.rb

@@ -55,7 +55,7 @@ module OllamaChat::ToolCalling
   # @return [ Hash ] a hash containing the registered tools
   def tools
     tools_support.off? and return []
-    enabled_tools.filter_map { OllamaChat::Tools.registered[it]&.to_hash }
+    enabled_tools.filter_map { OllamaChat::Tools.registered[_1]&.to_hash }
   end
 
   # The default_enabled_tools method returns an array of tool names that are

data/lib/ollama_chat/tools/compute_bmi.rb

@@ -85,13 +85,15 @@ class OllamaChat::Tools::ComputeBMI
     raise OllamaChat::ToolFunctionArgumentError, 'Height must be greater than zero and in kg/lbs' if height <= 0
     raise OllamaChat::ToolFunctionArgumentError, 'Weight must be less than 3m and in meter/feet' if height > 3
 
-    bmi      = ( weight / (height**2) ).round(2)
+    bmi      = ( weight / height**2 ).round(2)
     category = calculate_category(bmi)
+    message  = "This BMI is #{bmi}, which falls into the #{category} category."
 
     {
-      bmi:        bmi,
-      category:   category,
-      units:      ,
+      bmi:,
+      category:,
+      units:,
+      message:,
     }.to_json
   rescue => e
     { error: e.class, message: e.message }.to_json

data/lib/ollama_chat/tools/execute_grep.rb

@@ -88,7 +88,17 @@ class OllamaChat::Tools::ExecuteGrep
     context     = normalize_number(args.context)
     cmd         = eval_template(config, pattern, path, max_results, ignore_case, before, after, context)
     result      = OllamaChat::Utils::Fetcher.execute(cmd, &:read)
-    { cmd:, result: }.to_json
+    message =
+      if result.blank?
+        "No matches found for #{args.pattern.inspect} in #{path.inspect}."
+      else
+        "Found some matches for #{args.pattern.inspect} in #{path.inspect}."
+      end
+    {
+      cmd:,
+      result:,
+      message:,
+    }.to_json
   rescue => e
     { error: e.class, message: e.message }.to_json
   end

data/lib/ollama_chat/tools/file_context.rb

@@ -65,9 +65,10 @@ class OllamaChat::Tools::FileContext
   # @return [String] the generated context data in the configured format (JSON by default)
   # @return [String] a JSON string containing error information if the operation fails
   def execute(tool_call, **opts)
-    config      = opts[:chat].config
+    chat        = opts[:chat]
+    config      = chat.config
     pattern     = tool_call.function.arguments.pattern
-    format      = config.context.format
+    format      = chat.context_format.selected
 
     directory   = Pathname.new(tool_call.function.arguments.directory || ?.)
     search_path = directory + pattern

data/lib/ollama_chat/tools/generate_password.rb

@@ -137,13 +137,16 @@ class OllamaChat::Tools::GeneratePassword
               Tins::Token.new(length:, alphabet:)
             end
 
+    message = "Successfully generated a #{token.length}-character secure password using the #{alphabet_type} alphabet."
+
     result = {
       password:      token,
       length:        token.length,
       bits:          token.bits,
-      alphabet_type: alphabet_type,
+      alphabet_type: ,
       uppercase:     ,
       extended:      ,
+      message:        ,
       generated_at:  Time.now.iso8601
     }
     if alphabet_type == 'default'

data/lib/ollama_chat/tools/get_current_weather.rb

@@ -53,8 +53,19 @@ class OllamaChat::Tools::GetCurrentWeather
     chat   = opts[:chat]
     config = chat.config
     units  = config.location.units =~ /SI/ ? 'si' : 'us'
+
     data   = { current_time: Time.now, units: } |
       JSON(get_weather_data(chat, config, units)).deep_symbolize_keys
+
+    temp      = data.dig(:currently, :temperature)
+    curr_sum  = data.dig(:currently, :summary)
+    daily_sum = data.dig(:daily, :summary)
+    unit_sym  = units == 'si' ? '°C' : '°F'
+
+    message = "Currently #{temp}#{unit_sym} and #{curr_sum}. Today's forecast: #{daily_sum}"
+
+    data[:message] = message
+
     data.to_json
   rescue => e
     {

data/lib/ollama_chat/tools/get_time.rb

@@ -54,8 +54,19 @@ class OllamaChat::Tools::GetTime
   #   execute(tool_call, config:)
   #   # => {"time":"2026-02-09T14:32:00+01:00","weekday":"Monday"}
   def execute(_tool_call, **_opts)
-    now = Time.now
-    { time: now.iso8601, weekday: now.strftime('%A') }.to_json
+    now  = Time.now
+    hour = now.hour
+
+    greeting = case hour
+               when 5..11  then 'Good morning'
+               when 12..17 then 'Good afternoon'
+               when 18..23 then 'Good evening'
+               else             'Good night'
+               end
+
+    message = "#{greeting}! It is currently #{now.strftime('%H:%M')} on #{now.strftime('%A')}."
+
+    { time: now.iso8601, weekday: now.strftime('%A'), message: }.to_json
   end
 
   self

data/lib/ollama_chat/tools/open_file_in_editor.rb

@@ -82,10 +82,10 @@ class OllamaChat::Tools::OpenFileInEditor
 
     {
       success:    true,
-      message:   ,
+      message:    ,
       path:       file_path,
-      start_line: start_line,
-      end_line:   end_line,
+      start_line: ,
+      end_line:   ,
     }.to_json
   rescue => e
     {

data/lib/ollama_chat/tools/read_file.rb

@@ -73,12 +73,15 @@ class OllamaChat::Tools::ReadFile
 
     path    = assert_valid_path(args.path, config.tools.functions.read_file.allowed?, check: :file)
     content = extract_range(path.read, start_line, end_line)
+    es      = OllamaChat::TokenEstimator.estimate(content)
+    message = "Read #{es.bytes_formatted} (#{es.tokens_formatted}) from #{path.to_s.inspect}."
 
     {
       path:,
       content:,
       start_line:,
       end_line:,
+      message:,
     }.to_json
   rescue => e
     {

data/lib/ollama_chat/tools/retrieve_document_snippets.rb

@@ -123,15 +123,22 @@ class OllamaChat::Tools::RetrieveDocumentSnippets
       records = rerank_records(chat, query, records)
     end
 
-    message = records.map { |record|
-      link = if record.source =~ %r(\Ahttps?://)
-               record.source
-             else
-               'file://%s' % File.expand_path(record.source)
-             end
-      link && record.tags.any? or next
-      [ link, ?# + record.tags.first ]
-    }.flat_map { |l, t| chat.hyperlink(l, t) }.join(' ')
+    collection_name = chat.documents.collection
+    message =
+      if records.any?
+        "Retrieved #{records.size} relevant snippets from collection #{collection_name.inspect} for query #{query.inspect}. See snippets below:\n\n" +
+          records.map { |record|
+            link = if record.source =~ %r(\Ahttps?://)
+                     record.source
+                   else
+                     'file://%s' % File.expand_path(record.source)
+                   end
+            link && record.tags.any? or next
+            [ link, ?# + record.tags.first ]
+          }.flat_map { |l, t| chat.hyperlink(l, t) }.join(' ')
+      else
+        "No relevant snippets found for query #{query.inspect} in collection #{collection_name.inspect}."
+      end
 
     {
       prompt: 'Consider these snippets generated from retrieval when formulating your response!',
@@ -181,7 +188,7 @@ class OllamaChat::Tools::RetrieveDocumentSnippets
     begin
       # We use the active chat model to perform the surgical precision
       # filtering
-      if response = chat.generate(prompt:)&.response.full?
+      if response = chat.generate(prompt:).full?
         indices  = response.scan(/\d+/).map(&:to_i).select { |i| (0...records.size).include?(i) }
         records  = records.values_at(*indices) if indices.any?
       end
@@ -208,7 +215,7 @@ class OllamaChat::Tools::RetrieveDocumentSnippets
       prompt:         chat.config.embedding.model.prompt?,
       text_size:      ,
       text_count:     ,
-      min_similarity: min_similarity
+      min_similarity:
     )
   end