ollama_chat 0.0.113 → 0.0.115

data/lib/ollama_chat/tools/execute_shell.rb

@@ -0,0 +1,158 @@
+require 'open3'
+
+# Shell command executor with mandatory human review.
+#
+# The LLM proposes a command; the user reviews it in their configured
+# editor (modify or cancel), then answers a y/n/i confirm prompt that
+# cannot be disabled via configuration.  Output is displayed via pager.
+class OllamaChat::Tools::ExecuteShell
+  include OllamaChat::Tools::Concern
+  include Term::ANSIColor
+  include OllamaChat::Utils::StripANSI
+
+  # @return [String] the registered name for this tool
+  def self.register_name = 'execute_shell'
+
+  # Compaction summary: one-liner for lookup_group output.
+  #
+  # @param result [String] the raw JSON result string
+  # @return [String] a short human-readable summary
+  def self.summary_template(result:)
+    data = JSON.parse(result)
+    if data['error']
+      "❌ #{data['message']}"
+    else
+      "✅ #{data['command']} (exit #{data['exit_code']})"
+    end
+  end
+
+  # @return [Ollama::Tool] a tool definition for shell execution
+  def tool
+    Tool.new(
+      type: 'function',
+      function: Tool::Function.new(
+        name:,
+        description: <<~EOT,
+          Shell executor – Runs a shell command via `sh -c`. The
+          command is opened in your editor for review/modification,
+          then a mandatory y/n/i confirm prompt gates execution.
+          Last resort: use ONLY when no dedicated tool covers
+          the task (e.g. `git commit`, `bundle install`, `make`).
+          Prefer `execute_grep`, `directory_structure`, `read_file`,
+          `patch_file` over shell equivalents. Only invoke when
+          the user explicitly requests it or you have proposed
+          the command to the user beforehand. Runs in the current
+          working directory.
+        EOT
+        parameters: Tool::Function::Parameters.new(
+          type: 'object',
+          properties: {
+            command: Tool::Function::Parameters::Property.new(
+              type: 'string',
+              description: 'The shell command to execute'
+            ),
+            monochrome: Tool::Function::Parameters::Property.new(
+              type: 'boolean',
+              description: 'Strip ANSI codes from captured output' \
+                           ' (default: true)'
+            ),
+          },
+          required: %w[command]
+        )
+      )
+    )
+  end
+
+  # Execute the shell command after editor review and confirmation.
+  #
+  # @param tool_call [OllamaChat::Tool::Call] the tool call with args
+  # @param opts [Hash] additional options
+  # @option opts [OllamaChat::Chat] :chat the chat instance
+  # @return [String] a JSON result string
+  def execute(tool_call, **opts)
+    chat    = opts[:chat]
+    args    = tool_call.function.arguments
+    command = args.command.to_s.strip
+    raise OllamaChat::ToolFunctionArgumentError,
+          'command required' if command.empty?
+
+    monochrome = args.monochrome.nil? ? true : args.monochrome
+
+    unless OllamaChat.test_mode?
+      reviewed = review(command, chat:)
+      raise OllamaChat::ToolFunctionArgumentError,
+            "Shell command cancelled by user: #{command}" unless reviewed
+      command = reviewed
+
+      STDOUT.puts "\n$ #{command}\n"
+      answer = chat.confirm?(
+        prompt: '❓ Allow ✅[y]es / ⛔️[n]o / 📝[i]nstruct? '
+      )&.to_s&.downcase
+
+      case answer
+      when 'y'
+        # proceed to execution
+      when 'n'
+        raise OllamaChat::ToolFunctionArgumentError,
+              "Shell command cancelled by user: #{command}"
+      else
+        instr   = chat.ask?(prompt: '📝 Instructions: ')&.strip
+        resolve = instr.full? || 'You **MUST** ask the user for instructions!'
+        raise OllamaChat::ToolFunctionArgumentError,
+              "User instruct: #{resolve} (command: #{command})"
+      end
+    end
+
+    stdout, stderr, status = Open3.capture3('sh', '-c', command)
+    exit_code = status.exitstatus
+    if monochrome
+      stdout = strip_ansi(stdout)
+      stderr = strip_ansi(stderr)
+    end
+
+    chat.log(:info, 'Shell executed', data: {
+      tool: name, command:, exit_code:,
+      stdout_bytes: stdout.bytesize,
+      stderr_bytes: stderr.bytesize,
+    })
+
+    display(chat, stdout, stderr, exit_code)
+
+    {
+      stdout:, stderr:, exit_code:, command:,
+      message: "Shell command finished (exit #{exit_code}): #{command}",
+    }.to_json
+  rescue => e
+    cmd = args&.command&.to_s
+    chat.log(:error, e, data: { tool: name, command: cmd })
+    { error: e.class.name, message: e.message, command: cmd }.to_json
+  end
+
+  private
+
+  # Open the command in the user's editor for review.
+  #
+  # @return [String, nil] the (possibly modified) command, or nil
+  #   if the user abandoned or cleared the editor.
+  def review(command, chat:)
+    edited = chat.edit_text(command, basename: %w[cmd .sh])
+    edited.full?(:chomp)
+  end
+
+  # Display command output through the pager.
+  def display(chat, stdout, stderr, exit_code)
+    chat.use_pager do |io|
+      if stdout.present?
+        io.puts bold { "stdout:" }, ""
+        io.puts stdout
+      end
+      if stderr.present?
+        io.puts bold { "stderr:" }, ""
+        io.puts stderr
+      end
+      io.puts bold{ "🎌 exit: #{exit_code}" }
+    end
+  end
+
+  self
+end.register

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

