ollama_chat 0.0.113 → 0.0.114

data/lib/ollama_chat/config_handling.rb

@@ -1,3 +1,5 @@
+require 'open3'
+
 # Provides functionality for handling configuration files and settings for
 # OllamaChat. It loads configuration from YAML files, supports environment
 # variable overrides, and offers methods to read and write configuration data.
@@ -20,6 +22,36 @@ module OllamaChat::ConfigHandling
     self.class.config
   end
 
+  # Returns the first enabled syntax checker whose suffixes match the
+  # given file's extension, or nil if no match.
+  #
+  # @param path [String, Pathname] the file path to check
+  # @return [ComplexConfig::Settings, nil] the matching checker config
+  def syntax_checker_for(path)
+    path = Pathname.new(path)
+    ext = path.extname.delete_prefix(?.).full? or return
+    config.syntax_checkers.attribute_values.each do |checker|
+      next unless checker.enabled
+      return checker if checker.suffixes.include?(ext)
+    end
+    nil
+  end
+
+  # Runs the syntax checker on the given file and returns a result hash.
+  #
+  # @param checker [ComplexConfig::Settings] the resolved checker config
+  # @param path [String, Pathname] the file to check
+  # @return [Hash, nil] { status:, output: } or nil if binary is missing
+  def run_syntax_check(checker, path)
+    _stdout, stderr, status = Open3.capture3(*checker.cmd, path.to_s)
+    {
+      status: status.success? ? 'pass' : 'fail',
+      output: stderr.strip
+    }
+  rescue Errno::ENOENT
+    nil
+  end
+
   private
 
   # The config= method assigns a new configuration object to the class.

data/lib/ollama_chat/database/migrations/010_add_enabled_to_collections.rb

@@ -0,0 +1,7 @@
+Sequel.migration do
+  change do
+    alter_table :collections do
+      add_column :enabled, :boolean, default: true, null: false
+    end
+  end
+end

data/lib/ollama_chat/database/models/app_state.rb

@@ -62,17 +62,8 @@ class OllamaChat::Database::Models::AppState < Sequel::Model(OllamaChat::DB)
 
     stored_fingerprint = stored&.dig('fingerprint')
 
-    hashes = {}
-    chat.config.prompts.to_h.each do |context, prompts|
-      prompts.each do |name, content|
-        hashes["#{context}/#{name}"] =
-          Digest::SHA256.hexdigest(content.to_s)
-      end
-    end
-
-    fingerprint = hashes.values.reduce(0) do |sum, hex|
-      sum ^ hex.to_i(16)
-    end.to_s(16)
+    hashes    = compute_hashes(chat.config.prompts)
+    fingerprint = fingerprint_from(hashes)
 
     return true if fingerprint == stored_fingerprint
 
@@ -88,23 +79,32 @@ class OllamaChat::Database::Models::AppState < Sequel::Model(OllamaChat::DB)
       removed.each { |k| STDERR.puts "  - #{k} (removed)" }
     elsif !OllamaChat.test_mode?
       STDERR.puts '⚠️  First run — storing prompt fingerprints.'
-      set(:prompt_defaults_fingerprint,
-          { fingerprint:, hashes:, computed_at: Time.now.iso8601 })
+      store_fingerprint(fingerprint, hashes)
       return true
     end
 
     prompt = <<~EOT.chomp << ' '
       Keep local prompts (stop nagging)?
-      Consider adopting via /prompt sync or /prompt reset. (y/n) %s
+      Consider adopting via /prompt sync or just ignore? (y/n) %s
     EOT
     if OllamaChat.test_mode? || chat.confirm?(prompt:, yes: /\Ay/i, timeout: 5)
-      set(:prompt_defaults_fingerprint,
-          { fingerprint:, hashes:, computed_at: Time.now.iso8601 })
+      store_fingerprint(fingerprint, hashes)
     end
 
     true
   end
 
