bddgenx 0.1.49 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 230aa1f7581925ef006f2a3a433edc0aafdd3054839ebaef6b0f1da0118b4753
-  data.tar.gz: 4107e5a54d49b50db2b705b78dcc0384d4469fa875d35cc781113fc70880d15f
+  metadata.gz: 691d4d259476c68894a8859cc74ab4d926fdfe3b7304f5a020f05843442f33d2
+  data.tar.gz: 0aeff404aee94ac4d8419dec2772379a0816fdb5ce69a1e8cf967d47499e2f48
 SHA512:
-  metadata.gz: d99c0c4be91f5ff9f78c4d4cea0280effff83cd0c25db1ac408a99e5f439fdd70a59c06b6d4b5fa0c25eb2ec8a681e86c085438535f99ec51ee4032a2e2ba000
-  data.tar.gz: dde6912e1e6a73b64a447d1516e5f79e84d75120083e0a79460e4acec59c7f3a6dc6b24da9f744c368db9993cb77f8ae951b8dea761121b4b64bb222455f992f
+  metadata.gz: c08188d0e944723b8e109063d2c2e682e335be6c05ff731f51962daba3a3dccac072201107fb23dda9f0d0b3901f75b97a10e1bcb289cf3305ad6deab8ccc198
+  data.tar.gz: fd8bf60a0b13bb05e63486daa3b4ccead3ddfdc4653046e5f48b252eede5cb8af35498d0d259a23870c203a5912a63a1c70cfc01fdd9b1e5141e58bc56d4c986

data/VERSION

@@ -1 +1 @@
-0.1.49
+1.0.0

data/lib/bddgenx/generator.rb

@@ -7,67 +7,68 @@
 # 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
-  # Gera cenários e arquivos .feature baseados em histórias e grupos de passos.
   class Generator
-    # Palavras-chave Gherkin em Português
-    # @return [Array<String>]
     GHERKIN_KEYS_PT = %w[Dado Quando Então E Mas].freeze
-
-    # Palavras-chave Gherkin em Inglês
-    # @return [Array<String>]
     GHERKIN_KEYS_EN = %w[Given When Then And But].freeze
-
-    # Mapeamento PT -> EN
-    # @return [Hash{String=>String}]
     GHERKIN_MAP_PT_EN = GHERKIN_KEYS_PT.zip(GHERKIN_KEYS_EN).to_h
-
-    # Mapeamento EN -> PT
-    # @return [Hash{String=>String}]
     GHERKIN_MAP_EN_PT = GHERKIN_KEYS_EN.zip(GHERKIN_KEYS_PT).to_h
-
-    # Conjunto de todas as palavras-chave suportadas (PT + EN)
-    # @return [Array<String>]
     ALL_KEYS = GHERKIN_KEYS_PT + GHERKIN_KEYS_EN
 
-    # Seleciona apenas as linhas que representam exemplos do cenário
-    #
-    # @param raw [Array<String>] Lista de linhas brutas do bloco de exemplos
-    # @return [Array<String>] Linhas que começam com '|' representando a tabela de exemplos
     def self.dividir_examples(raw)
       raw.select { |l| l.strip.start_with?('|') }
     end
 
-    # Gera conteúdo de um arquivo .feature a partir de um hash de história ou caminho para arquivo
-    #
-    # @param input [Hash, String]
-    #   Objeto de história com chaves :idioma, :quero, :como, :para, :grupos
-    #   Ou caminho para um arquivo de história que será lido via Parser.ler_historia
-    # @param override_path [String, nil]
-    #   Caminho de saída alternativo para o arquivo .feature
-    # @raise [ArgumentError] Se Parser.ler_historia lançar erro ao ler arquivo
-    # @return [Array(String, String)] Array com caminho e conteúdo gerado
     def self.gerar_feature(input, override_path = nil)
-      historia = input.is_a?(String) ? Parser.ler_historia(input) : input
-      idioma   = historia[:idioma] || 'pt'
+      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)
+        raw_txt = File.read(input)
+        historia = {
+          idioma: 'pt',
+          quero: File.basename(input, '.txt').tr('_', ' ').capitalize,
+          como: '',
+          para: '',
+          grupos: []
+        }
+
+        texto_gerado = if modo == :gemini
+                         GeminiCliente.gerar_cenarios(raw_txt)
+                       else
+                         ChatGPTCliente.gerar_cenarios(raw_txt)
+                       end
+
+        historia[:grupos] << {
+          tipo: 'gerado',
+          tag: 'ia',
+          passos: GherkinCleaner.limpar(texto_gerado).lines.map(&:strip).reject(&:empty?)
+        }
+
+      else
+        # Caminho tradicional (hash de entrada ou parser de arquivo)
+        historia = input.is_a?(String) ? Parser.ler_historia(input) : input
+      end
+
+      idioma = historia[:idioma] || 'pt'
       cont = 1
 
