bddgenx 2.3.2 → 2.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e698593de325dd2b637d34cfe839977790826ba2c889a67e97e517aac5aac5b
-  data.tar.gz: 7b3e501dbb053795b7246f9463131412d69515f2b58e241eaf04c53376894b22
+  metadata.gz: 4cfed14eace60df849622da45beb5a391ef24a8f2cec73191e86d993183f47e1
+  data.tar.gz: ee6cae8cc16805c90028f461edc51e0327471d7bcbb9869aec4119cf8adc945e
 SHA512:
-  metadata.gz: 0e6bf1eadd971b1e48f60b8ea786378d3d5cdd51a07167dca8054fc98b75c3ca30476075d6ba055cffc76e64d9c72106cf0cd253a3b86c1a39f240e4a6215440
-  data.tar.gz: '08865b4ca3c1b7745badbf319edec6d100b354914a29c04fecbc80526b16ff7c5e11c7fc023d06aed75a68f6318e0d43f5dbc866f1e9fa3013418eb5c3afeae6'
+  metadata.gz: 6e0c7e03df28a0bec6a70a0324843ca774b2f1f9b2523b21ded4106ae85436478215462c9037c5efcee12802d26afc1f400eea693a9bdc8c1bf7ded9d3b2a66d
+  data.tar.gz: 8fcbaebb88edd22bd3755650988797f4ffef3aac64e0d117cee6528ebf35d0db1e0b027a1242c4999b77421143eef993be0c1dcd16a4d52a39a7ecc1b4d978a2

data/README.md

@@ -149,34 +149,42 @@ Bddgenx::Runner.execute
 
 ## 📦 Geração manual via Rake
 ```Ruby
-require_relative 'lib/env' # ajuste conforme seu projeto
 require 'rake'
+require 'bddgenx'
 
 namespace :bddgenx do
-  desc 'Gera arquivos BDD com IA ou modo estático. Use: rake bddgenx:generate[modo]'
-  task :generate, [:modo] do |_, args|
-    modo = args[:modo]&.downcase&.to_sym || :static
-
-    unless %i[static chatgpt gemini deepseek].include?(modo)
-      puts "❌ Modo inválido: #{modo}"
-      puts "Use: rake bddgenx:generate[static|chatgpt|gemini|deepseek]"
-      exit 1
-    end
+  desc 'Executa geração interativa: escolha entre static, chatgpt, gemini ou deepseek'
+  task :generate do
+    puts "=== Qual modo deseja usar para gerar os cenários? ==="
+    puts "1. static (sem IA)"
+    puts "2. chatgpt (via OpenAI)"
+    puts "3. gemini (via Google)"
+    print "Digite o número (1-3): "
+
+    escolha = STDIN.gets.chomp.to_i
+
+    modo = case escolha
+           when 1 then :static
+           when 2 then :chatgpt
+           when 3 then :gemini
+           else
+             puts "❌ Opção inválida. Saindo."; exit 1
+           end
 
     Bddgenx.configure do |config|
       config.mode = modo
       config.openai_api_key_env = 'OPENAI_API_KEY'
       config.gemini_api_key_env = 'GEMINI_API_KEY'
-      config.deepseek_api_key_env = 'DEEPSEEK_API_KEY'
     end
 
-    ENV['BDDGENX_MODE'] = modo.to_s
+    # ⚠️ Limpa o ARGV antes de executar para evitar que [static] seja interpretado como nome de arquivo
+    ARGV.clear
 
-    puts "⚙️  Gerando com modo: #{modo}"
+    ENV['BDDGENX_MODE'] = modo.to_s
+    puts "\n⚙️  Modo selecionado: #{modo}\n\n"
     Bddgenx::Runner.execute
   end
 end
-
 ```
 
 ## 📝 Formato do Arquivo de Entrada (`.txt`)
@@ -184,17 +192,37 @@ end
 ```txt
 # language: pt
 Como um usuário do sistema
-Quero fazer login
-Para acessar minha conta
+Quero fazer login corretamente
+Para acessar minha conta com segurança
+
+[CONTEXT]
+Dado que estou na tela de login
 
 [SUCCESS]
-Quando preencho <email> e <senha>
+Quando preencho email e senha válidos
 Então vejo a tela inicial
 
+[SUCCESS]
+Quando tento logar com "<email>" e "<senha>"
+Então recebo "<mensagem>"
+
+[EXAMPLES]
+| email            | senha   | mensagem                  |
+| user@site.com    | 123456  | login realizado           |
+| errado@site.com  | senha   | credenciais inválidas     |
+|                  | senha   | email é obrigatório       |
+| user@site.com    |         | senha é obrigatória       |
+
+[SUCCESS]
+Quando deixo o campo "<campo>" vazio
+Então recebo a mensagem "<mensagem>"
+
 [EXAMPLES]
-| email            | senha   |
-| user@site.com    | 123456  |
-| errado@site.com  | senha   |
+| campo  | mensagem                  |
+|        | login realizado           |
+|        | credenciais inválidas     |
+| email  | email é obrigatório       |
+| senha  | senha é obrigatória       |
 ```
 
 ---

data/Rakefile

@@ -1,49 +1,36 @@
-# Rakefile
-require_relative 'lib/env'
+require 'bddgenx'
 require 'rake'
 
 namespace :bddgenx do
-  desc 'Inicializar projeto'
-  task :setup do
-    Bddgenx::Setup.inicializar_projeto
-  end
-
-  desc 'Executa a geração BDD usando o modo atual (static, chatgpt, gemini)'
+  desc 'Executa geração interativa: escolha entre static, chatgpt, gemini ou deepseek'
   task :generate do
-    puts "⚙️  Modo de geração: #{Bddgenx.configuration.mode}"
+    puts "=== Qual modo deseja usar para gerar os cenários? ==="
+    puts "1. static (sem IA)"
+    puts "2. chatgpt (via OpenAI)"
+    puts "3. gemini (via Google)"
+    print "Digite o número (1-3): "
 
-    # Evita que ARGV contenha o nome da task (como "bddgenx:static")
-    ARGV.clear
+    escolha = STDIN.gets.chomp.to_i
 
-    Bddgenx::Runner.execute
-  end
-
-  desc 'Gera features no modo estático (sem IA)'
-  task :static do
-    Bddgenx.configure do |config|
-      config.mode = :static
-    end
-    ENV['BDDGENX_MODE'] = 'static'
-    Rake::Task['bddgenx:generate'].invoke
-  end
+    modo = case escolha
+           when 1 then :static
+           when 2 then :chatgpt
+           when 3 then :gemini
+           else
+             puts "❌ Opção inválida. Saindo."; exit 1
+           end
 
-  desc 'Gera features usando ChatGPT'
-  task :chatgpt do
     Bddgenx.configure do |config|
-      config.mode = :chatgpt
+      config.mode = modo
       config.openai_api_key_env = 'OPENAI_API_KEY'
-    end
-    ENV['BDDGENX_MODE'] = 'chatgpt'
-    Rake::Task['bddgenx:generate'].invoke
-  end
-
-  desc 'Gera features usando Gemini'
-  task :gemini do
-    Bddgenx.configure do |config|
-      config.mode = :gemini
       config.gemini_api_key_env = 'GEMINI_API_KEY'
     end
-    ENV['BDDGENX_MODE'] = 'gemini'
-    Rake::Task['bddgenx:generate'].invoke
+
+    # ⚠️ Limpa o ARGV antes de executar para evitar que [static] seja interpretado como nome de arquivo
+    ARGV.clear
+
+    ENV['BDDGENX_MODE'] = modo.to_s
+    puts "\n⚙️  Modo selecionado: #{modo}\n\n"
+    Bddgenx::Runner.execute
   end
 end

data/VERSION

@@ -1 +1 @@
-2.3.2
+2.4.2

data/lib/bddgenx/generators/generator.rb

@@ -1,10 +1,10 @@
 # lib/bddgenx/generator.rb
 # encoding: utf-8
 #
-# Este arquivo define a classe Generator, responsável por gerar arquivos
-# .feature a partir de um hash de história ou de um arquivo de história em texto.
-# Suporta Gherkin em Português e Inglês, inclusão de tags, cenários simples
-# e esquemas de cenário com exemplos.
+# Classe responsável pela geração de arquivos `.feature` no formato Gherkin
+# a partir de arquivos de entrada de histórias ou estruturas hash.
+# Suporta palavras-chave Gherkin em Português e Inglês, além de integração com IA
+# (ChatGPT ou Gemini) para geração automática de cenários.
 
 module Bddgenx
   class Generator
@@ -14,37 +14,39 @@ module Bddgenx
     # Palavras-chave do Gherkin em Inglês
     GHERKIN_KEYS_EN = %w[Given When Then And But].freeze
 
-    # Mapeamento de PT → EN
+    # Mapeamento PT → EN
     GHERKIN_MAP_PT_EN = GHERKIN_KEYS_PT.zip(GHERKIN_KEYS_EN).to_h
 
-    # Mapeamento de EN → PT
+    # Mapeamento EN → PT
     GHERKIN_MAP_EN_PT = GHERKIN_KEYS_EN.zip(GHERKIN_KEYS_PT).to_h
 
-    # Todas as palavras-chave reconhecidas
+    # Todas as palavras-chave reconhecidas pelos parsers
     ALL_KEYS = GHERKIN_KEYS_PT + GHERKIN_KEYS_EN
 
     ##
     # Extrai todas as linhas de exemplo de um array de strings.
     #
-    # @param raw [Array<String>] um array contendo linhas de texto
-    # @return [Array<String>] apenas as linhas que começam com '|', ou seja, exemplos
+    # @param raw [Array<String>] Array com linhas do grupo de passos
+    # @return [Array<String>] Somente as linhas que contêm exemplos (começam com '|')
     def self.dividir_examples(raw)
       raw.select { |l| l.strip.start_with?('|') }
     end
 
     ##
-    # Gera o conteúdo de um arquivo `.feature` a partir de uma história.
-    # Pode operar em três modos: estático (hash ou arquivo estruturado),
-    # IA com Gemini, ou IA com ChatGPT.
+    # Gera o conteúdo de um arquivo `.feature` baseado na história fornecida.
+    # Pode operar em três modos:
+    # - :static (sem IA)
+    # - :chatgpt (usando OpenAI)
+    # - :gemini (usando Google Gemini)
     #
-    # @param input [String, Hash] caminho para um arquivo .txt ou um hash estruturado
-    # @param override_path [String, nil] caminho alternativo para salvar o arquivo gerado
-    # @return [Array(String, String)] caminho do arquivo gerado e conteúdo do .feature
+    # @param input [String, Hash] Caminho para um `.txt` ou estrutura de história já processada
+    # @param override_path [String, nil] Caminho alternativo de saída
+    # @return [Array<String, String>] Caminho e conteúdo do `.feature`
     def self.gerar_feature(input, override_path = nil)
       modo = ENV['BDD_MODE']&.to_sym || :static
 
       if input.is_a?(String) && input.end_with?('.txt') && [:gemini, :chatgpt].include?(modo)
-        # Modo com IA: gera cenários automaticamente com base no texto da história
+        # Geração com IA
         raw_txt = File.read(input)
         historia = {
           idioma: 'pt',
@@ -66,14 +68,14 @@ module Bddgenx
           passos: GherkinCleaner.limpar(texto_gerado).lines.map(&:strip).reject(&:empty?)
         }
       else
-        # Modo estático: utiliza estrutura vinda do Parser ou de um hash diretamente
+        # Geração estática
         historia = input.is_a?(String) ? Parser.ler_historia(input) : input
       end
 
       idioma = historia[:idioma] || 'pt'
       cont = 1
 
-      # Normaliza o nome base do arquivo
+      # Cria nome-base do arquivo .feature
       nome_base = historia[:quero]
                     .gsub(/[^a-z0-9]/i, '_')
                     .downcase
@@ -84,7 +86,7 @@ module Bddgenx
 
       caminho = override_path || "features/#{nome_base}.feature"
 
-      # Define palavras-chave com base no idioma
+      # Palavras-chave localizadas
       palavras = {
         feature:  idioma == 'en' ? 'Feature'          : 'Funcionalidade',
         contexto: idioma == 'en' ? 'Background'       : 'Contexto',
@@ -94,6 +96,7 @@ module Bddgenx
         regra:    idioma == 'en' ? 'Rule'             : 'Regra'
       }
 
+      # Cabeçalho do arquivo .feature
       conteudo = <<~GHK
         # language: #{idioma}
         #{palavras[:feature]}: #{historia[:quero].sub(/^Quero\s*/i,'')}
@@ -102,14 +105,14 @@ module Bddgenx
           # #{historia[:para]}
       GHK
 
+      # Controle para não repetir passos
       passos_unicos = Set.new
       pt_map = GHERKIN_MAP_PT_EN
       en_map = GHERKIN_MAP_EN_PT
       detect = ALL_KEYS
-      cont = 1
 
       historia[:grupos].each do |grupo|
-        passos   = grupo[:passos]  || []
+        passos   = grupo[:passos]   || []
         exemplos = grupo[:exemplos] || []
         next if passos.empty?
 
@@ -151,20 +154,21 @@ module Bddgenx
     end
 
     ##
-    # Gera o caminho padrão de saída para um arquivo `.feature` com base no nome do `.txt`.
+    # Retorna o caminho padrão do arquivo `.feature` baseado no nome do `.txt`.
     #
-    # @param arquivo_txt [String] caminho do arquivo .txt de entrada
-    # @return [String] caminho completo do arquivo .feature correspondente
+    # @param arquivo_txt [String] Caminho do arquivo .txt
+    # @return [String] Caminho final da feature gerada
     def self.path_para_feature(arquivo_txt)
       nome = File.basename(arquivo_txt, '.txt')
       File.join('features', "#{nome}.feature")
     end
 
     ##
-    # Salva o conteúdo gerado no disco, criando diretórios se necessário.
+    # Salva o conteúdo do arquivo `.feature` no disco.
+    # Cria diretórios intermediários, se necessário.
     #
-    # @param caminho [String] caminho completo para salvar o arquivo
-    # @param conteudo [String] conteúdo do arquivo .feature
+    # @param caminho [String] Caminho completo do arquivo
+    # @param conteudo [String] Conteúdo da feature a ser salva
     # @return [void]
     def self.salvar_feature(caminho, conteudo)
       FileUtils.mkdir_p(File.dirname(caminho))

data/lib/bddgenx/generators/runner.rb

@@ -2,28 +2,35 @@
 # encoding: utf-8
 #
 # Este arquivo define a classe Runner (CLI) da gem bddgenx,
-# responsável por orquestrar o fluxo de leitura de histórias,
-# validação, geração de features, steps, backups e exportação de PDFs.
+# responsável por orquestrar todo o fluxo de geração BDD:
+# leitura e validação de histórias, geração de features, steps,
+# exportação de PDFs e controle de modo (static / IA).
+
 require_relative '../../bddgenx'
 
 module Bddgenx
-  # Ponto de entrada da gem: coordena todo o processo de geração BDD.
+  # Classe principal de execução da gem.
+  # Atua como ponto de entrada (CLI) para processar arquivos de entrada
+  # e gerar todos os artefatos BDD relacionados.
   class Runner
-    # Seleciona arquivos de entrada para processamento.
-    # Se houver argumentos em ARGV, usa-os como nomes de arquivos .txt;
-    # caso contrário, exibe prompt interativo para escolha.
+
+    ##
+    # Retorna a lista de arquivos de entrada.
+    # Se houver argumentos em ARGV, utiliza-os como nomes de arquivos `.txt`.
+    # Caso contrário, chama prompt interativo.
     #
-    # @param input_dir [String] Diretório onde estão os arquivos .txt de histórias
-    # @return [Array<String>] Lista de caminhos para os arquivos a serem processados
+    # @param input_dir [String] Caminho do diretório de entrada
+    # @return [Array<String>] Lista de arquivos `.txt` a processar
     def self.choose_files(input_dir)
       ARGV.any? ? selecionar_arquivos_txt(input_dir) : choose_input(input_dir)
     end
 
-    # Mapeia ARGV para paths de arquivos .txt em input_dir.
-    # Adiciona extensão '.txt' se necessário e filtra arquivos inexistentes.
+    ##
+    # Processa argumentos ARGV e converte em caminhos válidos de arquivos `.txt`.
+    # Adiciona extensão `.txt` se ausente e remove arquivos inexistentes.
     #
-    # @param input_dir [String] Diretório de entrada
-    # @return [Array<String>] Caminhos válidos para processamento
+    # @param input_dir [String] Diretório onde estão os arquivos
+    # @return [Array<String>] Caminhos válidos para arquivos de entrada
     def self.selecionar_arquivos_txt(input_dir)
       ARGV.map do |arg|
         nome = arg.end_with?('.txt') ? arg : "#{arg}.txt"
@@ -36,12 +43,12 @@ module Bddgenx
       end.compact
     end
 
-    # Exibe prompt interativo para o usuário escolher qual arquivo processar
-    # entre todos os .txt disponíveis em input_dir.
+    ##
+    # Interface interativa para o usuário selecionar arquivos `.txt` a processar.
+    # Exibe uma lista dos arquivos disponíveis e solicita um número ao usuário.
     #
     # @param input_dir [String] Diretório de entrada
-    # @exit [1] Se nenhum arquivo for encontrado ou escolha inválida
-    # @return [Array<String>] Um único arquivo escolhido ou todos se ENTER
+    # @return [Array<String>] Lista com o arquivo escolhido ou todos
     def self.choose_input(input_dir)
       files = Dir.glob(File.join(input_dir, '*.txt'))
       if files.empty?
@@ -61,29 +68,29 @@ module Bddgenx
       [files[idx]]
     end
 
-    # Executa todo o fluxo de geração BDD.
-    # - Cria pasta 'input' se não existir
-    # - Seleciona arquivos de histórias
-    # - Para cada arquivo:
-    #   - Lê e valida a história
-    #   - Gera arquivo .feature e salva backup da versão anterior
-    #   - Gera definitions de steps
-    #   - Exporta PDFs novos via PDFExporter
-    # - Exibe resumo final com estatísticas
+    ##
+    # Executa o fluxo completo de geração BDD:
+    # - Define o modo (static / IA)
+    # - Coleta arquivos de entrada
+    # - Valida as histórias
+    # - Gera arquivos `.feature` e `steps`
+    # - Exporta PDFs e faz backup de versões antigas
+    #
+    # O modo de execução é lido da variável de ambiente `BDDGENX_MODE`.
     #
     # @return [void]
     def self.execute
       modo = ENV['BDDGENX_MODE'] || 'static'
-
       input_dir = 'input'
       Dir.mkdir(input_dir) unless Dir.exist?(input_dir)
 
       arquivos = choose_files(input_dir)
       if arquivos.empty?
-        warn "❌ Nenhum arquivo de história para processar."; exit 1
+        warn I18n.t('messages.no_files')
+        exit 1
       end
 
-      # Inicializa contadores
+      # Contadores de geração
       total = features = steps = ignored = 0
       skipped_steps = []
       generated_pdfs = []
@@ -91,63 +98,67 @@ module Bddgenx
 
       arquivos.each do |arquivo|
         total += 1
-        puts "\n🔍 Processando: #{arquivo}"
+        puts "\n🔍 #{I18n.t('messages.processing')}: #{arquivo}"
 
         historia = Parser.ler_historia(arquivo)
         unless Validator.validar(historia)
           ignored += 1
-          puts "❌ História inválida: #{arquivo}"
+          puts "❌ #{I18n.t('messages.invalid_story')}: #{arquivo}"
           next
         end
 
-        # Geração de feature
-        if modo == 'gemini' || modo == 'chatgpt'
-          puts "🤖 Gerando cenários com IA (#{modo.capitalize})..."
+        # Geração via IA (ChatGPT, Gemini, Deepseek)
+        if %w[gemini chatgpt deepseek].include?(modo)
+          puts I18n.t('messages.start_ia', modo: modo.capitalize)
           idioma = IA::GeminiCliente.detecta_idioma_arquivo(arquivo)
-          feature_text =
-            if modo == 'gemini'
+
+          feature_text = Support::Loader.run(I18n.t('messages.ia_waiting'), :default) do
+            case modo
+            when 'gemini'
               IA::GeminiCliente.gerar_cenarios(historia, idioma)
-            else
+            when 'chatgpt'
               IA::ChatGptCliente.gerar_cenarios(historia, idioma)
+            when 'deepseek'
+              IA::DeepseekCliente.gerar_cenarios(historia, idioma)
             end
+          end
+
           if feature_text
             feature_path = Generator.path_para_feature(arquivo)
             feature_content = Bddgenx::GherkinCleaner.limpar(feature_text)
           else
             ignored += 1
-            puts "❌ Falha ao gerar com IA: #{arquivo}"
+            puts I18n.t('messages.feature_fail', arquivo: arquivo)
             next
           end
         else
-          feature_path, feature_content = Generator.gerar_feature(historia)
+          # Geração local (modo static)
+          feature_path, feature_content = Support::Loader.run(I18n.t('messages.start_static'), :dots) do
+            sleep(2)
+            Generator.gerar_feature(historia)
+          end
         end
 
         Backup.salvar_versao_antiga(feature_path)
         features += 1 if Generator.salvar_feature(feature_path, feature_content)
 
-        # Geração de steps
         if StepsGenerator.gerar_passos(feature_path)
           steps += 1
         else
           skipped_steps << feature_path
         end
 
-        # Exportação de PDF (apenas novos)
         FileUtils.mkdir_p('reports')
         result = PDFExporter.exportar_todos(only_new: true)
         generated_pdfs.concat(result[:generated])
         skipped_pdfs.concat(result[:skipped])
       end
 
-      # Exibe relatório final
-      puts "\n✅ Processamento concluído"
-      puts "- Total de histórias:    #{total}"
-      puts "- Features geradas:      #{features}"
-      puts "- Steps gerados:         #{steps}"
-      puts "- Steps ignorados:       #{skipped_steps.size}"
-      puts "- PDFs gerados:          #{generated_pdfs.size}"
-      puts "- PDFs já existentes:    #{skipped_pdfs.size}"
-      puts "- Histórias ignoradas:   #{ignored}"
+      # Resumo final
+      puts "\n#{I18n.t('messages.processing_done')}"
+      puts "- #{I18n.t('messages.total_histories')}:    #{total}"
+      puts "- #{I18n.t('messages.features_generated')}: #{features}"
+      puts "- #{I18n.t('messages.steps_generated')}:    #{steps}"
     end
   end
 end

data/lib/bddgenx/generators/steps_generator.rb

@@ -1,10 +1,10 @@
 # lib/bddgenx/steps_generator.rb
 # encoding: utf-8
 #
-# Este arquivo define a classe StepsGenerator, responsável por gerar
-# definições de passos do Cucumber a partir de arquivos .feature.
-# Suporta palavras-chave Gherkin em Português e Inglês e parametriza
-# strings e números conforme necessário.
+# Classe responsável por gerar automaticamente os arquivos de definição
+# de passos do Cucumber a partir de arquivos `.feature`.
+# Suporta palavras-chave do Gherkin tanto em Português quanto em Inglês,
+# além de identificar parâmetros dinamicamente (strings e números).
 
 module Bddgenx
   class StepsGenerator
@@ -14,66 +14,67 @@ module Bddgenx
     # Palavras-chave Gherkin em Inglês
     GHERKIN_KEYS_EN = %w[Given When Then And But].freeze
 
-    # Conjunto de todas as palavras-chave suportadas
+    # Conjunto de todas as palavras-chave reconhecidas
     ALL_KEYS = GHERKIN_KEYS_PT + GHERKIN_KEYS_EN
 
     ##
-    # Transforma uma string em estilo camelCase.
-    #
-    # @param str [String] A string a ser transformada.
-    # @return [String] A string convertida para camelCase.
+    # Transforma uma string em camelCase (sem alterar acentuação).
     #
