ask-tools-shell 0.2.2 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03ed1e1f856f94afa4d5f5dc4b8fb278ad2598ddc6b7d698606c035a9e4034a9
-  data.tar.gz: a040e94935e8a1a5e03530f84e225ee6f55e662fc1d2d1ad3840bf4bcc6e168d
+  metadata.gz: 139a762b4412fcf6dac23e7360f7f49e537f32272491865e90f3ec36ae27da44
+  data.tar.gz: d074b1a2173259a65fc9f9eab1efd3424f2ef4bfcea2e3e868a3ee281ca5d5db
 SHA512:
-  metadata.gz: d8718eb919c2eec978e61c081a036cfbf34cb9adcc829bc0b4637fe490a566f9e573de48a6e327064558868b6abf351f9373178700e5d662b80f6cb128ad788c
-  data.tar.gz: 95312eb2e6b6db1dafca32d8bf074a9d789c4a3cca13c30ed16e116a03e726f308250f08d9292fb7f7f05bed829cd7e11bb792370376e86bb46f938a1b42513c
+  metadata.gz: 8e16c060e637dc9dfa1c420fff9eaf5c357a8abc2ce7c9489fa082bd2f319b65e4b03b64677d3310df359725877e313c334c0a39a5eaa0b5bd8ff44253c2aac9
+  data.tar.gz: ab4bbada08684a89410144614778b70be6a5bc7e7e1d0dbd596aac2727df3eab80d3ec94de9cf172d4a0519d6a1494d102010087c61ea9bee6118fed549bf17f

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.3.0 (2026-06-21)
+
+- Added `EditOperations` pluggable interface (read_file, write_file, file_exist?, file?, file_size, expand_path)
+- Added `DefaultEditOperations` default implementation
+- Added BOM detection/stripping to Edit tool (`Shell.strip_bom`)
+- Added line ending detection and preservation to Edit tool (`Shell.detect_line_ending`, `Shell.normalize_line_endings`, `Shell.restore_line_endings`)
+- Added `FileMutationQueue` for atomic batch file edits with rollback
+
+## 0.2.2
+
+- Various fixes

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

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ask
+  module Tools
+    module Shell
+      module ApplyPatchOperations
+        def read_file(path)
+          File.read(path)
+        end
+
+        def write_file(path, content)
+          File.write(path, content)
+        end
+
+        def file_exist?(path)
+          File.exist?(path)
+        end
+
+        def file?(path)
+          File.file?(path)
+        end
+
+        def delete_file(path)
+          File.delete(path)
+        end
+
+        def expand_path(path)
+          File.expand_path(path)
+        end
+
+        def mkdir_p(path)
+          FileUtils.mkdir_p(File.dirname(path))
+        end
+      end
+
+      class DefaultApplyPatchOperations
+        include ApplyPatchOperations
+      end
+    end
+
+    # Apply a patch to files using a unified diff format.
+    # Supports creating, updating, and deleting files within a
+    # "*** Begin Patch" / "*** End Patch" envelope.
+    class ApplyPatch < Ask::Tool
+      description "Edit files using a unified diff format. " \
+                   "Wrap all changes in a \"*** Begin Patch\" / \"*** End Patch\" envelope. " \
+                   "Each file section starts with a header: " \
+                   "\"*** Add File: <path>\" for new files, " \
+                   "\"*** Update File: <path>\" for changes, or " \
+                   "\"*** Delete File: <path>\" for removals. " \
+                   "Prefix new lines with +."
+
+      param :patchText, type: :string, desc: "The full patch text describing all file changes", required: true
+
+      attr_writer :operations
+
+      def operations
+        @operations ||= Shell::DefaultApplyPatchOperations.new
+      end
+
+      MAX_FILE_SIZE = 10_000_000
+
+      def execute(patchText:)
+        patches = parse_patch(patchText)
+        return Ask::Result.error(message: "No valid patch sections found") if patches.empty?
+
+        results = []
+        patches.each do |entry|
+          path = operations.expand_path(entry[:path])
+
+          case entry[:type]
+          when :add
+            if operations.file_exist?(path)
+              return Ask::Result.error(message: "File already exists: #{path}")
+            end
+            operations.mkdir_p(path)
+            content = entry[:lines].join("\n")
+            content += "\n" unless content.end_with?("\n")
+            operations.write_file(path, content)
+            results << { action: "add", path: entry[:path], lines: entry[:lines].size }
+
+          when :update
+            unless operations.file_exist?(path)
+              return Ask::Result.error(message: "File does not exist: #{path}")
+            end
+            unless operations.file?(path)
+              return Ask::Result.error(message: "Not a file: #{path}")
+            end
+
+            raw = operations.read_file(path)
+            size = raw.bytesize
+            if size > MAX_FILE_SIZE
+              return Ask::Result.error(message: "File too large (#{size} bytes)")
+            end
+
+            new_content = apply_chunks(raw, entry[:chunks])
+            operations.write_file(path, new_content)
+            results << { action: "update", path: entry[:path] }
+
+          when :delete
+            unless operations.file_exist?(path)
+              return Ask::Result.error(message: "File does not exist: #{path}")
+            end
+            operations.delete_file(path)
+            results << { action: "delete", path: entry[:path] }
+          end
+        end
+
+        summary = results.map { |r| "#{r[:action].upcase_first} #{r[:path]}" }.join("\n")
+        Ask::Result.ok(data: { summary: summary, results: results }, metadata: { results: results })
+      end
+
+      private
+
+      PATCH_START = "*** Begin Patch"
+      PATCH_END = "*** End Patch"
+      ADD_HEADER = /^\*\*\* Add File:\s+(.+)/i
+      UPDATE_HEADER = /^\*\*\* Update File:\s+(.+)/i
+      DELETE_HEADER = /^\*\*\* Delete File:\s+(.+)/i
+      HUNK_HEADER = /^@@/
+
+      def parse_patch(text)
+        text = text.dup.force_encoding("UTF-8")
+        start_idx = text.index(PATCH_START)
+        return [] unless start_idx
+
+        after_start = text[(start_idx + PATCH_START.length)..]
+        end_idx = after_start.index(PATCH_END)
+        body = end_idx ? after_start[0...end_idx] : after_start
+
+        entries = []
+        lines = body.split("\n")
+        i = 0
+        while i < lines.length
+          line = lines[i]
+
+          if (m = line.match(ADD_HEADER))
+            path = m[1].strip
+            i += 1
+            content_lines = []
+            while i < lines.length && !lines[i].start_with?("***")
+              content_lines << lines[i].sub(/^\+/, "") if lines[i].start_with?("+")
+              i += 1
+            end
+            entries << { type: :add, path: path, lines: content_lines }
+
+          elsif (m = line.match(UPDATE_HEADER))
+            path = m[1].strip
+            i += 1
+            chunks = []
+            while i < lines.length && !lines[i].start_with?("***")
+              if lines[i].match?(HUNK_HEADER)
+                i += 1
+                old_lines = []
+                new_lines = []
+                while i < lines.length && !lines[i].start_with?("***") && !lines[i].match?(HUNK_HEADER) && !lines[i].start_with?("***")
+                  if lines[i].start_with?("-")
+                    old_lines << lines[i][1..]
+                  elsif lines[i].start_with?("+")
+                    new_lines << lines[i][1..]
+                  elsif lines[i].start_with?(" ")
+                    old_lines << lines[i][1..]
+                    new_lines << lines[i][1..]
+                  end
+                  i += 1
+                end
+                chunks << { old: old_lines, new: new_lines } unless old_lines.empty? && new_lines.empty?
+              else
+                i += 1
+              end
+            end
+            entries << { type: :update, path: path, chunks: chunks }
+
+          elsif (m = line.match(DELETE_HEADER))
+            entries << { type: :delete, path: m[1].strip }
+            i += 1
+
+          else
+            i += 1
+          end
+        end
+
+        entries
+      end
+
+      def apply_chunks(content, chunks)
+        return content if chunks.empty?
+
+        lines = content.split("\n", -1)
+        chunks.each do |chunk|
+          old_text = chunk[:old].join("\n")
+          new_text = chunk[:new].join("\n")
+          file_text = lines.join("\n")
+          idx = file_text.index(old_text)
+          next unless idx
+
+          before = file_text[0...idx]
+          after = file_text[(idx + old_text.length)..]
+          file_text = before + new_text + after
+          lines = file_text.split("\n", -1)
+        end
+        lines.join("\n")
+      end
+    end
+  end
+end

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