-      # Geração do nome base do arquivo
       nome_base = historia[:quero]
                     .gsub(/[^a-z0-9]/i, '_')
                     .downcase
-                    .split('_', 3)
-                    .first(3)
+                    .split('_')
+                    .reject(&:empty?)
+                    .first(5)
                     .join('_')
 
-      caminho = if override_path.is_a?(String)
-                  override_path
-                else
-                  "features/#{nome_base}.feature"
-                end
+      caminho = override_path || "features/#{nome_base}.feature"
 
-      # Definição das palavras-chave Gherkin conforme idioma
       palavras = {
         feature:  idioma == 'en' ? 'Feature'          : 'Funcionalidade',
         contexto: idioma == 'en' ? 'Background'       : 'Contexto',
@@ -77,75 +78,70 @@ module Bddgenx
         regra:    idioma == 'en' ? 'Rule'             : 'Regra'
       }
 
-      # Cabeçalho do arquivo .feature
       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
 
-      pt_map  = GHERKIN_MAP_PT_EN
-      en_map  = GHERKIN_MAP_EN_PT
-      detect  = ALL_KEYS
+      # Set para rastrear steps únicos
+      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]  || []
         exemplos = grupo[:exemplos] || []
         next if passos.empty?
 
-        # Linha de tags para o grupo
-        tag_line = ["@#{grupo[:tipo].downcase}",
-                    ("@#{grupo[:tag]}" if grupo[:tag])]
-                     .compact.join(' ')
+        tag_line = ["@#{grupo[:tipo].downcase}", ("@#{grupo[:tag]}" if grupo[:tag])].compact.join(' ')
+
+        conteudo << "    #{tag_line}\n"
 
         if exemplos.any?
-          # Cenário com Esquema
-          conteudo << "    #{tag_line}\n"
-          conteudo << "    #{palavras[:esquema]}: Exemplo #{cont} \n"
+          conteudo << "    #{palavras[:esquema]}: Exemplo #{cont}\n"
           cont += 1
+        else
+          conteudo << "    #{palavras[:cenario]}: #{grupo[:tipo].capitalize}\n"
+        end
 
-          # Passos do cenário
-          passos.each do |p|
-            parts = p.strip.split(' ', 2)
-            con_in = detect.find { |k| k.casecmp(parts[0]) == 0 } || parts[0]
-            text   = parts[1] || ''
-            out_conn = idioma == 'en' ? pt_map[con_in] || con_in : en_map[con_in] || con_in
-            conteudo << "      #{out_conn} #{text}\n"
-          end
+        passos.each do |p|
+          parts = p.strip.split(' ', 2)
+          con_in = detect.find { |k| k.casecmp(parts[0]) == 0 } || parts[0]
+          text = parts[1] || ''
+          out_conn = idioma == 'en' ? pt_map[con_in] || con_in : en_map[con_in] || con_in
+          linha_step = "      #{out_conn} #{text}"
+
+          next if passos_unicos.include?(linha_step)
+
+          passos_unicos << linha_step
+          conteudo << "#{linha_step}\n"
+        end
 
-          # Bloco de exemplos original
+        if exemplos.any?
           conteudo << "\n      #{palavras[:exemplos]}:\n"
           exemplos.select { |l| l.strip.start_with?('|') }.each do |line|
             cleaned = line.strip.gsub(/^"|"$/, '')
             conteudo << "        #{cleaned}\n"
           end
-          conteudo << "\n"
-        else
-          # Cenário simples
-          conteudo << "    #{tag_line}\n"
-          conteudo << "    #{palavras[:cenario]}: #{grupo[:tipo].capitalize}\n"
-          passos.each do |p|
-            parts = p.strip.split(' ', 2)
-            con_in = detect.find { |k| k.casecmp(parts[0]) == 0 } || parts[0]
-            text   = parts[1] || ''
-            out_conn = idioma == 'en' ? pt_map[con_in] || con_in : en_map[con_in] || con_in
-            conteudo << "      #{out_conn} #{text}\n"
-          end
-          conteudo << "\n"
         end
+
+        conteudo << "\n"
       end
 
       [caminho, conteudo]
     end
 
