ollama_chat 0.0.113 → 0.0.114

data/lib/ollama_chat/ollama_chat_config/default_config.yml

@@ -74,6 +74,7 @@ prompts:
           markdown tables.
       - **Session**: %{session_name}
         - Context usage is %{context_usage}.
+        - Full conversation length is %{conversation_length}.
         - Markdown output is %{markdown}. **Never** output markdown as your
           responses if it is disabled.
         - Voice output is %{voice}. Speak naturally and short if voice
@@ -170,10 +171,10 @@ prompts:
 
       %{message_content}
     session_title: |
-      Create a title with a length of **less than %{length}** characters for this
-      conversation. Output only the title and nothing else:
-
       %{content}
+
+      Create a title with a length of **less than %{length}** characters for
+      the conversation above. Output only the title and nothing else.
     context_template_suggest: |
       Conversation History:
       %{history}
@@ -341,6 +342,39 @@ prompts:
       
       Output only the 9 suggestions as plain text, each separated by one empty line.
       No other text.
+  compaction:
+    system: |
+      You are a context summarizer for a chat application.
+      Your sole task is to produce a concise, factual narrative
+      summary of the conversation provided. Be precise, omit
+      speculation, and follow the formatting instructions in the
+      user prompt exactly. Output only the summary text.
+    summarize: |
+      previous_summary:
+      %{previous}
+
+      conversation:
+      %{groups}
+
+      Summarize the conversation above. Your narrative MUST:
+      - Name every file created or significantly modified (with
+        path), and the key methods or classes they define.
+      - State the architectural or design decisions made (e.g.
+        data-model choices, API shape, error-handling strategy).
+      - Describe the current state: what works, what is pending,
+        and any open questions or follow-ups.
+      - Do NOT merely report test counts or coverage percentages;
+        those are outcomes, not accomplishments.
+      - Be factual; do not invent details not present in the groups
+        above. Keep it to 6–12 sentences.
+    assemble: |-
+      %{narrative}
+
+      tool_calls:
+      %{tool_section}
+
+      To see the full output of any tool call above, use lookup_group
+      with the group UUID in parentheses.
   system:
     default: <%= OC::OLLAMA::CHAT::SYSTEM || "%{persona}\n\n%{runtime_info}".inspect %>
     persona: |
@@ -359,12 +393,22 @@ roles:
 markdown: true
 stream: true
 document_policy: importing
+parsing:
+  directory_structure_max_depth: 1
 think:
   mode: disabled
   loud: true
   strip: false
 context:
   format: JSON
+compaction:
+  enabled: true
+  reserve:
+    ratio: 0.60
+    min_tokens: 4096
+  keep_recent:
+    ratio: 0.20
+    min_tokens: 2048
 embedding:
   enabled: true
   paused: false
@@ -492,6 +536,10 @@ tools:
     gem_path_lookup:
       result_display_timeout: 3
       default: true
+    lookup_group:
+      default: true
+      require_confirmation: false
+      result_display_timeout: 3
     open_file_in_editor:
       default: true
       require_confirmation: false
@@ -561,3 +609,20 @@ tools:
     eval_ruby:
       default: false
       result_display_timeout: 3
+syntax_checkers:
+  ruby:
+    cmd: [ 'ruby', '-wc' ]
+    suffixes: [ 'rb', 'rake', 'gemspec' ]
+    enabled: true
+  javascript:
+    cmd: [ 'node', '--check' ]
+    suffixes: [ 'js', 'mjs' ]
+    enabled: false
+  python:
+    cmd: [ 'python3', '-m', 'py_compile' ]
+    suffixes: [ 'py' ]
+    enabled: false
+  shell:
+    cmd: [ 'bash', '-n' ]
+    suffixes: [ 'sh', 'bash' ]
+    enabled: true

data/lib/ollama_chat/parsing.rb

