ollama_chat 0.0.129 → 0.0.131

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9aae892b3b152a70e519a4d5a6268f046611c55d5b8ecfda66e2e4386a4681db
-  data.tar.gz: '038e498781b238aef6f3d6ff595ec3beb50d00b7efd722f8636bcb87a273bbb2'
+  metadata.gz: 8e7543207de9d23c4731b5c8b1e768ad28559f57a4d767bfcabaaf25dc7f4541
+  data.tar.gz: 7a3a03b47e077f2c0b6fa7d042a910d8dab32d30bcd0253c0e706f105d0a4e86
 SHA512:
-  metadata.gz: 740289c0e7fdf453718f120f26fa201f68c1f677777b71e440789df72bb14db52526026114adb06ce15a2ea93b78ce6e39a478bfe77a22c1657692e1a5162445
-  data.tar.gz: 1b553c6648636b5088857f199a21cd87b86836c59df746fa50c504569be8609fd0181c3b233dda977a065cefdddfda1cd7ce7640a154a742bef8ab7392513346
+  metadata.gz: d585ff38e8daeb72ddccedf4eb0ef1711c35f843fb3028f73c00bad1df84045ba5228b82916dec834bb4c2d518a15c198a5f009eb5bc541bd46eca0513458542
+  data.tar.gz: 291074810f529cf30873946a74e52a83de45461808ce0cb8aff4f366ef17c8cb70a5fccefc1b98c1b6e0a234dd2d67419788e59ad5da22ea64d1c1e04982b171

data/CHANGES.md

@@ -1,5 +1,70 @@
 # Changes
 
+## 2026-10-10 v0.0.131
+
+* Extracted ANSI, emoji, and formatting logic from `Information` into a new
+  `OllamaChat::ContextUsage` class, providing a `colored`, `plain`, `filled`,
+  and `percent` API.
+* Converted `context_usage_colored`, `context_filled`, and
+  `context_usage_plain` into one-line delegators on `Information`.
+* Removed `context_percentage` and `context_gauge` methods, absorbing their
+  logic into `ContextUsage` private helpers.
+* Updated `MessageList#compact!` to capture `context_usage_colored` for both
+  before and after states, ensuring the compaction report renders
+  threshold-colored values.
+* Changed the plain format to be percent-first: `27.9% · 73.1 KT of 262.1 KT`.
+* Updated `session_management.rb` log data to use `context_usage_plain`.
+* Added `spec/ollama_chat/context_usage_spec.rb` to pin green/yellow/red
+  thresholds, plain format, nil-context fallback, and fill ratio.
+* Added per-letter emojis to clear menu prompts in `rag_handling.rb` (🔍 view,
+  🧹 clear, 🔙 other) to improve scannability of single-keypress `confirm?`
+  letter menus.
+* Updated `asr.rb` to use `%w[]` for `Tempfile.new` prefix/suffix arguments and
+  replaced `File.size(wav.path)` with `wav.size`.
+* Updated `asr_spec.rb` to stub the `Tempfile#size` instance method instead of
+  the `File.size` class method.
+* Migrated spec temporary paths to the `asset_tmp_path` helper across 15 spec
+  files, replacing hardcoded `tmp/` paths, `Dir.tmpdir` + `$$` PID suffixes,
+  hand-rolled `Tins::Token.new(bits: 128)` strings, and `Time.now.to_i` epoch
+  hacks.
+* Converted `File.write(pathname, ...)` calls to `pathname.write(...)` in
+  `delete_file_spec`, `parsing_spec`, `resolve_tag_spec`, and
+  `prompt_handling_spec`.
+* Updated `prompt_handling_spec` to use `asset_pathname('prompt_file.txt')` for
+  the `Pathname#write` idiom.
+* Removed `.txt` suffix from `include` assertions in `move_file_spec` as
+  tokenized basenames no longer match the original extension.
+* Added a collection chooser to `memory_restore`, allowing users to select
+  which collections from a dump file to restore, with `[ALL]` / `[DONE]`
+  support.
+* Updated `memory_dump` to use `Set#sort` directly instead of `Set#to_a.sort`.
+* Added a new `asset_tmp_path` helper in `spec_helper.rb` that generates
+  collision-free temp paths via `Tins::Token` (128-bit).
+* Updated restore specs to include chooser stubs, cancel and selective-restore
+  cases, and switched temp files to `asset_tmp_path`.
+
+## 2026-10-08 v0.0.130
+
+*   Replace `ask?` with `confirm?` in `rag_handling.rb` for the `[v]iew` /
+    `[c]lear` prompts in `#clear_collection_tags` and
+    `#clear_collection_sources` to bypass `Reline` and keep command history
+    clean.
+*   Add `use_pager(force: true)` in the `#clear_collection_sources` view branch
+    to fix display.
+*   Rewrite `confirm?` YARD documentation in `dialog.rb` to clarify the
+    two-branch return contract (`yes: nil` → raw char, `yes:` matcher → matched
+    char or `nil`) and history-pollution rationale.
+*   Swap 7 `ask?` → `confirm?` stubs in `rag_handling_spec.rb`.
+*   Add `line_numbers: true` to the `read_file` tool block in
+    `default_config.yml`.
+*   Update `read_file.rb` to fall back to `tool_config.line_numbers?` when the
+    model omits the argument and interpolate the live default into the tool
+    description.
+*   Fix typo in description: `linenumbers` → `line numbers`.
+*   Update specs to extract `let :tool`, adjust `nil`-arg expectations for the
+    `1: ` prefix, checksum, and `line_count`, and add a new spec asserting raw
+    content when `tool_config.line_numbers` is stubbed to `false`.
+
 ## 2026-10-08 v0.0.129
 
 ### Features

