bddgenx 1.0.0 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 691d4d259476c68894a8859cc74ab4d926fdfe3b7304f5a020f05843442f33d2
-  data.tar.gz: 0aeff404aee94ac4d8419dec2772379a0816fdb5ce69a1e8cf967d47499e2f48
+  metadata.gz: 0ee7808e2b0f0cf6e65b1dbc5ea11689a1522dbc06ec2db6ed35494329920913
+  data.tar.gz: f88f37264c7e26caa90f4b25aef60e194cd5b08d7a97819b4aa623a7e99d6b04
 SHA512:
-  metadata.gz: c08188d0e944723b8e109063d2c2e682e335be6c05ff731f51962daba3a3dccac072201107fb23dda9f0d0b3901f75b97a10e1bcb289cf3305ad6deab8ccc198
-  data.tar.gz: fd8bf60a0b13bb05e63486daa3b4ccead3ddfdc4653046e5f48b252eede5cb8af35498d0d259a23870c203a5912a63a1c70cfc01fdd9b1e5141e58bc56d4c986
+  metadata.gz: 1bdc7124701b3fd7eba6e60993e75e31fb19613a1ae53cb7549afeae1c0d4a7f167a3e5c19bf6805ee118ffd6a6c7a6b5d29b0d25e34e894dbfb86c0e45f2879
+  data.tar.gz: eec2871ad622cb5c638163854dbb7dabcb5da57e6bb784732c561c50cc1a4fabc81c3647b82c63509a6bd125e72801db2a69a88415d550af44ccf9f944ed7ac7

data/README.md

@@ -5,6 +5,56 @@
 
 Ferramenta Ruby para gerar automaticamente arquivos Gherkin (`.feature`) e definições de passos (`steps.rb`) a partir de histórias em texto. Atende aos padrões ISTQB, suporta parametrização com blocos de exemplos e fornece relatórios de QA (rastreabilidade, backups e PDF).
 
+## Estrutura do projeto
+```
+bdd-generation/
+├── .github/                     # Workflows do GitHub Actions
+│   └── workflows/
+│       └── main.yml
+├── bin/
+│   └── console                  # Execução local (se necessário)
+├── features/                    # Gherkin gerados automaticamente
+│   └── steps/                   # Steps correspondentes
+├── input/                       # Histórias de entrada
+│   ├── historia.txt
+│   ├── historia_en.txt
+│   └── ...
+├── lib/
+│   └── bddgenx/
+│       ├── ia/                  # Módulo de IA
+│       │   ├── chatgpt_cliente.rb
+│       │   └── gemini_cliente.rb
+│       ├── generators/          # Responsável por geração
+│       │   ├── generator.rb
+│       │   ├── steps_generator.rb
+│       │   └── runner.rb
+│       ├── reports/            # Exportadores, backups e rastreabilidade
+│       │   ├── pdf_exporter.rb
+│       │   ├── backup.rb
+│       │   └── tracer.rb
+│       ├── support/            # Utilitários auxiliares
+│       │   ├── gherkin_cleaner.rb
+│       │   ├── remover_steps_duplicados.rb
+│       │   ├── validator.rb
+│       │   └── font_loader.rb
+│       ├── parser.rb           # Parse do .txt
+│       ├── version.rb          # Versão da gem
+│       └── bddgenx.rb          # Arquivo principal (require central)
+├── reports/                     # Saídas: PDF, backup, rastreabilidade
+│   ├── pdf/
+│   ├── backup/
+│   └── rastreabilidade/
+├── .env                         # Variáveis de ambiente
+├── .gitignore
+├── bddgenx.gemspec
+├── bump_version.sh
+├── Gemfile
+├── Gemfile.lock
+├── LICENSE
+├── Rakefile
+├── README.md
+└── VERSION
+```
 ## Instalação
 
 Adicione ao seu `Gemfile`:

data/VERSION

@@ -1 +1 @@
-1.0.0
+2.0.5

data/bin/bddgenx

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
-require_relative "../lib/bddgenx/runner"
+require_relative "../lib/bddgenx/generators/runner"
 
 Bddgenx::Runner.execute

data/lib/bddgenx/{generator.rb → generators/generator.rb}

@@ -6,30 +6,45 @@
 # Suporta Gherkin em Português e Inglês, inclusão de tags, cenários simples
 # e esquemas de cenário com exemplos.
 
-require 'fileutils'
-require 'set'
-require_relative 'utils/gherkin_cleaner'
-require_relative 'ia/gemini_cliente'
-require_relative 'utils/remover_steps_duplicados'
-# require_relative 'clients/chatgpt_cliente'
-
 module Bddgenx
   class Generator
+    # Palavras-chave do Gherkin em Português
     GHERKIN_KEYS_PT = %w[Dado Quando Então E Mas].freeze
+
+    # Palavras-chave do Gherkin em Inglês
     GHERKIN_KEYS_EN = %w[Given When Then And But].freeze
+
+    # Mapeamento de PT → EN
     GHERKIN_MAP_PT_EN = GHERKIN_KEYS_PT.zip(GHERKIN_KEYS_EN).to_h
+
+    # Mapeamento de EN → PT
     GHERKIN_MAP_EN_PT = GHERKIN_KEYS_EN.zip(GHERKIN_KEYS_PT).to_h
+
+    # Todas as palavras-chave reconhecidas
     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
     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.
+    #
+    # @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
     def self.gerar_feature(input, override_path = nil)
       modo = ENV['BDD_MODE']&.to_sym || :static
 
