gitpr-cli 0.0.11__py3-none-any.whl

main.py

@@ -0,0 +1,299 @@
+import os
+from datetime import datetime
+import click
+import sys
+
+# Importações dos nossos módulos internos atualizadas
+from src.config import setup_environment, check_internet_connection, get_ai_provider
+from src.updater import check_and_update, __version__
+from src.core import (
+    get_git_diff, 
+    get_git_full_diff,
+    get_current_branch, 
+    generate_pr_content,  
+    generate_skill_template,
+    install_git_hooks
+)
+from src.linter_engine import parse_diff_and_lint
+
+
+def print_banner():
+    """Exibe a assinatura ASCII Art do projeto"""
+    banner = """
+ ,----.   ,--.  ,--.  ,------. ,------.  
+'  .-./   `--',-'  '-.|  .--. '|  .--. ' 
+|  | .---.,--.'-.  .-'|  '--' ||  '--'.' 
+'  '--'  ||  |  |  |  |  | --' |  |\  \  
+ `------' `--'  `--'  `--'     `--' '--' 
+                                         
+"""
+    click.secho(banner, fg="cyan", bold=True)
+    click.secho(f"  🚀 Automação Inteligente de PRs com IA (v{__version__})", fg="yellow", bold=True)
+    click.secho("  Opções: -c,--commit | -r,--review | -f,--fullreview | -l,--linter | -s,--skill | -u,--update | -ih,--installhooks | -h ou --help\n", fg="white", dim=True)
+
+
+# Configuração nativa do Click para aceitar -h além de --help
+@click.command()
+@click.help_option('-h', '--help', help='Mostra esta mensagem e sai.')
+@click.option('-c', '--commit', is_flag=True, help="Gera apenas a mensagem de commit e exibe no console.")
+@click.option('-r', '--review', is_flag=True, help="Faz um code review das alterações locais (git diff).")
+@click.option('-f', '--fullreview', is_flag=True, help="Faz um code review de todas as alterações desde a branch principal (origin/main).")
+@click.option('-l', '--linter', is_flag=True, help="Roda apenas o linter estático local (ideal para CI/CD).")
+@click.option('-s', '--skill', is_flag=True, help="Gera o arquivo de template .gitpr.md na pasta atual.")
+@click.option('-u', '--update', is_flag=True, help="Verifica e instala a versão mais recente do GitPR.")
+@click.option('-ih', '--installhooks', is_flag=True, help="Instala automaticamente os Git Hooks de validação no projeto.")
+@click.option('--hook', type=click.Path(), hidden=True, help="Caminho do arquivo de commit (uso interno dos hooks).")
+@click.option('-q', '--quiet', is_flag=True, hidden=True, help="Oculta o banner e logs não essenciais (uso interno).")
+@click.option('-i', '--input', type=click.Path(exists=True), help="Caminho de um arquivo específico para análise completa.")
+@click.option('-p', '--provider', type=click.Choice(['gemini', 'deepseek']), help="Força a utilização de um provedor de IA específico nesta execução.")
+def cli(commit, review, fullreview, linter, skill, update, installhooks, hook, quiet, provider, input):
+    """
+    GitPR CLI - Automação de PRs e Code Review com IA.
+
+    COMPORTAMENTO PADRÃO (Sem opções):
+    Faz o fetch, compara com a branch principal remota e gera um arquivo Markdown (.md) com a descrição completa para o Pull Request.
+    """
+    # Silencia o banner se estiver no modo quiet ou via hook
+    if not quiet and not hook:
+        print_banner()
+
+    # Identifica se a ferramenta está rodando como binário (PyInstaller) ou via PIP
+    is_compiled = getattr(sys, 'frozen', False)
+
+    # Limpeza do Hot-Swap (Apenas no modo Binário)
+    if is_compiled:
+        old_exe = sys.executable + ".old"
+        if os.path.exists(old_exe):
+            try:
+                os.remove(old_exe)
+            except OSError:
+                pass
+
+    if linter:
+        diff_text = get_git_diff()
+        
+        if not diff_text or not diff_text.strip():
+            if not quiet: click.secho("✅ Nada para validar (diff vazio).", fg="green")
+            return
+
+        linter_results = parse_diff_and_lint(diff_text)
+        
+        has_warnings = len(linter_results["warnings"]) > 0
+        has_errors = len(linter_results["errors"]) > 0
+
+        # Processamento de Warnings (Apenas Avisos)
+        if has_warnings:
+            # Os avisos DEVEM aparecer sempre, mesmo no modo quiet
+            click.secho(f"\n⚠️ O Linter gerou {len(linter_results['warnings'])} aviso(s) de boas práticas:", fg="yellow", bold=True)
+            for alert in linter_results["warnings"]:
+                click.echo(f"  - {alert}")
+
+        # Processamento de Erros (Críticos, Bloqueiam o Commit)
+        if has_errors:
+            # Os erros DEVEM aparecer sempre, mesmo no modo quiet
+            click.secho(f"\n🚨 Falha na validação! Encontrados {len(linter_results['errors'])} erro(s) críticos:", fg="red", bold=True)
+            for alert in linter_results["errors"]:
+                click.echo(f"  - {alert}")
+            # Trava o Git apenas se houver erros críticos
+            sys.exit(1)
+        
+        # Sucesso silencioso (Nenhum erro crítico encontrado)
+        if not quiet: 
+            if has_warnings:
+                click.secho("\n✅ Código aprovado com avisos. O commit prosseguirá.", fg="green")
+            else:
+                click.secho("\n✅ Código limpo! Nenhuma violação encontrada pelo Linter local.", fg="green", bold=True)
+        return
+
+    # Guardião de Conexão (Failing Fast)
+    check_internet_connection()
+
+    # Módulo de Atualização (Pip-Aware)
+    if update:
+        if is_compiled:
+            click.secho("🔍 Verificando atualizações no GitHub...", fg="cyan")
+            check_and_update()
+        else:
+            click.secho("💡 Como você instalou via PIP, atualize rodando: pip install --upgrade gitpr-cli", fg="cyan", bold=True)
+        return
+    else:
+        # Verificação automática em segundo plano a cada uso (Apenas binário)
+        if is_compiled:
+            check_and_update()
+
+    # Opção --skill: Gera o template e encerra
+    if skill:
+        generate_skill_template()
+        return
+    
+    if installhooks:
+        if install_git_hooks():
+            click.secho("\n✅ Git Hooks instalados com sucesso!", fg="green", bold=True)
+            click.echo("O Linter será agora executado automaticamente antes de cada commit.")
+            
+            click.echo("\n---")
+            click.echo("📚 Guias de Utilização:")
+            
+            # Link da documentação geral de Hooks
+            click.echo("• Como utilizar Git Hooks:")
+            click.secho("  https://github.com/natanfiuza/gitpr/blob/main/docs/git-hooks-locais.md", fg="blue")
+            
+            # Novo link: Documentação de Regras Customizadas
+            click.echo("• Como criar novas regras de Linter (.gitpr.linter.yml):")
+            click.secho("  https://github.com/natanfiuza/gitpr/blob/main/docs/linter-regras-customizadas.md", fg="blue")
+            click.echo("---\n")
+        return
+    
+    # Validação do Modo Input
+    if input and not (review or fullreview):
+        click.secho("\n❌ Erro: A opção --input (-i) só pode ser utilizada em conjunto com --review (-r) ou --fullreview (-f).", fg="red", bold=True)
+        return
+    
+    # Garante que o ambiente e as chaves estão configurados
+    setup_environment()
+
+    # Determina o provedor de IA a ser usado (opção de linha de comando tem prioridade)
+    active_provider = provider if provider else get_ai_provider()
+    
+    # Determina o tipo de ação e qual diff capturar
+    action_type = "pr"
+    diff_text = ""
+    
+    if input:
+        # MODO FILE REVIEW: Lê o arquivo físico em vez do git diff
+        action_type = "filereview"
+        try:
+            with open(input, "r", encoding="utf-8") as f:
+                diff_text = f.read()
+            click.secho(f"📄 Modo Arquivo: Analisando conteúdo integral de '{input}'...", fg="blue")
+        except Exception as e:
+            click.secho(f"❌ Erro ao ler o arquivo: {e}", fg="red")
+            return
+    elif commit:
+        action_type = "commit"
+        diff_text = get_git_diff()
+    elif review:
+        action_type = "review"
+        diff_text = get_git_diff()
+    elif fullreview:
+        action_type = "fullreview" 
+        diff_text = get_git_full_diff()
+    else:
+        # Padrão: Descrição de PR usando o Full Diff contra a main remota
+        action_type = "pr"
+        diff_text = get_git_full_diff()
+   
+    # CRÍTICO: Avisa o usuário antes de sair se não houver alterações
+    if not diff_text or not diff_text.strip():
+        click.secho("\n⚠️ Nenhum código novo encontrado. Faça alguma alteração ou verifique sua branch antes de rodar o comando.\n", fg="yellow")
+        return
+
+    # Chama a IA de acordo com active_provider utilizando a nova assinatura da função
+    # A assinatura requer: action_folder, action_type, diff_text, provider
+    # Usamos o próprio action_type como action_folder, pois a função lida com isso internamente.
+    data = generate_pr_content(action_type, action_type, diff_text, active_provider)
+    if not data:
+        return
+
+    # Processamento da Saída
+    branch_name = get_current_branch()
+    safe_branch_name = branch_name.replace("/", "-").replace("\\", "-")
+    current_time = datetime.now().strftime("%Y%m%d%H%M%S")
+
+    # Apenas Commit no console
+    if action_type == "commit":
+        msg = data.get('commit_message', 'Atualização de código')
+
+        if hook:
+            # MODO HOOK: Injeta a mensagem direto no arquivo do Git
+            try:
+                with open(hook, "r", encoding="utf-8") as f:
+                    original_content = f.read()
+                
+                # Coloca a sugestão no topo, mantendo os comentários originais do Git abaixo
+                with open(hook, "w", encoding="utf-8") as f:
+                    f.write(f"{msg}\n\n{original_content}")
+                
+                click.secho(f"✅ Mensagem injetada com sucesso no editor!", fg="green")
+            except Exception as e:
+                click.secho(f"❌ Erro ao injetar no hook: {e}", fg="red")
+        else:
+            # MODO CONSOLE: O comportamento original que já existia
+            click.secho("\n💡 Dica: Use sem --commit para gerar o PR completo.\n", fg="yellow")
+            click.secho("\n📝 Sugestão de Commit:\n", fg="green", bold=True)
+            click.echo(msg)
+            click.echo("\n")
+        return
+
+    # Code Review e File Review (Arquivo)  
+    if action_type in ["review", "fullreview", "filereview"]:
+        
+        if fullreview:
+            pattern = os.getenv("OUTPUT_FILE_NAME_FULLREVIEW", "{branch}_{datetime}_PR_FULLREVIEW.txt")
+        elif action_type == "filereview":
+            pattern = os.getenv("OUTPUT_FILE_NAME_FILEREVIEW", "{branch}_{datetime}_FILE_REVIEW.txt")
+        else:
+            pattern = os.getenv("OUTPUT_FILE_NAME_REVIEW", "{branch}_{datetime}_PR_REVIEW.txt")            
+
+        output_filename = pattern.format(
+            branch=safe_branch_name,
+            datetime=current_time
+        )
+        content = data.get('review', 'Nenhuma análise gerada.')
+        
+        # Chama o Linter. Se for "filereview", ativa o modo de arquivo completo.
+        if action_type == "filereview":
+            linter_results = parse_diff_and_lint(diff_text, is_full_file=True, file_path=input)
+        else:
+            linter_results = parse_diff_and_lint(diff_text)
+            
+        all_alerts = linter_results["errors"] + linter_results["warnings"]
+        
+        if all_alerts:
+            
+            click.secho(f"⚠️ Atenção! Encontrados {len(all_alerts)} alertas nas regras do Linter.", fg="yellow")
+            
+            # Monta o cabeçalho com os erros do linter
+            linter_header = "## 🚨 Alertas de Análise Estática Local (Regras YAML)\n\n"
+            for alert in all_alerts:
+                linter_header += f"- {alert}\n"
+            linter_header += "\n---\n\n## 🤖 Code Review da IA\n\n"
+            
+            # Injeta o cabeçalho no topo do conteúdo gerado pela IA
+            content = linter_header + content
+        else:
+            click.secho("✅ Linter Local passou sem violações de regras!", fg="green")
+
+        try:
+            with open(output_filename, "w", encoding="utf-8") as f:
+                f.write(content)
+            click.secho(f"\n✅ Code Review gerado com sucesso: '{output_filename}'", fg="green", bold=True)
+        except Exception as e:
+            click.secho(f"\n❌ Erro ao salvar o review: {e}", fg="red")
+        return
+
+    # Pull Request Padrão (Arquivo .md)
+    filename_pattern = os.getenv("OUTPUT_FILE_NAME", "{branch}_{datetime}_PR_DESC.md")
+    output_filename = filename_pattern.format(branch=safe_branch_name, datetime=current_time)
+
+    markdown_content = f"""# 🚀 Sugestão de Pull Request
+
+**Commit Message Recomendada:**
+```text
+{data.get('commit_message', 'Atualização de código')}
+```
+
+---
+
+{data.get('pr_description', 'Sem descrição detalhada.')}
+"""
+
+    try:
+        with open(output_filename, "w", encoding="utf-8") as f:
+            f.write(markdown_content)
+        click.secho(f"\n✅ Sucesso! O arquivo '{output_filename}' foi gerado na pasta atual.", fg="green", bold=True)
+    except Exception as e:
+        click.secho(f"\n❌ Erro ao guardar o arquivo: {e}", fg="red")
+        
+if __name__ == "__main__":
+    cli()