+  # Acknowledges the current shipped-prompt state, suppressing the boot
+  # drift notification. Called after `/prompt sync` so the user is not
+  # nagged again on the next launch.
+  #
+  # @param chat [OllamaChat::Chat] the chat instance providing the config
+  def self.acknowledge(chat)
+    hashes      = compute_hashes(chat.config.prompts)
+    fingerprint = fingerprint_from(hashes)
+    store_fingerprint(fingerprint, hashes)
+  end
+
   # @!attribute [v] id
   #   @return [Integer] The primary key for the state entry.
   #
@@ -119,4 +119,36 @@ class OllamaChat::Database::Models::AppState < Sequel::Model(OllamaChat::DB)
   #
   # @!attribute [v] updated_at
   #   @return [Time, nil] The timestamp of the last update to the state.
+
+  private
+
+  # Builds a per-prompt SHA256 hash map from a prompts config object.
+  #
+  # @param prompts_config [OllamaChatConfig::Prompts] the config prompts
+  # @return [Hash{String => String}] mapping "context/name" → SHA256 hex
+  def self.compute_hashes(prompts_config)
+    prompts_config.to_h.each_with_object({}) do |(context, prompts), hashes|
+      prompts.each do |name, content|
+        hashes["#{context}/#{name}"] =
+          Digest::SHA256.hexdigest(content.to_s)
+      end
+    end
+  end
+
+  # Computes an XOR fingerprint from a hash map.
+  #
+  # @param hashes [Hash{String => String}] the per-prompt SHA256 hex values
+  # @return [String] the XOR-combined fingerprint as a hex string
+  def self.fingerprint_from(hashes)
+    hashes.values.reduce(0) { |sum, hex| sum ^ hex.to_i(16) }.to_s(16)
+  end
+
+  # Stores the fingerprint and hash map under the standard state key.
+  #
+  # @param fingerprint [String] the XOR fingerprint
+  # @param hashes [Hash{String => String}] the per-prompt hash map
+  def self.store_fingerprint(fingerprint, hashes)
+    set(:prompt_defaults_fingerprint,
+        { fingerprint:, hashes:, computed_at: Time.now.iso8601 })
+  end
 end

data/lib/ollama_chat/database/models/session.rb

@@ -54,8 +54,7 @@ class OllamaChat::Database::Models::Session < Sequel::Model(OllamaChat::DB)
   #
   # @return [OllamaChat::TokenEstimator::Estimate] the estimated token and byte counts
   def estimate_tokens
-    size_bytes = messages.to_s.size
-    OllamaChat::TokenEstimator.estimate(size_bytes)
+    OllamaChat::TokenEstimator.estimate(messages.to_s)
   end
 
   # Counts the number of messages in the session's JSONL history.

data/lib/ollama_chat/database.rb

@@ -28,8 +28,10 @@ module OllamaChat::Database
     db_path = OC::XDG_STATE_HOME.join('settings.db').expand_path
 
     url = 'sqlite://' + db_path.to_path
-    OC::OLLAMA::CHAT::DATABASE_LOGFILE.dirname.mkpath
-    logger = Logger.new(OC::OLLAMA::CHAT::DATABASE_LOGFILE)
+    db_log = OC::OLLAMA::CHAT::LOG::DATABASE
+    db_log.dirname.mkpath
+    logger = Logger.new(db_log)
+    logger.level = Logger::WARN
     unless OllamaChat.const_defined?('DB')
       OllamaChat.const_set('DB', Sequel.connect(url, logger:))
     end

data/lib/ollama_chat/information.rb

@@ -133,11 +133,12 @@ module OllamaChat::Information
     end
     output.puts "🧠 Current chat model is #{bold{@model}}."
     context_usage = '%s of %s (%s)' % [
-      session.estimate_tokens.tokens_formatted,
+      messages.compacted_estimate_tokens.tokens_formatted,
       format_tokens(current_context_length),
-      bold { '%.1f%%' % (100 * context_filled)},
+      context_gauge(format('%.1f%%', 100 * context_filled)),
     ]