data/lib/ollama_chat/asr.rb

@@ -26,8 +26,8 @@ module OllamaChat
       def transcribe(source_io, chat:, language: nil)
         asr_url   = OC::OLLAMA::CHAT::ASR::URL
         asr_model = OC::OLLAMA::CHAT::ASR::MODEL
-        input = Tempfile.new(['asr_in'])
-        wav   = Tempfile.new(['asr', '.wav'])
+        input = Tempfile.new(%w[ asr_in ])
+        wav   = Tempfile.new(%w[ asr .wav ])
         begin
           IO.copy_stream(source_io, input)
           input.flush
@@ -41,7 +41,7 @@ module OllamaChat
             chat.feedback("ASR: #{executable} not found in PATH.", type: :warn)
             return
           end
-          unless File.size(wav.path) > 0
+          unless wav.size > 0
             chat.feedback("ASR: #{executable} produced no output.", type: :warn)
             return
           end

data/lib/ollama_chat/context_usage.rb

@@ -0,0 +1,123 @@
+require 'term/ansicolor'
+require 'ollama_chat/utils/value_formatter'
+
+module OllamaChat
+  # Renders the current context-window usage as colored or plain strings.
+  #
+  # Wraps an {OllamaChat::Chat} instance and concentrates the ANSI coloring,
+  # emoji, and token-formatting logic that was previously inlined in
+  # {OllamaChat::Information}. The color reflects how full the context is
+  # relative to the compaction `keep_recent` / `reserve` budgets:
+  #
+  #   🟢 green  — below `keep_recent` (plenty of room)
+  #   🟡 yellow — between `keep_recent` and `reserve` (getting tight)
+  #   🔴 red    — above `reserve` (compaction imminent)
+  class ContextUsage
+    include Term::ANSIColor
+    include OllamaChat::Utils::ValueFormatter
+
+    EMOJI = { green: '🟢', yellow: '🟡', red: '🔴' }.freeze
+
+    # @param chat [OllamaChat::Chat] the chat instance to read state from
+    def initialize(chat)
+      @chat = chat
+    end
+
+    # Colored usage string, e.g. `🟢 73.1 KT of 262.1 KT (27.9%)`.
+    #
+    # Every value (used tokens, context limit, percentage) is painted with the
+    # threshold color; the surrounding text is bold. Returns a bold `n/a` when
+    # the context length cannot be determined.
+    #
+    # @return [String] the ANSI-colored usage string
+    def colored
+      ctx = @chat.current_context_length
+      return bold { 'n/a' } unless ctx
+
+      es      = estimate
+      color   = color_for(es.tokens, ctx)
+      percent = percent_for(es.tokens, ctx)
+
+      [
+        EMOJI[color], ' ',
+        bold { paint(color, percent) },
+        ' · ',
+        paint(color, es.tokens_formatted),
+        ' of ',
+        paint(color, format_tokens(ctx)),
+      ] * ''
+    end
+
+    # Plain (uncolored) usage string, e.g. `73.1 KT of 262.1 KT (27.9%)`.
+    #
+    # @return [String, nil] the usage string, or nil when the context length
+    #   is unknown.
+    def plain
+      ctx = @chat.current_context_length
+      return nil unless ctx
+
+      es = estimate
+      '%s · %s of %s' % [
+        percent_for(es.tokens, ctx),
+        es.tokens_formatted,
+        format_tokens(ctx),
+      ]
+    end
+
+    # Fraction of the context window currently in use, clamped to 0.0–1.0.
+    #
+    # @return [Float] the fill ratio (e.g. `0.279`)
+    def filled
+      es = estimate
+      (es.tokens.to_f / @chat.current_context_length).clamp(0..1).to_f
+    end
+
+    # Formatted percentage string, e.g. `27.9%`.
+    #
+    # @return [String] the percentage
+    def percent
+      format('%.1f%%', 100 * filled)
+    end
+
+    private
+
+    # @return [OllamaChat::TokenEstimator::Estimate] the compacted estimate
+    def estimate
+      @chat.messages.compacted_estimate_tokens
+    end
+
+    # @param tokens [Integer] used tokens
+    # @param ctx [Integer] context length
+    # @return [String] the formatted percentage
+    def percent_for(tokens, ctx)
+      format('%.1f%%', 100 * (tokens.to_f / ctx).clamp(0..1))
+    end
+
+    # Resolves the threshold color for a given fill level.
+    #
+    # @param tokens [Integer] used tokens
+    # @param ctx [Integer] context length
+    # @return [Symbol] one of :green, :yellow, :red
+    def color_for(tokens, ctx)
+      keep_recent = @chat.compact_ratio_tokens(:keep_recent, ctx)
+      reserve     = @chat.compact_ratio_tokens(:reserve, ctx)
+      if tokens < keep_recent then :green
+      elsif tokens <= reserve then :yellow
+      else :red
+      end
+    end
+
+    # Paints a string with the given threshold color.
+    #
+    # @param color [Symbol] one of :green, :yellow, :red
+    # @param string [String] the text to colorize
+    # @return [String] the ANSI-colored string
+    def paint(color, string)
+      case color
+      when :green  then green  { string }
+      when :yellow then yellow { string }
+      else              red    { string }
+      end
+    end
+  end
+end

