gitpr-cli 0.0.24__py3-none-any.whl → 0.0.26__py3-none-any.whl

{gitpr_cli-0.0.24.dist-info → gitpr_cli-0.0.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitpr-cli
-Version: 0.0.24
+Version: 0.0.26
 Summary: Automação de PRs, Commits e Code Review com IA (Gemini e DeepSeek)
 Author-email: Natan Fiuza <contato@natanfiuza.dev.br>
 Requires-Python: >=3.10
@@ -126,7 +126,9 @@ You can pass the following *flags* for specific actions:
 * `-r` or `--review`: Performs a detailed **Code Review** of local changes.
 * `-f` or `--fullreview`: Performs a **Full Code Review** analyzing all changes since the remote branch.
 * `-i <file>` or `--input <file>`: **Full File Audit.** Must be used together with `-r` or `-f`; it ignores git history and does a Code Review of the entire file. Excellent for acting as a consultant on legacy code refactoring.
-* `--provider <gemini|deepseek>`: Forces the use of a specific AI only for this execution, ignoring your default saved in `.env`.
+* `--provider <gemini|deepseek|ollama>`: Forces the use of a specific AI only for this execution, ignoring your default saved in `.env`.
+* `--lang <code>`: Forces the interface language for this execution (e.g.: `en_us`, `pt_br`). Overrides `GITPR_LANG` in `.env` without persisting the change.
+* `-ch` or `--chat`: Opens the **Interactive Pair Programming Chat** — a TUI terminal where the AI sees your current diff and maintains a contextual conversation. Features memory per branch, slash commands (`/explain`, `/tests`, `/optimize`, `/clear`), auto-patching (F5), diff refresh (F2), and session export (F6).
 * `-l` or `--linter`: Runs **only the local static linter** (no AI calls). Ideal for use in CI/CD pipelines to block non-compliant code.
 * `-ih` or `--installhooks`: Automatically installs **local Git Hooks** (`pre-commit` and `prepare-commit-msg`) in your repository.
 * `-s` or `--skill`: Creates the AI context template files (`.gitpr.commit.md`, `.gitpr.pr.md`, `.gitpr.review.md`, `.gitpr.filereview.md`, `.gitpr.issue.md`, `.gitpr.blame.md`) and the Linter (`.gitpr.linter.yml`) at the project root.
@@ -165,6 +167,7 @@ The Linter analyzes only the **added lines** in your `git diff`, ensuring a focu
 GitPR is not tied to a single Artificial Intelligence. During initial setup, the user can choose their default engine. We currently support:
 * **Google Gemini** (Default: `gemini-2.5-flash`)
 * **DeepSeek** (Default: `deepseek-chat`)
+* **Ollama** (Local) — run models locally without internet, fully compatible with the OpenAI API format
 
 You can dynamically switch models by configuring the `GEMINI_API_MODEL` or `DEEPSEEK_API_MODEL` variables in your `~/.gitpr/.env` file, or switch in real-time using the `--provider` flag.
 
@@ -197,20 +200,35 @@ To force a specific language, set `GITPR_LANG=pt_br` or `GITPR_LANG=en` in `~/.g
 
 To keep this README concise, we detail the most advanced **DevOps** and **Continuous Integration** focused implementations in separate documents.
 
-If you want to implement GitPR as an automated quality barrier in your team, check out the guides below:
-
-* [**Local Git Hooks (Shift-Left)**](docs/git-hooks-locais.md): How to use `gitpr --installhooks` to create guardrails on the developer's machine and use AI to automatically write commit messages.
-* [**Customizable Static Linter**](docs/linter-regras-customizadas.md): How to create validation rules in `.gitpr.linter.yml` for CI/CD and pre-commit hooks.
-* [**Issue Generation and TUI Interface**](docs/issue-tui-help.md): How to use the terminal graphical interface (TUI) and the 3 context engines to manage structured Issues.
-* [**AI Code Review**](docs/code-review-ia.md): Guide to review modes (`--review`, `--fullreview`) and file auditing (`--input`).
-* [**AI Commit Messages**](docs/commit-message-ia.md): How to generate messages in the Conventional Commits standard and integrate with Git Hooks.
-* [**Code Archaeologist (Git Blame)**](docs/blame-arqueologo.md): How to trace the origin of business rules with `git blame` and AI.
-* [**Skills and Templates System**](docs/skill-template.md): How to customize AI behavior with `.gitpr.*.md` files.
-* [**Auto-Updater**](docs/auto-update.md): How GitPR's automatic update (hot-swap) works.
-* [**AI Providers**](docs/providers-ia.md): Configuration and selection between Google Gemini and DeepSeek.
-* [**Pull Request (Default Mode)**](docs/pr-descricao-padrao.md): Complete flow for generating PR descriptions without flags.
-* [**CI/CD Integration (GitHub Actions)**](docs/github-ci-linter.md): How to run GitPR in the pipeline to block "Merge" of PRs with violations.
-* [**GitHub Token (PAT) Integration and Security**](docs/github-pat-integration.md): Understand how GitPR creates issues directly in the repository with authentication.
+If you want to implement GitPR as an automated quality barrier in your team, check out the guides below.
+
+> 🌐 Each guide is available in **5 languages** — add `.pt_br`, `.pt_pt`, `.fr_fr`, or `.es_es` before the `.md` extension for translated versions (e.g., `docs/understanding_chat_functionality.pt_br.md`). English is the default with no suffix.
+
+### Chat & Interactive Features
+
+* [**🧠 Interactive Chat (Pair Programming)**](https://github.com/natanfiuza/gitpr/blob/main/docs/understanding_chat_functionality.md) — How to use the AI chat with memory, slash commands, auto-patch, and session export.
+
+### DevOps & CI/CD
+
+* [**Local Git Hooks (Shift-Left)**](https://github.com/natanfiuza/gitpr/blob/main/docs/git-hooks-locais.md) — How to use `gitpr --installhooks` to create guardrails on the developer's machine and use AI to automatically write commit messages.
+* [**Customizable Static Linter**](https://github.com/natanfiuza/gitpr/blob/main/docs/linter-regras-customizadas.md) — How to create validation rules in `.gitpr.linter.yml` for CI/CD and pre-commit hooks.
+* [**CI/CD Integration (GitHub Actions)**](https://github.com/natanfiuza/gitpr/blob/main/docs/github-ci-linter.md) — How to run GitPR in the pipeline to block "Merge" of PRs with violations.
+
+### Core Features
+
+* [**Pull Request (Default Mode)**](https://github.com/natanfiuza/gitpr/blob/main/docs/pr-descricao-padrao.md) — Complete flow for generating PR descriptions without flags.
+* [**AI Code Review**](https://github.com/natanfiuza/gitpr/blob/main/docs/code-review-ia.md) — Guide to review modes (`--review`, `--fullreview`) and file auditing (`--input`).
+* [**AI Commit Messages**](https://github.com/natanfiuza/gitpr/blob/main/docs/commit-message-ia.md) — How to generate messages in the Conventional Commits standard and integrate with Git Hooks.
+* [**Issue Generation and TUI Interface**](https://github.com/natanfiuza/gitpr/blob/main/docs/issue-tui-help.md) — How to use the terminal graphical interface (TUI) and the 3 context engines to manage structured Issues.
+* [**Code Archaeologist (Git Blame)**](https://github.com/natanfiuza/gitpr/blob/main/docs/blame-arqueologo.md) — How to trace the origin of business rules with `git blame` and AI.
+* [**Skills and Templates System**](https://github.com/natanfiuza/gitpr/blob/main/docs/skill-template.md) — How to customize AI behavior with `.gitpr.*.md` files.
+
+### Configuration & Infrastructure
+
+* [**AI Providers**](https://github.com/natanfiuza/gitpr/blob/main/docs/providers-ia.md) — Configuration and selection between Google Gemini, DeepSeek, and Ollama.
+* [**Auto-Updater**](https://github.com/natanfiuza/gitpr/blob/main/docs/auto-update.md) — How GitPR's automatic update (hot-swap) works.
+* [**GitHub Token (PAT) Integration and Security**](https://github.com/natanfiuza/gitpr/blob/main/docs/github-pat-integration.md) — Understand how GitPR creates issues directly in the repository with authentication.
+* [**Internationalization (i18n)**](https://github.com/natanfiuza/gitpr/blob/main/docs/i18n_explanation.md) — Architecture, usage patterns, and how to add new languages.
 
 ## ⚡ Local Cache System (Quota Savings)
 

gitpr_cli-0.0.26.dist-info/RECORD

@@ -0,0 +1,25 @@
+gitpr_cli-0.0.26.dist-info/licenses/LICENSE,sha256=UQzLC6mwqb-ZNDkBBAqOxC-SMQcEID0gaM6oFcu6u48,27030
+src/__init__.py,sha256=U6ksarernNcryHO20aj4rNG7w0thT7xdMs5KzBJyPvE,28
+src/ai_providers.py,sha256=gjWhl38AAVtCVDd4E_YOBlC_gKvtRBSoOj0b_kJ6N1I,8316
+src/blame_engine.py,sha256=Ci7t08xTcC1kBWAjQ_ulP-Zraau_PC35MDfAngc4AYk,10396
+src/cache.py,sha256=XggMTy00GlZfeF1VoLEYCdxL5h0eTg11TJfPIRPx7fs,3201
+src/chat_memory.py,sha256=vdYuElIQb6-flFm4SfzapnQZGRIwgbLECzIcsAc0Oo8,8724
+src/config.py,sha256=VJ9ekDlTVG5ETWDuO1kZWlgrncXbrvduxa5Zg7wN_ZY,9064
+src/core.py,sha256=TGtSA_7wyNoa-B6ytFhunCpEmpW9miQzvlizUQcyhis,18259
+src/i18n.py,sha256=QED7hTSdWCC1lSNJ-l6VuOba18OrWgFTMQcZ7cQmXbY,3599
+src/issue_engine.py,sha256=435kPPgdsFMcY3nvutxdIfJAnLP0U4FMCPdbok6C2sc,3626
+src/linter_engine.py,sha256=D04wvOgRa-vZEYknm-z-Cg7V_3gnoQz_64PMorWnISo,4414
+src/main.py,sha256=QryicYBsYiRaNCUTs9eJbM-x-S3Z4-jWvjGR3SwkmJ8,31412
+src/security.py,sha256=Li0zM8ZURTK2nKRHIt49TWLO4DIddBEHzXPrVycv0Rs,1343
+src/spinner.py,sha256=nnnoz91qt2NMEA3aMIT27XH7KImSMNVt_SyRAjNS8rk,6922
+src/tui_issue.py,sha256=gcAJCIfMcdeMjrFJUWQQvdgBv7fnOBtxQxwdBk2Sk40,1789
+src/updater.py,sha256=BDBRFpL9ek4MvduIKa3A_UH1KM-YCOCaXwPvN-eVREw,5886
+src/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/ui/chat_app.py,sha256=y-py5UpisQbPLqqDON8AIkyA7X1IM5LAn1GbeYr2p_U,25598
+src/ui/help_screen.py,sha256=tjbokXhwyzLnkOC0S56NbpX-78hcFQnvsQMpNU1wt0c,1862
+src/ui/issue_app.py,sha256=8MdBcOVdCHPFx6EUhs80CiZ2G-29KulskkCz9qMZ_Lg,4737
+gitpr_cli-0.0.26.dist-info/METADATA,sha256=RReNTAFsjM1rMKH3aordrfMn90pZygCt0jn-tTo3X-M,17450
+gitpr_cli-0.0.26.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+gitpr_cli-0.0.26.dist-info/entry_points.txt,sha256=mh_4F_idM4cj0XhfRGBDQb5Nnku93YJ-dyKh5SufwlE,39
+gitpr_cli-0.0.26.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+gitpr_cli-0.0.26.dist-info/RECORD,,

src/ai_providers.py

@@ -3,8 +3,12 @@ import time
 import click
 from google import genai
 from openai import OpenAI
+import urllib.request
+from pathlib import Path
+
 from src.spinner import Spinner
-from src.i18n import __
+from src.i18n import __,CURRENT_LANG
+
 
 def call_ai_model(provider, api_key, api_model, prompt, system_instruction, quiet=False):
     """
@@ -77,4 +81,117 @@ def call_ai_model(provider, api_key, api_model, prompt, system_instruction, quie
                     click.secho(__("\r❌ Critical error contacting {provider} API after {max_retries} attempts: {error}", provider=provider.capitalize(), max_retries=max_retries, error=str(e)), fg="red", bold=True)
                     return None
     finally:
-        spinner.stop()
+        spinner.stop()
+
+def load_chat_commands():
+    """Download and cache the translated chat commands."""
+    lang_suffix = "" if CURRENT_LANG.startswith("en") else f".{CURRENT_LANG}"
+    url = f"https://raw.githubusercontent.com/natanfiuza/gitpr/main/templates/chat_commands{lang_suffix}.json"
+    
+    cache_dir = Path.home() / ".gitpr" / "cache"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    cache_file = cache_dir / f"chat_commands{lang_suffix}.json"
+
+    # Try loading from the local cache first to avoid slowing down the terminal
+    if cache_file.exists():
+        try:
+            with open(cache_file, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            pass
+
+    # If it is not in the cache, download it from the remote repository
+    try:
+        req = urllib.request.Request(url, headers={'User-Agent': 'GitPR-Chat'})
+        with urllib.request.urlopen(req, timeout=5) as response:
+            data = json.loads(response.read().decode())
+            with open(cache_file, "w", encoding="utf-8") as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+            return data
+    except Exception:
+        # Safety fallback if the user is offline
+        return {
+            "/explain": "Explains the diff line by line.",
+            "/tests": "Generates unit tests for the changed functions.",
+            "/optimize": "Analyzes cyclomatic complexity and performance.",
+            "/clear": "Clears conversation and creates a new chat session for the current diff."
+        }
+
+def process_chat_command(message):
+    """
+    Check whether the message is a command (e.g., /explain).
+    Returns a tuple: (is_command, is_clear_command, processed_message)
+    """
+    msg_trimmed = message.strip().lower()
+    if not msg_trimmed.startswith("/"):
+        return False, False, message
+
+    commands = load_chat_commands()
+    
+    for cmd, prompt in commands.items():
+        if msg_trimmed == cmd.lower():
+            # Special flag so the UI knows whether to reset the session without calling the AI
+            is_clear = (cmd.lower() in ["/clear", "/limpar", "/limpiar", "/effacer"])
+            return True, is_clear, prompt
+            
+    return False, False, message
+
+def call_ai_chat(provider, api_key, api_model, system_instruction, chat_history, new_message, quiet=False):
+    """
+    Dedicated engine for the Interactive Chat.
+    Keeps the historical context and returns free Markdown (does not force JSON).
+    """
+    spinner = Spinner(quiet=quiet)
+    spinner.start()
+
+    try:
+        if provider == "gemini":
+            client = genai.Client(api_key=api_key)
+            
+            # Format the history into the Gemini SDK format
+            formatted_contents = []
+            for msg in chat_history:
+                role = "model" if msg["role"] == "assistant" else "user"
+                formatted_contents.append({"role": role, "parts": [{"text": msg["content"]}]})
+            
+            formatted_contents.append({"role": "user", "parts": [{"text": new_message}]})
+
+            response = client.models.generate_content(
+                model=api_model,
+                contents=formatted_contents,
+                config={
+                    "system_instruction": system_instruction,
+                    "temperature": 0.3 # Slightly higher so the chat feels more natural
+                }
+            )
+            result_text = response.text
+
+        elif provider in ["deepseek", "ollama"]:
+            base_url = "https://api.deepseek.com" if provider == "deepseek" else "http://localhost:11434/v1"
+            client = OpenAI(api_key=api_key, base_url=base_url)
+            
+            messages = [{"role": "system", "content": system_instruction}]
+            for msg in chat_history:
+                messages.append({"role": msg["role"], "content": msg["content"]})
+            messages.append({"role": "user", "content": new_message})
+            
+            response = client.chat.completions.create(
+                model=api_model, 
+                messages=messages,
+                temperature=0.3
+            )
+            result_text = response.choices[0].message.content
+        else:
+            spinner.stop()
+            click.secho(__("❌ Unknown AI provider: {provider}", provider=provider), fg="red")
+            return None
+
+        spinner.stop()
+        return result_text
+
+    except Exception as e:
+        spinner.stop()
+        click.secho(__("\r❌ Critical error in Chat API ({provider}): {error}", provider=provider.capitalize(), error=str(e)), fg="red", bold=True)
+        return None
+    finally:
+        spinner.stop()        

src/blame_engine.py

@@ -4,7 +4,7 @@ import re
 import os
 from datetime import datetime
 from src.core import get_current_branch
-from src.config import get_api_key, get_api_model, get_ai_provider
+from src.config import get_api_key, get_api_model, get_ai_provider, resolve_skill_path
 from src.ai_providers import call_ai_model
 from src.i18n import __
 
@@ -69,7 +69,7 @@ def analyze_commit_with_ai(commit_hash, file_path):
     # Use the 'simple' model (Flash/Lite) to save money in the loop
     api_model = get_api_model(provider, task_complexity="simple")
 
-    skill_path = os.path.join(os.getcwd(), ".gitpr.blame.md")
+    skill_path = resolve_skill_path(".gitpr.blame.md")
     if os.path.exists(skill_path):
         with open(skill_path, "r", encoding="utf-8") as f:
             sys_inst = f.read()

src/chat_memory.py

@@ -0,0 +1,218 @@
+import os
+import json
+import hashlib
+import random
+import string
+from datetime import datetime
+from pathlib import Path
+
+def gerar_uuid_base_15():
+    """
+    Generate a UUID with a base of 15 characters (group 4-5-4)
+
+    Returns:
+        str: UUID in the format XXXX-XXXXX-XXXX
+    """
+    
+    def gerar_grupo(tamanho):
+        """
+        Helper function to generate a group of characters with at least one number
+
+        Args:
+            tamanho (int): Size of the group to be generated
+
+        Returns:
+            str: Group of characters with at least one number
+        """
+        letras = string.ascii_letters  # 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+        numeros = string.digits        # '0123456789'
+        todos_caracteres = letras + numeros
+        
+        # Ensures that at least one number will be present in the group
+        grupo = []
+        numero_inserido = False
+        
+        for i in range(tamanho):
+            if i == tamanho - 1 and not numero_inserido:
+                # If it is the last character and we have not inserted a number yet
+                grupo.append(random.choice(numeros))
+            else:
+                caractere = random.choice(todos_caracteres)
+                if caractere.isdigit():
+                    numero_inserido = True
+                grupo.append(caractere)
+        
+        return ''.join(grupo)
+    
+    # Generate the three groups of characters
+    grupo1 = gerar_grupo(4)
+    grupo2 = gerar_grupo(5)
+    grupo3 = gerar_grupo(4)
+    
+    # Combine the groups into the desired format
+    return f"{grupo1}-{grupo2}-{grupo3}"
+
+class ChatMemoryManager:
+    """
+    State and Memory Manager for GitPR's Hybrid Chat sessions.
+    Keeps the message history and tracks code changes (diff) during the session.
+    """
+    def __init__(self, repo_name, branch_name, current_diff, git_user, git_email):
+        self.repo_name = repo_name
+        self.branch_name = branch_name
+        self.git_user = git_user
+        self.git_email = git_email
+        
+        self.base_dir = Path.home() / ".gitpr" / "cache" / "chat"
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+        
+        self.session_uuid = None
+        self.session_dir = None
+        self.config_file = None
+        self.conversation_file = None
+        
+        self._initialize_session(current_diff)
+
+    def _generate_md5(self, text):
+        return hashlib.md5(text.encode('utf-8')).hexdigest()
+
+    def _initialize_session(self, current_diff):
+        """Look for an open session for the current branch or create a new one."""
+        diff_md5 = self._generate_md5(current_diff)
+        latest_session = None
+        latest_time = None
+
+        # Look for the most recent session for this repository and branch
+        for session_folder in self.base_dir.iterdir():
+            if session_folder.is_dir():
+                uuid_str = session_folder.name
+                cfg_path = session_folder / f"chat-config_{uuid_str}.json"
+                
+                if cfg_path.exists():
+                    try:
+                        with open(cfg_path, "r", encoding="utf-8") as f:
+                            cfg = json.load(f)
+                            
+                        if cfg.get("repo") == self.repo_name and cfg.get("branch") == self.branch_name:
+                            # Compare the modification time to pick the most recent chat for this branch
+                            mtime = cfg_path.stat().st_mtime
+                            if latest_time is None or mtime > latest_time:
+                                latest_time = mtime
+                                latest_session = (uuid_str, session_folder, cfg_path, cfg)
+                    except Exception:
+                        continue
+
+        if latest_session:
+            # Reopen the existing session
+            self.session_uuid, self.session_dir, self.config_file, cfg_data = latest_session
+            self.conversation_file = self.session_dir / f"conversation_{self.session_uuid}.json"
+            
+            # Check whether the code (diff) has changed since last time
+            diff_history = cfg_data.get("diff_history", [])
+            last_diff_md5 = diff_history[-1]["md5"] if diff_history else None
+            
+            if last_diff_md5 != diff_md5:
+                self._append_diff_to_history(cfg_data, current_diff, diff_md5)
+        else:
+            # No session found for this branch, create a new one from scratch
+            self._create_new_session(current_diff, diff_md5)
+
+    def _append_diff_to_history(self, cfg_data, diff_text, diff_md5):
+        """Store the new diff in the configuration file."""
+        new_entry = {
+            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "md5": diff_md5,
+            "diff": diff_text
+        }
+        cfg_data.setdefault("diff_history", []).append(new_entry)
+        
+        with open(self.config_file, "w", encoding="utf-8") as f:
+            json.dump(cfg_data, f, indent=2, ensure_ascii=False)
+
+    def _create_new_session(self, current_diff, diff_md5):
+        """Set up a new base-15 UUID folder with the initial JSON files."""
+        self.session_uuid = gerar_uuid_base_15()
+        self.session_dir = self.base_dir / self.session_uuid
+        self.session_dir.mkdir(parents=True, exist_ok=True)
+        
+        self.config_file = self.session_dir / f"chat-config_{self.session_uuid}.json"
+        self.conversation_file = self.session_dir / f"conversation_{self.session_uuid}.json"
+        
+        initial_config = {
+            "session_uuid": self.session_uuid,
+            "folder_name": self.session_uuid,
+            "repo": self.repo_name,
+            "branch": self.branch_name,
+            "git_user": self.git_user,
+            "git_email": self.git_email,
+            "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "diff_history": [
+                {
+                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                    "md5": diff_md5,
+                    "diff": current_diff
+                }
+            ]
+        }
+        
+        # Write the metadata
+        with open(self.config_file, "w", encoding="utf-8") as f:
+            json.dump(initial_config, f, indent=2, ensure_ascii=False)
+            
+        # Create the empty chat memory
+        with open(self.conversation_file, "w", encoding="utf-8") as f:
+            json.dump([], f, indent=2, ensure_ascii=False)
+
+    def get_history(self):
+        """Return the conversation history from the JSON file."""
+        if self.conversation_file.exists():
+            try:
+                with open(self.conversation_file, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except Exception:
+                return []
+        return []
+
+    def save_message(self, role, content):
+        """
+        Save a new message to the conversation.
+        'role' must be 'user', 'assistant' or 'system'.
+        """
+        history = self.get_history()
+        history.append({
+            "role": role,
+            "content": content,
+            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        })
+        with open(self.conversation_file, "w", encoding="utf-8") as f:
+            json.dump(history, f, indent=2, ensure_ascii=False)
+            
+    def get_latest_diff(self):
+        """Retrieve the most recent current diff from the session configuration."""
+        try:
+            with open(self.config_file, "r", encoding="utf-8") as f:
+                cfg = json.load(f)
+            return cfg.get("diff_history", [])[-1]["diff"]
+        except Exception:
+            return ""
+
+    def update_diff_if_changed(self, new_diff):
+        """
+        Silently check whether the code has changed.
+        Used by the F2 key to update the chat context in real time.
+        Returns True if the diff was updated, False otherwise.
+        """
+        new_md5 = self._generate_md5(new_diff)
+        try:
+            with open(self.config_file, "r", encoding="utf-8") as f:
+                cfg = json.load(f)
+                
+            diff_history = cfg.get("diff_history", [])
+            last_diff_md5 = diff_history[-1]["md5"] if diff_history else None
+            
+            if last_diff_md5 != new_md5:
+                self._append_diff_to_history(cfg, new_diff, new_md5)
+                return True
+            return False
+        except Exception:
+            return False

src/config.py

@@ -1,6 +1,7 @@
 import os
 import sys
 import socket
+import shutil
 import click
 import yaml
 from pathlib import Path
@@ -28,6 +29,41 @@ DEFAULT_CONFIG = {
     "OUTPUT_FILE_NAME_ISSUE": "{branch}_{datetime}_ISSUE.md"
 }
 
+def get_skill_dir():
+    """Returns the absolute path to the project's skill folder (.gitpr/skill)."""
+    return os.path.join(os.getcwd(), ".gitpr", "skill")
+
+
+def resolve_skill_path(filename):
+    """
+    Resolves the path of a skill/config file (e.g.: .gitpr.commit.md).
+
+    The canonical location is the '.gitpr/skill/' folder inside the project.
+    For backward compatibility, if the file still lives in the project root,
+    it is transparently migrated (moved) into '.gitpr/skill/'.
+
+    Always returns the path inside '.gitpr/skill/' (whether the file exists or
+    not), unless a migration failed — in that case it falls back to the legacy
+    root path so the tool keeps working.
+    """
+    skill_dir = get_skill_dir()
+    target_path = os.path.join(skill_dir, filename)
+    legacy_path = os.path.join(os.getcwd(), filename)
+
+    # Migrate a legacy root file into the skill folder (only if not already there)
+    if os.path.exists(legacy_path) and not os.path.exists(target_path):
+        try:
+            os.makedirs(skill_dir, exist_ok=True)
+            shutil.move(legacy_path, target_path)
+            click.secho(__("📦 Skill file {filename} moved to .gitpr/skill/", filename=filename), fg="cyan", dim=True)
+        except Exception as e:
+            # If moving fails, fall back to the legacy location so the tool keeps working
+            click.secho(__("⚠️ Warning: Could not move {filename} to .gitpr/skill/ ({error})", filename=filename, error=str(e)), fg="yellow")
+            return legacy_path
+
+    return target_path
+
+
 def get_ai_provider():
     """Returns the configured default AI provider, or 'gemini' as fallback."""
     load_dotenv(ENV_FILE)
@@ -37,6 +73,11 @@ def get_api_key(provider):
     """Reads and decrypts the API key corresponding to the chosen provider."""
     load_dotenv(ENV_FILE)
 
+    # Suporte a CI/CD: Tenta ler a chave raw primeiro (ex: injetada via GitHub Secrets)
+    raw_key = os.getenv(f"{provider.upper()}_API_KEY")
+    if raw_key:
+        return raw_key
+
     if provider == "gemini":
         encrypted_key = os.getenv("GEMINI_API_KEY_ENCRYPTED")
     elif provider == "deepseek":
@@ -99,6 +140,12 @@ def setup_environment():
     # Check if the chosen provider's key exists
     api_key = get_api_key(provider)
     if not api_key:
+        # 🛡️ Escudo de CI/CD: Impede que o prompt trave a pipeline do GitHub Actions
+        if os.getenv("CI") or os.getenv("GITHUB_ACTIONS"):
+            click.secho(__("❌ Error: API Key not configured for provider '{provider}' in the CI/CD environment.", provider=provider), fg="red")
+            click.secho(__("💡 Tip: Pass the key as an environment variable (e.g., GEMINI_API_KEY)."), fg="yellow")
+            sys.exit(1)
+            
         click.secho(__("🔑 API Key for {provider} not found.", provider=provider.capitalize()), fg="yellow")
         raw_key = click.prompt(__("Paste your {provider} API key here", provider=provider.capitalize()), hide_input=True)
 
@@ -136,7 +183,7 @@ def load_linter_rules():
     Loads the static linter rules from the .gitpr.linter.yml file.
     Returns a list of rules or an empty list if the file does not exist.
     """
-    file_path = os.path.join(os.getcwd(), ".gitpr.linter.yml")
+    file_path = resolve_skill_path(".gitpr.linter.yml")
 
     # If the file does not exist in the project, it's not an error. There are simply no rules to apply.
     if not os.path.exists(file_path):