@@ -279,7 +279,8 @@ module OllamaChat::Parsing
     contents = [ content ]
     content.scan(CONTENT_REGEXP).each { |url, file_url, quoted_file, file|
       if file && Pathname.new(file).expand_path.directory?
-        contents << generate_structure(file).to_json
+        max_depth = config.parsing.directory_structure_max_depth
+        contents << generate_structure(file, max_depth:).to_json
         next
       end
       check_exist = false

data/lib/ollama_chat/prompt_handling.rb

@@ -90,7 +90,7 @@ module OllamaChat::PromptHandling
 
     content = filename.read if filename&.exist?
     log(:info, "Prompt loaded from file", data: {
-      file: filename&.to_s, bytes: content&.size
+      file: filename&.to_s, bytes: content&.bytesize
     })
     content
   end

data/lib/ollama_chat/prompt_management.rb

@@ -449,6 +449,7 @@ module OllamaChat::PromptManagement
       end
     end
 
+    models::AppState.acknowledge(self)
     self
   end
 

data/lib/ollama_chat/rag_handling.rb

@@ -23,8 +23,6 @@ module OllamaChat::RAGHandling
     @documents.collection = old_collection
   end
 
-  private
-
   # Looks up a collection in the database by name.
   #
   # @param collection [String, Symbol, #to_s] the collection name to look up
@@ -34,6 +32,8 @@ module OllamaChat::RAGHandling
     models::Collection[name: collection.to_s]
   end
 
+  private
+
   # Returns the name of the currently active document collection.
   #
   # @return [String, Symbol] the name of the current collection
@@ -160,12 +160,13 @@ module OllamaChat::RAGHandling
   # highlighting the active one.
   def list_collections
     current_collection = collection.to_s
-    collections = all_collections.select(:name, :description)
+    collections = all_collections.select(:name, :description, :enabled)
     use_pager do |output|
       collections.each { |c|
         collection_name = current_collection == c.name ? bold { c.name } : c.name
         collection_description = c.description
-        output.puts '%s: %s' % [ collection_name, collection_description ]
+        suffix = c.enabled ? '' : ' [DISABLED]'
+        output.puts '%s: %s%s' % [ collection_name, collection_description, suffix ]
       }
     end
   end
@@ -306,13 +307,26 @@ module OllamaChat::RAGHandling
       extract_patterns(patterns_str)
     end
 
+    enabled_prompt = col.enabled ?
+      "🚫 Disable this collection? (hidden from the model) (y/n) " :
+      "✅ Enable this collection? (visible to the model) (y/n) "
+    toggle = case confirm?(prompt: enabled_prompt)
+             when /\Ay/i then true
+             when /\An/i then false
+             end
+
     col.description = new_description.full? ? new_description.to_s : col.description
     col.patterns    = patterns
+    col.enabled     = toggle ^ col.enabled unless toggle.nil?
 
     begin
       col.save
+      if toggle
+        status = col.enabled ? 'enabled' : 'disabled'
+        STDOUT.puts "🔄 Collection '#{col.name}' is now #{status}."
+      end
       STDOUT.puts "✅ Updated collection '#{col.name}'."
-      log(:info, "Collection updated", data: { name: col.name })
+      log(:info, "Collection updated", data: { name: col.name, enabled: col.enabled })
     rescue Sequel::Error => e
       STDERR.puts "❌ Database error: #{e.message}"
     end

data/lib/ollama_chat/session_management.rb

@@ -13,7 +13,7 @@ module OllamaChat::SessionManagement
     output = StringIO.new
     messages.write_conversation_jsonl(output)
     session.update(messages: output.string)
-    es = session.estimate_tokens
+    es = session.estimate_tokens # We just use the formatted bytecount
     log(:info, "Messages stored in session", data: {
       session_id:    session.id,
       size:          es.bytes_formatted,
@@ -135,9 +135,11 @@ module OllamaChat::SessionManagement
   #
   # @param output [IO] the output stream to write the information to (default: STDOUT)
   def show_session(output: STDOUT)
-    es             = session.estimate_tokens
+    es             = messages.full_estimate_tokens
     messages_count = session.count_messages
-    output.puts "#{bold{session.name}} (#{italic{session.id}}), #{es.bytes_formatted}/#{es.tokens_formatted}, #{messages_count} messages"
+    output.puts "#{bold{session.name}} (#{italic{session.id}}), "\
+      "#{es.tokens_formatted} (#{es.bytes_formatted}), "\
+      "#{messages_count} messages"
   end
 
   # Interactively prompts the user for a unique session name.

data/lib/ollama_chat/token_estimator/crude.rb

@@ -7,7 +7,7 @@ class OllamaChat::TokenEstimator::Crude
   # @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
+      @bytes = text.bytesize
     elsif bytes = arg.ask_and_send(:to_int)
       @bytes = bytes
     else

data/lib/ollama_chat/token_estimator.rb

@@ -10,7 +10,7 @@ require 'ollama_chat/token_estimator/crude'
 module OllamaChat::TokenEstimator
   # Represents the result of a calculation including raw values
   # and their human-readable formatted strings.
-  class Estimate < Struct.new(:bytes, :tokens)
+  class Estimate < Data.define(:bytes, :tokens)
     include OllamaChat::Utils::ValueFormatter
 
     # Returns the byte count in a formatted string (e.g., "1.2 KB").

data/lib/ollama_chat/tools/concern.rb

@@ -29,6 +29,23 @@ module OllamaChat::Tools::Concern
     #
     # @return [ String ] the register name of the tool
     attr_accessor :register_name
+
+    # Generates a one-line summary of a tool execution result for inclusion
+    # in compaction narratives.
+    #
+    # The default implementation extracts the `message` field from the
+    # result JSON (most tools already produce one). Falls back to a
+    # generic sentence if the field is absent or parsing fails.
+    #
+    # @param result [String] the raw JSON result string returned by `execute`
+    # @return [String] a short natural-language description of the call
+    def summary_template(result:)
+      default_message = "was called."
+      data            = JSON.parse(result)
+      data.is_a?(Hash) && data['message'] || default_message
+    rescue JSON::ParserError
+      default_message
+    end
   end
 
   # The name method returns the registered name of the tool.

data/lib/ollama_chat/tools/directory_structure.rb

@@ -28,10 +28,10 @@ class OllamaChat::Tools::DirectoryStructure
         description: <<~EOT,
           Tree viewer – Returns JSON describing files/folders under path up to
           max_depth (<= height of the tree), optionally only files ending with
-          suffix, e. g. rb for ruby files. Handy for locating resources or
-          presenting a project layout. Limit the required tokens by using the
-          max_depth parameter if possible, because the number of nodes in a
-          tree can grow exponentially with its height.
+          suffix / file extension, e. g. rb for ruby files. Handy for locating
+          resources or presenting a project layout. Limit the required tokens
+          by using the max_depth parameter if possible, because the number of
+          nodes in a tree can grow exponentially with its height.
         EOT
         parameters: Tool::Function::Parameters.new(
           type: 'object',
@@ -42,13 +42,17 @@ class OllamaChat::Tools::DirectoryStructure
             ),
             suffix: Tool::Function::Parameters::Property.new(
               type: 'string',
-              description: 'Only include files with this suffix, e. g. "rb" (defaults to all)'
+              description: <<~EOT
+                Only include files with this suffix / file extension, e. g.
+                "rb" (defaults to all)
+              EOT
             ),
             max_depth: Tool::Function::Parameters::Property.new(
               type: 'integer',
               description: <<~EOT,
-                Maximum depth of directory structure to return upto the total
-                height of the directory structure (defaults to disabled)
+                How many levels of the tree to include. 1 = immediate
+                children only, 2 = children + grandchildren, nil =
+                unlimited (defaults to nil)
               EOT
             ),
           },

data/lib/ollama_chat/tools/eval_ruby.rb

@@ -7,6 +7,7 @@ require 'open3'
 # It provides a safe way to test snippets and verify Ruby behavior.
 class OllamaChat::Tools::EvalRuby
   include OllamaChat::Tools::Concern
+  include Kramdown::ANSI::Width
 
   # @return [String] the registered name for this tool
   def self.register_name = 'eval_ruby'
@@ -79,18 +80,27 @@ class OllamaChat::Tools::EvalRuby
     result = stdout&.sub(/\ASwitch to inspect mode.\n/, '')
 
     if status.success?
+      result_truncated = truncate(result.to_s.strip, length: 80)
+      message          = "eval_ruby succeeded (#{version}): #{result_truncated.inspect}"
       {
         result:,
         version:,
-        status: 'success'
+        status: 'success',
+        message:  ,
       }.to_json
     else
+      message =
+        if stderr.empty?
+          "eval_ruby failed (#{version}): exit status #{status.exitstatus}"
+        else
+          "eval_ruby failed (#{version}): #{truncate(stderr.to_s.strip, length: 80).inspect}"
+        end
       {
-        error: 'ExecutionError',
-        message: stderr.empty? ? "Process exited with status #{status.exitstatus}" : stderr,
-        version:,
-        stdout:,
-        exit_status: status.exitstatus
+        error:       'ExecutionError',
+        message:     ,
+        version:     ,
+        stdout:      ,
+        exit_status: status.exitstatus,
       }.to_json
     end
   rescue => e

data/lib/ollama_chat/tools/get_rfc.rb

@@ -60,7 +60,9 @@ class OllamaChat::Tools::GetRFC
       },
       &:read
     )
