fantasy-cli 1.2.6

data/lib/gsd/tools/file_edit.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+require 'tempfile'
+
+module Gsd
+  module Tools
+    # FileEditTool - Edita arquivos com diff e backup
+    #
+    # Suporta:
+    # - Substituição de texto
+    # - Inserção em linha específica
+    # - Deleção de linhas
+    # - Geração de diff
+    #
+    # Uso:
+    #   tool = FileEditTool.new(cwd: '/path')
+    #   result = tool.execute(path: 'file.txt', operation: 'replace', ...)
+    class FileEditTool < Base
+      class << self
+        tool_name('file_edit')
+        tool_description('Edit files with diff generation and automatic backup')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            path: {
+              type: 'string',
+              description: 'Path to the file to edit (relative to cwd)'
+            },
+            operation: {
+              type: 'string',
+              description: 'Operation type: replace, insert, delete, append',
+              enum: ['replace', 'insert', 'delete', 'append']
+            },
+            search: {
+              type: 'string',
+              description: 'Text to search for (for replace/delete operations)'
+            },
+            replace: {
+              type: 'string',
+              description: 'Replacement text (for replace operation)'
+            },
+            line_number: {
+              type: 'integer',
+              description: 'Line number for insert/delete operations (1-based)'
+            },
+            content: {
+              type: 'string',
+              description: 'Content to insert/append'
+            },
+            create_backup: {
+              type: 'boolean',
+              description: 'Create backup before editing (default: true)',
+              default: true
+            }
+          },
+          required: ['path', 'operation']
+        })
+      end
+
+      # Executa edição no arquivo
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Resultado com diff e metadados
+      def execute(args)
+        path = args[:path] || args['path']
+        operation = args[:operation] || args['operation']
+        create_backup = args[:create_backup] || args['create_backup'] || true
+
+        raise ArgumentError, 'Path is required' unless path
+        raise ArgumentError, 'Operation is required' unless operation
+
+        log_debug("Editing: #{path}, Operation: #{operation}")
+
+        # Normaliza path
+        full_path = normalize_path(path)
+
+        # Verifica se arquivo existe
+        unless File.exist?(full_path)
+          return {
+            success: false,
+            error: 'file_not_found',
+            message: "File not found: #{path}"
+          }
+        end
+
+        # Lê conteúdo original
+        original_content = File.read(full_path)
+        original_lines = original_content.lines
+
+        # Executa operação
+        new_content = case operation
+                      when 'replace'
+                        do_replace(original_content, args)
+                      when 'insert'
+                        do_insert(original_lines, args)
+                      when 'delete'
+                        do_delete(original_lines, args)
+                      when 'append'
+                        do_append(original_content, args)
+                      else
+                        raise ArgumentError, "Unknown operation: #{operation}"
+                      end
+
+        # Gera diff
+        diff = generate_diff(original_content, new_content, path)
+
+        # Backup se necessário
+        backup_path = nil
+        if create_backup
+          backup_path = create_backup_file(full_path)
+        end
+
+        # Escreve novo conteúdo
+        File.write(full_path, new_content)
+
+        log_debug("File edited: #{full_path}")
+
+        {
+          success: true,
+          path: path,
+          full_path: full_path,
+          operation: operation,
+          backup: backup_path,
+          diff: diff,
+          original_lines: original_lines.count,
+          new_lines: new_content.lines.count,
+          changes: count_changes(original_content, new_content)
+        }
+      end
+
+      # Verifica se é safe
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] false
+      def self.safe?(args)
+        false
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] false
+      def self.read_only?(args)
+        false
+      end
+
+      # Verifica se é destrutivo
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true
+      def self.destructive?(args)
+        true
+      end
+
+      private
+
+      # Operação de replace
+      #
+      # @param content [String] Conteúdo original
+      # @param args [Hash] Argumentos
+      # @return [String] Novo conteúdo
+      def do_replace(content, args)
+        search = args[:search] || args['search']
+        replace = args[:replace] || args['replace'] || ''
+
+        raise ArgumentError, 'Search text is required for replace operation' unless search
+
+        content.gsub(search, replace)
+      end
+
+      # Operação de insert
+      #
+      # @param lines [Array] Linhas originais
+      # @param args [Hash] Argumentos
+      # @return [String] Novo conteúdo
+      def do_insert(lines, args)
+        line_number = args[:line_number] || args['line_number']
+        content = args[:content] || args['content']
+
+        raise ArgumentError, 'Line number is required for insert operation' unless line_number
+        raise ArgumentError, 'Content is required for insert operation' unless content
+
+        # Converte para 0-based
+        idx = line_number - 1
+        idx = [0, idx].max
+        idx = [lines.count, idx].min
+
+        lines.insert(idx, content + "\n")
+        lines.join
+      end
+
+      # Operação de delete
+      #
+      # @param lines [Array] Linhas originais
+      # @param args [Hash] Argumentos
+      # @return [String] Novo conteúdo
+      def do_delete(lines, args)
+        line_number = args[:line_number] || args['line_number']
+        search = args[:search] || args['search']
+
+        if line_number
+          # Deleta linha específica
+          idx = line_number - 1
+          lines.delete_at(idx)
+        elsif search
+          # Deleta linhas que contêm search
+          lines.reject! { |line| line.include?(search) }
+        else
+          raise ArgumentError, 'Line number or search text is required for delete operation'
+        end
+
+        lines.join
+      end
+
+      # Operação de append
+      #
+      # @param content [String] Conteúdo original
+      # @param args [Hash] Argumentos
+      # @return [String] Novo conteúdo
+      def do_append(content, args)
+        append_content = args[:content] || args['content'] || ''
+
+        content + "\n" + append_content + "\n"
+      end
+
+      # Gera diff unificado
+      #
+      # @param original [String] Conteúdo original
+      # @param modified [String] Conteúdo modificado
+      # @param path [String] Caminho do arquivo
+      # @return [String] Diff formatado
+      def generate_diff(original, modified, path)
+        # Cria arquivos temporários
+        original_file = Tempfile.new('original')
+        modified_file = Tempfile.new('modified')
+
+        begin
+          original_file.write(original)
+          original_file.close
+
+          modified_file.write(modified)
+          modified_file.close
+
+          # Gera diff
+          diff_result = `diff -u #{original_file.path} #{modified_file.path} 2>&1`
+
+          # Formata diff
+          diff_result.gsub(original_file.path, 'a/' + path)
+                     .gsub(modified_file.path, 'b/' + path)
+        ensure
+          original_file.unlink
+          modified_file.unlink
+        end
+      end
+
+      # Conta mudanças
+      #
+      # @param original [String] Conteúdo original
+      # @param modified [String] Conteúdo modificado
+      # @return [Hash] Contagem de mudanças
+      def count_changes(original, modified)
+        original_lines = original.lines.to_a
+        modified_lines = modified.lines.to_a
+
+        added = (modified_lines - original_lines).count
+        removed = (original_lines - modified_lines).count
+
+        {
+          added: added,
+          removed: removed,
+          total: added + removed
+        }
+      end
+
+      # Cria arquivo de backup
+      #
+      # @param path [String] Caminho do arquivo
+      # @return [String] Caminho do backup
+      def create_backup_file(path)
+        timestamp = Time.now.to_i
+        backup_path = "#{path}.bak.#{timestamp}"
+
+        # Se backup já existe, usa timestamp com nanos
+        if File.exist?(backup_path)
+          backup_path = "#{path}.bak.#{Time.now.to_f}"
+        end
+
+        File.rename(path, backup_path)
+        backup_path
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('file_edit', Gsd::Tools::FileEditTool, category: :files)