+    # @param str [String] A string de entrada
+    # @return [String] A string convertida para estilo camelCase
     def self.camelize(str)
       partes = str.strip.split(/[^a-zA-Z0-9]+/)
       partes.map.with_index { |palavra, i| i.zero? ? palavra.downcase : palavra.capitalize }.join
     end
 
     ##
-    # Gera arquivos de passos do Cucumber a partir de um arquivo .feature.
-    #
-    # O método lê o arquivo, detecta o idioma, extrai os passos,
-    # parametriza as variáveis (números e strings), e escreve os métodos
-    # em um novo arquivo no diretório `steps/`.
-    #
-    # @param feature_path [String] Caminho para o arquivo .feature.
-    # @return [Boolean] Retorna true se os passos forem gerados com sucesso, false se não houver passos.
-    # @raise [ArgumentError] Se o caminho fornecido não for uma String.
+    # Gera um arquivo de definição de passos do Cucumber com base em um `.feature`.
+    # Detecta automaticamente o idioma e converte os passos em métodos com placeholders.
     #
+    # @param feature_path [String] Caminho para o arquivo `.feature`
+    # @return [Boolean] Retorna true se os steps foram gerados, false se nenhum foi encontrado
+    # @raise [ArgumentError] Se o parâmetro não for uma String
     def self.gerar_passos(feature_path)
-      raise ArgumentError, "Caminho esperado como String, recebeu #{feature_path.class}" unless feature_path.is_a?(String)
+      raise ArgumentError, I18n.t('errors.invalid_path', path: feature_path.class) unless feature_path.is_a?(String)
 
       linhas = File.readlines(feature_path)
 
-      # Detecta o idioma com base na diretiva "# language:"
+      # Detecta o idioma a partir da linha `# language:`
       lang = if (m = linhas.find { |l| l =~ /^#\s*language:\s*(\w+)/i })
                m[/^#\s*language:\s*(\w+)/i, 1].downcase
              else
                'pt'
              end
 
+      # Define o locale do I18n conforme idioma detectado
+      I18n.locale = lang.to_sym rescue :pt
+
       pt_para_en = GHERKIN_KEYS_PT.zip(GHERKIN_KEYS_EN).to_h
       en_para_pt = GHERKIN_KEYS_EN.zip(GHERKIN_KEYS_PT).to_h
 
-      # Seleciona apenas linhas que começam com palavras-chave Gherkin
+      # Seleciona apenas as linhas que representam passos
       linhas_passos = linhas.map(&:strip).select do |linha|
         ALL_KEYS.any? { |chave| linha.start_with?(chave + ' ') }
       end
 
       return false if linhas_passos.empty?
 
+      # Cria diretório `steps` no mesmo nível do `.feature`
       dir_saida = File.join(File.dirname(feature_path), 'steps')
       FileUtils.mkdir_p(dir_saida)
+
       arquivo_saida = File.join(dir_saida, "#{File.basename(feature_path, '.feature')}_steps.rb")
 
+      # Cabeçalho do arquivo gerado
       conteudo = +"# encoding: utf-8\n"
-      conteudo << "# Definições de passos geradas automaticamente para #{File.basename(feature_path)}\n\n"
+      conteudo << "# #{I18n.t('steps.header', file: File.basename(feature_path))}\n\n"
 
       passos_unicos = Set.new
 
       linhas_passos.each do |linha|
         palavra_original, restante = linha.split(' ', 2)
 
-        # Tradução de palavras-chave se necessário
+        # Tradução da palavra-chave inicial
         chave = case lang
                 when 'en' then pt_para_en[palavra_original] || palavra_original
                 else           en_para_pt[palavra_original] || palavra_original
@@ -84,7 +85,7 @@ module Bddgenx
         padrao = ''
         tokens = []
 
-        # Analisa e parametriza o conteúdo dos passos
+        # Analisa e parametriza variáveis
         until scanner.eos?
           if scanner.check(/"<([^>]+)>"/)
             scanner.scan(/"<([^>]+)>"/)
@@ -94,8 +95,8 @@ module Bddgenx
             scanner.scan(/<([^>]+)>/)
             tokens << scanner[1]
             padrao << '{int}'
-          elsif scanner.check(/"([^"<>]+)"/)
-            scanner.scan(/"([^"<>]+)"/)
+          elsif scanner.check(/"([^"]+)"/)
+            scanner.scan(/"([^"]+)"/)
             tokens << scanner[1]
             padrao << '{string}'
           elsif scanner.check(/\d+(?:\.\d+)?/)
@@ -109,11 +110,11 @@ module Bddgenx
 
         padrao_seguro = padrao.gsub('"', '\\"')
 
-        # Impede criação de métodos duplicados
+        # Evita duplicatas de métodos
         next if passos_unicos.include?(padrao_seguro)
-
         passos_unicos << padrao_seguro
 
+        # Monta assinatura do step
         assinatura = "#{chave}(\"#{padrao_seguro}\")"
         if tokens.any?
           argumentos = tokens.each_index.map { |i| "arg#{i+1}" }.join(', ')
@@ -123,12 +124,13 @@ module Bddgenx
         end
 
         conteudo << "#{assinatura}\n"
-        conteudo << "  pending 'Implementar passo: #{texto_bruto}'\n"
+        conteudo << "  pending '#{I18n.t('steps.pending', text: texto_bruto)}'\n"
         conteudo << "end\n\n"
       end
 
+      # Escreve o arquivo final
       File.write(arquivo_saida, conteudo)
-      puts "✅ Steps gerados: #{arquivo_saida}"
+      puts I18n.t('steps.generated', path: arquivo_saida)
       true
     end
   end

data/lib/bddgenx/ia/chatgtp_cliente.rb

@@ -55,21 +55,31 @@ module Bddgenx
 
         # Prompt base enviado ao ChatGPT, instruindo a saída no formato correto
         prompt_base = <<~PROMPT