+    message = "RFC #{rfc_id} was fetched."
     {
+      message:,
       rfc_id: ,
       content:,
     }.to_json

data/lib/ollama_chat/tools/lookup_group.rb

@@ -0,0 +1,100 @@
+# A tool for retrieving full message content from a previous conversation
+# group by its short UUID suffix.
+#
+# When compaction summarizes older messages, the generated summary contains
+# short group UUIDs (last 8 hex chars) that reference the original
+# conversation turns. This tool lets the model retrieve the full content of
+# any referenced group, enabling it to "zoom back in" on specific details
+# that were compressed into the narrative.
+#
+# The search matches on the *suffix* of the `group_uuid` because the summary
+# only stores the last 8 hex characters (the random portion of the UUIDv7),
+# not the full 36-character string.
+#
+# @note The tool is read-only; it never mutates the chat or message list.
+class OllamaChat::Tools::LookupGroup
+  include OllamaChat::Tools::Concern
+
+  # @return [String] the registered name for this tool
+  def self.register_name = 'lookup_group'
+
+  # Returns the tool definition for use with the Ollama API.
+  #
+  # @return [Ollama::Tool] a tool definition for group lookup
+  def tool
+    Tool.new(
+      type: 'function',
+      function: Tool::Function.new(
+        name:,
+         description: <<~EOT,
+           Retrieve the full messages of a previous conversation group.
+
+           **IMPORTANT:** Provide the **last 8 hex characters** of the
+           group_uuid (the random suffix), e.g. "3b874564" — NOT the
+           full UUID, NOT the first 8 characters.
+
+           The summary's tool-summaries section and narrative contain
+           these short suffixes in parentheses after group references.
+        EOT
+        parameters: Tool::Function::Parameters.new(
+          type: 'object',
+          properties: {
+            group_uuid: Tool::Function::Parameters::Property.new(
+              type: 'string',
+               description: <<~EOT,
+                 The **last 8 hex characters** (suffix) of the group UUID,
+                 exactly as it appears in the compaction summary. e.g.
+                 "3b874564".
+               EOT
+            )
+          },
+          required: %w[group_uuid]
+        )
+      )
+    )
+  end
+
+  # Retrieves the messages belonging to the group identified by the short
+  # UUID suffix and returns them as formatted JSON.
+  #
+  # @param tool_call [OllamaChat::Tool::Call] the tool call with arguments
+  # @param opts [Hash] additional options
+  # @option opts [OllamaChat::Chat] :chat the chat instance
+  #
+  # @return [String] a JSON string containing the group messages
+  # @return [String] an error message as a JSON string if the group is
+  #   not found or the argument is invalid
+  def execute(tool_call, **opts)
+    chat = opts[:chat]
+    args = tool_call.function.arguments
+
+    uuid = args.group_uuid.to_s.strip
+    raise OllamaChat::ToolFunctionArgumentError, 'group_uuid required' if uuid.empty?
+
+    messages = chat.messages.each_group(role: %w[user assistant tool], tool: true).find do |group|
+      group.first.group_uuid.to_s.end_with?(uuid)
+    end
+
+    raise OllamaChat::OllamaChatError, "Group not found: #{uuid}" if messages.nil?
+
+    chat.log(:info, 'Group retrieved', data: {
+      tool: name, group_uuid: messages.first.group_uuid, messages: messages.size
+    })
+
+    formatted = messages.map do |msg|
+      tool_tag = msg.tool_name ? " (#{msg.tool_name})" : ''
+      "[#{msg.role}#{tool_tag}] #{msg.content.to_s.strip}"
+    end
+
+    {
+      group_uuid: messages.first.group_uuid,
+      message:    "Retrieved #{messages.size} message(s) for group #{uuid}.",
+      messages:   formatted,
+    }.to_json
+  rescue => e
+    chat.log(:error, e, data: { tool: name, group_uuid: args.group_uuid })
+    { error: e.class.name, message: e.message }.to_json
+  end
+
+  self
+end.register