@@ -2,11 +2,66 @@
 
 module Ask
   module Tools
-    # Edit a file by replacing exact text.
-    # Uses exact string matching — provide enough surrounding context for uniqueness.
+    module Shell
+      # Pluggable operations for the Edit tool.
+      module EditOperations
+        def read_file(path)
+          File.read(path)
+        end
+
+        def write_file(path, content)
+          File.write(path, content)
+        end
+
+        def file_exist?(path)
+          File.exist?(path)
+        end
+
+        def file?(path)
+          File.file?(path)
+        end
+
+        def file_size(path)
+          File.size(path)
+        end
+
+        def expand_path(path)
+          File.expand_path(path)
+        end
+      end
+
+      class DefaultEditOperations
+        include EditOperations
+      end
+
+      # Strip UTF-8 BOM from content. Returns { bom: String, text: String }.
+      def self.strip_bom(content)
+        bom = content.byteslice(0, 3) == "\xEF\xBB\xBF" ? content.byteslice(0, 3) : ""
+        [bom, bom.empty? ? content : content.byteslice(3..)]
+      end
+
+      # Detect the dominant line ending in content.
+      def self.detect_line_ending(content)
+        crlf = content.scan("\r\n").size
+        lf = content.count("\n") - crlf
+        crlf > lf ? "\r\n" : "\n"
+      end
+
+      # Normalize line endings to LF.
+      def self.normalize_line_endings(content)
+        content.gsub("\r\n", "\n").gsub("\r", "\n")
+      end
+
+      # Restore original line endings after normalization.
+      def self.restore_line_endings(content, original_ending)
+        return content if original_ending == "\n"
+        content.gsub("\n", original_ending)
+      end
+    end
+
+    # Edit a file by replacing exact text. Supports BOM, line-ending preservation.
     class Edit < Ask::Tool