data/lib/gsd/tools/file_read.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+
+module Gsd
+  module Tools
+    # FileReadTool - Lê arquivos com limites de segurança
+    #
+    # Uso:
+    #   tool = FileReadTool.new(cwd: '/path')
+    #   result = tool.execute(path: 'file.txt')
+    class FileReadTool < Base
+      class << self
+        tool_name('file_read')
+        tool_description('Read file contents with size limits and encoding detection')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            path: {
+              type: 'string',
+              description: 'Path to the file to read (relative to cwd)'
+            },
+            max_size: {
+              type: 'integer',
+              description: 'Maximum file size in bytes (default: 1MB)',
+              default: 1_000_000
+            },
+            encoding: {
+              type: 'string',
+              description: 'File encoding (default: utf-8)',
+              default: 'utf-8'
+            },
+            line_start: {
+              type: 'integer',
+              description: 'Start reading from this line (0-based, default: 0)'
+            },
+            line_count: {
+              type: 'integer',
+              description: 'Number of lines to read (default: all)'
+            }
+          },
+          required: ['path']
+        })
+      end
+
+      # Lê arquivo
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Conteúdo e metadados
+      def execute(args)
+        path = args[:path] || args['path']
+        max_size = args[:max_size] || args['max_size'] || 1_000_000
+        encoding = args[:encoding] || args['encoding'] || 'utf-8'
+        line_start = args[:line_start] || args['line_start']
+        line_count = args[:line_count] || args['line_count']
+
+        raise ArgumentError, 'Path is required' unless path
+
+        log_debug("Reading: #{path}")
+        log_debug("Max size: #{max_size}, Encoding: #{encoding}")
+
+        # Normaliza path (segurança)
+        full_path = normalize_path(path)
+
+        # Verifica se arquivo existe
+        unless File.exist?(full_path)
+          return {
+            success: false,
+            error: 'file_not_found',
+            message: "File not found: #{path}",
+            path: path
+          }
+        end
+
+        # Verifica se é arquivo (não diretório)
+        unless File.file?(full_path)
+          return {
+            success: false,
+            error: 'not_a_file',
+            message: "Not a file: #{path}",
+            path: path
+          }
+        end
+
+        # Lê metadados
+        file_size = File.size(full_path)
+        file_mtime = File.mtime(full_path)
+
+        log_debug("File size: #{file_size} bytes")
+
+        # Verifica tamanho
+        if file_size > max_size
+          return {
+            success: false,
+            error: 'file_too_large',
+            message: "File too large: #{file_size} bytes (max: #{max_size})",
+            path: path,
+            size: file_size,
+            max_size: max_size
+          }
+        end
+
+        # Detecta encoding se não especificado
+        if encoding == 'auto' || encoding.nil?
+          encoding = detect_encoding(full_path)
+        end
+
+        # Lê conteúdo
+        content = if line_start || line_count
+                    read_lines(full_path, encoding, line_start, line_count)
+                  else
+                    read_file(full_path, encoding)
+                  end
+
+        {
+          success: true,
+          content: content,
+          path: path,
+          full_path: full_path,
+          size: file_size,
+          encoding: encoding,
+          lines: content.lines.count,
+          mtime: file_mtime.iso8601
+        }
+      end
+
+      # Verifica se é safe (sempre safe para leitura)
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true
+      def self.safe?(args)
+        true
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true
+      def self.read_only?(args)
+        true
+      end
+
+      private
+
+      # Detecta encoding do arquivo
+      #
+      # @param path [String] Caminho do arquivo
+      # @return [String] Encoding detectado
+      def detect_encoding(path)
+        # Tenta UTF-8 primeiro
+        content = File.read(path)
+        content.valid_encoding? ? 'utf-8' : 'binary'
+      rescue
+        'utf-8'
+      end
+
+      # Lê arquivo completo
+      #
+      # @param path [String] Caminho
+      # @param encoding [String] Encoding
+      # @return [String] Conteúdo
+      def read_file(path, encoding)
+        File.read(path, encoding: encoding)
+      rescue Encoding::UndefinedConversionError => e
+        log_debug("Encoding error: #{e.message}")
+        # Fallback para binary
+        File.read(path, encoding: 'binary')
+      end
+
+      # Lê linhas específicas
+      #
+      # @param path [String] Caminho
+      # @param encoding [String] Encoding
+      # @param line_start [Integer] Linha inicial
+      # @param line_count [Integer] Número de linhas
+      # @return [String] Conteúdo
+      def read_lines(path, encoding, line_start, line_count)
+        lines = File.readlines(path, encoding: encoding)
+
+        start_idx = line_start || 0
+        count = line_count || lines.length
+
+        selected = lines[start_idx, count] || []
+        selected.join
+      rescue Encoding::UndefinedConversionError => e
+        log_debug("Encoding error: #{e.message}")
+        # Fallback para binary
+        lines = File.readlines(path, encoding: 'binary')
+        start_idx = line_start || 0
+        count = line_count || lines.length
+        selected = lines[start_idx, count] || []
+        selected.join
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('file_read', Gsd::Tools::FileReadTool, category: :files)