data/lib/ollama_chat/tools/paste_from_clipboard.rb

@@ -50,7 +50,7 @@ class OllamaChat::Tools::PasteFromClipboard
 
     # Use the chat instance's clipboard paste functionality
     content = chat.perform_paste_from_clipboard(edit:)
-    message = "Pasted #{format_bytes(content.to_s.size)} of content."
+    message = "Pasted #{format_bytes(content.to_s.bytesize)} of content."
 
     {
       success:  true,

data/lib/ollama_chat/tools/patch_file.rb

@@ -164,16 +164,34 @@ class OllamaChat::Tools::PatchFile
         "Failed to apply patch to file #{path.to_s.inspect}."
       end
 
+    syntax_check = nil
+    if result[:success] && (checker = chat.syntax_checker_for(path))
+      check = chat.run_syntax_check(checker, path)
+      syntax_check = check if check &&
+        (check[:status] == 'fail' || check[:output] != '')
+    end
+    if syntax_check
+      case syntax_check[:status]
+      when 'fail'
+        message = "#{message} — ❌ Syntax error detected"
+      when 'pass'
+        if warning = syntax_check[:output].lines.first&.chomp
+          message = "#{message} — ⚠️ #{warning}"
+        end
+      end
+    end
+
     mtime, checksum = File.open(path, 'rb') {
       [ _1.mtime.iso8601(0), '%08x' % Zlib.crc32(_1) ]
     }
 
     (result | {
-      path:     path.to_s,
-      message:  ,
-      mtime:    ,
-      checksum: ,
-    }).to_json
+      path:         path.to_s,
+      message:      ,
+      mtime:        ,
+      checksum:     ,
+      syntax_check: syntax_check,
+    }).compact.to_json
 
   rescue => e
     chat.log(:error, e, data: { tool: name, path: path.to_s })