-      description "Edit a file by replacing exact text. " \
-                   "Uses exact string matching — provide enough surrounding context for uniqueness."
+      description "Edit a file by replacing exact text."
 
       param :path, type: :string, desc: "Absolute path to the file", required: true
       param :old_string, type: :string, desc: "Exact text to replace", required: true
@@ -15,24 +70,34 @@ module Ask
 
       MAX_FILE_SIZE = 1_000_000
 
+      attr_writer :operations
+
+      def operations
+        @operations ||= Shell::DefaultEditOperations.new
+      end
+
       def execute(path:, old_string:, new_string:, replace_all: false)
-        path = File.expand_path(path)
+        path = operations.expand_path(path)
 
-        unless File.exist?(path)
-          return Ask::Result.error(message: "File does not exist: #{path}")
+        unless operations.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}")
+        unless operations.file?(path)
+          return Ask::Result.error(message: "Not a file: " + path)
         end
 
-        if File.size(path) > MAX_FILE_SIZE
+        size = operations.file_size(path)
+        if size > MAX_FILE_SIZE
           return Ask::Result.error(
-            message: "File too large (#{File.size(path)} bytes). Maximum is #{MAX_FILE_SIZE} bytes."
+            message: "File too large (#{size} bytes). Maximum is #{MAX_FILE_SIZE} bytes."
           )
         end
 
-        content = File.read(path)
+        raw = operations.read_file(path)
+        bom, content = Shell.strip_bom(raw)
+        original_ending = Shell.detect_line_ending(content)
+        content = Shell.normalize_line_endings(content)
 
         if replace_all
           count = content.scan(old_string).size
@@ -45,7 +110,11 @@ module Ask
           content = content.sub(old_string, new_string)
         end
 
-        File.write(path, content)
+        # Restore line endings and re-add BOM
+        content = Shell.restore_line_endings(content, original_ending)
+        content = bom + content
+
+        operations.write_file(path, content)
         Ask::Result.ok(data: { path: path, replacements: count },
                         metadata: { path: path, replacements: count })
       end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Ask