-    output.puts  "  Context Length: #{context_usage}"
+    output.puts  "  Context Usage: #{context_usage}"
+    output.puts  "  Conversation Length: #{conversation_length}"
     output.print '  '; think_mode.show(output:)
     output.print '  '; think_loud.show(output:)
     output.print '  '; think_strip.show(output:)
@@ -309,7 +310,8 @@ module OllamaChat::Information
   # @return [Hash{String => String}] a hash mapping collection names to their
   #   descriptions
   def collection_descriptions
-    cols = models::Collection.select(:name, :description).order(:name)
+    cols = models::Collection.where(enabled: true)
+      .select(:name, :description).order(:name)
     cols.each_with_object({}) do |c, hash|
       hash[c.name] = c.description
     end
@@ -344,6 +346,22 @@ module OllamaChat::Information
     prompt(:static_runtime_info).to_s % static_runtime_information_values
   end
 
+  # Returns a formatted string representing the estimated text length of
+  # the full stored conversation, excluding images and JSON scaffolding.
+  #
+  # Delegates to +MessageList#full_estimate_tokens+, which sums
+  # per-message +token_estimate+ (content + optional thinking) across
+  # all messages, respecting the +think_strip+ toggle. This differs from
+  # +Session#estimate_tokens+, which measures raw JSONL bytes including
+  # base64 images and metadata — the latter is the storage footprint,
+  # this is the model-facing text volume.
+  #
+  # @return [String] formatted as `"340.5 KT (1.2 MiB)"`
+  def conversation_length
+    es = messages.full_estimate_tokens
+    "%s (%s)" % [ es.tokens_formatted, es.bytes_formatted ]
+  end
+
   # The dynamic_runtime_information_values method compiles a set of
   # volatile runtime details that change frequently.
   #
@@ -367,6 +385,7 @@ module OllamaChat::Information
       voice:                voice.on? ? 'enabled' : 'disabled',
       weekday:              now.strftime('%A'),
       context_usage:        ,
+      conversation_length:  ,
     }
   end
 
@@ -402,7 +421,7 @@ module OllamaChat::Information
   #
   # @return [Float] the ratio of used context (e.g. `0.73` for 73%)
   def context_filled
-    es = session.estimate_tokens
+    es = messages.compacted_estimate_tokens
     (es.tokens.to_f / current_context_length).clamp(0..1).to_f
   end
 
@@ -417,10 +436,38 @@ module OllamaChat::Information
   def context_usage
     if cl = current_context_length
       '%s of %s (%s)' % [
-        session.estimate_tokens.tokens_formatted,
+        messages.compacted_estimate_tokens.tokens_formatted,
         format_tokens(current_context_length),
         '%.1f%%' % (100 * context_filled),
       ]
     end
   end
+  # Wraps a percentage string in an ANSI color based on context usage
+  # relative to compaction thresholds.
+  #
+  # Green:  below `keep_recent` budget — plenty of room.
+  # Yellow: between `keep_recent` and `reserve` — getting tight.
+  # Red:    above `reserve` — compaction imminent.
+  #
+  # Falls back to bold if context length is unknown.
+  #
+  # @param percent_string [String] the formatted percentage to colorize
+  # @return [String] the ANSI-colored percentage string
+  def context_gauge(percent_string)
+    tokens = messages.compacted_estimate_tokens.tokens
+    ctx    = current_context_length
+    return bold { percent_string } unless ctx
+
+    keep_recent = compact_ratio_tokens(:keep_recent, ctx)
+    reserve     = compact_ratio_tokens(:reserve, ctx)
+    bold do
+      if tokens < keep_recent
+        '🟢 ' + green { percent_string }
+      elsif tokens <= reserve
+        '🟡 ' + yellow { percent_string }
+      else
+        '🔴 ' + red { percent_string }
+      end
+    end
+  end
 end