-    # Salva o conteúdo gerado em arquivo .feature no disco
-    #
-    # @param caminho [String] Caminho completo para salvar o arquivo
-    # @param conteudo [String] Conteúdo do arquivo .feature
-    # @return [nil]
+    def self.path_para_feature(arquivo_txt)
+      nome = File.basename(arquivo_txt, '.txt')
+      File.join('features', "#{nome}.feature")
+    end
+
     def self.salvar_feature(caminho, conteudo)
       FileUtils.mkdir_p(File.dirname(caminho))
       File.write(caminho, conteudo)

data/lib/bddgenx/ia/gemini_cliente.rb

@@ -0,0 +1,120 @@
+# 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
+    class GeminiCliente
+      GEMINI_API_URL = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent'.freeze
+
+      def self.gerar_cenarios(historia, idioma = 'pt')
+        api_key = ENV['GEMINI_API_KEY']
+
+        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 para solicitar saída Gherkin estruturada da IA
+        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
+        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 }
+
+        request_body = {
+          contents: [
+            {
+              role: "user",
+              parts: [{ text: prompt }]
+            }
+          ]
+        }
+
+        response = Net::HTTP.post(uri, request_body.to_json, { "Content-Type" => "application/json" })
+
+        if response.is_a?(Net::HTTPSuccess)
+          json = JSON.parse(response.body)
+
+          unless json["candidates"]&.is_a?(Array) && json["candidates"].any?
+            warn "❌ Resposta da IA sem candidatos válidos:"
+            warn JSON.pretty_generate(json)
+            return nil
+          end
+
+          texto_ia = json["candidates"].first.dig("content", "parts", 0, "text")
+          if texto_ia
+            # Sanitiza o texto para garantir formato Gherkin correto
+            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
+            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 nil
+          end
+        else
+          warn "❌ Erro ao chamar Gemini: #{response.code} - #{response.body}"
+          return nil
+        end
+      end
+
+      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' # padrão
+      end
+    end
+  end
+end

data/lib/bddgenx/ia/gemini_generator.rb

@@ -0,0 +1,127 @@
+# 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/runner.rb

@@ -4,7 +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'
@@ -12,6 +12,8 @@ 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'
 
 module Bddgenx
   # Ponto de entrada da gem: coordena todo o processo de geração BDD.
@@ -80,6 +82,8 @@ module Bddgenx
     #
     # @return [void]
     def self.execute
+      modo = ENV['BDDGENX_MODE'] || 'static'
+
       input_dir = 'input'
       Dir.mkdir(input_dir) unless Dir.exist?(input_dir)
 
@@ -106,7 +110,38 @@ module Bddgenx
         end
 
         # Geração de feature
-        feature_path, feature_content = Generator.gerar_feature(historia)
+        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
+            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)
+          else
+            ignored += 1
+            puts "❌ Falha ao gerar com IA: #{arquivo}"
+            next
+          end
+        else
+          feature_path, feature_content = Generator.gerar_feature(historia)
+        end
+
         Backup.salvar_versao_antiga(feature_path)
         features += 1 if Generator.salvar_feature(feature_path, feature_content)
 

data/lib/bddgenx/steps_generator.rb

@@ -8,80 +8,54 @@
 
 require 'fileutils'
 require 'strscan'  # Para uso de StringScanner
+require 'set'
 
 module Bddgenx
-  # Gera arquivos de definições de passos Ruby para Cucumber
-  # com base em arquivos .feature.
   class StepsGenerator
-    # Palavras-chave Gherkin em Português usadas em arquivos de feature
-    # @return [Array<String>]
     GHERKIN_KEYS_PT = %w[Dado Quando Então E Mas].freeze
-
-    # Palavras-chave Gherkin em Inglês usadas em arquivos de feature
-    # @return [Array<String>]
     GHERKIN_KEYS_EN = %w[Given When Then And But].freeze
-
-    # Conjunto de todas as palavras-chave suportadas (PT + EN)
-    # @return [Array<String>]
     ALL_KEYS = GHERKIN_KEYS_PT + GHERKIN_KEYS_EN
 
-    # Converte uma string para camelCase, útil para nomes de argumentos
-    #
-    # @param [String] str Texto de entrada a ser convertido
-    # @return [String] Versão em camelCase do texto
     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 definições de passos a partir de um arquivo .feature
-    #
-    # @param [String] feature_path Caminho para o arquivo .feature
-    # @raise [ArgumentError] Se feature_path não for String
-    # @return [Boolean] Retorna true se passos foram gerados, false se não houver passos
     def self.gerar_passos(feature_path)