data/lib/ollama_chat/dialog.rb

@@ -29,21 +29,37 @@ module OllamaChat::Dialog
     prefill and Reline.pre_input_hook = old_pre_input_hook
   end
 
-  # The confirm? method displays a prompt and reads a single character input
-  # from the user in raw mode, then returns that character. This is best used
-  # for confirmation prompts.
+  # The confirm? method displays a prompt and reads a **single keypress**
+  # from the user in raw mode (no Enter required), returning that character.
+  # Unlike {#ask?}, it does not go through Reline, so it never pollutes the
+  # command history — making it the right tool for confirmation gates *and*
+  # terse single-key selections such as `[v]iew` / `[c]lear` menus.
+  #
+  # The returned value depends on whether a positive-response matcher (`yes`)
+  # is supplied:
+  #
+  # - `yes: nil` (default) — the raw keypress is returned verbatim so the
+  #   caller can dispatch on it (e.g. `case key; when /\Av/i; ...`); on
+  #   timeout the `default` value is returned, and on interrupt (Ctrl-C)
+  #   `nil` is returned.
+  # - `yes: <Regexp/Object>` — the keypress is returned only when it
+  #   satisfies `yes === keypress` (e.g. `yes: /\Ay/i`); any other keypress,
+  #   or an interrupt, yields `nil`.
   #
   # @param prompt   [String]  the prompt to display to the user
   # @param timeout  [Integer, nil] optional timeout in seconds; if nil, the
-  #   method blocks until input, if 0 the method immediately returns the default
-  #   value.
+  #   method blocks until input, if 0 it immediately returns the `default`
+  #   value without waiting.
   # @param default  [Object, nil]  value returned when the timeout expires
   #   (defaults to `nil`)