-      # IA: Lê o arquivo txt e passa para IA → aplica limpeza
       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
         raw_txt = File.read(input)
         historia = {
           idioma: 'pt',
@@ -50,15 +65,15 @@ module Bddgenx
           tag: 'ia',
           passos: GherkinCleaner.limpar(texto_gerado).lines.map(&:strip).reject(&:empty?)
         }
-
       else
-        # Caminho tradicional (hash de entrada ou parser de arquivo)
+        # Modo estático: utiliza estrutura vinda do Parser ou de um hash diretamente
         historia = input.is_a?(String) ? Parser.ler_historia(input) : input
       end
 
       idioma = historia[:idioma] || 'pt'
       cont = 1
 
+      # Normaliza o nome base do arquivo
       nome_base = historia[:quero]
                     .gsub(/[^a-z0-9]/i, '_')
                     .downcase
@@ -69,6 +84,7 @@ module Bddgenx
 
       caminho = override_path || "features/#{nome_base}.feature"
 
+      # Define palavras-chave com base no idioma
       palavras = {
         feature:  idioma == 'en' ? 'Feature'          : 'Funcionalidade',
         contexto: idioma == 'en' ? 'Background'       : 'Contexto',
@@ -79,15 +95,13 @@ module Bddgenx
       }
 
       conteudo = <<~GHK
-  # language: #{idioma}
-  #{palavras[:feature]}: #{historia[:quero].sub(/^Quero\s*/i,'')}
-    # #{historia[:como]}
-    # #{historia[:quero]}
-    # #{historia[:para]}
-
+        # language: #{idioma}
+        #{palavras[:feature]}: #{historia[:quero].sub(/^Quero\s*/i,'')}
+          # #{historia[:como]}
+          # #{historia[:quero]}
+          # #{historia[:para]}
       GHK
 
-      # Set para rastrear steps únicos
       passos_unicos = Set.new
       pt_map = GHERKIN_MAP_PT_EN
       en_map = GHERKIN_MAP_EN_PT
@@ -100,7 +114,6 @@ module Bddgenx
         next if passos.empty?
 
         tag_line = ["@#{grupo[:tipo].downcase}", ("@#{grupo[:tag]}" if grupo[:tag])].compact.join(' ')
-
         conteudo << "    #{tag_line}\n"
 
         if exemplos.any?
@@ -137,11 +150,22 @@ module Bddgenx
       [caminho, conteudo]
     end
 
+    ##
+    # Gera o caminho padrão de saída para um arquivo `.feature` com base no nome do `.txt`.
+    #
+    # @param arquivo_txt [String] caminho do arquivo .txt de entrada
+    # @return [String] caminho completo do arquivo .feature correspondente
     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.
+    #
+    # @param caminho [String] caminho completo para salvar o arquivo
+    # @param conteudo [String] conteúdo do arquivo .feature
+    # @return [void]
     def self.salvar_feature(caminho, conteudo)
       FileUtils.mkdir_p(File.dirname(caminho))
       File.write(caminho, conteudo)

data/lib/bddgenx/{runner.rb → generators/runner.rb}

@@ -4,16 +4,7 @@
 # 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.
-require 'dotenv/load'
-require 'fileutils'
-require_relative 'utils/parser'
-require_relative 'generator'
-require_relative 'utils/pdf_exporter'
-require_relative 'steps_generator'
-require_relative 'utils/validator'
-require_relative 'utils/backup'
-require_relative 'ia/gemini_cliente'
-require_relative 'utils/gherkin_cleaner'
+require_relative '../../bddgenx'
 
 module Bddgenx
   # Ponto de entrada da gem: coordena todo o processo de geração BDD.
@@ -110,26 +101,15 @@ module Bddgenx
         end
 
         # Geração de feature
-        if modo == 'gemini'
-          puts "🤖 Gerando cenários com IA (Gemini)..."
-          idioma = IA::GeminiCliente.detecta_idioma_arquivo(arquivo)  # Seu método que detecta o idioma no .txt (ex: 'pt' ou 'en')
-          spinner = Thread.new do
-            loop do
-              print "\r⏳ Aguardando resposta da IA "
-              3.times do |i|
-                print "." * (i + 1)
-                sleep(0.4)
-                print "\r⏳ Aguardando resposta da IA#{'.' * (i + 1)}   "
-              end
+        if modo == 'gemini' || modo == 'chatgpt'
+          puts "🤖 Gerando cenários com IA (#{modo.capitalize})..."
+          idioma = IA::GeminiCliente.detecta_idioma_arquivo(arquivo)
+          feature_text =
+            if modo == 'gemini'
+              IA::GeminiCliente.gerar_cenarios(historia, idioma)
+            else
+              IA::ChatGptCliente.gerar_cenarios(historia, idioma)
             end
-          end
-          begin
-            feature_text = IA::GeminiCliente.gerar_cenarios(historia, idioma)
-          ensure
-            Thread.kill(spinner)
-            print "\r✅ Resposta da IA recebida!        \n"
-          end
-          # feature_text = IA::GeminiCliente.gerar_cenarios(historia, idioma)
           if feature_text
             feature_path = Generator.path_para_feature(arquivo)
             feature_content = Bddgenx::GherkinCleaner.limpar(feature_text)

data/lib/bddgenx/{steps_generator.rb → generators/steps_generator.rb}

@@ -6,26 +6,45 @@
 # Suporta palavras-chave Gherkin em Português e Inglês e parametriza
 # strings e números conforme necessário.
 
-require 'fileutils'
-require 'strscan'  # Para uso de StringScanner
-require 'set'
-
 module Bddgenx
   class StepsGenerator
+    # Palavras-chave Gherkin em Português
     GHERKIN_KEYS_PT = %w[Dado Quando Então E Mas].freeze
