ollama_chat 0.0.66 → 0.0.67

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1a18f61aaf91ee38941a242b7ad2930db7e03e2070ce056f6c7e527fd669cdf
-  data.tar.gz: f9d94af7c77f4639ed977a783d353f2be3a476fe027264f55a405537839f5cc3
+  metadata.gz: 3eb8ee4b480c19b26ba27b6d112da4038ed16615881425ba4f7142483d329a79
+  data.tar.gz: 85a7d64b19b3e751d51d7ada7af2ff536e578f3425218394b0aa3efcd5301626
 SHA512:
-  metadata.gz: 9fc0f6fbb9f5b8afa6937f7f1a136f007b6ec41cc6085b4f8a72de1849624f41b3ff2212d0350ddf8eae3b2c181ed965e425d0fe33288d7960d6314db9e7cb3a
-  data.tar.gz: 0257f7bdee23f896e40e6b6610d9561c9c9c77d925eb706514e61ec890865476cff3d989c9dcdb42063a68625a58b34e3ec6d82cbfa327dae0cd4262c742bd5f
+  metadata.gz: f374a3d58183068936222115a61e090ee3e45efd637401ffd97cebc147286b971025730d6393e95dc2b5eeb2e89cacc65d33a3dc76f6467fb23e1aedfe13fffd
+  data.tar.gz: fefa35f2e685dab9c4f3e8b97487f4a4a072f3b2b982864ae423b8d4aaba29ea3e46dc4065dedb7db3908f3192c56c922f92e123163272ef186771b862b7ffc4

data/CHANGES.md

@@ -1,5 +1,18 @@
 # Changes
 
+## 2026-02-18 v0.0.67
+
+- Added `max_depth` option to directory listing tool
+    - Updated `OllamaChat::Tools::DirectoryStructure#execute` to accept `max_depth` parameter
+    - Enhanced `OllamaChat::Utils::AnalyzeDirectory#generate_structure` to handle `max_depth` limit
+    - Implemented depth and height computation for directory entries
+    - Added depth pruning functionality to remove children beyond the specified depth limit
+    - Attached `:depth` and `:height` metadata to each directory entry in JSON output
+    - Refactored internal helper method `recurse_generate_structure` to track entry depth
+    - Updated documentation comments to reflect new behavior
+    - Added comprehensive test coverage for `max_depth` functionality
+    - Added depth-pruning test cases in specification files
+
 ## 2026-02-16 v0.0.66
 
 - Updated `OllamaChat::Tools::GetCurrentWeather.execute` to return a JSON

data/lib/ollama_chat/tools/directory_structure.rb

@@ -24,7 +24,10 @@ class OllamaChat::Tools::DirectoryStructure
       type: 'function',
       function: Tool::Function.new(
         name:,
-        description: 'Retrieve the directory structure and file hierarchy for a given path',
+        description: <<~EOT,
+          Retrieve the directory structure and file hierarchy for a given path,
+          for depth of max_depth (if given).
+        EOT
         parameters: Tool::Function::Parameters.new(
           type: 'object',
           properties: {
@@ -32,6 +35,13 @@ class OllamaChat::Tools::DirectoryStructure
               type: 'string',
               description: 'Path to directory to list (defaults to current directory)'
             ),
+            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)
+              EOT
+            ),
           },
           required: []
         )
@@ -52,10 +62,11 @@ class OllamaChat::Tools::DirectoryStructure
   # @raise [StandardError] if there's an issue with directory traversal or JSON
   #   serialization
   def execute(tool_call, **opts)
-    config = opts[:config]
-    path   = Pathname.new(tool_call.function.arguments.path || '.')
+    config    = opts[:config]
+    path      = Pathname.new(tool_call.function.arguments.path || '.')
+    max_depth = tool_call.function.arguments.max_depth
 
-    structure = generate_structure(path, exclude: config.tools.directory_structure.exclude?)
+    structure = generate_structure(path, max_depth:, exclude: config.tools.directory_structure.exclude?)
     structure.to_json
   end
 

data/lib/ollama_chat/utils/analyze_directory.rb

@@ -1,64 +1,146 @@
-# A module that provides functionality for analyzing directory structures and
-# generating file listings.
-#
-# The AnalyzeDirectory module offers methods to traverse directory hierarchies
-# and create structured representations of file systems. It supports recursive
-# directory traversal, filtering of hidden files and symbolic links, and
-# generation of detailed file and directory information including paths, names,
-# and metadata.
-module OllamaChat::Utils::AnalyzeDirectory
-  module_function
+require 'pathname'
 
-  # 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 = ?., exclude: [])
-    exclude = Array(exclude).map { Pathname.new(_1).expand_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?
-      # Skip if excluded
-      next if exclude.any? { child.fnmatch?(_1.to_s, File::FNM_PATHNAME) }
+module OllamaChat
+  module Utils
+    # The `OllamaChat::Utils::AnalyzeDirectory` module provides a small,
+    # dependency‑free helper for walking a directory tree and producing a
+    # nested hash representation of the file system.
+    #
+    # It supports:
+    #
+    # * Recursive traversal of directories
+    # * Skipping hidden files/directories and symbolic links
+    # * Excluding arbitrary paths via glob patterns
+    # * Limiting the depth of the returned tree
+    #
+    # Example
+    #
+    #   require_relative 'analyze_directory'
+    #
+    #   include OllamaChat::Utils::AnalyzeDirectory
+    #
+    #   structure = generate_structure(
+    #     '/path/to/dir',
+    #     exclude: ['tmp', 'vendor'],
+    #     max_depth: 3
+    #   )
+    #
+    #   puts structure.inspect
+    #
+    # @api public
+    module AnalyzeDirectory
+      # Generate a nested hash representation of a directory tree.
+      #
+      # @param path [String, Pathname] The root directory to walk.
+      #   Defaults to the current working directory (`"."`).
+      # @param exclude [Array<String, Pathname>] Glob patterns (relative to
+      #   +path+) that should be ignored during traversal.
+      # @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.
+      #
+      # @return [Array<Hash>] An array of entry hashes.  Each hash contains:
+      #   * `:type`   – "file" or "directory"
+      #   * `:name`   – Base name of the file/directory
+      #   * `:path`   – Absolute path
+      #   * `:depth`  – Depth relative to the root (root = 0)
+      #   * `:height` – The maximum depth found in the entire tree
+      #   * `:children` – Array of child entry hashes (only for directories)
+      #
+      # @raise [StandardError] Any exception raised during traversal is
+      #   rescued and returned as a hash with `:error` and `:message`
+      #   keys.
+      #
+      # @example Basic usage
+      #   generate_structure(
+      #     '/tmp',
+      #     exclude: ['cache', 'logs'],
+      #     max_depth: 2
+      #   )
+      #
+      # @api public
+      def generate_structure(path = '.', exclude: [], max_depth: nil)
+        entries = recurse_generate_structure(path, exclude:)
+        height  = 0
 
-      if child.directory?
-        entries << {
-          type: 'directory',
-          name: child.basename.to_s,
-          path: child.expand_path.to_s,
-          children: generate_structure(child)
-        }
-      elsif child.file?
-        entries << {
-          type: 'file',
-          path: child.expand_path.to_s,
-          name: child.basename.to_s
-        }
+        structure_each_entry(entries) do |e|
+          height = e[:depth] if e[:depth] > height
+        end
+
+        structure_each_entry(entries) { |e| e[:height] = height }
+
+        if max_depth && max_depth < height
+          structure_each_entry(entries) do |e|
+            e[:children]&.reject! { |c| c[:depth] > max_depth }
+          end
+        end
+
+        entries
+      rescue => e
+        { error: e.class, message: e.message }
+      end
+
+      private
+
+      # Recursively walk *path* and build the tree.
+      #
+      # @param path [String, Pathname] Directory to traverse.
+      # @param exclude [Array<Pathname>] List of absolute paths to skip.
+      # @param depth [Integer] Current depth (root = 0).
+      #
+      # @return [Array<Hash>] Array of entry hashes.
+      #
+      # @api private
+      def recurse_generate_structure(path = '.', exclude: [], depth: 0)
+        exclude = Array(exclude).map { |p| Pathname.new(p).expand_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?
+          # Skip user‑excluded paths
+          next if exclude.any? { |e| child.fnmatch?(e.to_s, File::FNM_PATHNAME) }
+
+          if child.directory?
+            entries << {
+              type:     'directory',
+              name:     child.basename.to_s,
+              path:     child.expand_path.to_s,
+              children: recurse_generate_structure(child, exclude:, depth: depth + 1),
+              depth:
+            }
+          elsif child.file?
+            entries << {
+              type:  'file',
+              name:  child.basename.to_s,
+              path:  child.expand_path.to_s,
+              depth:
+            }
+          end
+        end
+
+        entries
+      end
+
+      # Iterate over every entry in *entries* (depth‑first).
+      #
+      # @param entries [Array<Hash>] The root array of entries.
+      # @yield [Hash] Yields each entry hash.
+      #
+      # @return [Array<Hash>] The original +entries+ array.
+      #
+      # @api private
+      def structure_each_entry(entries, &block)
+        queue = entries.dup
+        while entry = queue.shift
+          block.(entry)
+          queue.concat(entry[:children]) if entry[:children]
+        end
+        entries
       end
     end
-    entries
-  rescue => e
-    { error: e.class, message: e.message }
   end
 end

data/lib/ollama_chat/version.rb

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

data/ollama_chat.gemspec

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
-# stub: ollama_chat 0.0.66 ruby lib
+# stub: ollama_chat 0.0.67 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "ollama_chat".freeze
-  s.version = "0.0.66".freeze
+  s.version = "0.0.67".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]

data/spec/ollama_chat/tools/directory_structure_spec.rb

@@ -26,6 +26,7 @@ describe OllamaChat::Tools::DirectoryStructure do
         name: 'directory_structure',
         arguments: double(
           path: 'spec/assets',
+          max_depth: nil,
         )
       )
     )
