fantasy-cli 1.2.6

data/lib/gsd/tools/ask_user_question.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+
+module Gsd
+  module Tools
+    # AskUserQuestionTool - Faz perguntas ao usuário e aguarda resposta
+    #
+    # Uso:
+    #   tool = AskUserQuestionTool.new(cwd: '/path')
+    #   result = tool.execute(question: 'Qual arquivo editar?', options: ['a.rb', 'b.rb'])
+    class AskUserQuestionTool < Base
+      class << self
+        tool_name('ask_user_question')
+        tool_description('Ask the user a question and wait for their response')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            question: {
+              type: 'string',
+              description: 'The question to ask the user'
+            },
+            options: {
+              type: 'array',
+              description: 'Optional list of options for the user to choose from',
+              items: {
+                type: 'string'
+              }
+            },
+            allow_multiple: {
+              type: 'boolean',
+              description: 'Allow multiple selections (default: false)',
+              default: false
+            },
+            default: {
+              type: 'string',
+              description: 'Default value if user presses Enter'
+            },
+            timeout: {
+              type: 'integer',
+              description: 'Timeout in seconds (default: 300, 0 for no timeout)',
+              default: 300
+            }
+          },
+          required: ['question']
+        })
+      end
+
+      # Faz pergunta ao usuário
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Resposta do usuário
+      def execute(args)
+        question = args[:question] || args['question']
+        options = args[:options] || args['options']
+        allow_multiple = args[:allow_multiple] || args['allow_multiple'] || false
+        default = args[:default] || args['default']
+        timeout = args[:timeout] || args['timeout'] || 300
+
+        raise ArgumentError, 'Question is required' unless question
+
+        log_debug("Asking: #{question}")
+        log_debug("Options: #{options.inspect}") if options
+
+        # Exibe pergunta
+        puts "\n" + "=" * 60
+        puts "❓ #{question}"
+        puts "=" * 60
+
+        # Exibe opções se existirem
+        if options && options.any?
+          options.each_with_index do |opt, i|
+            puts "  [#{i + 1}] #{opt}"
+          end
+
+          if allow_multiple
+            puts "\nDigite os números separados por vírgula (ex: 1,3,5)"
+          else
+            puts "\nDigite o número da opção desejada"
+          end
+
+          puts "Ou pressione Enter para usar o default#{default ? " (#{default})" : ''}"
+        else
+          puts "\nDigite sua resposta:"
+        end
+
+        # Lê resposta com timeout
+        answer = read_input_with_timeout(timeout)
+
+        # Processa resposta
+        result = process_answer(answer, options, allow_multiple, default)
+
+        puts "\n✅ Resposta registrada: #{result[:answer]}"
+        puts "=" * 60 + "\n"
+
+        result
+      end
+
+      # Verifica se é safe
+      #
+      # @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
+
+      # Lê input com timeout
+      #
+      # @param timeout [Integer] Timeout em segundos
+      # @return [String] Input do usuário
+      def read_input_with_timeout(timeout)
+        require 'io/select'
+
+        if timeout > 0
+          # Usa IO.select para timeout
+          if IO.select([$stdin], nil, nil, timeout)
+            $stdin.gets&.chomp
+          else
+            puts "\n⏰ Timeout atingido!"
+            ''
+          end
+        else
+          # Sem timeout
+          $stdin.gets&.chomp
+        end
+      end
+
+      # Processa resposta do usuário
+      #
+      # @param answer [String] Resposta do usuário
+      # @param options [Array] Opções disponíveis
+      # @param allow_multiple [Boolean] Permite múltiplas
+      # @param default [String] Valor default
+      # @return [Hash] Resposta processada
+      def process_answer(answer, options, allow_multiple, default)
+        # Usa default se resposta vazia
+        if answer.nil? || answer.strip.empty?
+          return {
+            answer: default,
+            selected_options: default ? [default] : [],
+            indices: []
+          }
+        end
+
+        # Se há opções, converte índices
+        if options && options.any?
+          indices = answer.split(',').map(&:strip).map(&:to_i)
+          selected = indices.map { |i| options[i - 1] }.compact
+
+          return {
+            answer: allow_multiple ? selected.join(', ') : selected.first,
+            selected_options: selected,
+            indices: indices
+          }
+        end
+
+        # Resposta livre
+        {
+          answer: answer,
+          selected_options: [answer],
+          indices: []
+        }
+      end
+    end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('ask_user_question', Gsd::Tools::AskUserQuestionTool, category: :user)

data/lib/gsd/tools/base.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Gsd
+  module Tools
+    # Base Tool Class - Classe base para todas as tools
+    #
+    # Todas as tools devem herdar desta classe e implementar:
+    # - name (nome da tool)
+    # - description (descrição)
+    # - input_schema (schema JSON dos inputs)
+    # - execute (execução da tool)
+    class Base
+      class << self
+        attr_accessor :name, :description, :input_schema
+
+        # Define o nome da tool
+        #
+        # @param name [String] Nome da tool
+        # @return [void]
+        def tool_name(name)
+          @name = name
+        end
+
+        # Define a descrição da tool
+        #
+        # @param desc [String] Descrição
+        # @return [void]
+        def tool_description(desc)
+          @description = desc
+        end
+
+        # Define o schema de input da tool
+        #
+        # @param schema [Hash] Schema JSON
+        # @return [void]
+        def tool_input_schema(schema)
+          @input_schema = schema
+        end
+
+        # Verifica se a tool é segura para execução automática
+        #
+        # @param args [Hash] Argumentos
+        # @return [Boolean] true se segura
+        def safe?(args = {})
+          false
+        end
+
+        # Verifica se a tool é read-only
+        #
+        # @param args [Hash] Argumentos
+        # @return [Boolean] true se read-only
+        def read_only?(args = {})
+          false
+        end
+
+        # Verifica se a tool é destrutiva
+        #
+        # @param args [Hash] Argumentos
+        # @return [Boolean] true se destrutiva
+        def destructive?(args = {})
+          false
+        end
+      end
+
+      # Inicializa a tool
+      #
+      # @param cwd [String] Diretório de trabalho
+      # @param debug [Boolean] Habilitar debug
+      def initialize(cwd: Dir.pwd, debug: false)
+        @cwd = cwd
+        @debug = debug
+      end
+
+      # Executa a tool
+      #
+      # @param args [Hash] Argumentos da tool
+      # @return [Object] Resultado da execução
+      def execute(args)
+        raise NotImplementedError, 'Subclasses must implement #execute'
+      end
+
+      # Valida os argumentos da tool
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true se válido
+      def validate(args)
+        return true unless self.class.input_schema
+
+        # Validação básica
+        required = self.class.input_schema['required'] || []
+        properties = self.class.input_schema['properties'] || {}
+
+        required.each do |field|
+          return false unless args.key?(field.to_sym) || args.key?(field.to_s)
+        end
+
+        true
+      end
+
+      # Log de debug
+      #
+      # @param message [String] Mensagem de log
+      # @return [void]
+      def log_debug(message)
+        return unless @debug
+
+        puts "[#{self.class.name}] #{message}"
+      end
+
+      # Executa comando shell com segurança
+      #
+      # @param command [String] Comando
+      # @param timeout [Integer] Timeout em segundos
+      # @return [Hash] Resultado (stdout, stderr, status)
+      def run_shell_command(command, timeout: 30)
+        require 'open3'
+
+        log_debug("Running: #{command}")
+
+        stdout, stderr, status = Open3.capture3(command, chdir: @cwd)
+
+        {
+          stdout: stdout,
+          stderr: stderr,
+          status: status.exitstatus,
+          success: status.success?
+        }
+      rescue => e
+        log_debug("Error: #{e.message}")
+        {
+          stdout: '',
+          stderr: e.message,
+          status: -1,
+          success: false
+        }
+      end
+
+      # Lê arquivo com limite de tamanho
+      #
+      # @param path [String] Caminho do arquivo
+      # @param max_size [Integer] Tamanho máximo em bytes
+      # @return [String] Conteúdo do arquivo
+      def read_file(path, max_size: 1_000_000)
+        full_path = File.expand_path(path, @cwd)
+
+        raise "File not found: #{path}" unless File.exist?(full_path)
+
+        size = File.size(full_path)
+        raise "File too large: #{size} bytes (max: #{max_size})" if size > max_size
+
+        File.read(full_path)
+      end
+
+      # Escreve arquivo com backup
+      #
+      # @param path [String] Caminho do arquivo
+      # @param content [String] Conteúdo
+      # @param create_backup [Boolean] Criar backup
+      # @return [void]
+      def write_file(path, content, create_backup: true)
+        full_path = File.expand_path(path, @cwd)
+
+        # Cria diretórios se necessário
+        FileUtils.mkdir_p(File.dirname(full_path))
+
+        # Backup se arquivo existe
+        if File.exist?(full_path) && create_backup
+          backup_path = "#{full_path}.bak.#{Time.now.to_i}"
+          File.rename(full_path, backup_path)
+          log_debug("Backup created: #{backup_path}")
+        end
+
+        File.write(full_path, content)
+        log_debug("File written: #{full_path}")
+      end
+
+      # Verifica se path existe
+      #
+      # @param path [String] Caminho
+      # @return [Boolean] true se existe
+      def path_exists?(path)
+        full_path = File.expand_path(path, @cwd)
+        File.exist?(full_path)
+      end
+
+      # Normaliza path (previne directory traversal)
+      #
+      # @param path [String] Caminho
+      # @return [String] Path normalizado
+      def normalize_path(path)
+        full_path = File.expand_path(path, @cwd)
+
+        # Verifica se está dentro do cwd
+        unless full_path.start_with?(File.expand_path(@cwd))
+          raise "Path outside working directory: #{path}"
+        end
+
+        full_path
+      end
+    end
+  end
+end

data/lib/gsd/tools/bash.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+require 'open3'
+
+module Gsd
+  module Tools
+    # BashTool - Executa comandos shell
+    #
+    # Uso:
+    #   tool = BashTool.new(cwd: '/path')
+    #   result = tool.execute(command: 'ls -la')
+    class BashTool < Base
+      class << self
+        tool_name('bash')
+        tool_description('Execute shell commands with output streaming')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            command: {
+              type: 'string',
+              description: 'The shell command to execute'
+            },
+            timeout: {
+              type: 'integer',
+              description: 'Timeout in seconds (default: 30)',
+              default: 30
+            },
+            stream: {
+              type: 'boolean',
+              description: 'Stream output in real-time (default: false)',
+              default: false
+            }
+          },
+          required: ['command']
+        })
+      end
+
+      # Comandos bloqueados por segurança
+      BLOCKED_COMMANDS = [
+        'rm -rf /',
+        'mkfs',
+        'dd if=/dev/zero',
+        ':(){:|:&};:',
+        'chmod -R 000',
+        'chown -R'
+      ].freeze
+
+      # Comandos permitidos sem confirmação
+      SAFE_COMMANDS = [
+        'ls', 'dir', 'pwd', 'echo', 'cat', 'head', 'tail',
+        'grep', 'find', 'which', 'whoami', 'date', 'git',
+        'npm', 'yarn', 'bundle', 'gem', 'go', 'cargo',
+        'ruby', 'python', 'node', 'make'
+      ].freeze
+
+      # Executa comando bash
+      #
+      # @param args [Hash] Argumentos
+      # @return [Hash] Resultado da execução
+      def execute(args)
+        command = args[:command] || args['command']
+        timeout = args[:timeout] || args['timeout'] || 30
+        stream = args[:stream] || args['stream'] || false
+
+        raise ArgumentError, 'Command is required' unless command
+
+        # Validações de segurança
+        validate_command(command)
+
+        log_debug("Executing: #{command}")
+        log_debug("Timeout: #{timeout}s, Stream: #{stream}")
+
+        if stream
+          execute_with_stream(command, timeout)
+        else
+          execute_sync(command, timeout)
+        end
+      end
+
+      # Verifica se comando é seguro
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true se seguro
+      def self.safe?(args)
+        command = args[:command] || args['command'] || ''
+        SAFE_COMMANDS.any? { |safe| command.start_with?(safe) }
+      end
+
+      # Verifica se é read-only
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true se read-only
+      def self.read_only?(args)
+        command = args[:command] || args['command'] || ''
+        # Comandos que não modificam arquivos
+        ['ls', 'dir', 'pwd', 'cat', 'head', 'tail', 'grep', 'find', 'which', 'whoami', 'date'].any? { |c| command.start_with?(c) }
+      end
+
+      # Verifica se é destrutivo
+      #
+      # @param args [Hash] Argumentos
+      # @return [Boolean] true se destrutivo
+      def self.destructive?(args)
+        command = args[:command] || args['command'] || ''
+        # Comandos que podem modificar/deletar
+        ['rm', 'mv', 'cp', 'chmod', 'chown', 'mkdir', 'touch'].any? { |c| command.start_with?(c) }
+      end
+
+      private
+
+      # Valida comando por segurança
+      #
+      # @param command [String] Comando
+      # @raise [SecurityError] Se comando for perigoso
+      def validate_command(command)
+        # Verifica comandos bloqueados
+        BLOCKED_COMMANDS.each do |blocked|
+          if command.include?(blocked)
+            raise SecurityError, "Command blocked for security: #{blocked}"
+          end
+        end
+
+        # Verifica se tenta acessar paths fora do cwd
+        if command.include?('..') && !command.start_with?('git')
+          log_debug("Warning: Command contains '..'")
+        end
+
+        # Verifica se é sudo
+        if command.start_with?('sudo')
+          raise SecurityError, 'Sudo commands are not allowed'
+        end
+      end
+
+      # Executa comando com sync
+      #
+      # @param command [String] Comando
+      # @param timeout [Integer] Timeout
+      # @return [Hash] Resultado
+      def execute_sync(command, timeout)
+        start_time = Time.now
+
+        stdout, stderr, status = Open3.capture3(command, chdir: @cwd)
+
+        elapsed = Time.now - start_time
+
+        {
+          stdout: stdout,
+          stderr: stderr,
+          status: status.exitstatus,
+          success: status.success?,
+          elapsed: elapsed.round(2),
+          command: command
+        }
+      rescue => e
+        log_debug("Error: #{e.message}")
+        {
+          stdout: '',
+          stderr: e.message,
+          status: -1,
+          success: false,
+          elapsed: 0,
+          command: command,
+          error: e.class.name
+        }
+      end
+
+      # Executa comando com streaming
+      #
+      # @param command [String] Comando
+      # @param timeout [Integer] Timeout
+      # @return [Hash] Resultado
+      def execute_with_stream(command, timeout)
+        start_time = Time.now
+        stdout_data = +''
+        stderr_data = +''
+
+        Open3.popen3(command, chdir: @cwd) do |stdin, stdout, stderr, wait_thr|
+          # Threads para ler stdout e stderr
+          out_thread = Thread.new do
+            while line = stdout.gets
+              stdout_data << line
+              print line # Streaming em tempo real
+            end
+          end
+
+          err_thread = Thread.new do
+            while line = stderr.gets
+              stderr_data << line
+              $stderr.print line # Streaming em tempo real
+            end
+          end
+
+          # Aguarda threads
+          out_thread.join(timeout)
+          err_thread.join(timeout)
+
+          # Aguarda processo
+          status = wait_thr.value(timeout)
+          elapsed = Time.now - start_time
+
+          puts # Nova linha após streaming
+
+          {
+            stdout: stdout_data,
+            stderr: stderr_data,
+            status: status.exitstatus,
+            success: status.success?,
+            elapsed: elapsed.round(2),
+            command: command
+          }
+        end
+      rescue Timeout::Error => e
+        log_debug("Timeout after #{timeout}s")
+        {
+          stdout: stdout_data,
+          stderr: stderr_data,
+          status: -1,
+          success: false,
+          elapsed: timeout,
+          command: command,
+          error: 'timeout',
+          message: "Command timed out after #{timeout}s"
+        }
+      rescue => e
+        log_debug("Error: #{e.message}")
+        {
+          stdout: stdout_data,
+          stderr: stderr_data,
+          status: -1,
+          success: false,
+          elapsed: 0,
+          command: command,
+          error: e.class.name,
+          message: e.message
+        }
+      end
+    end
+
+    # Erro de segurança
+    class SecurityError < StandardError; end
+  end
+end
+
+# Registra a tool
+Gsd::Tools::Registry.register('bash', Gsd::Tools::BashTool, category: :shell)