+
+    # Palavras-chave Gherkin em Inglês
     GHERKIN_KEYS_EN = %w[Given When Then And But].freeze
+
+    # Conjunto de todas as palavras-chave suportadas
     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.
+    #
     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.
+    #
     def self.gerar_passos(feature_path)
       raise ArgumentError, "Caminho esperado como String, recebeu #{feature_path.class}" unless feature_path.is_a?(String)
 
       linhas = File.readlines(feature_path)
 
+      # Detecta o idioma com base na diretiva "# language:"
       lang = if (m = linhas.find { |l| l =~ /^#\s*language:\s*(\w+)/i })
                m[/^#\s*language:\s*(\w+)/i, 1].downcase
              else
@@ -35,6 +54,7 @@ module Bddgenx
       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
       linhas_passos = linhas.map(&:strip).select do |linha|
         ALL_KEYS.any? { |chave| linha.start_with?(chave + ' ') }
       end
@@ -53,6 +73,7 @@ module Bddgenx
       linhas_passos.each do |linha|
         palavra_original, restante = linha.split(' ', 2)
 
+        # Tradução de palavras-chave se necessário
         chave = case lang
                 when 'en' then pt_para_en[palavra_original] || palavra_original
                 else           en_para_pt[palavra_original] || palavra_original
@@ -63,6 +84,7 @@ module Bddgenx
         padrao = ''
         tokens = []
 
+        # Analisa e parametriza o conteúdo dos passos
         until scanner.eos?
           if scanner.check(/"<([^>]+)>"/)
             scanner.scan(/"<([^>]+)>"/)
@@ -87,7 +109,7 @@ module Bddgenx
 
         padrao_seguro = padrao.gsub('"', '\\"')
 
-        # Impede duplicatas
+        # Impede criação de métodos duplicados
         next if passos_unicos.include?(padrao_seguro)
 
         passos_unicos << padrao_seguro

data/lib/bddgenx/ia/chatgtp_cliente.rb

@@ -0,0 +1,147 @@
+# lib/bddgenx/ia/chatgpt_cliente.rb
+
+module Bddgenx
+  module IA
+    ##
+    # Cliente para interação com a API do ChatGPT da OpenAI para gerar
+    # cenários BDD no formato Gherkin, com suporte a fallback para Gemini.
+    #
+    class ChatGptCliente
+      CHATGPT_API_URL = 'https://api.openai.com/v1/chat/completions'.freeze
+      MODEL = 'gpt-4o'
+
+      ##
+      # Gera cenários BDD a partir de uma história fornecida,
+      # solicitando à API do ChatGPT a criação dos cenários em formato Gherkin.
+      # Se a API key não estiver configurada ou houver erro na requisição,
+      # utiliza fallback com o GeminiCliente.
+      #
+      # @param historia [String] Texto com a história para basear os cenários.
+      # @param idioma [String] Código do idioma ('pt' ou 'en'), padrão 'pt'.
+      # @return [String] Cenários gerados em formato Gherkin com palavras-chave no idioma indicado.
+      #
+      def self.gerar_cenarios(historia, idioma = 'pt')
+        api_key = ENV['OPENAI_API_KEY']
+
+        unless api_key
+          warn "❌ API Key do ChatGPT não encontrada no .env (OPENAI_API_KEY)"
+          return fallback_com_gemini(historia, idioma)
+        end
+
+        # Palavras-chave Gherkin para português e inglês
+        keywords_pt = {
+          feature: "Funcionalidade",
+          scenario: "Cenário",
+          scenario_outline: "Esquema do Cenário",
+          examples: "Exemplos",
+          given: "Dado",
+          when: "Quando",
+          then: "Então",
+          and: "E"
+        }
+
+        keywords_en = {
+          feature: "Feature",
+          scenario: "Scenario",
+          scenario_outline: "Scenario Outline",
+          examples: "Examples",
+          given: "Given",
+          when: "When",
+          then: "Then",
+          and: "And"
+        }
+
+        keywords = idioma == 'en' ? keywords_en : keywords_pt
+
+        # 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
+
+        uri = URI(CHATGPT_API_URL)
+        request_body = {
+          model: MODEL,
+          messages: [
+            {
+              role: "user",
+              content: prompt_base
+            }
+          ]
+        }
+
+        headers = {
+          "Content-Type" => "application/json",
+          "Authorization" => "Bearer #{api_key}"
+        }
+
+        response = Net::HTTP.post(uri, request_body.to_json, headers)
+
+        if response.is_a?(Net::HTTPSuccess)
+          json = JSON.parse(response.body)
+          texto_ia = json.dig("choices", 0, "message", "content")
+
+          if texto_ia
+            texto_limpo = Bddgenx::GherkinCleaner.limpar(texto_ia)
+            Utils::StepCleaner.remover_steps_duplicados(texto_ia, idioma)
+
+            # Ajusta a linha de idioma no arquivo gerado
+            texto_limpo.sub!(/^# language: .*/, "# language: #{idioma}")
+            texto_limpo.prepend("# language: #{idioma}\n") unless texto_limpo.start_with?("# language:")
+            return texto_limpo
+          else
+            warn "❌ Resposta da IA sem conteúdo de texto"
+            warn JSON.pretty_generate(json)
+            return fallback_com_gemini(historia, idioma)
+          end
+        else
+          warn "❌ Erro ao chamar ChatGPT: #{response.code} - #{response.body}"
+          return fallback_com_gemini(historia, idioma)
+        end
+      end
+
+      ##
+      # Método de fallback que chama o GeminiCliente para gerar cenários,
+      # usado quando a API do ChatGPT não está disponível ou ocorre erro.
+      #
+      # @param historia [String] Texto da história para basear os cenários.
+      # @param idioma [String] Código do idioma ('pt' ou 'en').
+      # @return [String] Cenários gerados pelo GeminiCliente.
+      #
+      def self.fallback_com_gemini(historia, idioma)
+        warn "🔁 Tentando gerar com Gemini como fallback..."
+        GeminiCliente.gerar_cenarios(historia, idioma)
+      end
+
+      ##
+      # Detecta o idioma de um arquivo de feature pela linha "# language:".
+      #
+      # @param caminho_arquivo [String] Caminho para o arquivo de feature.
+      # @return [String] Código do idioma detectado ('pt' por padrão).
+      #
+      def self.detecta_idioma_arquivo(caminho_arquivo)
+        return 'pt' unless File.exist?(caminho_arquivo)
+
+        File.foreach(caminho_arquivo) do |linha|
+          if linha =~ /^#\s*language:\s*(\w{2})/i
+            return $1.downcase
+          end
+        end
+
+        'pt'
+      end
+    end
+  end
+end

data/lib/bddgenx/ia/gemini_cliente.rb

@@ -1,15 +1,22 @@
 # lib/bddgenx/ia/gemini_cliente.rb
-require 'net/http'
-require 'json'
-require 'uri'
-require_relative '../utils/gherkin_cleaner'
-require_relative '../utils/remover_steps_duplicados'
 
 module Bddgenx
   module IA
+    ##
+    # Cliente para interação com a API Gemini do Google para geração
+    # de conteúdo, aqui usado para criar cenários BDD no formato Gherkin.
+    #
     class GeminiCliente
       GEMINI_API_URL = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent'.freeze
 
+      ##
+      # Gera cenários BDD baseados em uma história, solicitando à API Gemini
+      # o retorno no formato Gherkin com palavras-chave no idioma desejado.
+      #
+      # @param historia [String] Texto base da história para gerar os cenários.
+      # @param idioma [String] Código do idioma, 'pt' por padrão.
+      # @return [String, nil] Cenários no formato Gherkin, ou nil em caso de erro.
+      #
       def self.gerar_cenarios(historia, idioma = 'pt')
         api_key = ENV['GEMINI_API_KEY']
 
@@ -37,7 +44,7 @@ module Bddgenx
 
         keywords = idioma == 'en' ? keywords_en : keywords_pt
 
-        # Prompt base para solicitar saída Gherkin estruturada da IA
+        # 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]}
@@ -54,23 +61,25 @@ module Bddgenx
           História:
           #{historia}
         PROMPT
+
         unless api_key
           warn "❌ API Key do Gemini não encontrada no .env (GEMINI_API_KEY)"
           return nil
         end
 
         uri = URI("#{GEMINI_API_URL}?key=#{api_key}")
-        prompt = prompt_base % { historia: historia }
 
+        # Estrutura do corpo da requisição para a API Gemini
         request_body = {
           contents: [
             {
               role: "user",
-              parts: [{ text: prompt }]
+              parts: [{ text: prompt_base }]
             }
           ]
         }
 
+        # Executa requisição POST para a API Gemini
         response = Net::HTTP.post(uri, request_body.to_json, { "Content-Type" => "application/json" })
 
         if response.is_a?(Net::HTTPSuccess)
@@ -84,11 +93,11 @@ module Bddgenx
 
           texto_ia = json["candidates"].first.dig("content", "parts", 0, "text")
           if texto_ia
-            # Sanitiza o texto para garantir formato Gherkin correto
+            # Limpeza e sanitização do texto para manter padrão Gherkin
             texto_limpo = Bddgenx::GherkinCleaner.limpar(texto_ia)
             Utils::StepCleaner.remover_steps_duplicados(texto_ia, idioma)
 
-            # Insere a diretiva language dinamicamente com base no idioma detectado
+            # Ajuste da diretiva de idioma na saída gerada
             texto_limpo.sub!(/^# language: .*/, "# language: #{idioma}")
             texto_limpo.prepend("# language: #{idioma}\n") unless texto_limpo.start_with?("# language:")
 
@@ -104,6 +113,12 @@ module Bddgenx
         end
       end
 
+      ##
+      # Detecta o idioma do arquivo de feature pela linha "# language:".
+      #
+      # @param caminho_arquivo [String] Caminho do arquivo para detecção do idioma.
+      # @return [String] Código do idioma detectado (ex: 'pt'), padrão 'pt'.
+      #
       def self.detecta_idioma_arquivo(caminho_arquivo)
         return 'pt' unless File.exist?(caminho_arquivo)
 
@@ -113,7 +128,7 @@ module Bddgenx
           end
         end
 
-        'pt' # padrão
+        'pt' # idioma padrão caso não encontre
       end
     end
   end

data/lib/bddgenx/{utils → reports}/backup.rb

@@ -4,10 +4,6 @@
 # Este arquivo define a classe Backup, responsável por criar cópias de segurança
 # de arquivos .feature antes de serem sobrescritos.
 # As cópias são salvas em 'reports/backup' com timestamp no nome.
-
-require 'fileutils'
-require 'time'
-
 module Bddgenx
   # Gerencia a criação de backups de arquivos .feature
   class Backup

data/lib/bddgenx/{utils → reports}/pdf_exporter.rb

@@ -6,11 +6,6 @@
 # preto e branco.
 # Utiliza a gem Prawn para renderização de texto e tabelas.
 
-require 'prawn'
-require 'prawn/table'
-require 'fileutils'
-require_relative 'font_loader'
-
 # Suprime aviso de internacionalização para fontes AFM internas
 Prawn::Fonts::AFM.hide_m17n_warning = true
 

data/lib/bddgenx/{utils → reports}/tracer.rb

@@ -4,10 +4,6 @@
 # Este arquivo define a classe Tracer, responsável por gerar e manter
 # informações de rastreabilidade de cenários e passos em um arquivo CSV.
 # Útil para auditoria e análise de cobertura de cenários gerados.
-
-require 'csv'
-require 'fileutils'
-
 module Bddgenx
   # Classe para adicionar registros de rastreabilidade a um relatório CSV.
   class Tracer

data/lib/bddgenx/{utils → support}/font_loader.rb

@@ -4,10 +4,6 @@
 # Este arquivo define a classe FontLoader, responsável por localizar e carregar
 # famílias de fontes TrueType para uso com Prawn em geração de PDFs.
 # Busca os arquivos de fonte no diretório assets/fonts dentro da gem.
-
-require 'prawn'
-require 'rubygems'  # para Gem.loaded_specs se necessário
-
 module Bddgenx
   # Gerencia o carregamento de fontes TTF para os documentos PDF.
   class FontLoader

data/lib/bddgenx/support/gherkin_cleaner.rb

@@ -0,0 +1,102 @@
+module Bddgenx
+  class GherkinCleaner
+    # Método principal para limpar o texto Gherkin recebido.
+    # Executa uma sequência de operações para deixar o texto formatado e correto.
+    #
+    # Passos:
+    # - Remove blocos de código markdown (```).
+    # - Garante que exista somente uma linha # language: correta.
+    # - Corrige a indentação dos blocos Gherkin para o padrão esperado.
+    # - Remove espaços em branco no início/fim do texto.
+    #
+    # Retorna o texto limpo e formatado.
+    def self.limpar(texto)
+      texto = remover_blocos_markdown(texto)
+      texto = corrigir_language(texto)
+      texto = corrigir_indentacao(texto)
+      texto.strip
+    end
+
+    # Remove blocos markdown que usam as crases tripas (```).
+    # Muitas vezes a IA retorna os textos dentro desses blocos, que precisam ser limpos.
+    #
+    # Exemplo:
+    # ```gherkin
+    # Feature: Exemplo
+    # ```
+    #
+    # Essa função remove as linhas contendo as crases, deixando só o conteúdo.
+    def self.remover_blocos_markdown(texto)
+      texto.gsub(/```[a-z]*\n?/i, '').gsub(/```/, '')
+    end
+
+    # Garante que o arquivo contenha exatamente uma linha "# language: xx" no topo.
+    #
+    # Passos:
+    # - Procura a primeira ocorrência da linha de language no texto.
+    # - Remove todas as outras linhas duplicadas de language.
+    # - Se encontrar, move essa linha para o início do texto.
+    # - Se não encontrar, detecta o idioma do texto e adiciona a linha no topo.
+    #
+    # Isso evita erros de parsing em ferramentas BDD que exigem essa diretiva.
+    def self.corrigir_language(texto)
+      linhas = texto.lines
+      primeira_language = linhas.find { |linha| linha.strip.start_with?('# language:') }
+
+      # Remove todas as linhas duplicadas de language
+      linhas.reject! { |linha| linha.strip.start_with?('# language:') }
+
+      if primeira_language
+        # Insere a linha de language original no topo
+        linhas.unshift(primeira_language.strip + "\n")
+      else
+        # Se não existir, detecta o idioma e insere padrão
+        idioma = detectar_idioma(linhas.join)
+        linhas.unshift("# language: #{idioma}\n")
+      end
+
+      linhas.join
+    end
+
+    # Detecta o idioma do conteúdo baseado nas palavras-chave Gherkin presentes.
+    #
+    # Retorna:
+    # - 'pt' se encontrar palavras-chave em português (Dado, Quando, Então, E).
+    # - 'en' se encontrar palavras-chave em inglês (Given, When, Then, And).
+    # - 'pt' como padrão se não detectar.
+    #
+    # Isso ajuda a definir a diretiva # language: corretamente.
+    def self.detectar_idioma(texto)
+      return 'pt' if texto =~ /Dado|Quando|Então|E /i
+      return 'en' if texto =~ /Given|When|Then|And /i
+      'pt' # padrão
+    end
+
+    # Corrige a indentação das linhas para seguir o padrão Gherkin:
+    #
+    # Feature e Funcionalidade no nível 0 (sem indentação).
+    # Scenario e Scenario Outline com 2 espaços.
+    # Passos (Given, When, Then, And e equivalentes PT) com 4 espaços.
+    # Tabelas (linhas que começam com '|') com 6 espaços.
+    #
+    # Outras linhas recebem indentação padrão de 2 espaços.
+    #
+    # Essa padronização melhora legibilidade e compatibilidade com parsers Gherkin.
+    def self.corrigir_indentacao(texto)
+      linhas = texto.lines.map do |linha|
+        if linha.strip.start_with?('Feature', 'Funcionalidade')
+          linha.strip + "\n"
+        elsif linha.strip.start_with?('Scenario', 'Cenário', 'Scenario Outline', 'Esquema do Cenário')
+          "  #{linha.strip}\n"
+        elsif linha.strip.start_with?('Given', 'When', 'Then', 'And', 'Dado', 'Quando', 'Então', 'E')
+          "    #{linha.strip}\n"
+        elsif linha.strip.start_with?('|')
+          "      #{linha.strip}\n"
+        else
+          "  #{linha.strip}\n"
+        end
+      end
+      linhas.join
+    end
+  end
+end

data/lib/bddgenx/support/remover_steps_duplicados.rb

@@ -0,0 +1,81 @@
+module Bddgenx
+  module Utils
+    class StepCleaner
+      # Remove passos duplicados em um texto de cenários BDD,
+      # levando em conta o idioma para identificar as keywords (Given, When, Then, And / Dado, Quando, Então, E)
+      #
+      # Parâmetros:
+      # - texto: string contendo o texto do cenário BDD
+      # - idioma: 'en' para inglês ou qualquer outro para português
+      #
+      # Retorna o texto com passos duplicados removidos, preservando a ordem original
+      def self.remover_steps_duplicados(texto, idioma)
+        # Define as keywords principais para o idioma
+        keywords = idioma == 'en' ? %w[Given When Then And] : %w[Dado Quando Então E]
+
+        # Conjunto para rastrear passos já vistos (versão canônica)
+        seen = Set.new
+        resultado = []
+
+        # Percorre linha a linha
+        texto.each_line do |linha|
+          # Verifica se a linha começa com uma das keywords
+          if keywords.any? { |kw| linha.strip.start_with?(kw) }
+            # Canonicaliza o passo para comparação sem variações irrelevantes
+            canonical = canonicalize_step(linha, keywords)
+
+            # Só adiciona se ainda não viu o passo canônico
+            unless seen.include?(canonical)
+              seen.add(canonical)
+              resultado << linha
+            end
+          else
+            # Linhas que não são passos são adicionadas normalmente
+            resultado << linha
+          end
+        end
+
+        # Retorna o texto reconstruído sem duplicatas
+        resultado.join
+      end
+
+      # Gera uma versão canônica (normalizada) do passo para facilitar
+      # a identificação de duplicatas mesmo com variações menores de texto.
+      #
+      # Exemplo: Dado "usuario" fez login  e Dado <usuario> fez login
+      # gerarão o mesmo canonical para evitar repetição.
+      #
+      # Passos:
+      # - Remove a keyword (Given, When, etc) do começo
+      # - Substitui textos entre aspas, placeholders <> e números por <param>
+      # - Remove acentuação e pontuação para normalizar
+      # - Converte para minúsculas e remove espaços extras
+      #
+      # Parâmetros:
+      # - linha: string com o passo completo
+      # - keywords: array com as keywords para remoção
+      #
+      # Retorna uma string normalizada representando o passo
+      def self.canonicalize_step(linha, keywords)
+        texto = linha.dup.strip
+
+        # Remove a keyword do início, se existir
+        keywords.each do |kw|
+          texto.sub!(/^#{kw}\s+/i, '')
+        end
+
+        # Substitui textos entre aspas, placeholders e números por <param>
+        texto.gsub!(/"[^"]*"|<[^>]*>|\b\d+\b/, '<param>')
+
+        # Remove acentos usando Unicode Normalization Form KD (decompõe caracteres)
+        texto = Unicode.normalize_KD(texto).gsub(/\p{Mn}/, '')
+
+        # Remove pontuação, deixando apenas letras, números, espaços e <>
+        texto.gsub!(/[^a-zA-Z0-9\s<>]/, '')
+
+        # Converte para minúsculas, remove espaços extras e retorna
+        texto.downcase.strip.squeeze(" ")
+      end
+    end
+  end
+end

data/lib/bddgenx/{utils → support}/validator.rb

@@ -4,7 +4,6 @@
 # Este arquivo define a classe Validator, responsável por validar a estrutura
 # de uma história antes de gerar cenários ou arquivos .feature.
 # Verifica presença de cabeçalho obrigatório e integridade dos grupos de passos.
-
 module Bddgenx
   # Valida objetos de história garantindo que possuam campos e blocos corretos.
   class Validator

data/lib/bddgenx.rb

@@ -1,7 +1,16 @@
 #!/usr/bin/env ruby
-require_relative 'bddgenx/runner'
+# Shebang para permitir execução direta do script no Linux/macOS, usando o interpretador Ruby do PATH
 
-# Só executa quando este arquivo for o entrypoint, não no require da gem
+require_relative 'env'
+# Carrega o arquivo 'env.rb' relativo a este script. Geralmente contém configurações e carregamento da gem Bddgenx.
+
+## Evita warns na saida do console
+Gem::Specification.reset
+# Reseta as especificações das gems carregadas para evitar warnings no console, comum em alguns ambientes Ruby.
+
+# Só executa o código abaixo quando este arquivo for o ponto de entrada (entrypoint) da aplicação,
+# evitando que o código seja executado quando este arquivo for apenas requerido por outro arquivo.
 if __FILE__ == $PROGRAM_NAME
   Bddgenx::Runner.execute
+  # Invoca o método principal da gem Bddgenx para iniciar a execução da ferramenta.
 end

data/lib/env.rb

@@ -0,0 +1,46 @@
+# lib/bddgenx/env.rb
+
+# Carregamento de bibliotecas padrão e gems externas usadas no projeto
+
+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
+
+# Configura o caminho base do projeto e carrega as gems definidas no Gemfile (se existir)
+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
+
+# 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)
+
+# 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
+
+# Parser do arquivo de entrada e versão da gem
+require_relative  'parser'                                    # Parser para interpretar arquivos de entrada
+require_relative  'version'                                   # Informação da versão da gem
+
+# 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
+
+# Define variável de ambiente global para indicar que o ambiente BDDGENX está em modo desenvolvimento
+ENV['BDDGENX_ENV'] = 'development'

data/lib/{bddgenx/utils/parser.rb → parser.rb}

@@ -4,9 +4,7 @@
 # Este arquivo define a classe Parser, responsável por ler e interpretar
 # arquivos de história (.txt), extraindo cabeçalho e blocos de passos e exemplos.
 # Utiliza constantes para identificação de tipos de blocos e suporta idiomas
-# Português e Inglês na marcação de idioma e blocos de exemplos.
-require_relative '../ia/gemini_cliente'
-
+# Português e Inglês na marcação de idioma e blocos de exemplos
 module Bddgenx
   # Tipos de blocos reconhecidos na história (.txt), incluindo variações em Português
   # e Inglês para blocos de exemplo.

data/lib/version.rb

@@ -0,0 +1,14 @@
+module Bddgenx
+  # Caminho absoluto para o arquivo VERSION, que fica 3 níveis acima deste arquivo:
+  # lib/bddgenx/version.rb → lib/bddgenx → lib → raiz do projeto
+  VERSION_FILE = File.expand_path("../../VERSION", __FILE__)
+
+  # Lê o conteúdo do arquivo VERSION para definir a constante VERSION
+  # Se o arquivo não existir, exibe um aviso e define o valor padrão "0.0.0"
+  VERSION = if File.exist?(VERSION_FILE)
+              File.read(VERSION_FILE).strip
+            else
+              warn "WARNING: VERSION file not found, defaulting to 0.0.0"
+              "0.0.0"
+            end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bddgenx
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.5
 platform: ruby
 authors:
 - David Nascimento
@@ -52,6 +52,62 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.2
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: unicode
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
 description: Transforma arquivos .txt com histórias em arquivos .feature, com steps,
   rastreabilidade e integração com CI/CD.
 email:
@@ -70,20 +126,21 @@ files:
 - lib/bddgenx/assets/fonts/DejaVuSansMono-BoldOblique.ttf
 - lib/bddgenx/assets/fonts/DejaVuSansMono-Oblique.ttf
 - lib/bddgenx/assets/fonts/DejaVuSansMono.ttf
-- lib/bddgenx/generator.rb
+- lib/bddgenx/generators/generator.rb
+- lib/bddgenx/generators/runner.rb
+- lib/bddgenx/generators/steps_generator.rb
+- lib/bddgenx/ia/chatgtp_cliente.rb
 - lib/bddgenx/ia/gemini_cliente.rb
-- lib/bddgenx/ia/gemini_generator.rb
-- lib/bddgenx/runner.rb
-- lib/bddgenx/steps_generator.rb
-- lib/bddgenx/utils/backup.rb
-- lib/bddgenx/utils/font_loader.rb
-- lib/bddgenx/utils/gherkin_cleaner.rb
-- lib/bddgenx/utils/parser.rb
-- lib/bddgenx/utils/pdf_exporter.rb
-- lib/bddgenx/utils/remover_steps_duplicados.rb
-- lib/bddgenx/utils/tracer.rb
-- lib/bddgenx/utils/validator.rb
-- lib/bddgenx/version.rb
+- lib/bddgenx/reports/backup.rb
+- lib/bddgenx/reports/pdf_exporter.rb
+- lib/bddgenx/reports/tracer.rb
+- lib/bddgenx/support/font_loader.rb
+- lib/bddgenx/support/gherkin_cleaner.rb
+- lib/bddgenx/support/remover_steps_duplicados.rb
+- lib/bddgenx/support/validator.rb
+- lib/env.rb
+- lib/parser.rb
+- lib/version.rb
 homepage: https://github.com/David-Nascimento/bdd-generation
 licenses:
 - MIT

data/lib/bddgenx/ia/gemini_generator.rb

@@ -1,127 +0,0 @@
-# lib/bddgenx/cli.rb
-# 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.
-require 'dotenv/load'
-require 'fileutils'
-require_relative 'utils/parser'
-require_relative 'generator'
-require_relative 'utils/pdf_exporter'
-require_relative 'steps_generator'
-require_relative 'utils/validator'
-require_relative 'utils/backup'
-require_relative 'ia/gemini_cliente'
-require_relative 'utils/gherkin_cleaner'
-require_relative 'gemini_generator'
-
-module Bddgenx
-  # Ponto de entrada da gem: coordena todo o processo de geração BDD.
-  class Runner
-    def self.choose_files(input_dir)
-      ARGV.any? ? selecionar_arquivos_txt(input_dir) : choose_input(input_dir)
-    end
-
-    def self.selecionar_arquivos_txt(input_dir)
-      ARGV.map do |arg|
-        nome = arg.end_with?('.txt') ? arg : "#{arg}.txt"
-        path = File.join(input_dir, nome)
-        unless File.exist?(path)
-          warn "⚠️  Arquivo não encontrado: #{path}"
-          next
-        end
-        path
-      end.compact
-    end
-
-    def self.choose_input(input_dir)
-      files = Dir.glob(File.join(input_dir, '*.txt'))
-      if files.empty?
-        warn "❌ Não há arquivos .txt no diretório #{input_dir}"; exit 1
-      end
-
-      puts "Selecione o arquivo de história para processar:"
-      files.each_with_index { |f, i| puts "#{i+1}. #{File.basename(f)}" }
-      print "Digite o número correspondente (ou ENTER para todos): "
-      choice = STDIN.gets.chomp
-
-      return files if choice.empty?
-      idx = choice.to_i - 1
-      unless idx.between?(0, files.size - 1)
-        warn "❌ Escolha inválida."; exit 1
-      end
-      [files[idx]]
-    end
-
-    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
-      end
-
-      total = features = steps = ignored = 0
-      skipped_steps = []
-      generated_pdfs = []
-      skipped_pdfs = []
-
-      arquivos.each do |arquivo|
-        total += 1
-        puts "\n🔍 Processando: #{arquivo}"
-
-        historia =
-          if modo == 'gemini'
-            puts "🤖 Gerando cenários com IA (Gemini)..."
-            begin
-              idioma = GeminiCliente.detecta_idioma_arquivo(arquivo)
-              historia = File.read(arquivo)
-              GeminiCliente.gerar_cenarios(historia, idioma)
-            rescue => e
-              ignored += 1
-              puts "❌ Falha ao gerar com Gemini: #{e.message}"
-              next
-            end
-          else
-            historia = Parser.ler_historia(arquivo)
-            unless Validator.validar(historia)
-              ignored += 1
-              puts "❌ História inválida: #{arquivo}"
-              next
-            end
-            historia
-          end
-
-        historia_limpa = GherkinCleaner.limpar(historia_ia_gerada)
-        feature_path, feature_content = Generator.gerar_feature(historia_limpa)
-
-        Backup.salvar_versao_antiga(feature_path)
-        features += 1 if Generator.salvar_feature(feature_path, feature_content)
-
-        if StepsGenerator.gerar_passos(feature_path)
-          steps += 1
-        else
-          skipped_steps << feature_path
-        end
-
-        FileUtils.mkdir_p('reports')
-        result = PDFExporter.exportar_todos(only_new: true)
-        generated_pdfs.concat(result[:generated])
-        skipped_pdfs.concat(result[:skipped])
-      end
-
-      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}"
-    end
-  end
-end

data/lib/bddgenx/utils/gherkin_cleaner.rb

@@ -1,57 +0,0 @@
-require 'set'
-require 'unicode'
-
-module Bddgenx
-  class GherkinCleaner
-    def self.limpar(texto)
-      texto = remover_blocos_markdown(texto)
-      texto = corrigir_language(texto)
-      texto = corrigir_indentacao(texto)
-      texto.strip
-    end
-
-    def self.remover_blocos_markdown(texto)
-      texto.gsub(/```[a-z]*\n?/i, '').gsub(/```/, '')
-    end
-
-    def self.corrigir_language(texto)
-      linhas = texto.lines
-      primeira_language = linhas.find { |linha| linha.strip.start_with?('# language:') }
-
-      # Remove duplicações de # language
-      linhas.reject! { |linha| linha.strip.start_with?('# language:') }
-
-      if primeira_language
-        linhas.unshift(primeira_language.strip + "\n")
-      else
-        idioma = detectar_idioma(linhas.join)
-        linhas.unshift("# language: #{idioma}\n")
-      end
-
-      linhas.join
-    end
-
-    def self.detectar_idioma(texto)
-      return 'pt' if texto =~ /Dado|Quando|Então|E /i
-      return 'en' if texto =~ /Given|When|Then|And /i
-      'pt' # padrão
-    end
-
-    def self.corrigir_indentacao(texto)
-      linhas = texto.lines.map do |linha|
-        if linha.strip.start_with?('Feature', 'Funcionalidade')
-          linha.strip + "\n"
-        elsif linha.strip.start_with?('Scenario', 'Cenário', 'Scenario Outline', 'Esquema do Cenário')
-          "  #{linha.strip}\n"
-        elsif linha.strip.start_with?('Given', 'When', 'Then', 'And', 'Dado', 'Quando', 'Então', 'E')
-          "    #{linha.strip}\n"
-        elsif linha.strip.start_with?('|')
-          "      #{linha.strip}\n"
-        else
-          "  #{linha.strip}\n"
-        end
-      end
-      linhas.join
-    end
-  end
-end

data/lib/bddgenx/utils/remover_steps_duplicados.rb

@@ -1,44 +0,0 @@
-require 'set'
-require 'unicode'
-
-module Bddgenx
-  module Utils
-    class StepCleaner
-      def self.remover_steps_duplicados(texto, idioma)
-        keywords = idioma == 'en' ? %w[Given When Then And] : %w[Dado Quando Então E]
-        seen = Set.new
-        resultado = []
-
-        texto.each_line do |linha|
-          if keywords.any? { |kw| linha.strip.start_with?(kw) }
-            canonical = canonicalize_step(linha, keywords)
-            unless seen.include?(canonical)
-              seen.add(canonical)
-              resultado << linha
-            end
-          else
-            resultado << linha
-          end
-        end
-
-        resultado.join
-      end
-
-      def self.canonicalize_step(linha, keywords)
-        # Remove keyword
-        texto = linha.dup.strip
-        keywords.each do |kw|
-          texto.sub!(/^#{kw}\s+/i, '')
-        end
-
-        # Generaliza: substitui textos entre aspas, colchetes e números por <param>
-        texto.gsub!(/"[^"]*"|<[^>]*>|\b\d+\b/, '<param>')
-
-        # Remove acentos e pontuação, normaliza espaços
-        texto = Unicode.normalize_KD(texto).gsub(/\p{Mn}/, '')
-        texto.gsub!(/[^a-zA-Z0-9\s<>]/, '')
-        texto.downcase.strip.squeeze(" ")
-      end
-    end
-  end
-end

data/lib/bddgenx/version.rb

@@ -1,11 +0,0 @@
-module Bddgenx
-  # Sobe 3 níveis: lib/bddgenx/version.rb → bddgenx → lib → [raiz do projeto]
-  VERSION_FILE = File.expand_path("../../../VERSION", __FILE__)
-
-  VERSION = if File.exist?(VERSION_FILE)
-              File.read(VERSION_FILE).strip
-            else
-              warn "WARNING: VERSION file not found, defaulting to 0.0.0"
-              "0.0.0"
-            end
-end