+  module Tools
+    module Shell
+      # Queues file mutations and applies them atomically.
+      # Rollback on any failure — no partial writes.
+      #
+      #   queue = FileMutationQueue.new
+      #   queue.stage("path/to/file.rb", ->(content) {
+      #     content.gsub("old", "new")
+      #   })
+      #   queue.apply!  # reads all staged files, applies transforms, writes back
+      #
+      class FileMutationQueue
+        class ApplyError < StandardError; end
+
+        def initialize(operations: nil)
+          @staged = []
+          @operations = operations || DefaultEditOperations.new
+        end
+
+        # Stage a mutation for a file.
+        # @param path [String] absolute path to the file
+        # @yield [content] raw file content, returns modified content
+        # @yieldparam content [String] the original file content
+        # @yieldreturn [String] the modified content
+        def stage(path, &block)
+          @staged << { path: File.expand_path(path), block: block }
+        end
+
+        # Apply all staged mutations atomically.
+        # Reads all files, applies transforms, then writes all back.
+        # If any write fails, all written files are rolled back to original.
+        # @return [Array<Hash>] results with :path, :original_size, :new_size, :success
+        # @raise [ApplyError] if any mutation fails (after rollback)
+        def apply!
+          snapshots = []
+
+          # Phase 1: read all files and apply transforms
+          @staged.each do |entry|
+            path = entry[:path]
+            original = @operations.read_file(path)
+            modified = entry[:block].call(original)
+            snapshots << { path: path, original: original, modified: modified }
+          end
+
+          # Phase 2: write all files, track rollback info
+          written = []
+          begin
+            snapshots.each do |s|
+              @operations.write_file(s[:path], s[:modified])
+              written << s[:path]
+            end
+          rescue => e
+            # Rollback: restore originals for files we already wrote
+            written.each do |path|
+              snapshot = snapshots.find { |s| s[:path] == path }
+              @operations.write_file(path, snapshot[:original]) if snapshot
+            rescue => rb_e
+              $stderr.puts "[FileMutationQueue] Rollback failed for #{path}: #{rb_e.message}"
+            end
+            raise ApplyError, "Mutation failed at #{e.class}: #{e.message}. Rolled back #{written.size} files."
+          end
+
+          snapshots.map do |s|
+            { path: s[:path], original_size: s[:original].length,
+              new_size: s[:modified].length, success: true }
+          end
+        end
+
+        # Clear all staged mutations without applying.
+        def clear!
+          @staged.clear
+        end
+
+        # Number of staged mutations.
+        def size
+          @staged.size
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Ask
   module Tools
     module Shell
-      VERSION = "0.2.2"
+      VERSION = "0.3.1"
     end
   end
 end

data/lib/ask/tools/shell.rb

@@ -9,11 +9,16 @@ require_relative "shell/edit"
 require_relative "shell/glob"
 require_relative "shell/grep"
 require_relative "shell/code"
+require_relative "shell/apply_patch"
 
 module Ask
   module Tools
     module Shell
-      TOOLS = [Bash, Read, Write, Edit, Glob, Grep, Code].freeze
+      TOOLS = [Bash, Read, Write, Edit, Glob, Grep, Code, ApplyPatch].freeze
+
+      def self.all
+        TOOLS.map(&:new)
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-tools-shell
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.1
 platform: ruby
 authors:
 - Kaka Ruto
@@ -13,28 +13,28 @@ dependencies:
   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: ask-sandbox-providers
   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
@@ -86,14 +86,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - lib/ask-tools-shell.rb
 - lib/ask/skills/shell.patterns/SKILL.md
 - lib/ask/tools/shell.rb
+- lib/ask/tools/shell/apply_patch.rb
 - lib/ask/tools/shell/bash.rb
 - lib/ask/tools/shell/code.rb
 - lib/ask/tools/shell/edit.rb
+- lib/ask/tools/shell/file_mutation_queue.rb
 - lib/ask/tools/shell/glob.rb
 - lib/ask/tools/shell/grep.rb
 - lib/ask/tools/shell/read.rb
@@ -102,7 +105,10 @@ files:
 homepage: https://github.com/ask-rb/ask-tools-shell
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/ask-rb/ask-tools-shell
+  source_code_uri: https://github.com/ask-rb/ask-tools-shell
+  changelog_uri: https://github.com/ask-rb/ask-tools-shell/blob/master/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib