shared_tools 0.4.2 → 0.6.0

data/lib/shared_tools/text_diff.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module SharedTools
+  # Line-based diff via longest-common-subsequence, used by DiffTool. Produces
+  # a readable diff ('-'/'+'/' ' prefixes) with long unchanged runs elided.
+  # Pure stdlib, no external dependency.
+  module TextDiff
+    module_function
+
+    def unified(old_text, new_text, old_label: "old", new_label: "new", context: 3)
+      a = old_text.to_s.lines
+      b = new_text.to_s.lines
+      ops = diff_ops(a, b)
+      return "(no differences)" if ops.all? { |type, _| type == :eq }
+
+      render(ops, old_label, new_label, context)
+    end
+
+    def diff_ops(a, b)
+      n = a.size
+      m = b.size
+      lcs = Array.new(n + 1) { Array.new(m + 1, 0) }
+      (n - 1).downto(0) do |i|
+        (m - 1).downto(0) do |j|
+          lcs[i][j] = a[i] == b[j] ? lcs[i + 1][j + 1] + 1 : [lcs[i + 1][j], lcs[i][j + 1]].max
+        end
+      end
+
+      ops = []
+      i = 0
+      j = 0
+      while i < n && j < m
+        if a[i] == b[j]
+          ops << [:eq, a[i]]
+          i += 1
+          j += 1
+        elsif lcs[i + 1][j] >= lcs[i][j + 1]
+          ops << [:del, a[i]]
+          i += 1
+        else
+          ops << [:add, b[j]]
+          j += 1
+        end
+      end
+      ops.concat(a[i..].map { |line| [:del, line] }) if i < n
+      ops.concat(b[j..].map { |line| [:add, line] }) if j < m
+      ops
+    end
+
+    def render(ops, old_label, new_label, context)
+      out = ["--- #{old_label}", "+++ #{new_label}"]
+      i = 0
+      while i < ops.size
+        type, line = ops[i]
+        if type == :eq
+          run = []
+          while i < ops.size && ops[i][0] == :eq
+            run << ops[i][1]
+            i += 1
+          end
+          emit_context(out, run, context)
+        else
+          out << "#{type == :del ? '-' : '+'} #{line.chomp}"
+          i += 1
+        end
+      end
+      out.join("\n")
+    end
+
+    def emit_context(out, run, context)
+      if run.size > (context * 2) + 1
+        run.first(context).each { |line| out << "  #{line.chomp}" }
+        out << "  ⋮ (#{run.size - (context * 2)} unchanged lines)"
+        run.last(context).each { |line| out << "  #{line.chomp}" }
+      else
+        run.each { |line| out << "  #{line.chomp}" }
+      end
+    end
+  end
+end

data/lib/shared_tools/todo_write_tool.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+# Shim: require 'shared_tools/todo_write_tool'
+require 'shared_tools'
+require 'shared_tools/tools/todo_write_tool'

data/lib/shared_tools/toml_parser.rb