-      # Valida tipo de entrada
-      unless feature_path.is_a?(String)
-        raise ArgumentError, "Caminho esperado como String, recebeu #{feature_path.class}"
-      end
+      raise ArgumentError, "Caminho esperado como String, recebeu #{feature_path.class}" unless feature_path.is_a?(String)
 
       linhas = File.readlines(feature_path)
 
-      # Detecta idioma no cabeçalho: "# language: pt" ou "# language: en"
       lang = if (m = linhas.find { |l| l =~ /^#\s*language:\s*(\w+)/i })
                m[/^#\s*language:\s*(\w+)/i, 1].downcase
              else
                'pt'
              end
 
-      # Mapas de tradução entre PT e EN
       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 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
 
-      # Se não encontrar passos, retorna false
       return false if linhas_passos.empty?
 
-      # Cria diretório e arquivo de saída
       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"
 
+      passos_unicos = Set.new
+
       linhas_passos.each do |linha|
         palavra_original, restante = linha.split(' ', 2)
 
-        # Define palavra-chave no idioma de saída
         chave = case lang
                 when 'en' then pt_para_en[palavra_original] || palavra_original
-                else         en_para_pt[palavra_original] || palavra_original
+                else           en_para_pt[palavra_original] || palavra_original
                 end
 
         texto_bruto = restante.dup
@@ -111,11 +85,14 @@ module Bddgenx
           end
         end
 
-        # Escapa aspas no padrão
         padrao_seguro = padrao.gsub('"', '\\"')
-        assinatura = "#{chave}(\"#{padrao_seguro}\")"
 
-        # Adiciona parâmetros se existirem tokens
+        # Impede duplicatas
+        next if passos_unicos.include?(padrao_seguro)
+
+        passos_unicos << padrao_seguro
+
+        assinatura = "#{chave}(\"#{padrao_seguro}\")"
         if tokens.any?
           argumentos = tokens.each_index.map { |i| "arg#{i+1}" }.join(', ')
           assinatura << " do |#{argumentos}|"
@@ -128,7 +105,6 @@ module Bddgenx
         conteudo << "end\n\n"
       end
 
-      # Escreve arquivo de saída
       File.write(arquivo_saida, conteudo)
       puts "✅ Steps gerados: #{arquivo_saida}"
       true

data/lib/bddgenx/utils/gherkin_cleaner.rb

@@ -0,0 +1,57 @@
+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/parser.rb

@@ -5,6 +5,7 @@
 # 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'
 
 module Bddgenx
   # Tipos de blocos reconhecidos na história (.txt), incluindo variações em Português
@@ -42,10 +43,13 @@ module Bddgenx
     def self.ler_historia(caminho_arquivo)
       # Carrega linhas do arquivo, preservando linhas vazias e encoding UTF-8
       linhas = File.readlines(caminho_arquivo, encoding: 'utf-8').map(&:rstrip)
+      # parser.rb (durante leitura do .txt)
+      primeira_linha = File.readlines(caminho_arquivo).first
+      idioma_forcado = primeira_linha&.match(/^#\s*lang(?:uage)?\s*:\s*(\w+)/i)&.captures&.first
 
       # Detecta idioma no topo do arquivo: suporta '# lang: <codigo>' ou '# language: <codigo>'
       idioma = 'pt'
-      if linhas.first =~ /^#\s*lang(?:uage)?\s*:\s*(\w+)/i
+      if linhas.first == idioma_forcado
         idioma = Regexp.last_match(1).downcase
         linhas.shift
       end

data/lib/bddgenx/utils/pdf_exporter.rb

@@ -9,7 +9,7 @@
 require 'prawn'
 require 'prawn/table'
 require 'fileutils'
-require_relative 'fontLoader'
+require_relative 'font_loader'
 
 # Suprime aviso de internacionalização para fontes AFM internas
 Prawn::Fonts::AFM.hide_m17n_warning = true

data/lib/bddgenx/utils/remover_steps_duplicados.rb

@@ -0,0 +1,44 @@
+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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bddgenx
 version: !ruby/object:Gem::Version
-  version: 0.1.49
+  version: 1.0.0
 platform: ruby
 authors:
 - David Nascimento
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-16 00:00:00.000000000 Z
+date: 2025-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prawn
@@ -28,28 +28,28 @@ dependencies:
   name: prawn-table
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.37.0
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.37.0
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: prawn-svg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.2
 description: Transforma arquivos .txt com histórias em arquivos .feature, com steps,
@@ -71,12 +71,16 @@ files:
 - lib/bddgenx/assets/fonts/DejaVuSansMono-Oblique.ttf
 - lib/bddgenx/assets/fonts/DejaVuSansMono.ttf
 - lib/bddgenx/generator.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/fontLoader.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