ask-tools-shell 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: df1f5ba13ed96fd946f5fae6eaa010ac2ae9c8ef6c87a48fcec7ec0b994f1164
+  data.tar.gz: 79a8c50c47d6b43ba2fbe9dddd8a514aac6f2baa5951c240131003f4f88ac22d
+SHA512:
+  metadata.gz: d918ba9bd43e27f511c82f9adc4de3d6daa8817531555cfc567729f807f92df8e18f28932aa6e59738c0d2f1e653562255240df5974f3e128249e8ac04258418
+  data.tar.gz: 226ea5d605b60d10a8b6839c4469d5cbc97076f3c08596e59c0adb0fe29ed0b03bc95b54261af51a3c6babd074489a9b0ca3b55f47281d0cd8a4d1f41e01fe24

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kaka Ruto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,173 @@
+# ask-tools-shell
+
+Shell, filesystem, and code execution tools for AI agents. Part of the ask-rb ecosystem.
+
+Provides **Bash**, **Read**, **Write**, **Edit**, **Glob**, **Grep**, and **Code** — the execution tools every agent needs.
+
+```ruby
+gem "ask-tools-shell"
+```
+
+## Dependencies
+
+- **ask-tools** ~> 0.1 (provides `Ask::Tool` base class and `Ask::Result`)
+
+---
+
+## Quick Start
+
+```ruby
+require "ask-tools-shell"
+
+# List all available tools
+Ask::Tools::Shell.all.map(&:name)
+# => ["bash", "read", "write", "edit", "glob", "grep", "code"]
+
+# Use a tool standalone
+result = Ask::Tools::Bash.new.call(command: "echo hello")
+result.ok?              # => true
+result.output[:stdout]  # => "hello\n"
+result.output[:exit_code] # => 0
+```
+
+---
+
+## Tools
+
+### `Ask::Tools::Bash`
+
+Execute shell commands in a sandboxed temp directory.
+
+| Param | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `command` | `string` | Yes | — | The bash command to execute |
+| `timeout` | `integer` | No | 30 | Timeout in seconds |
+| `workdir` | `string` | No | temp dir | Working directory |
+
+Returns `{ stdout, stderr, exit_code, timed_out }`. Output truncated to 100KB. Process killed on timeout.
+
+```ruby
+Ask::Tools::Bash.new.call(command: "ls -la", timeout: 10)
+```
+
+### `Ask::Tools::Read`
+
+Read file contents with line numbers, or list directory entries.
+
+| Param | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `path` | `string` | Yes | — | Absolute path to file or directory |
+| `offset` | `integer` | No | 0 | Starting line number (0-indexed) |
+| `limit` | `integer` | No | 2000 | Maximum lines to read |
+
+```ruby
+Ask::Tools::Read.new.call(path: "/etc/hosts")
+Ask::Tools::Read.new.call(path: "large.log", offset: 100, limit: 50)
+```
+
+### `Ask::Tools::Write`
+
+Write content to a file. Creates parent directories automatically.
+
+| Param | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `path` | `string` | Yes | — | Absolute path to write to |
+| `content` | `string` | Yes | — | File content (max 500KB) |
+
+```ruby
+Ask::Tools::Write.new.call(path: "/tmp/hello.txt", content: "Hello, World!")
+```
+
+### `Ask::Tools::Edit`
+
+Replace exact text in a file. Uses exact string matching.
+
+| Param | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `path` | `string` | Yes | — | Absolute path to the file |
+| `old_string` | `string` | Yes | — | Exact text to replace |
+| `new_string` | `string` | Yes | — | Replacement text |
+| `replace_all` | `boolean` | No | false | Replace all occurrences |
+
+```ruby
+Ask::Tools::Edit.new.call(path: "file.rb", old_string: "foo", new_string: "bar")
+Ask::Tools::Edit.new.call(path: "file.rb", old_string: "x", new_string: "y", replace_all: true)
+```
+
+### `Ask::Tools::Glob`
+
+Find files matching a glob pattern, sorted by modification time (newest first).
+
+| Param | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `pattern` | `string` | Yes | — | Glob pattern (e.g. `**/*.rb`) |
+| `path` | `string` | No | current dir | Base directory |
+
+Max 1000 results.
+
+```ruby
+Ask::Tools::Glob.new.call(pattern: "**/*.rb", path: "/path/to/project")
+```
+
+### `Ask::Tools::Grep`
+
+Search file contents using a regex pattern.
+
+| Param | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `pattern` | `string` | Yes | — | Regex pattern to search for |
+| `path` | `string` | No | current dir | Directory to search |
+| `include` | `string` | No | `**/*` | File pattern filter (e.g. `*.rb`) |
+
+Max 100 matches. Line content capped at 500 chars. Skips `.git`, `node_modules`, `vendor`, `.bundle`, `tmp`, `log`.
+
+```ruby
+Ask::Tools::Grep.new.call(pattern: "TODO", path: ".", include: "*.rb")
+```
+
+### `Ask::Tools::Code`
+
+Write and execute Ruby code in a subprocess. Uses gems already available in the environment.
+
+| Param | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `code` | `string` | Yes | — | Ruby source code to execute |
+
+Returns `{ stdout, stderr, exit_code }`. Output truncated to 100KB.
+
+```ruby
+Ask::Tools::Code.new.call(code: <<~RUBY)
+  puts "Hello from Ruby!"
+  result = 2 + 2
+  puts "2 + 2 = #{result}"
+RUBY
+```
+
+---
+
+## Using Tools with an Agent
+
+```ruby
+require "ask-tools-shell"
+
+# All tools
+tools = Ask::Tools::Shell.all
+
+# Find by name
+bash = Ask::Tools["bash"]
+bash.call(command: "date")
+```
+
+---
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test
+gem build ask-tools-shell.gemspec
+```
+
+## License
+
+MIT

data/lib/ask/tools/shell/bash.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tempfile"
+require "stringio"
+require "tmpdir"
+
+module Ask
+  module Tools
+    # Execute shell commands in a sandboxed environment.
+    # Returns stdout, stderr, exit code, and a timed_out flag.
+    # Output is truncated to 100KB.
+    class Bash < Ask::Tool
+      description "Execute a bash command in a sandboxed environment. " \
+                   "Returns stdout, stderr, and exit code. " \
+                   "Output is truncated to 100KB."
+
+      param :command, type: :string, desc: "The bash command to execute", required: true
+      param :timeout, type: :integer, desc: "Timeout in seconds", required: false
+      param :workdir, type: :string, desc: "Working directory", required: false
+
+      MAX_OUTPUT_SIZE = 102_400
+
+      def execute(command:, timeout: 30, workdir: nil)
+        Dir.mktmpdir("ask_bash") do |dir|
+          workdir ||= dir
+
+          stdout = StringIO.new
+          stderr = StringIO.new
+          timed_out = false
+          exit_code = -1
+
+          begin
+            Open3.popen3("bash", "-c", command, chdir: workdir) do |stdin, out, err, wait_thr|
+              stdin.close
+
+              threads = [
+                Thread.new { IO.copy_stream(out, stdout) rescue nil },
+                Thread.new { IO.copy_stream(err, stderr) rescue nil }
+              ]
+
+              unless wait_thr.join(timeout)
+                Process.kill("-KILL", wait_thr.pid) rescue nil
+                timed_out = true
+              end
+
+              threads.each(&:join)
+              exit_code = timed_out ? -1 : wait_thr.value.exitstatus
+            end
+          rescue => e
+            return Ask::Result.error(message: "Bash execution failed: #{e.message}",
+                                     metadata: { stdout: stdout.string, stderr: stderr.string })
+          end
+
+          out_text = stdout.string
+          err_text = stderr.string
+
+          if out_text.length > MAX_OUTPUT_SIZE
+            header = "[Output truncated to #{MAX_OUTPUT_SIZE / 1024}KB]\n"
+            out_text = "#{header}#{out_text[-(MAX_OUTPUT_SIZE - header.length)..]}"
+          end
+
+          if err_text.length > MAX_OUTPUT_SIZE
+            header = "[Error output truncated to #{MAX_OUTPUT_SIZE / 1024}KB]\n"
+            err_text = "#{header}#{err_text[-(MAX_OUTPUT_SIZE - header.length)..]}"
+          end
+
+          Ask::Result.ok(data: {
+            stdout: out_text,
+            stderr: err_text,
+            exit_code: exit_code,
+            timed_out: timed_out
+          })
+        end
+      end
+    end
+  end
+end

data/lib/ask/tools/shell/code.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tmpdir"
+
+module Ask
+  module Tools
+    # Write and execute Ruby code in a subprocess.
+    # Runs in a temp directory via ruby -e.
+    class Code < Ask::Tool
+      description "Write and execute Ruby code in a subprocess. " \
+                   "Returns stdout, stderr, and exit code. " \
+                   "Uses gems already available in the environment."
+
+      param :code, type: :string, desc: "Ruby source code to execute", required: true
+
+      MAX_OUTPUT_SIZE = 102_400
+
+      def execute(code:)
+        Dir.mktmpdir("ask_code") do |_dir|
+          stdout = StringIO.new
+          stderr = StringIO.new
+          exit_code = -1
+
+          begin
+            Open3.popen3("ruby", "-e", code, chdir: Dir.pwd) do |stdin, out, err, wait_thr|
+              stdin.close
+
+              threads = [
+                Thread.new { IO.copy_stream(out, stdout) rescue nil },
+                Thread.new { IO.copy_stream(err, stderr) rescue nil }
+              ]
+
+              threads.each(&:join)
+              exit_code = wait_thr.value.exitstatus
+            end
+          rescue => e
+            return Ask::Result.error(message: "Code execution failed: #{e.message}",
+                                     metadata: { stdout: stdout.string, stderr: stderr.string })
+          end
+
+          out_text = stdout.string
+          err_text = stderr.string
+
+          if out_text.length > MAX_OUTPUT_SIZE
+            header = "[Output truncated to #{MAX_OUTPUT_SIZE / 1024}KB]\n"
+            out_text = "#{header}#{out_text[-(MAX_OUTPUT_SIZE - header.length)..]}"
+          end
+
+          Ask::Result.ok(data: {
+            stdout: out_text,
+            stderr: err_text,
+            exit_code: exit_code
+          })
+        end
+      end
+    end
+  end
+end

data/lib/ask/tools/shell/edit.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Ask
+  module Tools
+    # Edit a file by replacing exact text.
+    # Uses exact string matching — provide enough surrounding context for uniqueness.
+    class Edit < Ask::Tool
+      description "Edit a file by replacing exact text. " \
+                   "Uses exact string matching — provide enough surrounding context for uniqueness."
+
+      param :path, type: :string, desc: "Absolute path to the file", required: true
+      param :old_string, type: :string, desc: "Exact text to replace", required: true
+      param :new_string, type: :string, desc: "Replacement text", required: true
+      param :replace_all, type: :boolean, desc: "Replace all occurrences if true", required: false
+
+      MAX_FILE_SIZE = 1_000_000
+
+      def execute(path:, old_string:, new_string:, replace_all: false)
+        path = File.expand_path(path)
+
+        unless File.exist?(path)
+          return Ask::Result.error(message: "File does not exist: #{path}")
+        end
+
+        unless File.file?(path)
+          return Ask::Result.error(message: "Not a file: #{path}")
+        end
+
+        if File.size(path) > MAX_FILE_SIZE
+          return Ask::Result.error(
+            message: "File too large (#{File.size(path)} bytes). Maximum is #{MAX_FILE_SIZE} bytes."
+          )
+        end
+
+        content = File.read(path)
+
+        if replace_all
+          count = content.scan(old_string).size
+          return Ask::Result.error(message: "String not found") if count == 0
+          content = content.gsub(old_string, new_string)
+        else
+          index = content.index(old_string)
+          return Ask::Result.error(message: "String not found") unless index
+          count = 1
+          content = content.sub(old_string, new_string)
+        end
+
+        File.write(path, content)
+        Ask::Result.ok(data: { path: path, replacements: count },
+                        metadata: { path: path, replacements: count })
+      end
+    end
+  end
+end

data/lib/ask/tools/shell/glob.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Ask
+  module Tools
+    # Find files matching a glob pattern, newest first.
+    class Glob < Ask::Tool
+      description "Find files matching a glob pattern. " \
+                   "Returns up to 1000 matching file paths sorted by modification time (newest first)."
+
+      param :pattern, type: :string, desc: "Glob pattern (e.g. **/*.rb)", required: true
+      param :path, type: :string, desc: "Base directory (default: current)", required: false
+
+      MAX_RESULTS = 1000
+
+      def execute(pattern:, path: nil)
+        base = path ? File.expand_path(path) : Dir.pwd
+
+        unless File.directory?(base)
+          return Ask::Result.error(message: "Directory does not exist: #{base}")
+        end
+
+        files = Dir.glob(pattern, base: base).map { |f| File.join(base, f) }
+        files = files.select { |f| File.file?(f) }
+        files = files.sort_by { |f| -File.mtime(f).to_i }
+        files = files.first(MAX_RESULTS)
+
+        if files.empty?
+          return Ask::Result.error(message: "No files found matching: #{pattern}")
+        end
+
+        result = files.join("\n")
+        result << "\n... (#{files.size} files shown)" if files.size == MAX_RESULTS
+
+        Ask::Result.ok(data: result, metadata: { count: files.size, truncated: files.size == MAX_RESULTS })
+      end
+    end
+  end
+end

data/lib/ask/tools/shell/grep.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Ask
+  module Tools
+    # Search file contents using a regex pattern.
+    class Grep < Ask::Tool
+      description "Search file contents using a regex pattern. " \
+                   "Returns matching file paths with line numbers and content. " \
+                   "Truncated to 100 matches with line content capped at 500 chars."
+
+      param :pattern, type: :string, desc: "Regex pattern to search for", required: true
+      param :path, type: :string, desc: "Directory to search in (default: current)", required: false
+      param :include, type: :string, desc: "File pattern filter (e.g. *.rb)", required: false
+
+      MAX_MATCHES = 100
+      MAX_LINE_LENGTH = 500
+      EXCLUDE_DIRS = %w[.git node_modules vendor .bundle tmp log].freeze
+
+      def execute(pattern:, path: nil, include: nil)
+        base = path ? File.expand_path(path) : Dir.pwd
+
+        unless File.directory?(base)
+          return Ask::Result.error(message: "Directory does not exist: #{base}")
+        end
+
+        begin
+          regex = Regexp.new(pattern, Regexp::IGNORECASE)
+        rescue RegexpError => e
+          return Ask::Result.error(message: "Invalid regex: #{e.message}")
+        end
+
+        matches = []
+        glob = include || "**/*"
+
+        Dir.glob(File.join(base, glob)).each do |file|
+          next unless File.file?(file)
+          next if EXCLUDE_DIRS.any? { |d| file.include?("/#{d}/") }
+
+          begin
+            File.readlines(file).each_with_index do |line, i|
+              next unless regex.match?(line)
+              line_text = line.chomp
+              line_text = line_text[0, MAX_LINE_LENGTH] + "..." if line_text.length > MAX_LINE_LENGTH
+              matches << "#{file}:#{i + 1}: #{line_text}"
+              if matches.size >= MAX_MATCHES
+                return Ask::Result.ok(data: matches.join("\n") + "\n... (too many matches)",
+                                       metadata: { count: matches.size, truncated: true })
+              end
+            end
+          rescue => e
+            matches << "#{file}: error reading: #{e.message}"
+          end
+        end
+
+        if matches.empty?
+          return Ask::Result.error(message: "No matches found for: #{pattern}")
+        end
+
+        Ask::Result.ok(data: matches.join("\n"), metadata: { count: matches.size, truncated: false })
+      end
+    end
+  end
+end

data/lib/ask/tools/shell/read.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ask
+  module Tools
+    # Read file contents with line numbers, or list directory contents.
+    # Output is truncated to 2000 lines.
+    class Read < Ask::Tool
+      description "Read the contents of a file or list a directory. " \
+                   "Files are displayed with line numbers. " \
+                   "Output is truncated to 2000 lines."
+
+      param :path, type: :string, desc: "Absolute path to the file or directory", required: true
+      param :offset, type: :integer, desc: "Starting line number (0-indexed)", required: false
+      param :limit, type: :integer, desc: "Maximum number of lines to read", required: false
+
+      MAX_LINES = 2000
+
+      def execute(path:, offset: nil, limit: nil)
+        path = File.expand_path(path)
+
+        unless File.exist?(path)
+          return Ask::Result.error(message: "Path does not exist: #{path}")
+        end
+
+        if File.directory?(path)
+          entries = Dir.children(path).sort
+          entries.map! do |e|
+            full = File.join(path, e)
+            "#{e}#{File.directory?(full) ? '/' : ''}"
+          end
+          return Ask::Result.ok(data: entries.join("\n"), metadata: { type: "directory", count: entries.size })
+        end
+
+        unless File.file?(path)
+          return Ask::Result.error(message: "Not a file: #{path}")
+        end
+
+        if File.size(path) > 1_000_000
+          return Ask::Result.error(
+            message: "File too large (#{File.size(path)} bytes). Use offset/limit to read portions."
+          )
+        end
+
+        lines = File.readlines(path, chomp: true)
+        total = lines.size
+        offset_val = offset.to_i.clamp(0, total)
+        limit_val = limit || MAX_LINES
+
+        selected = lines[offset_val, limit_val]
+        truncated = selected.size < (total - offset_val)
+
+        result = selected.each_with_index.map do |line, i|
+          "#{offset_val + i + 1}: #{line}"
+        end.join("\n")
+
+        result << "\n... (#{total - offset_val - selected.size} more lines)" if truncated
+
+        Ask::Result.ok(data: result, metadata: {
+          total_lines: total,
+          start_line: offset_val + 1,
+          end_line: offset_val + selected.size,
+          truncated: truncated
+        })
+      end
+    end
+  end
+end

data/lib/ask/tools/shell/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ask
+  module Tools
+    module Shell
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/ask/tools/shell/write.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ask
+  module Tools
+    # Write content to a file, creating parent directories automatically.
+    class Write < Ask::Tool
+      description "Write content to a file at the specified path. " \
+                   "Creates parent directories automatically. " \
+                   "Returns the path and number of bytes written."
+
+      param :path, type: :string, desc: "Absolute path to write to", required: true
+      param :content, type: :string, desc: "File content to write", required: true
+
+      MAX_CONTENT_SIZE = 500_000
+
+      def execute(path:, content:)
+        path = File.expand_path(path)
+
+        if content.length > MAX_CONTENT_SIZE
+          return Ask::Result.error(
+            message: "Content too large (#{content.length} bytes). Maximum is #{MAX_CONTENT_SIZE} bytes."
+          )
+        end
+
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+        bytes = File.write(path, content)
+        Ask::Result.ok(data: { path: path, bytes: bytes },
+                        metadata: { path: path, bytes: bytes })
+      end
+    end
+  end
+end

data/lib/ask/tools/shell.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ask
+  module Tools
+    # Collection point for shell tools.
+    #
+    #   Ask::Tools::Shell.all  # => [Bash, Read, Write, ...] instances
+    #
+    module Shell
+      TOOLS = [Bash, Read, Write, Edit, Glob, Grep, Code].freeze
+
+      # Return an instance of every registered shell tool.
+      #
+      # @return [Array<Ask::Tool>]
+      def self.all
+        TOOLS.map(&:new)
+      end
+    end
+  end
+end

data/lib/ask-tools-shell.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "ask-tools"
+
+require_relative "ask/tools/shell/version"
+require_relative "ask/tools/shell/bash"
+require_relative "ask/tools/shell/read"
+require_relative "ask/tools/shell/write"
+require_relative "ask/tools/shell/edit"
+require_relative "ask/tools/shell/glob"
+require_relative "ask/tools/shell/grep"
+require_relative "ask/tools/shell/code"
+require_relative "ask/tools/shell"

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: ask-tools-shell
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kaka Ruto
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ask-tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Bash, Read, Write, Edit, Glob, Grep, and Code tools for the ask-rb ecosystem.
+email:
+- kaka@myrrlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/ask-tools-shell.rb
+- lib/ask/tools/shell.rb
+- lib/ask/tools/shell/bash.rb
+- lib/ask/tools/shell/code.rb
+- lib/ask/tools/shell/edit.rb
+- lib/ask/tools/shell/glob.rb
+- lib/ask/tools/shell/grep.rb
+- lib/ask/tools/shell/read.rb
+- lib/ask/tools/shell/version.rb
+- lib/ask/tools/shell/write.rb
+homepage: https://github.com/ask-rb/ask-tools-shell
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Shell, filesystem, and code execution tools
+test_files: []