data/lib/ollama_chat/logging.rb

@@ -8,8 +8,9 @@ module OllamaChat::Logging
   # @return [Logger] the active Logger instance
   def logger
     @logger ||= begin
-      OC::OLLAMA::CHAT::LOGFILE.dirname.mkpath
-      l = Logger.new(OC::OLLAMA::CHAT::LOGFILE)
+      path = OC::OLLAMA::CHAT::LOG::CHAT
+      path.dirname.mkpath
+      l = Logger.new(path)
       l.formatter = -> (severity, time, _progname, msg) do
         msg = msg.stringify_keys_recursive
         msg['level']    = severity

data/lib/ollama_chat/message.rb

@@ -16,6 +16,9 @@ module OllamaChat::MessageMixin
     if group_uuid = attributes[:group_uuid]
       self.group_uuid = group_uuid
     end
+    if tool_calls = attributes[:tool_calls]
+      self.tool_calls = tool_calls
+    end
   end
 
   # @!attribute content
@@ -40,6 +43,12 @@ module OllamaChat::MessageMixin
   #   @option setter [String] The UUIDv7 for the logical exchange.
   attr_accessor :group_uuid
 
+  # @!attribute tool_calls
+  #   @option getter [Array<Hash>, nil] structured tool-call entries for
+  #     programmatic access (e.g., on summary messages).
+  #   @option setter [Array<Hash>, nil] the tool-call entries.
+  attr_accessor :tool_calls
+
   # Ensures that the message has a `group_uuid` by generating a UUIDv7 if
   # missing. Returns self to allow for method chaining.
   #
@@ -57,6 +66,18 @@ module OllamaChat::MessageMixin
     Time.at((group_uuid.delete(?-)[0, 16].to_i(16) >> 16) / 1000.0) if group_uuid
   end
 
+  # Estimates the token count for this message's text content.
+  #
+  # @param strip_thinking [Boolean] if true, exclude the thinking content
+  #   from the byte count.
+  # @return [OllamaChat::TokenEstimator::Estimate] the estimated bytes and
+  #   tokens.
+  def token_estimate(strip_thinking: false)
+    bytes  = content.to_s.bytesize
+    bytes += thinking.to_s.bytesize unless strip_thinking
+    OllamaChat::TokenEstimator.estimate(bytes)
+  end
+
   # Returns true if the message is a tool message.
   #
   # @return [Boolean] true if the message has a present tool name, false
@@ -70,7 +91,7 @@ module OllamaChat::MessageMixin
   # @param a [Array] optional arguments for JSON conversion.
   # @return [Hash] a hash representation of the message.
   def as_json(*a)
-    { sender_name:, group_uuid: }.compact | super
+    { sender_name:, group_uuid:, tool_calls:, }.compact | super
   end
 end
 

data/lib/ollama_chat/message_format.rb

@@ -108,8 +108,7 @@ module OllamaChat::MessageFormat
   # @return [ String, nil ] the annotated string with a thinking emoji if
   #   enabled, otherwise nil
   def think_annotate(think_loud: chat.think_loud?, &block)
-    string = block.()
-    string.to_s.size == 0 and return
+    string = block.().full?(:to_s) or return
     if think_loud
       "💭\n#{string}\n"
     end

data/lib/ollama_chat/message_list.rb

@@ -70,6 +70,212 @@ class OllamaChat::MessageList
     @messages.size
   end
 