data/lib/gsd/tools/file_write.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+require 'fileutils'
+
+module Gsd
+  module Tools
+    # FileWriteTool - Escreve arquivos com backup automático
+    #
+    # Uso:
+    #   tool = FileWriteTool.new(cwd: '/path')
+    #   result = tool.execute(path: 'file.txt', content: 'content')
+    class FileWriteTool < Base
+      class << self
+        tool_name('file_write')
+        tool_description('Write content to files with automatic backup')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            path: {
+              type: 'string',
+              description: 'Path to the file to write (relative to cwd)'
+            },
+            content: {
+              type: 'string',
+              description: 'Content to write to the file'
+            },
+            append: {
+              type: 'boolean',
+              description: 'Append to file instead of overwrite (default: false)',
+              default: false
+            },
+            create_backup: {
+              type: 'boolean',
+              description: 'Create backup of existing file (default: true)',
+              default: true
+            },
+            encoding: {
+              type: 'string',
+              description: 'File encoding (default: utf-8)',
+              default: 'utf-8'
+            }
+          },
+          required: ['path', 'content']
+        })
+      end
+
+      # Escreve arquivo
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Resultado da escrita
+      def execute(args)
+        path = args[:path] || args['path']
+        content = args[:content] || args['content']
+        append = args[:append] || args['append'] || false
+        create_backup = args[:create_backup] || args['create_backup'] || true
+        encoding = args[:encoding] || args['encoding'] || 'utf-8'
+
+        raise ArgumentError, 'Path is required' unless path
+        raise ArgumentError, 'Content is required' unless content
+
+        log_debug("Writing: #{path}")
+        log_debug("Append: #{append}, Backup: #{create_backup}, Encoding: #{encoding}")
+
+        # Normaliza path (segurança)
+        full_path = normalize_path(path)
+
+        # Cria diretórios se necessário
+        FileUtils.mkdir_p(File.dirname(full_path))
+
+        # Backup se arquivo existe e create_backup é true
+        backup_path = nil
+        if File.exist?(full_path) && create_backup
+          backup_path = create_backup_file(full_path)
+          log_debug("Backup created: #{backup_path}")
+        end
+
+        # Escreve conteúdo
+        if append
+          File.open(full_path, 'a', encoding: encoding) do |f|
+            f.write(content)
+          end
+          log_debug("Content appended to: #{full_path}")
+        else
+          File.write(full_path, content, encoding: encoding)
+          log_debug("File written: #{full_path}")
+        end
+
+        # Retorna metadados
+        file_size = File.size(full_path)
+        file_mtime = File.mtime(full_path)
+
+        {
+          success: true,
+          path: path,
+          full_path: full_path,
+          size: file_size,
+          written_bytes: content.bytesize,
+          mode: append ? 'append' : 'overwrite',
+          backup: backup_path,
+          mtime: file_mtime.iso8601
+        }
+      end
+
+      # Verifica se é safe (não é safe para execução automática)
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] false
+      def self.safe?(args)
+        false
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] false (escreve no arquivo)
+      def self.read_only?(args)
+        false
+      end
+
+      # Verifica se é destrutivo
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true (pode sobrescrever arquivos)
+      def self.destructive?(args)
+        append = args[:append] || args['append'] || false
+        !append # É destrutivo se não for append
+      end
+
+      private
+
+      # Cria arquivo de backup
+      #
+      # @param path [String] Caminho do arquivo
+      # @return [String] Caminho do backup
+      def create_backup_file(path)
+        timestamp = Time.now.to_i
+        backup_path = "#{path}.bak.#{timestamp}"
+
+        # Se backup já existe, usa timestamp com nanos
+        if File.exist?(backup_path)
+          backup_path = "#{path}.bak.#{Time.now.to_f}"
+        end
+
+        File.rename(path, backup_path)
+        backup_path
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('file_write', Gsd::Tools::FileWriteTool, category: :files)