ollama_chat 0.0.61 → 0.0.63

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9c81f6b541a81aff2a9988c4b00512724805592857d64a395689e4a3cb32e7c
-  data.tar.gz: 440a433901396bf91ac0872128c353b88bb4da55995e5acdaff15f88c0bb4d94
+  metadata.gz: 5d207c29d7838f0cb8bb885dfc93038d2c246eb63d829d0af2e0cdef4c404d3f
+  data.tar.gz: 3b70df18f2d302506614a56556ec0f98d2e814a3558a7bc141b73cc0716c5158
 SHA512:
-  metadata.gz: 483ea8c92759e79ce445df26226e47e53383089e5724dfa1af72be23ce8b90a0c7899fef859fbbf31699edeb033e52caf9fff8be3ca876d31575fd13938b8d72
-  data.tar.gz: efa523df1b2c2659e791677ec6243e441f01d70be634472bcadcc10ce28e036faed2b05c3d06e879f9d50c41c18ed3b18125b7fab043e86c94f46193037d220e
+  metadata.gz: 9b2647b7371490991e879f6f48682a7e7e2a2c3d7ab0fafd41fc7275cd204f9bb288b0ca0e8b11d5be9b0c23b54c93d141e418f0495ce4782de2b0165df1a703
+  data.tar.gz: 83fa7ff6da22352d5d5af335e98975d423641ab3969e51f311068fd0912f4fb3494c22058c1a66e892cf1d11574cc705d9dc3c714ef50123ad555ca67011311b

data/CHANGES.md

@@ -1,5 +1,83 @@
 # Changes
 
+## 2026-02-09 v0.0.63
+
+- Added `OllamaChat::Utils::PathValidator` module with `assert_valid_path`
+  helper and `OllamaChat::InvalidPathError` exception
+- Refactored `FileContext`, `ReadFile`, and `WriteFile` tools to use new path
+  validation logic
+- Simplified `OllamaChat::Tools::FileContext` to use glob pattern only,
+  removing the `path` parameter
+- Added `ignore_case` flag to `execute_grep` tool with dynamic command
+  construction using `eval_template`
+- Renamed tool classes and files to more descriptive names:
+  - `browser.rb` → `browse.rb` (class `Browser` → `Browse`)
+  - `grep.rb` → `execute_grep.rb` (class `Grep` → `ExecuteGrep`)
+  - `weather.rb` → `get_current_weather.rb` (class `Weather` → `GetCurrentWeather`)
+  - `cve.rb` → `get_cve.rb` (class `CVE` → `GetCVE`)
+  - `endoflife.rb` → `get_endoflife.rb` (class `EndOfLife` → `GetEndoflife`)
+  - `location.rb` → `get_location.rb` (class `Location` → `GetLocation`)
+  - `file_reader.rb` → `read_file.rb` (class `FileReader` → `ReadFile`)
+  - `file_writer.rb` → `write_file.rb` (class `FileWriter` → `WriteFile`)
+- Updated `follow_chat.rb` to use `require_confirmation?` instead of `confirm?`
+  when checking tool confirmation
+- Added scheme whitelist to `ImportURL` tool with `schemes: [http, https]`
+  configuration
+- Introduced `read_file` tool with path validation and error handling
+- Added `run_tests` tool for executing RSpec or Test-Unit test suites with
+  configurable runner and coverage reporting
+- Added `vim_open_file` tool for remote Vim file opening with line range
+  support
+- Enhanced `OllamaChat::Vim` class with file opening and line/range selection
+  capabilities
+- Added `GemPathLookup` tool to find gem installation paths using Bundler
+- Added `valid_json?` method to `OllamaChat::Tools::Concern` for consistent
+  JSON validation
+- Implemented `ImportURL` tool for fetching web content
+
+## 2026-02-07 v0.0.62
+
+**Tool Execution**  
+- All tools now return structured JSON errors (`error` + `message`).  
+- Confirmation prompts (`confirm?`) added to `OllamaChat::FollowChat`.  
+- `infobar` displays a busy indicator and status messages during tool runs.  
+- Tool methods accept `config:` and `chat:` keyword arguments.
+
+**Tool Registration**  
+- Centralized logic via `OllamaChat::Tools::Concern` to prevent duplicate
+  registrations.
+
+**File Context Tool (`file_context`)**  
+- Supports an exact `path:` argument in addition to `directory:` + `pattern:`.  
+- Uses `blank?` for argument validation.  
+- YARD documentation added.
+
+**Directory Structure Tool (`directory_structure`)**  
+- Delegates to `OllamaChat::Utils::AnalyzeDirectory.generate_structure`.  
+- Excludes hidden files, symlinks, and the `pkg` directory by default.  
+- `exclude` option configurable in `default_config.yml`.
+
+**Utility Module**  
+- New `OllamaChat::Utils::AnalyzeDirectory` containing the `generate_structure`
+  method.
+
+**Error Handling**  
+- `CVE`, `EndOfLife`, `Grep`, and `Weather` tools now catch all exceptions and return structured JSON errors.
+
+**Testing**  
+- Added comprehensive specs for `AnalyzeDirectory` (traversal, exclusions,
+  error handling).  
+- Tests for exact `path` usage in `file_context` with conflict detection.  
+- Updated `test_files` list in the gemspec.
+
+**Configuration**  
+- `directory_structure` accepts an `exclude` option via `default_config.yml`.  
+- Tool signatures updated to accept `config:` and `chat:`.
+
+**Gem Specification**  
+- Updated `test_files`, `extra_rdoc_files`, and `files` arrays to include new
+  utilities, tests, and documentation.
+
 ## 2026-02-06 v0.0.61
 
 ### New Features

data/Rakefile

@@ -59,6 +59,7 @@ GemHadar do
   dependency             'csv',                   '~> 3.0'
   dependency             'const_conf',            '~> 0.3'
   dependency             'context_spook',         '~> 1.5'
+  dependency             'infobar',               '>= 0.13.1'
   dependency             'rubyzip',               '~> 3.0'
   development_dependency 'all_images',            '~> 0.6'
   development_dependency 'rspec',                 '~> 3.2'

data/lib/ollama_chat/chat.rb

@@ -95,27 +95,21 @@ class OllamaChat::Chat
     connect_ollama
     @model           = choose_model(@opts[?m], config.model.name)
     @model_options   = Ollama::Options[config.model.options]
-    model_system     = pull_model_unless_present(@model, @model_options)
-    embedding_enabled.set(config.embedding.enabled && !@opts[?E])
+    @model_system    = pull_model_unless_present(@model, @model_options)
     if @opts[?c]
       messages.load_conversation(@opts[?c])
     else
-      default = config.system_prompts.default? || model_system
-      if @opts[?s] =~ /\A\?/
-        change_system_prompt(default, system: @opts[?s])
-      else
-        system = OllamaChat::Utils::FileArgument.get_file_argument(@opts[?s], default:)
-        system.present? and messages.set_system_prompt(system)
-      end
+      setup_system_prompt
     end
+    embedding_enabled.set(config.embedding.enabled && !@opts[?E])
     @documents            = setup_documents
     @cache                = setup_cache
     @images               = []
     @kramdown_ansi_styles = configure_kramdown_ansi_styles
+    @enabled_tools        = default_enabled_tools
+    @tool_call_results    = {}
     init_chat_history
     @opts[?S] and init_server_socket
-    @enabled_tools = config.tools.to_h.map { |n, v| n.to_s if v[:default] }.compact
-    @tool_call_results = {}
   rescue ComplexConfig::AttributeMissing, ComplexConfig::ConfigurationSyntaxError => e
     fix_config(e)
   end
@@ -208,6 +202,25 @@ class OllamaChat::Chat
     interact_with_user
   end
 
+  # The vim method creates and returns a new Vim instance for interacting with
+  # a Vim server.
+  #
+  # This method initializes a Vim client that can be used to insert text into
+  # Vim buffers or open files in a running Vim server. It derives the server
+  # name from the provided argument or uses a default server name based on the
+  # current working directory.
+  #
+  # @param server_name [ String, nil ] the name of the Vim server to connect to
+  #   If nil or empty, a default server name is derived from the current
+  #   working directory
+  #
+  # @return [ OllamaChat::Vim ] a new Vim instance configured with the
+  #   specified server name
+  def vim(server_name = nil)
+    clientserver = config.vim?&.clientserver
+    OllamaChat::Vim.new(server_name, clientserver:)
+  end
+
   private
 
   # Handles user input commands and processes chat interactions.
@@ -248,7 +261,7 @@ class OllamaChat::Chat
       messages.list_conversation(n)
       :next
     when %r(^/last(?:\s+(\d*))?$)
-      n = $1.to_i if $1
+      n = $1.to_i.clamp(1..)
       messages.show_last(n)
       :next
     when %r(^/clear(?:\s+(messages|links|history|tags|all))?$)
@@ -370,8 +383,7 @@ class OllamaChat::Chat
       :next
     when %r(^/vim(?:\s+(.+))?$)
       if message = messages.last
-        clientserver = config.vim?&.clientserver
-        OllamaChat::Vim.new($1, clientserver:).insert message.content
+        vim($1).insert message.content
       else
         STDERR.puts "Warning: No message found to insert into Vim"
       end
@@ -702,8 +714,6 @@ class OllamaChat::Chat
     save_history
   end
 
-  private
-
   # The base_url method returns the Ollama server URL from command-line options
   # or environment configuration.
   #
@@ -738,6 +748,26 @@ class OllamaChat::Chat
     @ollama
   end
 
+  # Sets up the system prompt for the chat session.
+  #
+  # This method determines whether to use a default system prompt or a custom
+  # one specified via command-line options. If a custom system prompt is
+  # provided with a regex selector (starting with ?), it invokes the
+  # change_system_prompt method to handle the selection. Otherwise, it
+  # retrieves the system prompt from a file or uses the default value, then
+  # sets it in the message history.
+  #
+  # @return [ void ] this method returns nil after setting up the system prompt
+  def setup_system_prompt
+    default = config.system_prompts.default? || @model_system
+    if @opts[?s] =~ /\A\?/
+      change_system_prompt(default, system: @opts[?s])
+    else
+      system = OllamaChat::Utils::FileArgument.get_file_argument(@opts[?s], default:)
+      system.present? and messages.set_system_prompt(system)
+    end
+  end
+
   # The setup_documents method initializes the document processing pipeline by
   # configuring the embedding model and database connection.
   # It then loads specified documents into the system and returns the

data/lib/ollama_chat/env_config.rb

@@ -51,6 +51,14 @@ module OllamaChat
       end
     end
 
+    BROWSER = set do
+      description 'Browser to use'
+
+      default do
+        %w[ open xdg-open ].find { `which #{_1}` }.full?(:chomp)
+      end
+    end
+
     DIFF_TOOL = set do
       description 'Diff tool to apply changes with'
 
@@ -128,6 +136,16 @@ module OllamaChat
           description 'File to save the chat history in'
           default     XDG_CACHE_HOME + 'history.json'
         end
+
+        module TOOLS
+          description 'Tool specific configuration settings'
+
+          RUN_TESTS_TEST_RUNNER = set do
+            description 'Configured test runner for run_tests tool function'
+            default     'rspec'
+            required     true
+          end
+        end
       end
     end
   end

data/lib/ollama_chat/follow_chat.rb

@@ -102,8 +102,47 @@ class OllamaChat::FollowChat
 
     response.message.tool_calls.each do |tool_call|
       name = tool_call.function.name
-      @chat.tool_call_results[name] = OllamaChat::Tools.registered[name].
-        execute(tool_call, chat: @chat, config: @chat.config)
+      unless @chat.config.tools.attribute_set?(name)
+        STDERR.printf("Unconfigured tool named %s ignored => Skip.\n", name)
+        next
+      end
+      unless OllamaChat::Tools.registered?(name)
+        STDERR.printf("Unregistered tool named %s ignored => Skip.\n", name)
+        next
+      end
+      STDOUT.puts
+      confirmed = true
+      args = JSON.pretty_generate(tool_call.function.arguments)
+      if @chat.config.tools[name].require_confirmation?
+        prompt = "I want to execute tool %s\n%s\nConfirm? (y/n) " % [
+          bold { name },
+          italic { args  },
+        ]
+        confirmed = @chat.ask?(prompt:) =~ /\Ay/i
+      else
+        STDOUT.puts "Executing tool %s\n%s" % [
+          bold { name },
+          italic { args  },
+        ]
+      end
+      result = nil
+      if confirmed
+        STDOUT.printf(
+          "\n%s Execution of tool %s confirmed.\n\n", ?✅, bold { name }
+        )
+        result = OllamaChat::Tools.registered[name].
+          execute(tool_call, chat: @chat, config: @chat.config)
+      else
+        result = JSON(
+          message: 'User denied confirmation!',
+          resolve: 'You **MUST** ask the user for instructions on how to proceed!!!',
+        )
+        STDOUT.printf(
+          "\n%s Execution of tool %s denied by user.\n", ?🚫, bold { name }
+        )
+        sleep 1
+      end
+      @chat.tool_call_results[name] = result
     end
   end
 

data/lib/ollama_chat/message_list.rb

@@ -113,7 +113,9 @@ class OllamaChat::MessageList
     end
     @messages =
       File.open(filename, 'r') do |output|
-        JSON(output.read).map { Ollama::Message.from_hash(_1) }
+        JSON(output.read).map {
+          Ollama::Message.from_hash(_1 | { 'content' => nil })
+        }
       end
     self
   end

data/lib/ollama_chat/ollama_chat_config/default_config.yml

@@ -98,8 +98,45 @@ tools:
     default: true
   file_context:
     default: false
+    require_confirmation: true
+    allowed:
+      - ./spec
   directory_structure:
     default: false
+    require_confirmation: true
+    exclude:
+      - corpus
+      - pkg
   execute_grep:
     default: true
-    cmd: 'grep -m %{max_results} -r %{pattern} %{path}'
+    cmd: |
+      grep #{'-i' if ignore_case} -m #{max_results} -r #{pattern} #{path}
+  browse:
+    default: false
+  write_file:
+    default: false
+    require_confirmation: true
+    allowed:
+      - ./tmp
+  read_file:
+    default: false
+    require_confirmation: false
+    allowed:
+      - ./tmp
+      - ./lib
+      - ./spec
+  search_web:
+    default: true
+  import_url:
+    default: true
+    require_confirmation: true
+    schemes:
+      - http
+      - https
+  gem_path_lookup:
+    default: true
+  vim_open_file:
+    default: true
+  run_tests:
+    require_confirmation: true
+    default: true

data/lib/ollama_chat/parsing.rb

@@ -219,6 +219,10 @@ module OllamaChat::Parsing
     tags = Documentrix::Utils::Tags.new valid_tag: /\A#*([\w\]\[]+)/
     contents = [ content ]
     content.scan(CONTENT_REGEXP).each { |url, tag, file_url, quoted_file, file|
+      if file && File.directory?(file)
+        contents << OllamaChat::Utils::AnalyzeDirectory.generate_structure(file)
+        next
+      end
       check_exist = false
       case
       when tag

data/lib/ollama_chat/tool_calling.rb

@@ -13,6 +13,27 @@ module OllamaChat::ToolCalling
     @enabled_tools.map { OllamaChat::Tools.registered[it]&.to_hash }.compact
   end
 
+  # The default_enabled_tools method returns an array of tool names that are
+  # configured as default tools.
+  #
+  # This method iterates through the configured tools and collects those that
+  # are registered and have the default flag set to true. Unregistered tools
+  # are skipped with a warning message.
+  #
+  # @return [Array<String>] a sorted array of tool names that are configured as
+  #   default tools
+  def default_enabled_tools
+    result = []
+    config.tools.each { |n, v|
+      if OllamaChat::Tools.registered?(n)
+        result << n.to_s if v.default
+      else
+        STDERR.puts "Skipping configuration for unregistered tool %s" % bold { n }
+      end
+    }
+    result
+  end
+
   # The configured_tools method returns an array of tool names configured for
   # the chat session.
   #
@@ -39,7 +60,11 @@ module OllamaChat::ToolCalling
   def list_tools
     configured_tools.each do |tool|
       enabled = @enabled_tools.member?(tool) ? ?✓ : ?☐
-      printf "%s %s\n", enabled, (enabled ? bold { tool } : tool)
+      require_confirmation = config.tools[tool].require_confirmation? ? ?? : ?☐
+      printf(
+        "%s %s %s\n",
+        enabled, require_confirmation, (enabled ? bold { tool } : tool)
+      )
     end
   end
 

data/lib/ollama_chat/tools/browse.rb

@@ -0,0 +1,86 @@
+require "shellwords"
+
+# A tool for opening URLs/files in the user's default browser application.
+#
+# This tool enables the chat client to open web URLs or local files in the
+# user's default browser, allowing users to view content directly in their
+# browser environment. It integrates with the Ollama tool calling system to
+# provide
+# seamless web browsing capabilities during chat interactions.
+class OllamaChat::Tools::Browse
+  include OllamaChat::Tools::Concern
+
+  def self.register_name = 'browse'
+
+  # Creates and returns a tool definition for opening URLs/files in the browser.
+  #
+  # This method constructs the function signature that describes what the tool
+  # does, its parameters, and required fields. The tool expects a URL parameter
+  # to be provided.
+  #
+  # @return [Ollama::Tool] a tool definition for opening URLs/files in the browser
+  def tool
+    Tool.new(
+      type: 'function',
+      function: Tool::Function.new(
+        name:,
+        description: <<~EOT,
+          Open a URL or file in the user\'s default browser application so they
+          can view the content directly
+        EOT
+        parameters: Tool::Function::Parameters.new(
+          type: 'object',
+          properties: {
+            url: Tool::Function::Parameters::Property.new(
+              type: 'string',
+              description: <<~EOT,
+                The URL or file to open in the user\'s browser for them to view
+                directly
+              EOT
+            ),
+          },
+          required: %w[url]
+        )
+      )
+    )
+  end
+
+  # Executes the browser opening operation.
+  #
+  # This method opens the specified URL or file in the user's default browser
+  # application. It handles the system call and returns the result status.
+  #
+  # @param tool_call [Ollama::Tool::Call] the tool call object containing function details
+  # @param opts [Hash] additional options
+  # @return [String] the execution result as JSON string
+  # @raise [StandardError] if there's an issue with opening the URL/file
+  def execute(tool_call, **opts)
+    url    = tool_call.function.arguments.url
+    result = browse_url(url)
+    {
+      success:    result.success?,
+      exitstatus: result.exitstatus,
+      message:    'opening URL/file',
+      url:        ,
+    }.to_json
+  rescue => e
+    { error: e.class, message: e.message }.to_json
+  end
+
+  private
+
+  # Opens a URL or file in the system browser.
+  #
+  # This method uses the system's default browser to open the provided URL or file.
+  # It respects the BROWSER environment variable if set, otherwise defaults to "open".
+  #
+  # @param url [String] the URL or file path to open
+  # @return [Process::Status] the process status of the system call
+  def browse_url(url)
+    browser = OllamaChat::EnvConfig::BROWSER? || "open"
+    system %{#{browser} #{Shellwords.escape(url)}}
+    $?
+  end
+
+  self
+end.register

data/lib/ollama_chat/tools/concern.rb

@@ -0,0 +1,59 @@
+# A module that provides common functionality for OllamaChat tools.
+#
+# This module serves as a base class for all tool implementations in the
+# OllamaChat application, providing shared behavior and methods that tools can
+# inherit from. It includes delegation to the tool name and registration
+# functionality to integrate tools into the chat system's tool registry.
+module OllamaChat::Tools::Concern
+  extend Tins::Concern
+
+  included do
+    include Ollama
+
+    implement :tool, :submodule
+  end
+
+  class_methods do
+    # The register method registers the tool with the tools registry.
+    # @return [ OllamaChat::Tools ] the current instance after registration
+    def register
+      OllamaChat::Tools.register(self)
+    end
+
+    # The register_name attribute accessor provides read and write access to
+    # the register name of the tool.
+    #
+    # @return [ String ] the register name of the tool
+    attr_accessor :register_name
+  end
+
+  # The name method returns the registered name of the tool.
+  #
+  # @return [String] the registered name of the tool instance
+  def name
+    self.class.register_name
+  end
+
+  # The valid_json? method returns a proc that validates JSON data from a
+  # temporary file.
+  #
+  # @return [Proc] a proc that takes a temporary file and returns its JSON
+  #   content or raises an error
+  def valid_json?
+    -> tmp {
+      if data = tmp.read.full?
+        JSON.parse(data)
+        return data
+      else
+        raise JSON::ParserError, 'require JSON data'
+      end
+    }
+  end
+
+  # The to_hash method converts the tool to a hash representation.
+  #
+  # @return [ Hash ] a hash representation of the tool
+  def to_hash
+    tool.to_hash
+  end
+end

data/lib/ollama_chat/tools/directory_structure.rb

@@ -7,19 +7,10 @@
 # The tool supports traversing directories and returns a structured
 # representation of the file system hierarchy.
 class OllamaChat::Tools::DirectoryStructure
-  include Ollama
+  include OllamaChat::Tools::Concern
+  include OllamaChat::Utils::AnalyzeDirectory
 
-  # Initializes a new directory_structure tool instance.
-  #
-  # @return [OllamaChat::Tools::DirectoryStructure] a new directory_structure tool instance
-  def initialize
-    @name = 'directory_structure'
-  end
-
-  # Returns the name of the tool.
-  #
-  # @return [String] the name of the tool ('directory_structure')
-  attr_reader :name
+  def self.register_name = 'directory_structure'
 
   # Creates and returns a tool definition for retrieving directory structure.
   #
@@ -51,77 +42,22 @@ class OllamaChat::Tools::DirectoryStructure
   # Executes the directory structure retrieval operation.
   #
   # This method traverses the directory structure starting from the specified
-  # path and returns a structured representation of
-  # the file system hierarchy.
+  # path and returns a structured representation of the file system hierarchy.
+  #
+  # @param tool_call [Ollama::Tool::Call] the tool call object containing
+  #   function details
   #
-  # @param tool_call [Ollama::Tool::Call] the tool call object containing function details
   # @param opts [Hash] additional options
   # @return [String] the directory structure as a JSON string
-  # @raise [StandardError] if there's an issue with directory traversal or JSON serialization
+  # @raise [StandardError] if there's an issue with directory traversal or JSON
+  #   serialization
   def execute(tool_call, **opts)
-    path = Pathname.new(tool_call.function.arguments.path || '.')
+    config = opts[:config]
+    path   = Pathname.new(tool_call.function.arguments.path || '.')
 
-    structure = generate_structure(path)
+    structure = generate_structure(path, exclude: config.tools.directory_structure.exclude?)
     structure.to_json
   end
 
-  # Converts the tool to a hash representation.
-  #
-  # This method provides a standardized way to serialize the tool definition
-  # for use in tool calling systems.
-  #
-  # @return [Hash] a hash representation of the tool
-  def to_hash
-    tool.to_hash
-  end
-
-  private
-
-  # Generates a directory structure representation with files and
-  # subdirectories.
-  #
-  # @param path [String] the path to start generating the structure from,
-  # defaults to current directory
-  #
-  # @return [Array<Hash>, Hash] an array of hashes representing files and
-  # directories, or a hash with error information if an exception occurs
-  # @return [Array] an empty array if the path is invalid or has no children
-  # @return [Hash] a hash with error details if an exception is raised during processing
-  #
-  # @example Generate structure for current directory
-  #   generate_structure
-  #
-  # @example Generate structure for a specific path
-  #   generate_structure('/path/to/directory')
-  #
-  # @note Hidden files and directories (starting with '.') are skipped
-  # @note Symbolic links are skipped
-  # @note The method uses recursive calls to traverse subdirectories
-  # @note If an error occurs during traversal, it returns a hash with error details
-  def generate_structure(path = ?.)
-    path = Pathname.new(path).expand_path
-    entries = []
-    path.children.sort.each do |child|
-      # Skip hidden files/directories
-      next if child.basename.to_s.start_with?('.')
-      # Skip symlinks
-      next if child.symlink?
-
-      if child.directory?
-        entries << {
-          type: 'directory',
-          name: child.basename.to_s,
-          children: generate_structure(child)
-        }
-      elsif child.file?
-        entries << {
-          type: 'file',
-          name: child.basename.to_s
-        }
-      end
-    end
-    entries
-  rescue => e
-    { error: e.class, message: e.message }
-  end
-end
+  self
+end.register