@@ -45,6 +46,7 @@ describe OllamaChat::Tools::DirectoryStructure do
         name: 'directory_structure',
         arguments: double(
           path: nil,  # Should default to '.'
+          max_depth: nil,
         )
       )
     )
@@ -64,6 +66,7 @@ describe OllamaChat::Tools::DirectoryStructure do
         name: 'directory_structure',
         arguments: double(
           path: '/nonexistent/path',
+          max_depth: nil,
         )
       )
     )

data/spec/ollama_chat/utils/analyze_directory_spec.rb

@@ -3,7 +3,11 @@ require 'tmpdir'
 require 'fileutils'
 
 describe OllamaChat::Utils::AnalyzeDirectory do
-  let(:generate) { described_class.method(:generate_structure) }
+  let :generate do
+    obj = double
+    obj.extend(described_class)
+    obj.method(:generate_structure)
+  end
 
   context 'basic directory structure' do
     before do
@@ -28,9 +32,24 @@ describe OllamaChat::Utils::AnalyzeDirectory do
       expect(result.map { |e| e[:name] }).to contain_exactly('a.txt', 'b.rb', 'sub')
 
       sub = result.find { |e| e[:name] == 'sub' }
+      expect(sub[:depth]).to eq 0
       expect(sub[:type]).to eq('directory')
       expect(sub[:children]).to be_an(Array)
       expect(sub[:children].map { |e| e[:name] }).to contain_exactly('c.md')
+      expect(sub[:children].map { |e| e[:depth] }).to eq [ 1 ]
+    end
+
+    it 'returns an array of entries with depth max_depth' do
+      result = generate.call(@tmp_dir, max_depth: 0)
+
+      expect(result).to be_an(Array)
+      expect(result.map { |e| e[:name] }).to contain_exactly('a.txt', 'b.rb', 'sub')
+
+      sub = result.find { |e| e[:name] == 'sub' }
+      expect(sub[:depth]).to eq 0
+      expect(sub[:type]).to eq('directory')
+      expect(sub[:children]).to be_an(Array)
+      expect(sub[:children]).to be_empty
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ollama_chat
 version: !ruby/object:Gem::Version
-  version: 0.0.66
+  version: 0.0.67
 platform: ruby
 authors:
 - Florian Frank