@@ -0,0 +1,409 @@
+# frozen_string_literal: true
+
+module SharedTools
+  # A small, dependency-free TOML parser used by TomlQueryTool. Covers the
+  # common surface of TOML 1.0 used by real config files: comments;
+  # bare/quoted/dotted keys; [tables] and [[arrays of tables]]; basic/literal
+  # strings and their multiline forms; integers (with underscores and
+  # 0x/0o/0b), floats (exponents, inf, nan), booleans; offset/local
+  # date-times, dates and times (kept as strings); arrays (multiline, nested,
+  # heterogeneous); and inline tables. Returns nested Hashes/Arrays with
+  # string keys, ready for JSON output or DataPath navigation.
+  module TomlParser
+    class ParseError < StandardError; end
+
+    module_function
+
+    def parse(text)
+      Parser.new(text).parse
+    end
+
+    # Recursive-descent parser over a character cursor.
+    class Parser
+      DATETIME = /\A(\d{4}-\d{2}-\d{2}([Tt ]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:\d{2})?)?|\d{2}:\d{2}:\d{2}(\.\d+)?)/
+
+      def initialize(source)
+        @s = source.to_s
+        @i = 0
+        @len = @s.length
+        @root = {}
+      end
+
+      def parse
+        @current = @root
+        loop do
+          skip_blank
+          break if eof?
+
+          if peek == "["
+            parse_table_header
+          else
+            key = parse_key
+            skip_inline_ws
+            expect("=")
+            value = parse_value
+            assign(@current, key, value)
+            expect_line_end
+          end
+        end
+        @root
+      end
+
+      private
+
+      # --- table headers ------------------------------------------------
+      def parse_table_header
+        advance # [
+        array = false
+        if peek == "["
+          advance
+          array = true
+        end
+        skip_inline_ws
+        keys = parse_key
+        skip_inline_ws
+        expect("]")
+        expect("]") if array
+        expect_line_end
+
+        @current = array ? open_array_table(keys) : open_table(keys)
+      end
+
+      def open_table(keys)
+        node = @root
+        keys.each do |k|
+          node[k] = {} unless node.key?(k)
+          raise ParseError, "cannot redefine #{k.inspect} as a table" unless node[k].is_a?(Hash) || node[k].is_a?(Array)
+
+          node = node[k].is_a?(Array) ? node[k].last : node[k]
+        end
+        node
+      end
+
+      def open_array_table(keys)
+        node = @root
+        keys[0..-2].each do |k|
+          node[k] = {} unless node.key?(k)
+          raise ParseError, "cannot redefine #{k.inspect} as a table" unless node[k].is_a?(Hash) || node[k].is_a?(Array)
+
+          node = node[k].is_a?(Array) ? node[k].last : node[k]
+        end
+        last = keys[-1]
+        node[last] ||= []
+        raise ParseError, "key #{last.inspect} is not an array of tables" unless node[last].is_a?(Array)
+
+        fresh = {}
+        node[last] << fresh
+        fresh
+      end
+
+      # --- keys ---------------------------------------------------------
+      def parse_key
+        parts = []
+        loop do
+          skip_inline_ws
+          parts << parse_key_segment
+          skip_inline_ws
+          break unless peek == "."
+
+          advance
+        end
+        parts
+      end
+
+      def parse_key_segment
+        case peek
+        when '"' then parse_basic_string
+        when "'" then parse_literal_string
+        else
+          start = @i
+          advance while !eof? && peek.match?(/[A-Za-z0-9_-]/)
+          raise ParseError, "empty key near position #{@i}" if @i == start
+
+          @s[start...@i]
+        end
+      end
+
+      def assign(table, keys, value)
+        node = table
+        keys[0..-2].each do |k|
+          node[k] = {} unless node.key?(k)
+          raise ParseError, "cannot redefine #{k.inspect} as a table" unless node[k].is_a?(Hash)
+
+          node = node[k]
+        end
+        node[keys[-1]] = value
+      end
+
+      # --- values -------------------------------------------------------
+      def parse_value
+        skip_inline_ws
+        case peek
+        when '"', "'" then parse_string
+        when "[" then parse_array
+        when "{" then parse_inline_table
+        else parse_atom
+        end
+      end
+
+      def parse_atom
+        rest = @s[@i..]
+        if (m = rest.match(DATETIME))
+          @i += m[0].length
+          return m[0]
+        end
+        if rest.start_with?("true")
+          @i += 4
+          return true
+        end
+        if rest.start_with?("false")
+          @i += 5
+          return false
+        end
+        parse_number
+      end
+
+      def parse_number
+        start = @i
+        advance while !eof? && !peek.match?(/[\s,\]}#]/)
+        token = @s[start...@i]
+        raise ParseError, "expected a value near position #{start}" if token.empty?
+
+        classify_number(token)
+      end
+
+      def classify_number(token)
+        t = token.gsub("_", "")
+        return Float::INFINITY if %w[inf +inf].include?(t)
+        return -Float::INFINITY if t == "-inf"
+        return Float::NAN if %w[nan +nan -nan].include?(t)
+
+        if (m = t.match(/\A[+-]?0(x|o|b)(.+)\z/))
+          base = { "x" => 16, "o" => 8, "b" => 2 }[m[1]]
+          return Integer(m[2], base)
+        end
+        return Float(t) if t.match?(/[.eE]/) && !t.match?(/\A[+-]?0x/i)
+
+        Integer(t, 10)
+      rescue ArgumentError
+        raise ParseError, "invalid number: #{token.inspect}"
+      end
+
+      # --- strings ------------------------------------------------------
+      def parse_string
+        if @s[@i, 3] == '"""'
+          parse_multiline_basic
+        elsif @s[@i, 3] == "'''"
+          parse_multiline_literal
+        elsif peek == '"'
+          parse_basic_string
+        else
+          parse_literal_string
+        end
+      end
+
+      def parse_basic_string
+        advance # opening "
+        out = +""
+        until eof?
+          c = peek
+          raise ParseError, "unterminated string" if c == "\n"
+
+          if c == '"'
+            advance
+            return out
+          elsif c == "\\"
+            advance
+            out << read_escape
+          else
+            out << c
+            advance
+          end
+        end
+        raise ParseError, "unterminated string"
+      end
+
+      def parse_literal_string
+        advance # opening '
+        start = @i
+        advance while !eof? && peek != "'" && peek != "\n"
+        raise ParseError, "unterminated literal string" if eof? || peek == "\n"
+
+        str = @s[start...@i]
+        advance # closing '
+        str
+      end
+
+      def parse_multiline_basic
+        @i += 3
+        @i += 1 if peek == "\n"
+        out = +""
+        until eof?
+          if @s[@i, 3] == '"""'
+            @i += 3
+            return out
+          elsif peek == "\\" && @s[@i + 1..].match?(/\A[ \t]*\r?\n/)
+            @i += 1
+            @i += 1 while !eof? && peek.match?(/[\s]/)
+          elsif peek == "\\"
+            advance
+            out << read_escape
+          else
+            out << peek
+            advance
+          end
+        end
+        raise ParseError, "unterminated multiline string"
+      end
+
+      def parse_multiline_literal
+        @i += 3
+        @i += 1 if peek == "\n"
+        start = @i
+        until eof?
+          if @s[@i, 3] == "'''"
+            str = @s[start...@i]
+            @i += 3
+            return str
+          end
+          advance
+        end
+        raise ParseError, "unterminated multiline literal string"
+      end
+
+      def read_escape
+        c = peek
+        advance
+        case c
+        when "n" then "\n"
+        when "t" then "\t"
+        when "r" then "\r"
+        when "b" then "\b"
+        when "f" then "\f"
+        when '"' then '"'
+        when "\\" then "\\"
+        when "u" then read_unicode(4)
+        when "U" then read_unicode(8)
+        else raise ParseError, "invalid escape: \\#{c}"
+        end
+      end
+
+      def read_unicode(width)
+        hex = @s[@i, width]
+        raise ParseError, "invalid unicode escape" unless hex && hex.match?(/\A[0-9A-Fa-f]{#{width}}\z/)
+
+        @i += width
+        [hex.to_i(16)].pack("U")
+      end
+
+      # --- arrays & inline tables --------------------------------------
+      def parse_array
+        advance # [
+        arr = []
+        loop do
+          skip_ws_comments
+          break if eof?
+
+          if peek == "]"
+            advance
+            return arr
+          end
+          arr << parse_value
+          skip_ws_comments
+          if peek == ","
+            advance
+          elsif peek == "]"
+            advance
+            return arr
+          else
+            raise ParseError, "expected ',' or ']' in array near position #{@i}"
+          end
+        end
+        raise ParseError, "unterminated array"
+      end
+
+      def parse_inline_table
+        advance # {
+        table = {}
+        skip_ws_comments
+        if peek == "}"
+          advance
+          return table
+        end
+        loop do
+          skip_ws_comments
+          key = parse_key
+          skip_inline_ws
+          expect("=")
+          assign(table, key, parse_value)
+          skip_ws_comments
+          if peek == ","
+            advance
+          elsif peek == "}"
+            advance
+            return table
+          else
+            raise ParseError, "expected ',' or '}' in inline table near position #{@i}"
+          end
+        end
+      end
+
+      # --- cursor helpers ----------------------------------------------
+      def peek
+        @s[@i]
+      end
+
+      def advance
+        @i += 1
+      end
+
+      def eof?
+        @i >= @len
+      end
+
+      def expect(char)
+        raise ParseError, "expected #{char.inspect} near position #{@i}, got #{peek.inspect}" unless peek == char
+
+        advance
+      end
+
+      def skip_inline_ws
+        advance while !eof? && (peek == " " || peek == "\t")
+      end
+
+      # Between top-level statements: whitespace, newlines and comment lines.
+      def skip_blank
+        loop do
+          if !eof? && peek.match?(/[ \t\r\n]/)
+            advance
+          elsif peek == "#"
+            advance while !eof? && peek != "\n"
+          else
+            break
+          end
+        end
+      end
+
+      # Inside arrays/inline tables: whitespace, newlines and comments.
+      def skip_ws_comments
+        skip_blank
+      end
+
+      # After a key/value or header: optional comment, then newline or EOF.
+      def expect_line_end
+        skip_inline_ws
+        if peek == "#"
+          advance while !eof? && peek != "\n"
+        end
+        return if eof?
+
+        advance if peek == "\r"
+        if peek == "\n"
+          advance
+        elsif !eof?
+          raise ParseError, "expected end of line near position #{@i}, got #{peek.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/shared_tools/toml_query_tool.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+# Shim: require 'shared_tools/toml_query_tool'
+require 'shared_tools'
+require 'shared_tools/tools/toml_query_tool'

data/lib/shared_tools/tools/apply_patch_tool.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'pathname'
+require_relative '../../shared_tools'
+
+module SharedTools
+  module Tools
+    # Applies a unified diff to files under root using `git apply`. Complements
+    # MultiEditTool when the caller wants to emit a whole multi-hunk patch
+    # (e.g. straight out of Git::DiffTool or DiffTool). The patch is validated
+    # with `git apply --check` before anything is written, and every touched
+    # path is confined to root — a patch cannot escape root even when root is
+    # a subdirectory of a larger git repo. Works with or without root being a
+    # git repository; requires git to be installed. Mutating — requires user
+    # authorization (see SharedTools.execute?).
+    #
+    # @example
+    #   tool = SharedTools::Tools::ApplyPatchTool.new
+    #   tool.execute(patch: unified_diff_text)
+    #   tool.execute(patch: unified_diff_text, check: true) # dry run
+    class ApplyPatchTool < ::RubyLLM::Tool
+      GIT_ENV = { "GIT_PAGER" => "cat", "GIT_TERMINAL_PROMPT" => "0" }.freeze
+
+      def self.name = 'apply_patch'
+
+      description "Apply a unified diff to files under root (as produced by `git diff` / `diff -u`). " \
+                  "Validates the patch first and reports the affected files; nothing is written if it " \
+                  "would not apply cleanly. Set check: true for a dry run only. Requires git to be " \
+                  "installed; root does not need to be a git repository."
+
+      parameters do
+        string  :patch, description: "The unified diff text to apply."
+        boolean :check, description: "Validate only (dry run); do not write changes. Default false.", required: false
+      end
+
+      # @param root [String] optional, defaults to the current directory
+      # @param logger [Logger] optional logger
+      def initialize(root: nil, logger: nil)
+        @root = root || Dir.pwd
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @param patch [String]
+      # @param check [Boolean]
+      #
+      # @return [String, Hash]
+      def execute(patch:, check: false)
+        @logger.info("#{self.class.name}#execute check=#{check}")
+
+        diff = patch.to_s
+        diff += "\n" unless diff.end_with?("\n")
+        return { error: "patch is empty" } if diff.strip.empty?
+
+        validate_patch_paths!(diff)
+
+        verify = run_git_apply("--check", stdin: diff)
+        return { error: "patch does not apply cleanly: #{message(verify)}" } unless succeeded?(verify)
+
+        files = changed_files(diff)
+        return "Patch applies cleanly (dry run). Affected files: #{files.join(', ')}" if check
+
+        allowed = SharedTools.execute?(tool: self.class.to_s, stuff: "Apply patch affecting #{files.size} file(s): #{files.join(', ')}")
+        unless allowed
+          @logger.warn("User declined to apply the patch")
+          return { error: "User declined to apply the patch" }
+        end
+
+        result = run_git_apply(stdin: diff)
+        return { error: "apply failed: #{message(result)}" } unless succeeded?(result)
+
+        "Applied patch to #{files.size} file#{files.size == 1 ? '' : 's'}: #{files.join(', ')}"
+      rescue SecurityError => e
+        @logger.error("#{self.class.name} path denied: #{e.message}")
+        { error: "patch path escapes root: #{e.message}" }
+      rescue Errno::ENOENT
+        @logger.error("#{self.class.name}: git is not available")
+        { error: "git is not available on the host" }
+      end
+
+      private
+
+      def run_git_apply(*args, stdin:)
+        Open3.capture3(GIT_ENV, "git", "-C", @root.to_s, "apply", *args, stdin_data: stdin)
+      end
+
+      def succeeded?((_out, _err, status))
+        status.exitstatus&.zero?
+      end
+
+      def message((out, err, _status))
+        (err.to_s.empty? ? out.to_s : err.to_s).strip
+      end
+
+      def validate_patch_paths!(diff)
+        root = Pathname.new(File.expand_path(@root))
+        diff.each_line do |line|
+          if line.start_with?("+++ ")
+            check_patch_path!(line[4..].chomp.sub(%r{\Ab/}, ""), root)
+          elsif line.start_with?("--- ")
+            check_patch_path!(line[4..].chomp.sub(%r{\Aa/}, ""), root)
+          end
+        end
+      end
+
+      def check_patch_path!(path, root)
+        return if path.empty? || path == "/dev/null"
+
+        resolved = (root + path).cleanpath
+        raise SecurityError, path unless resolved.ascend.any? { |ancestor| ancestor == root }
+      end
+
+      def changed_files(diff)
+        out, = run_git_apply("--numstat", stdin: diff)
+        out.to_s.each_line.filter_map do |line|
+          parts = line.strip.split("\t")
+          parts.last if parts.size >= 3
+        end
+      end
+    end
+  end
+end