-  # @param yes      [Object, nil]  value that is considered a positive response
+  # @param yes      [Object, nil]  matcher (`#===`) that defines a positive
+  #   response; when `nil` the raw keypress is returned for the caller to
+  #   interpret (default: `nil`)
   # @param output   [IO]  the IO object to write the prompt and the answer to
   #
-  # @return [Object] the character entered by the user, the `default` value
-  #   if a timeout occurs, or `nil` if the read is interrupted (e.g. Ctrl-C)
+  # @return [Object, nil] see the dispatch rules above: the keypress (or
+  #   `default` on timeout / `nil` on interrupt) when `yes:` is nil, otherwise
+  #   the keypress only if it matches `yes`, else `nil`.
   def confirm?(prompt:, timeout: nil, default: nil, yes: nil, output: STDOUT)
     return default if timeout&.zero?
     if prompt.include?('%s')

data/lib/ollama_chat/information.rb

@@ -124,18 +124,15 @@ module OllamaChat::Information
     end
   end
 
-  # The context_usage_colored method computes a summary string of the current
-  # context window's token usage. It formats the compacted message
-  # estimate, the maximum context length, and a visual gauge indicating
-  # the percentage of the context that is currently filled.
+  # The context_usage_colored method returns a summary string of the current
+  # context window's token usage, with the used, maximum, and percentage
+  # values all ANSI-colored according to the compaction thresholds.
   #
-  # @return [ String ] the formatted string representing context usage
+  # Delegates the presentation (emoji + color) to {ContextUsage}.
+  #
+  # @return [ String ] the formatted, colored string representing context usage
   def context_usage_colored
-    '%s of %s (%s)' % [
-      messages.compacted_estimate_tokens.tokens_formatted,
-      format_tokens(current_context_length),
-      context_gauge(context_percentage),
-    ]
+    context_usage.colored
   end
 
   # Displays a detailed view of the current chat session state, including the
@@ -397,7 +394,7 @@ module OllamaChat::Information
       tools_support:        tools_support.on? ? 'enabled' : 'disabled',
       voice:                voice.on? ? 'enabled' : 'disabled',
       weekday:              now.strftime('%A'),
-      context_usage:        ,
+      context_usage:        context_usage_plain,
       conversation_length:  ,
     }
   end
@@ -455,66 +452,32 @@ module OllamaChat::Information
 
   # Computes the fraction of the context window currently in use.
   #
-  # Divides the estimated token count of the session's messages by the
-  # effective context length, clamped to the range 0.0–1.0.
+  # Delegates to {ContextUsage#filled}; clamped to 0.0–1.0.
   #
   # @return [Float] the ratio of used context (e.g. `0.73` for 73%)
   def context_filled
-    es = messages.compacted_estimate_tokens
-    (es.tokens.to_f / current_context_length).clamp(0..1).to_f
-  end
-
-  # Formats the current context fill ratio as a percentage string.
-  #
-  # @return [String] the formatted percentage (e.g. `"64.0%"`)
-  def context_percentage
-    format('%.1f%%', 100 * context_filled)
+    context_usage.filled
   end
 
   # Formats the current context usage as a human-readable string.
   #
   # Returns a string like `"167.7 KT of 262.1 KT (64.0%)"` combining
   # the estimated tokens in use, the effective context length, and
-  # the percentage (via +context_filled+).
+  # the percentage. Delegates to {ContextUsage#plain}.
   #
   # @return [String, nil] the formatted usage string, or +nil+ if
   #   the context length cannot be determined.
-  def context_usage
-    if cl = current_context_length
-      '%s of %s (%s)' % [
-        messages.compacted_estimate_tokens.tokens_formatted,
-        format_tokens(current_context_length),
-        context_percentage,
-      ]
-    end
+  def context_usage_plain
+    context_usage.plain
   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
+  private
+
+  # Lazily builds and caches the {ContextUsage} bound to this chat,
+  # which owns the ANSI/emoji presentation logic for context usage.
+  #
+  # @return [ContextUsage]
+  def context_usage
+    @context_usage ||= OllamaChat::ContextUsage.new(self)
   end
 end

data/lib/ollama_chat/message_list.rb

@@ -164,7 +164,7 @@ class OllamaChat::MessageList
     cand_es = OllamaChat::TokenEstimator::Crude.new(
       candidates.sum { |m| m.content.to_s.bytesize }
     ).perform