@@ -48,6 +48,7 @@ require 'ollama_chat/tools/directory_structure'
 require 'ollama_chat/tools/eval_ruby'
 require 'ollama_chat/tools/execute_grep'
 require 'ollama_chat/tools/execute_ri'
+require 'ollama_chat/tools/execute_shell'
 require 'ollama_chat/tools/execute_jira_twg'
 require 'ollama_chat/tools/file_context'
 require 'ollama_chat/tools/gem_path_lookup'
@@ -62,6 +63,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

data/lib/ollama_chat/utils/strip_ansi.rb

@@ -0,0 +1,22 @@
+# Strips ANSI escape sequences from a string.
+#
+# Handles both SGR (Select Graphic Rendition) sequences like
+# `\e[38;2;255;128;0m` and OSC (Operating System Command) sequences
+# like `\e]0;title\a` or `\e]8;;url\e\\`.
+#
+# @example
+#   OllamaChat::Utils::StripANSI.strip_ansi("\e[31mred\e[0m")
+#   # => "red"
+module OllamaChat::Utils::StripANSI
+  module_function
+
+  ANSI_RE = /\e\[[0-9;?]*[A-Za-z]|\e\].*?(\e\\|\a)/m
+
+  # Removes all ANSI escape sequences from the given string.
+  #
+  # @param line [String] the string potentially containing ANSI escapes
+  # @return [String] the string with all ANSI escape sequences removed
+  def strip_ansi(line)
+    line.to_s.gsub(ANSI_RE, '')
+  end
+end

data/lib/ollama_chat/utils/tag_resolver.rb

@@ -35,7 +35,7 @@ class OllamaChat::Utils::TagResolver
   # A lightweight struct representing a single tag entry. It extends the base
   # `Struct` with convenience methods for generating human‑readable messages and
   # JSON representations.
-  class TagResult < Struct.new(*(HEADERS + %i[ linenumber ]))
+  class TagResult < Data.define(*(HEADERS + %i[ linenumber ]))
     # @return [String] Human readable description of this tag result.
     def message
       "#{symbol} of kind #{kind} (#{kind_type}) at #{filename}:#{linenumber}"
@@ -86,7 +86,7 @@ class OllamaChat::Utils::TagResolver
   #   with this string.
   # @return [Array<TagResult>] All matching results sorted by the order they
   #   appear in the tags file.
-  def resolve(symbol:, kind: nil, directory: nil)
+  def resolve(chat:, symbol:, kind: nil, directory: nil)
     directory and directory = Pathname.new(directory).expand_path.to_path
     @tags_file.rewind
     results       = []
@@ -117,7 +117,7 @@ class OllamaChat::Utils::TagResolver
       obj.linenumber = linenumber
       results << obj
     rescue => e
-      log(:error, e, data: { context: 'tag_resolver' }, warn: true)
+      chat.log(:error, e, data: { context: 'tag_resolver' }, warn: true)
     end
     results
   end

data/lib/ollama_chat/utils.rb

@@ -20,5 +20,7 @@ require 'ollama_chat/utils/path_completer'
 require 'ollama_chat/utils/path_validator'
 require 'ollama_chat/utils/png_metadata_extractor'
 require 'ollama_chat/utils/tag_resolver'
+require 'ollama_chat/utils/strip_ansi'
 require 'ollama_chat/utils/value_formatter'
 require 'ollama_chat/utils/log_viewer'
+require 'ollama_chat/utils/log_rotation'

data/lib/ollama_chat/version.rb

@@ -1,6 +1,6 @@
 module OllamaChat
   # OllamaChat version
-  VERSION         = '0.0.113'
+  VERSION         = '0.0.115'
   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

@@ -66,6 +66,12 @@ module OllamaChat
   class OllamaChatQuitError < OllamaChatError
   end
 
+  # Raised when a compaction operation fails, e.g. the LLM returns an
+  # empty or unusable summary, or the context window is too small to
+  # accommodate the summarization prompt.
+  class CompactionError < OllamaChatError
+  end
+
   # Regular expression defining the allowed characters for collection names.
   #
   # Matches alphanumeric characters, underscores, hyphens, and dots.
@@ -146,6 +152,7 @@ require 'ollama_chat/favourites_management'
 require 'ollama_chat/prompt_handling'
 require 'ollama_chat/system_prompt_management'
 require 'ollama_chat/prompt_management'
+require 'ollama_chat/compaction'
 require 'ollama_chat/token_estimator'
 require 'ollama_chat/say'
 require 'ollama_chat/chat'