security.py

@@ -0,0 +1,42 @@
+from cryptography.fernet import Fernet
+from pathlib import Path
+
+# Caminho onde a chave mestra de criptografia será guardada
+KEY_PATH = Path.home() / ".gitpr" / "secret.key"
+
+def get_or_create_key():
+    """
+    Recupera a chave mestra do disco ou gera uma nova caso não exista.
+    """
+    if not KEY_PATH.exists():
+        KEY_PATH.parent.mkdir(parents=True, exist_ok=True)
+        key = Fernet.generate_key()
+        with open(KEY_PATH, "wb") as key_file:
+            key_file.write(key)
+    return open(KEY_PATH, "rb").read()
+
+def encrypt_data(data: str) -> str:
+    """
+    Transforma uma string em um hash criptografado.
+    """
+    if not data:
+        return ""
+    key = get_or_create_key()
+    f = Fernet(key)
+    # Encripta a string (convertida em bytes) e retorna como string legível
+    return f.encrypt(data.encode()).decode()
+
+def decrypt_data(encrypted_data: str) -> str:
+    """
+    Transforma o hash criptografado de volta na string original.
+    """
+    if not encrypted_data:
+        return ""
+    try:
+        key = get_or_create_key()
+        f = Fernet(key)
+        # Desencripta e converte de volta para string (utf-8)
+        return f.decrypt(encrypted_data.encode()).decode()
+    except Exception:
+        # Caso a chave seja inválida ou os dados estejam corrompidos
+        return ""