data/lib/ollama_chat/tools/read_file.rb

@@ -91,7 +91,7 @@ class OllamaChat::Tools::ReadFile
     content, line_count = extract_range(full_content, start_line, end_line, line_numbers:)
     checksum            = '%08x' % Zlib.crc32(full_content) if line_numbers && !start_line && !end_line
     es                  = OllamaChat::TokenEstimator.estimate(content)
-    message             = "Read #{es.bytes_formatted} (#{es.tokens_formatted}) from #{path.to_s.inspect}."
+    message             = "Read #{es.tokens_formatted} (#{es.bytes_formatted}) from #{path.to_s.inspect}."
     chat.log(:info, "File read", data: {
       tool: name, path: path.to_s, bytes: es.bytes_formatted, tokens: es.tokens_formatted
     })

data/lib/ollama_chat/tools/resolve_tag.rb

@@ -66,7 +66,7 @@ class OllamaChat::Tools::ResolveTag
 
     tags    = OC::OLLAMA::CHAT::TOOLS::TAGS_FILE
     results = OllamaChat::Utils::TagResolver.new(tags).
-      resolve(symbol:, kind:, directory:)
+      resolve(chat:, symbol:, kind:, directory:)
 
     message = "Found %{results_count} results of symbol \"%{symbol}\"." % {
       results_count: results.size, symbol:

data/lib/ollama_chat/tools/search_knowledge.rb

@@ -114,7 +114,13 @@ class OllamaChat::Tools::SearchKnowledge
 
     if collection = args.collection.full?
       unless collection.to_s.match?(/\A#{OllamaChat::COLLECTION_NAME_REGEXP.source}\z/)
-        raise OllamaChat::ToolFunctionArgumentError, "Invalid collection name: #{collection}"
+        raise OllamaChat::ToolFunctionArgumentError,
+          "Invalid collection name: #{collection}"
+      end
+      col = chat.database_collection?(collection)
+      if col&.enabled == false
+        raise OllamaChat::ToolFunctionArgumentError,
+          "Collection #{collection} is disabled."
       end
       old_collection            = chat.documents.collection
       chat.documents.collection = collection

data/lib/ollama_chat/tools/write_file.rb

@@ -112,17 +112,36 @@ class OllamaChat::Tools::WriteFile
       raise ArgumentError, 'Invalid mode %s' % args.mode.inspect
     end
 
-    message = "Wrote #{es.bytes_formatted} (#{es.tokens_formatted}) to file #{path.to_s.inspect}."
+    syntax_check = nil
+    if checker = chat.syntax_checker_for(path)
+      check = chat.run_syntax_check(checker, path)
+      syntax_check = check if check &&
+        (check[:status] == 'fail' || check[:output] != '')
+    end
+
+    message = "Wrote #{es.tokens_formatted} (#{es.bytes_formatted}) to file #{path.to_s.inspect}."
+    if syntax_check
+      case syntax_check[:status]
+      when 'fail'
+        message << " — ❌ Syntax error detected"
+      when 'pass'
+        if warning = syntax_check[:output].lines.first&.chomp
+          message << " — ⚠️ #{warning}"
+        end
+      end
+    end
+
     chat.log(:info, "File written", data: {
       tool: name, path: path.to_s, mode: args.mode || 'overwrite', bytes: es.bytes_formatted
     })
 
     {
-      success:  true,
-      path:     path.to_s,
-      backup:   backup_path.to_s,
-      message:  ,
-    }.to_json
+      success:      true,
+      path:         path.to_s,
+      backup:       backup_path.to_s,
+      message:      ,
+      syntax_check: syntax_check,
+    }.compact.to_json
   rescue => e
     chat.log(:error, e, data: { tool: name, path: args.path })
     {

data/lib/ollama_chat/tools.rb

@@ -62,6 +62,7 @@ require 'ollama_chat/tools/get_location'
 require 'ollama_chat/tools/get_rfc'
 require 'ollama_chat/tools/get_time'
 require 'ollama_chat/tools/get_url'
+require 'ollama_chat/tools/lookup_group'
 require 'ollama_chat/tools/move_file'
 require 'ollama_chat/tools/open_file_in_editor'
 require 'ollama_chat/tools/paste_from_clipboard'

data/lib/ollama_chat/utils/analyze_directory.rb

@@ -37,8 +37,9 @@ module OllamaChat::Utils::AnalyzeDirectory
   #   only files with this suffix are included in the result. Pass `nil` or an empty string
   #   to include all files.
   # @param max_depth [Integer, nil] Optional depth limit. If `nil`,
-  #   the entire tree is returned.  When an integer is supplied, all
-  #   entries deeper than that depth are pruned.
+  #   the entire tree is returned. When an integer is supplied, entries
+  #   at that level and deeper are pruned. Use **1** to show only
+  #   immediate children, **2** for children + grandchildren, etc.
   #
   # @return [Array<Hash>] An array of entry hashes.  Each hash contains:
   #   * `:type`   – "file" or "directory"
@@ -70,9 +71,9 @@ module OllamaChat::Utils::AnalyzeDirectory
 
     structure_each_entry(entries) { |e| e[:height] = height }
 
-    if max_depth && max_depth < height
+    if max_depth && max_depth <= height
       structure_each_entry(entries) do |e|
-        e[:children]&.reject! { |c| c[:depth] > max_depth }
+        e[:children]&.reject! { |c| c[:depth] >= max_depth }
       end
     end
 

data/lib/ollama_chat/utils/fetcher.rb

@@ -312,7 +312,7 @@ class OllamaChat::Utils::Fetcher
         end
         body = response.body
         tmp.print body
-        infobar.update(message: message(body.size, body.size), force: true)
+        infobar.update(message: message(body.bytesize, body.bytesize), force: true)
         decorate_io(tmp, response)
         infobar.finish
         block.(tmp)

data/lib/ollama_chat/utils/log_rotation.rb

@@ -0,0 +1,29 @@
+require 'file/tail'
+
+# Truncates a log file in-place, keeping only the last N lines.
+#
+# Uses `File::Tail#backward` to seek to the start of the tail portion
+# without loading the entire file into memory. The file is rewritten
+# in-place (same inode) so that tailing processes (e.g.
+# `ollama_chat_log`) can continue following the file.
+module OllamaChat::Utils::LogRotation
+  # Truncates a log file in-place, keeping only the last +keep_lines+.
+  #
+  # If the file has fewer lines than +keep_lines+, it is left untouched.
+  # The operation is a no-op if the file does not exist.
+  #
+  # @param path [String, Pathname] the log file to truncate
+  # @param keep_lines [Integer] the number of lines to retain
+  def self.truncate_tail(path, keep_lines:)
+    return unless File.exist?(path)
+    File.open(path, 'r+') do |f|
+      f.extend(File::Tail)
+      f.backward(keep_lines)
+      return if f.pos.zero?
+      tail = f.read
+      f.rewind
+      f.write(tail)
+      f.truncate(f.pos)
+    end
+  end
+end