+  # Finds the message index at which compaction should cut.
+  #
+  # Walks non-system message groups (from +start+ onward) backward from
+  # the tail, accumulating per-group token estimates. Returns the index of
+  # the first message in the group whose addition causes the running total
+  # to meet or exceed +keep_recent_tokens+. Messages from +start+ up to
+  # that index are candidates for summarization; messages from that index
+  # onward are preserved.
+  #
+  # If every group together still fits under the budget, the index of the
+  # first group at or after +start+ is returned (signalling a no-op cut).
+  #
+  # @param start [Integer] the index at which to begin scanning (messages
+  #   before this index are excluded; typically the position just past an
+  #   existing summary message).
+  # @param keep_recent_tokens [Integer] the token budget for preserved
+  #   (recent) messages.
+  # @return [Integer, nil] the cut index into +@messages+, or +nil+ if
+  #   there are no non-system groups at or after +start+.
+  def find_cut_point(start:, keep_recent_tokens:)
+    groups = []
+    @messages.each_with_index do |msg, i|
+      next if msg.role == 'system'
+      next if i < start
+      tokens = msg.token_estimate(
+        strip_thinking: @chat.think_strip.on?
+      ).tokens
+      uuid = msg.group_uuid
+      if last = groups.last and last[:uuid] == uuid
+        last[:tokens] += tokens
+      else
+        groups << { uuid:, start: i, tokens: }
+      end
+    end
+    return nil if groups.empty?
+
+    accumulated = 0
+    groups.reverse_each do |group|
+      accumulated += group[:tokens]
+      return group[:start] if accumulated >= keep_recent_tokens
+    end
+    groups.first[:start]
+  end
+
+  # Finds the most recent summary message in the list.
+  #
+  # Scans backward from the tail for a message with
+  # `role == 'tool'` and `tool_name == 'summary'`.
+  #
+  # @return [OllamaChat::Message, nil] the summary message, or
+  #   `nil` if no summary has been inserted yet.
+  def find_summary
+    messages.reverse_each.find do |m|
+      m.role == 'tool' && m.tool_name == 'summary'
+    end
+  end
+
+  # Compacts the message list by summarizing old groups and inserting
+  # a single summary tool message at the cut point.
+  #
+  # Resolves the keep-recent token budget from the current model's context
+  # length, finds the cut point, summarizes all groups before it (passing
+  # any existing summary as +previous_summary+ for iterative re-compaction),
+  # then inserts the new summary at the cut point. Old groups remain in
+  # the list for retrieval via +lookup_group+; the LLM context builder
+  # skips them on the next call.
+  #
+  # @return [OllamaChat::Compaction::Result, nil] a +Result+ with
+  #   before/after context estimates on success, or +nil+ if there was
+  #   nothing to compact.
+  def compact!
+    ctx    = @chat.current_context_length
+    budget = @chat.compact_ratio_tokens(:keep_recent, ctx)
+
+    existing_summary = find_summary
+    start = @messages.each_with_index.find do |m, i|
+      m.role == 'tool' && m.tool_name == 'summary' and break i + 1
+    end
+    start ||= 0
+    start   = start.clamp(0..(@messages.size - 1))
+
+    # Cut among post-summary groups; the old summary is excluded
+    # from the budget window by +start+.
+    cut = find_cut_point(start:, keep_recent_tokens: budget)
+    return nil if cut.nil? || cut <= 1
+
+    candidates = @messages[start...cut]
+      .reject { |m| m.role == 'system' }
+      .reject { |m| m.role == 'tool' && m.tool_name == 'summary' }
+    return nil if candidates.empty?
+
+    cand_es = OllamaChat::TokenEstimator::Crude.new(
+      candidates.sum { |m| m.content.to_s.bytesize }
+    ).perform
+    context_before = @chat.context_usage
+
+    @chat.log(:info, 'Compaction: starting', data: {
+      context_length: ctx,
+      budget:         budget,
+      cut_index:      cut,
+      candidates:     candidates.size,
+      candidate_bytes: cand_es.bytes_formatted,
+      candidate_tokens: cand_es.tokens_formatted,
+      previous_summary: existing_summary ? 'yes' : 'no',
+    })
+
+    summary_text, all_tool_entries = @chat.summarize_for_compaction(
+      messages:         candidates,
+      previous_summary: existing_summary,
+    )
+
+    compact_es = OllamaChat::TokenEstimator.estimate(summary_text.bytesize)
+    @chat.log(:info, 'Compaction: summary generated', data: {
+      summary_bytes:   compact_es.bytes_formatted,
+      summary_tokens:  compact_es.tokens_formatted,
+    })
+
+    summary_msg = OllamaChat::Message.new(
+      role:       'tool',
+      tool_name:  'summary',
+      content:    summary_text,
+      tool_calls: all_tool_entries,
+    ).initialize_group_uuid
+
+    # Remove old summary (if any) and adjust cut for the shift.
+    if existing_summary
+      idx = @messages.index(existing_summary)
+      @messages.delete_at(idx)
+      cut -= 1 if idx < cut
+    end
+
+    @messages.insert(cut, summary_msg)
+    @chat.log(:info, 'Compaction: done', data: {
+      total_messages: @messages.size,
+      summary_at:     cut,
+    })
+    sync
+
+    OllamaChat::Compaction::Result.new(
+      context_before:,
+      context_after:  @chat.context_usage,
+      candidates:     candidates.size,
+      candidate_size: "#{cand_es.bytes_formatted} / " \
+                      "#{cand_es.tokens_formatted}",
+      summary_size:   "#{compact_es.bytes_formatted} / " \
+                      "#{compact_es.tokens_formatted}",
+      stored_total:   @chat.conversation_length,
+    )
+  end
+
+  # Returns the messages that will actually be sent to the LLM.
+  #
+  # If no summary message exists, returns all messages (identical to
+  # +to_ary+). If a summary is present, returns only the system prompt,
+  # the summary, and everything after it — groups before the summary
+  # are invisible to the model but remain in the list for
+  # +lookup_group+ retrieval.
+  #
+  # @return [Array<OllamaChat::Message>] the messages to send to the LLM
+  def compacted_messages
+    idx = @messages.rindex do |m|
+      m.role == 'tool' && m.tool_name == 'summary'
+    end
+    return to_ary if idx.nil?
+
+    system = @messages.take_while { |m| m.role == 'system' }
+    system + [@messages[idx]] + @messages[(idx + 1)..]
+  end
+
+  # Estimates the token and byte size of the messages that will actually
+  # be sent to the LLM (i.e. +compacted_messages+).
+  #
+  # When no summary message exists this is identical to the full list.
+  # When a summary is present, the pre-summary groups are excluded.
+  #
+  # Uses per-message +token_estimate+ which counts only text content
+  # (and thinking, unless +think_strip+ is enabled), excluding images
+  # and metadata scaffolding that would inflate a raw serialization.
+  #
+  # @return [OllamaChat::TokenEstimator::Estimate] the estimated token and
+  #   byte counts for the effective LLM payload.
+  def compacted_estimate_tokens
+    strip = @chat.think_strip.on?
+    bytes = compacted_messages.sum {
+      _1.token_estimate(strip_thinking: strip).bytes
+    }
+    OllamaChat::TokenEstimator.estimate(bytes)
+  end
+
+  # Estimates the token and byte size of the **full** stored message
+  # list (i.e. +@messages+), using per-message +token_estimate+.
+  #
+  # Unlike +Session#estimate_tokens+ which measures raw JSONL bytes
+  # (including base64 images and JSON scaffolding), this counts only
+  # text content and thinking (unless +think_strip+ is enabled).
+  #
+  # @return [OllamaChat::TokenEstimator::Estimate] the estimated token
+  #   and byte counts for the full conversation payload.
+  def full_estimate_tokens
+    strip = @chat.think_strip.on?
+    bytes = @messages.sum {
+      _1.token_estimate(strip_thinking: strip).bytes
+    }
+    OllamaChat::TokenEstimator.estimate(bytes)
+  end
+
   # The clear method removes all non-system messages from the message list.
   #
   # @return [ OllamaChat::MessageList ] self