-          Gere cenários BDD no formato Gherkin, usando as palavras-chave de estrutura no idioma \"#{idioma}\":
-            Feature: #{keywords[:feature]}
-            Scenario: #{keywords[:scenario]}
-            Scenario Outline: #{keywords[:scenario_outline]}
-            Examples: #{keywords[:examples]}
-            Given: #{keywords[:given]}
-            When: #{keywords[:when]}
-            Then: #{keywords[:then]}
-            And: #{keywords[:and]}
-
-          Atenção: Os textos e descrições dos cenários e passos devem ser escritos em português, mesmo que as palavras-chave estejam em inglês.
-
-          História:
-          #{historia}
-        PROMPT
+                        Gere cenários BDD no formato Gherkin, utilizando as palavras-chave estruturais no idioma "#{idioma}":
+                          Feature: #{keywords[:feature]}
+                          Scenario: #{keywords[:scenario]}
+                          Scenario Outline: #{keywords[:scenario_outline]}
+                          Examples: #{keywords[:examples]}
+                          Given: #{keywords[:given]}
+                          When: #{keywords[:when]}
+                          Then: #{keywords[:then]}
+                          And: #{keywords[:and]}
+                      
+                        Instruções:
+                        - Todos os textos dos passos devem ser escritos em **português**.
+                        - Use as palavras-chave Gherkin no idioma especificado ("#{idioma}").
+                        - Gere **vários cenários**, incluindo positivos e negativos.
+                        - Use `Scenario Outline` e `Examples` sempre que houver valores variáveis.
+                        - Mantenha os parâmetros como `<email>`, `<senha>` e outros entre colchetes angulares, exatamente como aparecem.
+                        - Se a história fornecer contexto (ex: `[CONTEXT]` ou "Dado que..."), utilize-o como base para os cenários.
+                        - Se não houver contexto explícito, **crie um coerente** baseado na história.
+                        - A primeira linha do resultado deve conter obrigatoriamente `# language: #{idioma}`.
+                        - Evite passos vagos ou genéricos. Use ações claras e específicas.
+                        - Gere apenas o conteúdo da feature, sem explicações adicionais.
+                      
+                        História fornecida:
+                        #{historia}
+                      PROMPT
 
         uri = URI(CHATGPT_API_URL)
         request_body = {
@@ -107,7 +117,10 @@ module Bddgenx
             return fallback_com_gemini(historia, idioma)
           end
         else
-          warn "❌ Erro ao chamar ChatGPT: #{response.code} - #{response.body}"
+          if response.code.to_i == 429
+            warn "❌ Limite de uso da API OpenAI excedido."
+            warn "🔗 Verifique sua conta: https://platform.openai.com/account/usage"
+          end
           return fallback_com_gemini(historia, idioma)
         end
       end

data/lib/bddgenx/ia/gemini_cliente.rb

@@ -46,21 +46,33 @@ module Bddgenx
 
         # Prompt base que instrui a IA a gerar cenários Gherkin no idioma indicado
         prompt_base = <<~PROMPT
-          Gere cenários BDD no formato Gherkin, usando as palavras-chave de estrutura no idioma "#{idioma}":
-            Feature: #{keywords[:feature]}
-            Scenario: #{keywords[:scenario]}
-            Scenario Outline: #{keywords[:scenario_outline]}
-            Examples: #{keywords[:examples]}
-            Given: #{keywords[:given]}
-            When: #{keywords[:when]}
-            Then: #{keywords[:then]}
-            And: #{keywords[:and]}
-
-          Atenção: Os textos e descrições dos cenários e passos devem ser escritos em português, mesmo que as palavras-chave estejam em inglês.
-
-          História:
-          #{historia}
-        PROMPT
+                        Gere cenários BDD no formato Gherkin, utilizando as palavras-chave estruturais no idioma "#{idioma}":
+                          Feature: #{keywords[:feature]}
+                          Scenario: #{keywords[:scenario]}
+                          Scenario Outline: #{keywords[:scenario_outline]}
+                          Examples: #{keywords[:examples]}
+                          Given: #{keywords[:given]}
+                          When: #{keywords[:when]}
+                          Then: #{keywords[:then]}
+                          And: #{keywords[:and]}
+                      
+                        Instruções:
+                        - Todos os textos dos passos devem ser escritos em **português**.
+                        - Use as palavras-chave Gherkin no idioma especificado ("#{idioma}").
+                        - Gere **vários cenários**, incluindo positivos e negativos.
+                        - Use `Scenario Outline` e `Examples` sempre que houver valores variáveis.
+                        - Mantenha os parâmetros como `<email>`, `<senha>` e outros entre colchetes angulares, exatamente como aparecem.
+                        - Se a história fornecer contexto (ex: `[CONTEXT]` ou "Dado que..."), utilize-o como base para os cenários.
+                        - Se não houver contexto explícito, **crie um coerente** baseado na história.
+                        - A primeira linha do resultado deve conter obrigatoriamente `# language: #{idioma}`.
+                        - Evite passos vagos ou genéricos. Use ações claras e específicas.
+                        - Gere apenas o conteúdo da feature, sem explicações adicionais.
+                      
+                        História fornecida:
+                        #{historia}
+                      PROMPT
+
+
 
         unless api_key
           warn "❌ API Key do Gemini não encontrada no .env (GEMINI_API_KEY)"
@@ -101,6 +113,11 @@ module Bddgenx
             texto_limpo.sub!(/^# language: .*/, "# language: #{idioma}")
             texto_limpo.prepend("# language: #{idioma}\n") unless texto_limpo.start_with?("# language:")
 
+            # Garante diretiva de idioma
+            feature_text = Bddgenx::GherkinCleaner.limpar(texto_ia)
+            feature_text.sub!(/^# language: .*/, "") # remove qualquer # language: existente
+            feature_text.prepend("# language: #{idioma}\n") # insere a correta
+
             return texto_limpo
           else
             warn "❌ Resposta da IA sem conteúdo de texto"

data/lib/bddgenx/locales/en.yml

@@ -0,0 +1,28 @@
+en:
+  messages:
+    start_ia: "🤖 Generating scenarios with AI (%{modo})..."
+    start_static: "⛏️  Generating static feature..."
+    ia_waiting: "⏳ Waiting for AI response..."
+    feature_fail: "❌ Failed to generate via AI: %{arquivo}"
+    no_files: "❌ No story file found to process."
+    not_found: "⚠️  File not found: %{arquivo}"
+    processing_done: "✅ Processing complete"
+    total_histories: "Total stories"
+    features_generated: "Generated features"
+    steps_generated: "Generated steps"
+    feature_created: "✅ .feature file generated: %{caminho}"
+  gherkin:
+    feature: "Feature"
+    context: "Background"
+    scenario: "Scenario"
+    scenario_outline: "Scenario Outline"
+    examples: "Examples"
+    rule: "Rule"
+  steps:
+    header: "Step definitions automatically generated for %{file}"
+    pending: "Implement step: %{text}"
+    generated: "✅ Steps generated: %{path}"
+  errors:
+    invalid_path: "Expected path as String, got %{path}"
+  messages2:
+    processing_done: "✅ Processing complete"

data/lib/bddgenx/locales/pt.yml

@@ -0,0 +1,27 @@
+pt:
+  messages:
+    start_ia: "🤖 Gerando cenários com IA (%{modo})..."
+    start_static: "⛏️  Gerando feature estática..."
+    ia_waiting: "⏳ Aguardando resposta da IA..."
+    feature_fail: "❌ Falha ao gerar com IA: %{arquivo}"
+    no_files: "❌ Nenhum arquivo de história para processar."
+    not_found: "⚠️  Arquivo não encontrado: %{arquivo}"
+    processing_done: "✅ Processamento concluído"
+    total_histories: "Total de histórias"
+    features_generated: "Features geradas"
+    steps_generated: "Steps gerados"
+    feature_created: "✅ Arquivo .feature gerado: %{caminho}"
+  gherkin:
+    feature: "Funcionalidade"
+    context: "Contexto"
+    scenario: "Cenário"
+    scenario_outline: "Esquema do Cenário"
+    examples: "Exemplos"
+    rule: "Regra"
+  steps:
+    header: "Definições de passos geradas automaticamente para %{file}"
+    pending: "Implementar passo: %{text}"
+    generated: "✅ Steps gerados: %{path}"
+  errors:
+    invalid_path: "Caminho esperado como String, recebeu %{path}"
+

data/lib/bddgenx/support/loader.rb

@@ -0,0 +1,31 @@
+module Bddgenx
+  module Support
+    class Loader
+      SPINNERS = {
+        default: %w[| / - \\],
+        dots: %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏]
+      }
+
+      def self.run(mensagem = "⏳ Processando...", tipo = :default)
+        spinner = SPINNERS[tipo] || SPINNERS[:default]
+        done = false
+
+        thread = Thread.new do
+          i = 0
+          print "\n"
+          until done
+            print "\r#{mensagem} #{spinner[i % spinner.length]}"
+            sleep(0.1)
+            i += 1
+          end
+        end
+
+        result = yield
+        done = true
+        thread.join
+        print "\r#{mensagem} ✅\n"
+        result
+      end
+    end
+  end
+end

data/lib/bddgenx.rb

@@ -1,6 +1,3 @@
-#!/usr/bin/env ruby
-# Shebang para permitir execução direta do script no Linux/macOS, usando o interpretador Ruby do PATH
-
 require_relative 'env'
 # Carrega o arquivo 'env.rb' relativo a este script. Geralmente contém configurações e carregamento da gem Bddgenx.
 

data/lib/env.rb

@@ -1,51 +1,109 @@
 # lib/bddgenx/env.rb
+# encoding: utf-8
+#
+# Responsável por carregar todas as dependências da gem bddgenx.
+# Inclui bibliotecas padrão, gems externas e arquivos internos
+# essenciais para o funcionamento da geração BDD, com suporte a I18n,
+# IA (ChatGPT, Gemini), geração de PDF, validações e estrutura de projeto.
 
-# Carregamento de bibliotecas padrão e gems externas usadas no projeto
+# --------------------------------------
+# 📦 Gems padrão da linguagem Ruby
+# --------------------------------------
 
-require 'json'           # Para manipulação de dados JSON
-require 'net/http'       # Para fazer requisições HTTP
-require 'uri'            # Para manipulação de URLs
-require 'fileutils'      # Para manipulação de arquivos e diretórios
-require 'prawn'          # Biblioteca para geração de PDFs
-require 'prawn/table'    # Suporte a tabelas no Prawn PDF
-require 'prawn-svg'      # Para incorporar SVG em PDFs com Prawn
-require 'open3'          # Para executar comandos externos com captura de saída
-require 'faraday'        # Cliente HTTP para Gemini API
-require 'dotenv'         # Para carregar variáveis de ambiente de arquivos .env
-require 'unicode'        # Para manipulação avançada de strings Unicode (ex: remoção de acentos)
-require 'bigdecimal'     # Para operações matemáticas precisas com decimais
+require 'json'           # Manipulação de dados JSON
+require 'net/http'       # Requisições HTTP nativas
+require 'uri'            # Manipulação de URLs
+require 'fileutils'      # Operações com arquivos e diretórios
+require 'open3'          # Execução de comandos externos com captura de saída
+require 'bigdecimal'     # Cálculos matemáticos de alta precisão
+require 'i18n'           # Internacionalização (traduções dinâmicas)
 
-Dotenv.load
+# --------------------------------------
+# 📚 Gems externas
+# --------------------------------------
 
-# Configura o caminho base do projeto e carrega as gems definidas no Gemfile (se existir)
+require 'prawn'          # Geração de documentos PDF
+require 'prawn/table'    # Suporte a tabelas no Prawn
+require 'prawn-svg'      # Suporte a SVG no PDF
+require 'faraday'        # Cliente HTTP para integração com APIs (ex: Gemini)
+require 'dotenv'         # Carrega variáveis de ambiente do arquivo `.env`
+require 'unicode'        # Manipulação e normalização de caracteres Unicode
+
+# --------------------------------------
+# 🌍 Configuração de idioma (I18n)
+# --------------------------------------
+
+Dotenv.load  # Carrega variáveis como BDDGENX_LANG e APIs
+
+# Define o caminho de arquivos de tradução YAML
+locales_path = File.expand_path('bddgenx/locales/*.yml', __dir__)
+I18n.load_path += Dir[locales_path]
+
+# Define o idioma ativo somente se estiver presente e válido
+idioma_env = ENV['BDDGENX_LANG']
+if idioma_env && !idioma_env.strip.empty?
+  I18n.locale = idioma_env.strip.to_sym
+else
+  I18n.locale = :pt
+end
+
+
+# --------------------------------------
+# 🔧 Bundler (para projetos com Gemfile)
+# --------------------------------------
+
+# Carrega as dependências listadas no Gemfile (se houver)
 require 'bundler/setup' if File.exist?(File.expand_path('../../Gemfile', __FILE__))
 
-# Carregamento dos módulos utilitários (helpers)
-require_relative  'bddgenx/support/gherkin_cleaner'          # Limpeza e normalização de textos Gherkin
-require_relative  'bddgenx/support/remover_steps_duplicados' # Remoção de steps duplicados em features
-require_relative  'bddgenx/support/validator'                # Validação de dados e entrada
-require_relative  'bddgenx/support/font_loader'              # Carregamento de fontes para geração PDF
+# --------------------------------------
+# 🧩 Módulos utilitários da gem
+# --------------------------------------
+
+require_relative 'bddgenx/support/gherkin_cleaner'           # Sanitização de Gherkin gerado
+require_relative 'bddgenx/support/remover_steps_duplicados'  # Remove passos duplicados
+require_relative 'bddgenx/support/validator'                 # Valida estrutura de entrada
+require_relative 'bddgenx/support/font_loader'               # Carrega fontes do PDF
+
+# --------------------------------------
+# 🤖 Clientes de IA (ChatGPT, Gemini)
+# --------------------------------------
+
+require_relative 'bddgenx/ia/gemini_cliente'   # Integração com Google Gemini
+require_relative 'bddgenx/ia/chatgtp_cliente'  # Integração com OpenAI (ChatGPT)
+
+# --------------------------------------
+# 🛠 Geradores (features, steps e execução)
+# --------------------------------------
+
+require_relative 'bddgenx/generators/generator'        # Geração do conteúdo `.feature`
+require_relative 'bddgenx/generators/steps_generator'  # Geração de arquivos `*_steps.rb`
+require_relative 'bddgenx/generators/runner'           # Orquestrador da execução CLI
+
+# --------------------------------------
+# 📄 Parser e metadados
+# --------------------------------------
+
+require_relative 'parser'               # Interpreta arquivos `.txt` de entrada
+require_relative 'bddgenx/version'      # Lê versão do arquivo `VERSION`
 
-# Carregamento dos clientes para Integração com Inteligência Artificial
-require_relative  'bddgenx/ia/gemini_cliente'                # Cliente para API Gemini (Google)
-require_relative  'bddgenx/ia/chatgtp_cliente'               # Cliente para API ChatGPT (OpenAI)
+# --------------------------------------
+# 📤 Relatórios e exportação
+# --------------------------------------
 
-# Carregamento dos geradores de BDD (features, steps e runner)
-require_relative  'bddgenx/generators/generator'             # Gerador principal de arquivos .feature
-require_relative  'bddgenx/generators/steps_generator'       # Gerador de arquivos steps.rb
-require_relative  'bddgenx/generators/runner'                 # Classe responsável pela execução do processo de geração
+require_relative 'bddgenx/reports/pdf_exporter'  # Exporta features para PDF
+require_relative 'bddgenx/reports/backup'        # Gera backups de arquivos
+require_relative 'bddgenx/reports/tracer'        # Rastreabilidade de geração
 
-# Parser do arquivo de entrada e versão da gem
-require_relative  'parser'                                    # Parser para interpretar arquivos de entrada
-require_relative 'bddgenx/version'                                   # Informação da versão da gem
+# --------------------------------------
+# ⚙️ Configuração da gem e loaders auxiliares
+# --------------------------------------
 
-# Relatórios e exportação
-require_relative  'bddgenx/reports/pdf_exporter'              # Exporta relatórios em PDF usando Prawn
-require_relative  'bddgenx/reports/backup'                    # Mecanismo de backup dos arquivos gerados
-require_relative  'bddgenx/reports/tracer'                    # Rastreabilidade dos processos
+require_relative 'bddgenx/configuration'  # Variáveis de configuração (modo, APIs, etc.)
+require_relative 'bddgenx/setup'          # Inicializa estrutura do projeto (input/, features/, etc.)
+require_relative 'bddgenx/support/loader' # Exibe loaders/spinners no terminal
 
-require_relative 'bddgenx/configuration'                      # Configuração das variaveis de IA
-require_relative 'bddgenx/setup'                               # Verifica estrutura do projeto, caso nao exista cria a nova.
+# --------------------------------------
+# 🔁 Define modo de execução (ambiente de dev por padrão)
+# --------------------------------------
 
-# Define variável de ambiente global para indicar que o ambiente BDDGENX está em modo desenvolvimento
 ENV['BDDGENX_ENV'] = 'development'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bddgenx
 version: !ruby/object:Gem::Version
-  version: 2.3.2
+  version: 2.4.2
 platform: ruby
 authors:
 - David Nascimento
@@ -132,12 +132,15 @@ files:
 - lib/bddgenx/generators/steps_generator.rb
 - lib/bddgenx/ia/chatgtp_cliente.rb
 - lib/bddgenx/ia/gemini_cliente.rb
+- lib/bddgenx/locales/en.yml
+- lib/bddgenx/locales/pt.yml
 - lib/bddgenx/reports/backup.rb
 - lib/bddgenx/reports/pdf_exporter.rb
 - lib/bddgenx/reports/tracer.rb
 - lib/bddgenx/setup.rb
 - lib/bddgenx/support/font_loader.rb
 - lib/bddgenx/support/gherkin_cleaner.rb
+- lib/bddgenx/support/loader.rb
 - lib/bddgenx/support/remover_steps_duplicados.rb
 - lib/bddgenx/support/validator.rb
 - lib/bddgenx/version.rb