-    context_before        = @chat.context_usage
+    context_before        = @chat.context_usage_colored
     context_filled_before = @chat.context_filled
 
     @chat.log(:info, 'Compaction: starting', data: {
@@ -211,7 +211,7 @@ class OllamaChat::MessageList
 
     OllamaChat::Compaction::Result.new(
       context_before:,
-      context_after:         @chat.context_usage,
+      context_after:         @chat.context_usage_colored,
       context_filled_before: ,
       context_filled_after:  @chat.context_filled,
       candidates:            candidates.size,

data/lib/ollama_chat/ollama_chat_config/default_config.yml

@@ -623,6 +623,7 @@ tools:
       default: true
       require_confirmation: false
       result_display_timeout: 3
+      line_numbers: true
       allowed:
         - './tmp'
         - './lib'

data/lib/ollama_chat/rag_handling.rb

@@ -137,10 +137,10 @@ module OllamaChat::RAGHandling
     filename = Pathname.new(filename).expand_path
     should_overwrite?(filename) or return
 
-    feedback("Dumping #{selected.size} collection(s): #{selected.to_a.sort.join(', ')}")
+    feedback("Dumping #{selected.size} collection(s): #{selected.sort.join(', ')}")
 
     records = []
-    selected.to_a.sort.each do |col|
+    selected.sort.each do |col|
       switch_collection(col) do
         @documents.each_record do |r|
           records << {
@@ -155,7 +155,7 @@ module OllamaChat::RAGHandling
 
     OllamaChat::Utils::JSONJSONLIO.new(filename).write(collection: records)
     log(:info, 'Memory dumped',
-        data: { collections: selected.to_a.sort, records: records.size, file: filename.to_s })
+        data: { collections: selected.sort, records: records.size, file: filename.to_s })
     feedback(
       "Dumped #{records.size} record(s) across #{selected.size} collection(s) to #{filename.to_s.inspect}.",
       type: :success
@@ -164,8 +164,10 @@ module OllamaChat::RAGHandling
 
   # Restores `memory-<persona>` collections from a JSONL dump file.
   #
-  # Each line's `collection` field determines the target collection;
-  # records are added with their original tag and source so timestamps
+  # Presents an accumulating chooser of all collections found in the file:
+  # pick individual collections (they drop out of the list once selected),
+  # `[ALL]` to grab everything remaining, or `[DONE]` to commit the restore.
+  # Records are added with their original tag and source so timestamps
   # and file associations survive.
   #
   # @param filename [String, nil] the input path (must end in .json/.jsonl);
@@ -184,19 +186,55 @@ module OllamaChat::RAGHandling
     entries = OllamaChat::Utils::JSONJSONLIO.new(filename).read.to_a
     return feedback("No records found in #{filename.to_s.inspect}.", type: :warn) if entries.empty?
 
+    collections = entries.group_by { |e| e['collection'] }.reject { _1.nil? }
+    return feedback('No collection field found in entries.', type: :warn) if collections.empty?
+
+    selected = Set.new
+    choose_with_state do
+      loop do
+        remaining = collections.keys - selected.to_a
+        choices   = (remaining.empty? ? [] : ['[ALL]'] + remaining) + ['[DONE]']
+        choice    = choose_entry(choices, prompt: 'Which memory collections to restore? %s')
+        case choice
+        when nil, '[DONE]'
+          break
+        when '[ALL]'
+          selected.merge(remaining)
+          break
+        else
+          selected.add(choice)
+        end
+      end
+    end
+
+    return feedback('Cancelled, no collections selected.', type: :cancel) if selected.empty?
+
+    selected = selected.sort
+
+    feedback("Restoring #{selected.size} collection(s): #{selected.join(', ')}")
+
     total = 0
-    entries.group_by { |e| e['collection'] }.each do |col, group|
+    collections.slice(*selected).sort.each do |col, group|
       create_memory_collection(col)
       switch_collection(col) do
         group.each do |entry|
-          @documents.add([entry['text']], tags: Array(entry['tags']), batch_size: 1, source: entry['source'])
+          @documents.add(
+            [entry['text']],
+            tags: Array(entry['tags']),
+            batch_size: 1,
+            source: entry['source']
+          )
           total += 1
         end
       end
     end
 
-    log(:info, 'Memory restored', data: { file: filename.to_s, records: total })
-    feedback("Restored #{total} record(s) from #{filename.to_s.inspect}.", type: :success)
+    log(:info, 'Memory restored',
+        data: { file: filename.to_s, collections: selected, records: total })
+    feedback(
+      "Restored #{total} record(s) across #{selected.size} collection(s) from #{filename.to_s.inspect}.",
+      type: :success
+    )
   end
 
   private
@@ -248,7 +286,7 @@ module OllamaChat::RAGHandling
             label   = source ? "#{source} #{snippet}" : snippet
             feedback(label, type: :info)
             view_tag_records(tag, [record])
-            ask?(prompt: "  [c]lear / other to go back: ") =~ /\Ac/i or next
+            confirm?(prompt: "  🧹[c]lear / 🔙other to go back: ") =~ /\Ac/i or next
             clear_tag_records(tag, source)
           else
             group_lines = []
@@ -270,7 +308,7 @@ module OllamaChat::RAGHandling
             )
             next if chosen.nil? || chosen == '[back]'
             src, recs = group_map[chosen]
-            action = ask?(prompt: "  [v]iew / [c]lear / other to go back: ")
+            action = confirm?(prompt: "  🔍[v]iew / 🧹[c]lear / 🔙other to go back: ")
             case action
             when /\Av/i
               view_tag_records(tag, recs)
@@ -350,11 +388,11 @@ module OllamaChat::RAGHandling
           break
         else
           source = display_map[chosen]
-          action = ask?(prompt: "  [v]iew / [c]lear / other to go back: ")
+          action = confirm?(prompt: "  🔍[v]iew / 🧹[c]lear / 🔙other to go back: ")
           case action
           when /\Av/i
             records = @documents.records(sources: [ source ])
-            use_pager do |output|
+            use_pager(force: true) do |output|
               output.puts "#{bold{source}} (#{records.size} records)"
               output.puts
               records.each do |record|

data/lib/ollama_chat/session_management.rb

@@ -17,7 +17,7 @@ module OllamaChat::SessionManagement
     log(:info, "Messages stored in session", data: {
       session_id:    session.id,
       size:          es.bytes_formatted,
-      context_usage: ,
+      context_usage: context_usage_plain,
       messages:      session.count_messages
     })
     self

data/lib/ollama_chat/tools/read_file.rb

@@ -28,7 +28,7 @@ class OllamaChat::Tools::ReadFile
           File reader – Returns raw text from path if it’s within allowed
           directories. No side effects; useful for inspecting config or source
           files. You can optionally specify a line range to read. You can also
-          enable prefixing with linenumbers; this is highly recommended (and
+          enable prefixing with line numbers; this is highly recommended (and
           practically mandatory) before calling `open_file_in_editor` to ensure
           the line range is precise.
         EOT
@@ -53,8 +53,8 @@ class OllamaChat::Tools::ReadFile
             line_numbers: Tool::Function::Parameters::Property.new(
               type: 'boolean',
               description: <<~EOT
-                Whether to prefix each line with its line number,
-                e.g. "666: The line content…
+                Whether to prefix each line with its line number, e.g.
+                "666: The line content…" (default: #{!!tool_config.line_numbers?})
               EOT
             )
           },
@@ -77,12 +77,12 @@ class OllamaChat::Tools::ReadFile
   # @return [String] an error message as a JSON string if the operation fails
   # @raise [JSON::ParserError] if the result cannot be serialized to JSON
   def execute(tool_call, **opts)
-
     args   = tool_call.function.arguments
 
     start_line   = args.start_line.full?
     end_line     = args.end_line.full?
     line_numbers = args.line_numbers
+    line_numbers.nil? and line_numbers = !!tool_config.line_numbers?
 
     path                = assert_valid_path(args.path, tool_config.allowed?, check: :file)
     full_content        = path.read

data/lib/ollama_chat/version.rb

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

data/lib/ollama_chat.rb

@@ -128,6 +128,7 @@ require 'ollama_chat/source_fetching'
 require 'ollama_chat/web_searching'
 require 'ollama_chat/dialog'
 require 'ollama_chat/think_control'
+require 'ollama_chat/context_usage'
 require 'ollama_chat/information'
 require 'ollama_chat/message_output'
 require 'ollama_chat/clipboard'