@@ -148,6 +354,8 @@ class OllamaChat::MessageList
   def each_message(role: %w[ user assistant ], tool: false, &block)
     block or return enum_for(__method__, role:, tool:)
 
+    role = Array(role)
+
     @messages.each do |message|
       role.include?(message.role) or next
       !tool && message.tool? and next
@@ -305,14 +513,21 @@ class OllamaChat::MessageList
     self
   end
 
-  # Groups user/assistant messages by their group_uuid, allowing for easy
-  # manipulation of whole exchanges (User -> Runtime Info -> Assistant -> Tools).
-  #
-  # @yield [Array<OllamaChat::Message>] an array of messages belonging to the same group.
+  # Groups messages by their +group_uuid+, yielding an array of messages
+  # belonging to the same conversational turn (User -> Assistant -> Tools).
+  #
+  # @param role [Array<String>] the message roles to include when grouping.
+  #   Defaults to +%w[user assistant]+. Pass +%w[user assistant tool]+
+  #   to include tool-result messages as well.
+  # @param tool [Boolean] whether to include messages that carry a
+  #   +tool_name+ (tool calls / responses) among +user+ / +assistant+ roles.
+  #   Defaults to +false+.
+  # @yield [Array<OllamaChat::Message>] an array of messages sharing the
+  #   same +group_uuid+.
   # @return [Enumerator] if no block is given, returns an enumerator.