updater.py

@@ -0,0 +1,90 @@
+import urllib.request
+import json
+import os
+import sys
+import shutil
+import click
+
+# Versão atual do seu executável local (Atualize isso a cada novo build!)
+__version__ = "0.0.11"
+GITHUB_API_URL = "https://api.github.com/repos/natanfiuza/gitpr/releases/latest"
+
+def get_gitpr_dir():
+    """Retorna o diretório ~/.gitpr/"""
+    return os.path.join(os.path.expanduser("~"), ".gitpr")
+
+def check_and_update():
+    """Verifica na API do GitHub se há um novo release com um hash diferente."""
+    try:
+        # Timeout curto para não travar a CLI se a API do GitHub estiver lenta
+        req = urllib.request.Request(GITHUB_API_URL, headers={'User-Agent': 'GitPR-Updater'})
+        with urllib.request.urlopen(req, timeout=3) as response:
+            data = json.loads(response.read().decode())
+        
+        # Pega a versão remota (apenas para log/exibição)
+        remote_version = data.get("tag_name", "").replace("v", "")
+        
+        # Procura o executável nos assets
+        assets = data.get("assets", [])
+        exe_asset = next((a for a in assets if a.get("name") == "gitpr.exe"), None)
+        
+        if not exe_asset:
+            return # Nenhum executável encontrado no release mais recente
+
+        remote_digest = exe_asset.get("digest", "").replace("sha256:", "")
+        download_url = exe_asset.get("browser_download_url")
+
+        if not remote_digest or not download_url:
+            return
+
+        # Compara com o hash local
+        gitpr_dir = get_gitpr_dir()
+        sha_file = os.path.join(gitpr_dir, ".sha256")
+        local_digest = ""
+        
+        if os.path.exists(sha_file):
+            with open(sha_file, "r") as f:
+                local_digest = f.read().strip()
+
+        # Se os hashes forem diferentes, dispara o update!
+        if remote_digest != local_digest:
+            click.secho(f"\n🚀 Nova versão do GitPR encontrada (v{remote_version})!", fg="green", bold=True)
+            click.secho("Baixando atualização em segundo plano...", fg="cyan")
+            _perform_hot_swap(download_url, remote_digest, sha_file)
+
+    except Exception as e:
+        # Silencia erros de timeout ou rede para não atrapalhar o fluxo do usuário
+        click.secho(f"Debug Updater: {e}", fg="red") # Descomente para debugar
+        pass
+
+def _perform_hot_swap(download_url, new_digest, sha_file):
+    """Faz o download e substitui o executável atual (Hot-Swap)."""
+    current_exe = sys.executable
+    
+    # Se não estiver rodando como executável compilado (PyInstaller), aborta o update
+    if not getattr(sys, 'frozen', False):
+        click.secho("⚠️ Aviso: Rodando via script Python. O Auto-Update funciona apenas no executável compilado.", fg="yellow")
+        return
+
+    old_exe = current_exe + ".old"
+    
+    try:
+        # 1. Renomeia o executável atual que está em uso
+        if os.path.exists(old_exe):
+            os.remove(old_exe) # Remove restos antigos se existirem
+        os.rename(current_exe, old_exe)
+        
+        # 2. Faz o download direto para o caminho original
+        urllib.request.urlretrieve(download_url, current_exe)
+        
+        # 3. Salva o novo hash
+        with open(sha_file, "w") as f:
+            f.write(new_digest)
+            
+        click.secho(f"✅ Atualização concluída com sucesso! Na próxima execução você já usará a nova versão.\n", fg="green", bold=True)
+        
+    except Exception as e:
+        # Se algo falhar na renomeação/download, tenta desfazer a bagunça
+        click.secho(f"❌ Falha ao aplicar atualização: {e}", fg="red")
+        if os.path.exists(old_exe) and not os.path.exists(current_exe):
+            os.rename(old_exe, current_exe)