-  def each_group(&block)
-    block or return enum_for(__method__)
-    each_message.group_by(&:group_uuid).values.each(&block)
+  def each_group(role: %w[ user assistant ], tool: false, &block)
+    block or return enum_for(__method__, role:, tool:)
+    each_message(role:, tool:).group_by(&:group_uuid).values.each(&block)
   end
 
   # Removes the last `n` conversation exchanges from the message list.
@@ -411,8 +626,7 @@ class OllamaChat::MessageList
   # @return [self, NilClass] nil if the system prompt is empty, otherwise self.
   def show_system_prompt
     current_system = system.to_s
-    size_bytes     = current_system.size
-    es             = OllamaChat::TokenEstimator.estimate(size_bytes)
+    es             = OllamaChat::TokenEstimator.estimate(current_system)
     system_prompt  = @chat.kramdown_ansi_parse(current_system).
        gsub(/\n+\z/, '').full?
     if system_prompt.blank?

data/lib/ollama_chat/model_handling.rb

@@ -23,7 +23,7 @@ module OllamaChat::ModelHandling
   # @attr_reader system [String] the system prompt associated with the model
   # @attr_reader capabilities [Array<String>] the capabilities supported by the model
   # @attr_reader families [Array<String>] the families of the model
-  class ModelMetadata < Struct.new(:name, :system, :capabilities, :families)
+  class ModelMetadata < Data.define(:name, :system, :capabilities, :families)
     # Checks if the given capability is included in the object's capabilities.
     #
     # @param capability [String] the capability to check for

data/lib/ollama_chat/oc.rb

@@ -158,14 +158,24 @@ module OC
         default     XDG_STATE_HOME + 'history.jsonl'
       end
 
-      LOGFILE = set do
-        description 'File to output log messages to'
-        default     XDG_STATE_HOME + 'chat.log'
-      end
+      module LOG
+        description 'Logging configuration'
+
+        CHAT = set do
+          description 'Chat log file path'
+          default     XDG_STATE_HOME + 'chat.log'
+        end
 
-      DATABASE_LOGFILE = set do
-        description 'File to output database log messages to'
-        default     XDG_STATE_HOME + 'database.log'
+        DATABASE = set do
+          description 'Database log file path'
+          default     XDG_STATE_HOME + 'database.log'
+        end
+
+        TAIL_LINES = set do
+          description 'Max lines to keep in log files (truncate older)'
+          default     10_000
+          decode      { Integer(_1) }
+        end
       end
 
       USER = set do