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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitpr-cli
-Version: 0.0.25
+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/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/core.py

@@ -40,21 +40,21 @@ def get_doc_url(filename):
         return f"https://github.com/natanfiuza/gitpr/blob/main/docs/{base}.{CURRENT_LANG}.{ext}"
 
 
-def get_git_diff():
+def get_git_diff(quiet=False):
     """Runs 'git diff HEAD' and returns the output, warning about untracked files."""
     try:
         # Check if there are new untracked files
         untracked_process = subprocess.run(
-            ["git", "ls-files", "--others", "--exclude-standard"], 
-            capture_output=True, 
-            text=True, 
+            ["git", "ls-files", "--others", "--exclude-standard"],
+            capture_output=True,
+            text=True,
             encoding="utf-8",
-            errors="replace"  # <--- CORREÇÃO AQUI (Evita crash com acentos)
+            errors="replace"
         )
         untracked_files = untracked_process.stdout.strip()
-        
+
         # If there are new files, display an educational warning in the console
-        if untracked_files:
+        if untracked_files and not quiet:
             click.secho(__("⚠️ Warning: Git detected new untracked files:"), fg="yellow")
             for file in untracked_files.split('\n'):
                 click.secho(f"  - {file}", fg="yellow", dim=True)
@@ -64,19 +64,21 @@ def get_git_diff():
         # Run the normal diff that captures tracked and staged files
         cmd = ["git", "diff", "HEAD", "--"] + SMART_EXCLUDES
         result = subprocess.run(
-            cmd, 
-            capture_output=True, 
-            text=True, 
+            cmd,
+            capture_output=True,
+            text=True,
             encoding="utf-8",
-            errors="replace",  
+            errors="replace",
             check=True
         )
         return result.stdout
     except subprocess.CalledProcessError as e:
-        click.secho(__("❌ Error running Git: {error}", error=e.stderr), fg="red")
+        if not quiet:
+            click.secho(__("❌ Error running Git: {error}", error=e.stderr), fg="red")
         return None
     except FileNotFoundError:
-        click.secho(__("❌ Git not found. Make sure it is installed and in the PATH."), fg="red")
+        if not quiet:
+            click.secho(__("❌ Git not found. Make sure it is installed and in the PATH."), fg="red")
         return None
 
 

src/i18n.py

@@ -82,6 +82,19 @@ def get_translations(lang_code):
 CURRENT_LANG = get_system_language()
 TRANSLATIONS = get_translations(CURRENT_LANG)
 
+
+def set_lang(lang: str) -> None:
+    """
+    Override the session language at runtime.
+    Updates CURRENT_LANG and TRANSLATIONS. Does NOT persist to .env.
+    Called by the --lang CLI flag before any command logic.
+    """
+    global CURRENT_LANG, TRANSLATIONS
+    lang = lang.lower().replace("-", "_")  # normalize pt-BR -> pt_br
+    CURRENT_LANG = lang
+    TRANSLATIONS = get_translations(lang)
+
+
 def __(key, **kwargs):
     """
     Translation Engine inspired by Laravel.

src/main.py

@@ -18,6 +18,9 @@ from src.core import (
 )
 from src.linter_engine import parse_diff_and_lint
 from src.i18n import __
+import subprocess
+from src.chat_memory import ChatMemoryManager
+from src.ui.chat_app import ChatApp
 
 def print_banner():
     """Displays the project ASCII Art signature"""
@@ -98,6 +101,16 @@ HELP_MAP: dict[str, dict[str, str]] = {
         'title': __('AI Provider Selection (--provider)'),
         'description': __('Forces the use of a specific AI provider for this execution: gemini (Google Gemini), deepseek (DeepSeek) or ollama (Local). Temporarily overrides the default provider defined in the .env file.'),
     },
+    'chat': {
+        'url': get_doc_url('chat-interativo.md'),
+        'title': __('Interactive Pair Programming Chat (--chat)'),
+        'description': __('Opens an interactive terminal (TUI) to chat with the AI about the current uncommitted changes. Features memory, auto-patching (F5), and live diff refresh (F2).'),
+    },
+    'lang': {
+        'url': get_doc_url('providers-ia.md'),
+        'title': __('Language Override (--lang)'),
+        'description': __('Forces the interface language for this execution (e.g.: en_us, pt_br). Overrides the GITPR_LANG environment variable and OS locale detection.'),
+    },
 }
 
 # Priority for contextual help when multiple flags are used with -h
@@ -115,6 +128,7 @@ HELP_PRIORITY: dict[str, int] = {
     'input': 10,
     'history': 11,
     'provider': 12,
+    'lang': 13,
 }
 
 
@@ -133,9 +147,11 @@ HELP_PRIORITY: dict[str, int] = {
 @click.option('-b', '--blame', type=str, help=__("Analyzes the origin of a business rule (e.g., file.py:10-20 or just file.py)."))
 @click.option('-ht', '--history', is_flag=True, help=__("Uses the entire branch history (Git Log + PR Cache) as context to generate the issue."))
 @click.option('-is', '--issue', is_flag=True, help=__("Generates a standardized Issue from current changes and opens the interactive interface."))
+@click.option('-ch', '--chat', is_flag=True, help=__("Opens the interactive Pair Programming chat with AI."))
 @click.option('-p', '--provider', type=click.Choice(['gemini', 'deepseek', 'ollama']), help=__("Forces the use of a specific AI provider for this execution."))
+@click.option('--lang', type=str, help=__("Forces the interface language for this execution (e.g.: en_us, pt_br)."))
 @click.option('-h', '--help', 'help_flag', is_flag=True, help=__("Shows this message and exits. Use with another flag for contextual help (e.g., -h --issue)."))
-def cli(commit, review, fullreview, linter, skill, update, installhooks, hook, quiet, provider, input, blame, history, issue, help_flag):
+def cli(commit, review, fullreview, linter, skill, update, installhooks, hook, quiet, provider, input, blame, history, issue, chat, help_flag, lang):
     """
     GitPR CLI - Intelligent PR Automation and AI Code Review.
 
@@ -197,6 +213,13 @@ def cli(commit, review, fullreview, linter, skill, update, installhooks, hook, q
         ctx = click.get_current_context()
         ctx.exit()
 
+    # Language override via --lang flag (one-shot, does not persist to .env)
+    if lang:
+        from src.i18n import set_lang
+        from src.spinner import reload_thinking_words
+        set_lang(lang)
+        reload_thinking_words(lang)
+
     # Silencia o banner se estiver no modo quiet ou via hook
     if not quiet and not hook:
         print_banner()
@@ -429,6 +452,57 @@ def cli(commit, review, fullreview, linter, skill, update, installhooks, hook, q
 
         return
 
+# Chat Module (Pair Programming TUI)
+    if chat:
+        from src.issue_engine import get_github_repo_info
+        from src.config import get_api_key
+        
+        setup_environment()
+        
+        diff_text = get_git_diff()
+        if not diff_text or not diff_text.strip():
+            click.secho(__("\n⚠️ No new code found. Make some changes before starting the chat.\n"), fg="yellow")
+            click.secho(f"📚 {__('Chat documentation:')} {get_doc_url('understanding_chat_functionality.md')}", fg="cyan")
+            return
+            
+        active_provider = provider if provider else get_ai_provider()
+        api_key = get_api_key(active_provider)
+        
+        if not api_key:
+            click.secho(__("❌ AI Provider API Key missing or invalid."), fg="red")
+            return
+        
+        repo_info = get_github_repo_info() or "local-repo"
+        branch_name = get_current_branch()
+        
+        try:
+            git_user = subprocess.run(["git", "config", "user.name"], capture_output=True, text=True).stdout.strip()
+            git_email = subprocess.run(["git", "config", "user.email"], capture_output=True, text=True).stdout.strip()
+        except Exception:
+            git_user, git_email = "Dev", "dev@local"
+            
+        memory = ChatMemoryManager(repo_info, branch_name, diff_text, git_user, git_email)
+        
+        system_instruction = __("You are a Senior Software Engineer acting as a Pair Programmer. Analyze the code provided and answer the user's questions clearly, objectively, and technically. Use Markdown to format code blocks. The current git diff is:\n\n{diff}", diff=diff_text)
+        
+        # Pega o modelo primário configurado no .env
+        env_model_key = f"{active_provider.upper()}_API_MODEL_PRIMARY"
+        api_model = os.getenv(env_model_key)
+        if not api_model:
+            click.secho(__("❌ Model configuration not found for provider {provider}.", provider=active_provider), fg="red")
+            return
+        
+        app = ChatApp(
+            memory_manager=memory,
+            provider=active_provider,
+            api_key=api_key,
+            api_model=api_model,
+            system_instruction=system_instruction
+        )
+        app.run()
+        click.secho(f"📚 {__('Chat documentation:')} {get_doc_url('understanding_chat_functionality.md')}", fg="cyan")
+        return
+
     # Input Mode validation (with guard to not interfere with contextual -h)
     if input and not help_flag:
         if not os.path.exists(input):

src/spinner.py

@@ -93,6 +93,21 @@ def _load_thinking_words():
     return list(_FALLBACK_WORDS)
 
 
+def reload_thinking_words(lang: str) -> None:
+    """
+    Recompute module-level spinner constants for the given language.
+    Called by cli() after set_lang() when --lang is provided.
+    Must be called before any Spinner instance is created.
+    """
+    global _LANG_SUFFIX, THINKING_WORDS_URL, THINKING_WORDS
+    _LANG_SUFFIX = "" if lang.startswith("en") else f".{lang}"
+    THINKING_WORDS_URL = (
+        "https://raw.githubusercontent.com/natanfiuza/gitpr/"
+        f"refs/heads/main/templates/gitpr.thinking-words{_LANG_SUFFIX}.md"
+    )
+    THINKING_WORDS = _load_thinking_words()
+
+
 # Words representing AI "thinking" (loaded from .env or remote template)
 THINKING_WORDS = _load_thinking_words()
 

src/ui/chat_app.py

@@ -0,0 +1,587 @@
+import re
+import random
+import string
+import webbrowser
+from textual.app import App, ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Header, Footer, Input, Markdown, Static, Button, ListView, ListItem
+from textual.containers import VerticalScroll, Vertical
+from textual.binding import Binding
+from textual import work
+from src.core import get_git_diff
+from src.i18n import __, CURRENT_LANG
+from src.ai_providers import call_ai_chat, process_chat_command, load_chat_commands
+from src.spinner import THINKING_WORDS
+
+class ChatMessage(Static):
+    """Custom component to render each message bubble."""
+    def __init__(self, role, content, msg_index=-1, **kwargs):
+        super().__init__(content, markup=False, **kwargs)
+        self.role = role
+        self.msg_index = msg_index
+
+    def compose(self) -> ComposeResult:
+        # Add the class corresponding to the role (user, assistant or system)
+        yield Markdown(self.content, classes=f"message {self.role}")
+
+class ChatHelpScreen(ModalScreen):
+    """Help modal showing keyboard shortcuts and slash commands."""
+
+    CSS = """
+    ChatHelpScreen { align: center middle; }
+    #help_dialog {
+        width: 72; height: auto; max-height: 90%; padding: 1 2;
+        background: $surface; border: thick $accent 50%;
+    }
+    #help_scroll {
+        max-height: 28; overflow-y: scroll;
+    }
+    .help_title { text-align: center; text-style: bold; margin-bottom: 1; }
+    .help_section { text-style: bold; color: $accent; margin-top: 1; margin-bottom: 1; }
+    .help_text { margin-bottom: 1; }
+    Button {
+        width: 20%;
+        margin-top: 1;
+        align: center middle;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        commands = load_chat_commands()
+        cmd_lines = []
+        for cmd, desc in commands.items():
+            cmd_lines.append(f"• [bold $accent]{cmd}[/bold $accent] — {desc}")
+        cmd_text = "\n".join(cmd_lines)
+
+        with Vertical(id="help_dialog"):
+            yield Static("💡 Chat Help", classes="help_title")
+            yield Static("⌨️ Keyboard Shortcuts", classes="help_section")
+            with VerticalScroll(id="help_scroll"):
+                yield Static(
+                    "• [bold]F1[/bold] Help — Shows this help modal\n"
+                    "• [bold]F2[/bold] Refresh Diff — Updates the chat context with the latest code changes\n"
+                    "• [bold]F5[/bold] Auto-Patch — Extracts code blocks from the last AI response\n"
+                    "• [bold]F6[/bold] Export — Saves the full conversation to a Markdown file\n"
+                    "• [bold]F7/F8[/bold] — Navigate focus between AI messages\n"
+                    "• [bold]Ctrlhift+S[/bold] — Auto-Patch the focused AI message\n"
+                    "• [bold]Ctrlhift+E[/bold] — Export the focused AI message\n"
+                    "• [bold]Esc[/bold] Exit — Closes the chat",
+                    classes="help_text"
+                )
+                yield Static("⚡ Slash Commands", classes="help_section")
+                yield Static(cmd_text, classes="help_text")
+            yield Button(__("Got it"), variant="primary", id="close_help")
+            yield Button(__("Online Help"), variant="default", id="online_help")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "close_help":
+            self.app.pop_screen()
+        elif event.button.id == "online_help":
+            lang_suffix = "" if CURRENT_LANG.startswith("en") else f".{CURRENT_LANG}"
+            url = f"https://github.com/natanfiuza/gitpr/blob/main/docs/understanding_chat_functionality{lang_suffix}.md"
+            webbrowser.open(url)
+
+
+class CommandSuggestions(Vertical):
+    """Slash-command suggestion panel that appears above the input while the user types."""
+
+    DEFAULT_CSS = """
+    CommandSuggestions {
+        margin: 0 2 1 2;
+        height: auto;
+        max-height: 12;
+        background: $surface-darken-1;
+        border: solid $accent;
+        display: none;
+    }
+    CommandSuggestions ListView {
+        height: auto;
+        max-height: 10;
+    }
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.commands = {}
+        self.filtered = []
+
+    def compose(self) -> ComposeResult:
+        yield ListView()
+
+    def load_commands(self):
+        """Load the translated command list."""
+        self.commands = load_chat_commands()
+
+    def filter_commands(self, query: str) -> None:
+        """Update the list with commands matching the partial input."""
+        list_view = self.query_one(ListView)
+        list_view.clear()
+        list_view.index = None  # Reset highlight so stale index doesn't cause wrong auto-complete
+
+        if not query.startswith("/"):
+            self.display = False
+            return
+
+        query_lower = query.lower()
+        matches = [
+            (cmd, desc) for cmd, desc in self.commands.items()
+            if cmd.lower().startswith(query_lower)
+        ]
+        if not matches:
+            self.display = False
+            return
+
+        for cmd, desc in matches:
+            list_view.append(ListItem(Static(f"{cmd} — {desc}")))
+
+        self.filtered = [cmd for cmd, _ in matches]
+        self.display = True
+
+    def get_selected_command(self) -> str | None:
+        """Return the highlighted command, or the first match as auto-complete fallback."""
+        list_view = self.query_one(ListView)
+        if list_view.index is not None and 0 <= list_view.index < len(self.filtered):
+            return self.filtered[list_view.index]
+        if self.filtered:
+            return self.filtered[0]
+        return None
+
+
+class ChatApp(App):
+    """Terminal interface for the Interactive Pair Programming Chat."""
+    
+    TITLE = "GitPR - AI Pair Programming"
+    ENABLE_COMMAND_PALETTE = False
+    
+    CSS = """
+    #chat_container {
+        height: 1fr;
+        padding: 1 2;
+        overflow-y: scroll;
+    }
+    .message {
+        margin-bottom: 1;
+        padding: 1 2;
+        border: solid $accent 50%;
+    }
+    .user {
+        background: $surface;
+        border-left: thick $accent;
+    }
+    .assistant {
+        background: $panel;
+        border-left: thick $success;
+    }
+    .assistant.focused {
+        border-left: thick $warning;
+        background: $accent 30%;
+    }
+    #focus_bar {
+        dock: bottom;
+        height: 1;
+        padding: 0 2;
+        background: $surface-darken-1;
+        color: $text-muted;
+    }
+    .system {
+        background: $warning-muted;
+        color: $text;
+        text-align: center;
+        border: none;
+        padding: 0 1;
+    }
+    #chat_input {
+        dock: bottom;
+        margin: 1 2;
+    }
+    """
+    
+    # Shortcuts already mapped for Phase 4!
+    BINDINGS = [
+        Binding("f1", "show_help", __("Help")),
+        Binding("f2", "refresh_diff", __("Refresh Diff")),
+        Binding("f5", "apply_code", __("Auto-Patch")),
+        Binding("f6", "export_session", __("Export")),
+        Binding("f7", "focus_prev_msg", __("Previous Msg")),
+        Binding("f8", "focus_next_msg", __("Next Msg")),
+        Binding("ctrl+s", "auto_patch_focused", __("Auto-Patch Msg"), priority=True),
+        Binding("ctrl+e", "export_focused_msg", __("Export Msg"), priority=True),
+        Binding("escape", "quit", __("Exit"))
+    ]
+
+    def __init__(self, memory_manager, provider, api_key, api_model, system_instruction, **kwargs):
+        super().__init__(**kwargs)
+        self.memory = memory_manager
+        self.provider = provider
+        self.api_key = api_key
+        self.api_model = api_model
+        self.system_instruction = system_instruction
+
+        self.sub_title = f"{self.memory.repo_name} | Branch: {self.memory.branch_name} | ID: {self.memory.session_uuid}"
+        self._thinking_widget = None
+        self._thinking_timer = None
+        self._thinking_state = {}
+        self._focused_msg_index = -1
+        self._focused_msg_content = ""
+        self._ai_msg_widgets = []
+        self._focus_bar = None
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with VerticalScroll(id="chat_container"):
+            pass # Populated dynamically in on_mount
+        yield Static("", id="focus_bar")
+        yield CommandSuggestions(id="cmd_suggestions")
+        yield Input(placeholder=__("Type your message or / for commands..."), id="chat_input")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Load the history stored in the base-15 UUID when opening the screen."""
+        self._focus_bar = self.query_one("#focus_bar", Static)
+        self.load_history()
+        self._cmd_suggestions = self.query_one("#cmd_suggestions", CommandSuggestions)
+        self._cmd_suggestions.load_commands()
+
+    def load_history(self):
+        container = self.query_one("#chat_container")
+        history = self.memory.get_history()
+        
+        if not history:
+            welcome_msg = __("🤖 Hello! I am your AI assistant. I'm looking at your current diff. How can I help you?")
+            container.mount(ChatMessage("system", welcome_msg))
+        else:
+            for msg in history:
+                msg_index = len(self._ai_msg_widgets) if msg["role"] == "assistant" else -1
+                widget = ChatMessage(msg["role"], msg["content"], msg_index=msg_index)
+                container.mount(widget)
+
+                if msg["role"] == "assistant":
+                    self._ai_msg_widgets.append(widget)
+
+            if self._ai_msg_widgets:
+                self._focused_msg_index = len(self._ai_msg_widgets) - 1
+                self._update_focus_visual()
+                
+        container.scroll_end(animate=False)
+
+    BRAILLE = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+    def _animate_thinking(self) -> None:
+        """Called by the App-level timer to animate the thinking indicator."""
+        if not self._thinking_widget or not self._thinking_state:
+            return
+
+        st = self._thinking_state
+        braille = self.BRAILLE[st["braille_idx"]]
+        st["braille_idx"] = (st["braille_idx"] + 1) % len(self.BRAILLE)
+
+        if len(st["discovered"]) < len(st["word"]):
+            st["char_step"] += 1
+            if st["char_step"] >= 4:
+                st["discovered"] = st["word"][:len(st["discovered"]) + 1]
+                st["char_step"] = 0
+            else:
+                fake = random.choice(string.ascii_uppercase + "0123456789!@#$")
+                st["discovered"] = st["word"][:len(st["discovered"])] + fake
+            display = f"  {braille} {st['discovered']}"
+        else:
+            st["dots_cycle"] = (st["dots_cycle"] + 1) % 12
+            if st["dots_cycle"] < 4:
+                dots = "."
+            elif st["dots_cycle"] < 8:
+                dots = ".."
+            else:
+                dots = "..."
+            display = f"  {braille} {st['word']}{dots}"
+
+            if st["dots_cycle"] == 0 and st["braille_idx"] == 0:
+                st["word"] = random.choice(THINKING_WORDS)
+                st["discovered"] = ""
+                st["char_step"] = 0
+
+        self._thinking_widget.update(display)
+
+    def add_message(self, role, content):
+        """Add the message visually and scroll the screen to the end."""
+        container = self.query_one("#chat_container")
+        msg_index = -1
+        if role == "assistant":
+            msg_index = len(self._ai_msg_widgets)
+        msg = ChatMessage(role, content, msg_index=msg_index)
+        container.mount(msg)
+        container.scroll_end(animate=True)
+        if role == "assistant":
+            self._ai_msg_widgets.append(msg)
+            self._focused_msg_index = msg_index
+            self._update_focus_visual()
+
+    # ── Message focus system ──────────────────────────────────────────
+
+    def _notify_action(self, message, severity="information"):
+        """Show a floating notification that does NOT scroll the chat."""
+        self.notify(message, severity=severity, timeout=5)
+    def _update_focus_visual(self):
+        for message in self._ai_msg_widgets:
+            message.query_one(Markdown).remove_class("focused")
+
+        if 0 <= self._focused_msg_index < len(self._ai_msg_widgets):
+            focused = self._ai_msg_widgets[self._focused_msg_index]
+            focused.query_one(Markdown).add_class("focused")
+            self._focused_msg_content = focused.content
+
+            if self._focus_bar:
+                self._focus_bar.update(
+                    __("Msg #{n} focused | Ctrl+S: Auto-Patch | Ctrlhift+E: Export",
+                    n=self._focused_msg_index + 1)
+                )
+        else:
+            self._focused_msg_content = ""
+
+            if self._focus_bar:
+                self._focus_bar.update("")
+    # def _update_focus_visual(self):
+    #     """Apply visual highlight to the active AI message and update the focus bar."""
+    #     for m in self._ai_msg_widgets:
+    #         m.styles.border_left = ("thick", "green")
+    #     if 0 <= self._focused_msg_index < len(self._ai_msg_widgets):
+    #         focused = self._ai_msg_widgets[self._focused_msg_index]
+    #         focused.styles.border_left = ("thick", "yellow")
+    #         self._focused_msg_content = focused.content
+    #         if self._focus_bar:
+    #             self._focus_bar.update(__("Msg #{n} focused | Ctrlhift+S: Auto-Patch | Ctrlhift+E: Export", n=self._focused_msg_index + 1))
+    #     else:
+    #         self._focused_msg_content = ""
+    #         if self._focus_bar:
+    #             self._focus_bar.update("")
+
+    def action_focus_prev_msg(self):
+        """F7: move focus to the previous AI message."""
+        if not self._ai_msg_widgets:
+            return
+        self._focused_msg_index = max(0, self._focused_msg_index - 1)
+        self._update_focus_visual()
+
+    def action_focus_next_msg(self):
+        """F8: move focus to the next AI message."""
+        if not self._ai_msg_widgets:
+            return
+        self._focused_msg_index = min(len(self._ai_msg_widgets) - 1, self._focused_msg_index + 1)
+        self._update_focus_visual()
+
+    def action_auto_patch_focused(self):
+        """Ctrlhift+S: extract code from the focused AI message only."""
+        if not self._focused_msg_content:
+            self._notify_action(__("❌ No AI message focused. Use F7/F8 to select one."), severity="warning")
+            return
+        content = self._focused_msg_content
+        code_blocks = re.findall(r'`{3}\s*(?:\w+)?\s*\n(.*?)`{3}', content, re.DOTALL)
+        if not code_blocks:
+            parts = content.split("```")
+            for i in range(1, len(parts), 2):
+                block = parts[i].strip()
+                if block:
+                    first_line_end = block.find("\n")
+                    if first_line_end > 0 and first_line_end < 20:
+                        first_line = block[:first_line_end].strip()
+                        if first_line and " " not in first_line:
+                            block = block[first_line_end + 1:]
+                    code_blocks.append(block.strip())
+        if code_blocks:
+            extracted_code = "\n\n".join(code_blocks)
+            key = ''.join(random.choices(string.ascii_letters + string.digits, k=3)) + '-' + ''.join(random.choices(string.ascii_letters + string.digits, k=3))
+            export_file = f"GITPR_PATCH_SUGGESTION_{key}.txt"
+            with open(export_file, "w", encoding="utf-8") as f:
+                f.write(extracted_code)
+            self._notify_action(__("🧪 Auto-Patch: Code extracted from message #{n} and saved to {file}!", n=self._focused_msg_index + 1, file=export_file))
+        else:
+            self._notify_action(__("❌ No code blocks found in message #{n}.", n=self._focused_msg_index + 1), severity="warning")
+
+    def action_export_focused_msg(self):
+        """Ctrlhift+E: export the focused AI message to a Markdown file."""
+        if not self._focused_msg_content:
+            self._notify_action(__("❌ No AI message focused. Use F7/F8 to select one."), severity="warning")
+            return
+        key = ''.join(random.choices(string.ascii_letters + string.digits, k=3)) + '-' + ''.join(random.choices(string.ascii_letters + string.digits, k=3))
+        export_file = f"MESSAGE_{self.memory.session_uuid}_{key}.md"
+        with open(export_file, "w", encoding="utf-8") as f:
+            f.write(self._focused_msg_content)
+        self._notify_action(__("📤 Message #{n} exported to {file}!", n=self._focused_msg_index + 1, file=export_file))
+
+    # ── Input handlers ────────────────────────────────────────────────
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Filter slash-command suggestions as the user types."""
+        self._cmd_suggestions.filter_commands(event.value)
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        """Fill the input with the clicked/highlighted slash command."""
+        cmd = self._cmd_suggestions.get_selected_command()
+        if cmd:
+            input_widget = self.query_one("#chat_input", Input)
+            input_widget.value = cmd + " "
+            input_widget.focus()
+            self._cmd_suggestions.display = False
+
+    async def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Capture the user's Enter key."""
+        user_text = event.value.strip()
+        if not user_text:
+            return
+
+        # Auto-complete slash command from the highlighted or first suggestion
+        if user_text.startswith("/"):
+            selected = self._cmd_suggestions.get_selected_command()
+            if selected and selected.startswith(user_text) and selected != user_text:
+                user_text = selected
+
+        # Hide suggestions after submission
+        self._cmd_suggestions.display = False
+
+        # Clear the input
+        input_widget = self.query_one("#chat_input", Input)
+        input_widget.value = ""
+        
+        # Intercept dynamic commands (Phase 2)
+        is_cmd, is_clear, processed_msg = process_chat_command(user_text)
+
+        if is_clear:
+            # Recreate the session to clear memory using the current diff
+            current_diff = self.memory.get_latest_diff()
+            diff_md5 = self.memory._generate_md5(current_diff)
+            self.memory._create_new_session(current_diff, diff_md5)
+            
+            # Clear the screen visually
+            container = self.query_one("#chat_container")
+            await container.query("*").remove()
+            self.sub_title = f"{self.memory.repo_name} | Branch: {self.memory.branch_name} | ID: {self.memory.session_uuid}"
+            self.add_message("system", __("🧹 Conversation cleared. A new session has started."))
+            return
+
+        # Display the user's message on screen (if it's a command, the screen shows the raw command, but the AI reads the processed one)
+        self.add_message("user", user_text)
+        
+        # Save the processed message to persistent memory
+        self.memory.save_message("user", processed_msg if is_cmd else user_text)
+        
+        # Show the animated thinking indicator (braille spinner + word discovery)
+        container = self.query_one("#chat_container")
+        self._thinking_widget = Static("  ⠋", classes="message system")
+        container.mount(self._thinking_widget)
+        self._thinking_state = {
+            "braille_idx": 0,
+            "word": random.choice(THINKING_WORDS),
+            "discovered": "",
+            "char_step": 0,
+            "dots_cycle": 0,
+        }
+        self._thinking_timer = self.set_interval(0.08, self._animate_thinking)
+        container.scroll_end(animate=True)
+
+        # Call the API asynchronously to avoid freezing the interface
+        self.call_ai_background()
+
+    @work(exclusive=True, thread=True)
+    def call_ai_background(self) -> None:
+        """Run the AI in the background (Thread) to keep the UI responsive."""
+        history = self.memory.get_history()
+        
+        # Since we already saved the user's message in history,
+        # we separate the last message from the rest to send to the Phase 2 function.
+        history_to_send = history[:-1]
+        new_message = history[-1]["content"]
+
+        response = call_ai_chat(
+            provider=self.provider,
+            api_key=self.api_key,
+            api_model=self.api_model,
+            system_instruction=self.system_instruction,
+            chat_history=history_to_send,
+            new_message=new_message,
+            quiet=True # Don't print terminal loading (sys.stdout) since we're in a TUI
+        )
+
+        # Update the interface from the main thread
+        def update_ui(result):
+            # Remove the animated thinking indicator
+            if self._thinking_timer:
+                self._thinking_timer.stop()
+                self._thinking_timer = None
+            if self._thinking_widget:
+                self._thinking_widget.remove()
+                self._thinking_widget = None
+            self._thinking_state = {}
+
+            if result:
+                self.memory.save_message("assistant", result)
+                self.add_message("assistant", result)
+            else:
+                self.add_message("system", __("❌ Failed to get response from AI."))
+
+        self.call_from_thread(update_ui, response)
+
+    def action_show_help(self):
+        """F1 shortcut: Show the help modal with shortcuts and slash commands."""
+        self.push_screen(ChatHelpScreen())
+
+    def action_refresh_diff(self):
+        """F2 shortcut: Update the chat context with the latest code diff."""
+        new_diff = get_git_diff(quiet=True)
+        updated = self.memory.update_diff_if_changed(new_diff)
+        if updated:
+            self.add_message("system", __("🔄 Diff updated! The AI now sees your latest changes."))
+        else:
+            self.add_message("system", __("✅ Diff is already up to date."))
+
+    def action_apply_code(self):
+        """F5 shortcut: Extract the last AI code block and save it to a suggestion file."""
+        history = self.memory.get_history()
+        
+        # Filter only the AI messages
+        ai_messages = [m for m in history if m["role"] == "assistant"]
+        if not ai_messages:
+            self._notify_action(__("❌ No AI responses available to extract code from."), severity="warning")
+            return
+
+        last_msg = ai_messages[-1]["content"]
+
+        # Match triple-backtick code blocks: ```python, ``` python, ```, etc.
+        code_blocks = re.findall(r'`{3}\s*(?:\w+)?\s*\n(.*?)`{3}', last_msg, re.DOTALL)
+
+        # Fallback: split by triple backticks and take odd-indexed parts
+        if not code_blocks:
+            parts = last_msg.split("```")
+            for i in range(1, len(parts), 2):
+                block = parts[i].strip()
+                if block:
+                    # Strip language identifier from first line if present
+                    first_line_end = block.find("\n")
+                    if first_line_end > 0 and first_line_end < 20:
+                        first_line = block[:first_line_end].strip()
+                        if first_line and not " " in first_line:
+                            block = block[first_line_end + 1 :]
+                    code_blocks.append(block.strip())
+
+        if code_blocks:
+            extracted_code = "\n\n".join(code_blocks)
+            key = ''.join(random.choices(string.ascii_letters + string.digits, k=3)) + '-' + ''.join(random.choices(string.ascii_letters + string.digits, k=3))
+            export_file = f"GITPR_PATCH_SUGGESTION_{key}.txt"
+            with open(export_file, "w", encoding="utf-8") as f:
+                f.write(extracted_code)
+            self._notify_action(__("⚡ Auto-Patch: Code extracted and saved to {file}!", file=export_file))
+        else:
+            self._notify_action(__("❌ No code blocks found in the last AI message."), severity="warning")
+    
+    def action_export_session(self):
+        """F6 shortcut: Export the entire conversation to a structured Markdown file at the project root."""
+        history = self.memory.get_history()
+        export_text = f"# GitPR Chat Session Export\n**Repo:** {self.memory.repo_name} | **Branch:** {self.memory.branch_name}\n\n"
+        
+        for msg in history:
+            role_icon = "🧑‍💻 User" if msg["role"] == "user" else "🤖 AI Assistant" if msg["role"] == "assistant" else "⚙️ System"
+            export_text += f"### {role_icon}\n{msg['content']}\n\n---\n\n"
+            
+        export_file = f"GITPR_CHAT_EXPORT_{self.memory.session_uuid}.md"
+        with open(export_file, "w", encoding="utf-8") as f:
+            f.write(export_text)
+            
+        self._notify_action(__("📤 Session exported successfully to {file}!", file=export_file))

src/updater.py

@@ -7,8 +7,8 @@ import click
 from datetime import datetime
 
 # Current version of your local executable (Update this on every new build!)
-__version__ = "0.0.25"  # GitPR current version
-__lang_version__ = "v0.0.3"  # Language dictionary version control
+__version__ = "0.0.26"  # GitPR current version
+__lang_version__ = "v0.0.4"  # Language dictionary version control
 GITHUB_API_URL = "https://api.github.com/repos/natanfiuza/gitpr/releases/latest"
 PYPI_API_URL = "https://pypi.org/pypi/gitpr-cli/json"
 

gitpr_cli-0.0.25.dist-info/RECORD

@@ -1,23 +0,0 @@
-gitpr_cli-0.0.25.dist-info/licenses/LICENSE,sha256=UQzLC6mwqb-ZNDkBBAqOxC-SMQcEID0gaM6oFcu6u48,27030
-src/__init__.py,sha256=U6ksarernNcryHO20aj4rNG7w0thT7xdMs5KzBJyPvE,28
-src/ai_providers.py,sha256=rf4IJTG6P8nLKU-C-BdUdy68JvhnsgzvhEsJdp-9El0,3477
-src/blame_engine.py,sha256=Ci7t08xTcC1kBWAjQ_ulP-Zraau_PC35MDfAngc4AYk,10396
-src/cache.py,sha256=XggMTy00GlZfeF1VoLEYCdxL5h0eTg11TJfPIRPx7fs,3201
-src/config.py,sha256=VJ9ekDlTVG5ETWDuO1kZWlgrncXbrvduxa5Zg7wN_ZY,9064
-src/core.py,sha256=MtcbftxhFFADNKzf6YBImeeTwW3oFxkQgvUArv-aHLA,18246
-src/i18n.py,sha256=Bn1OrhCYEaT0kUidu5SeTu6kiIuWOZ4OjB-7mIb6RtY,3185
-src/issue_engine.py,sha256=435kPPgdsFMcY3nvutxdIfJAnLP0U4FMCPdbok6C2sc,3626
-src/linter_engine.py,sha256=D04wvOgRa-vZEYknm-z-Cg7V_3gnoQz_64PMorWnISo,4414
-src/main.py,sha256=k4WNlrqWHZqR1t7-IGfKUpmlxjTyp17dulP_cS01jho,27734
-src/security.py,sha256=Li0zM8ZURTK2nKRHIt49TWLO4DIddBEHzXPrVycv0Rs,1343
-src/spinner.py,sha256=LeawExgx7lnHUvyuIlEx0Bc4WlAfC5KzSRWMEiu-ufY,6331
-src/tui_issue.py,sha256=gcAJCIfMcdeMjrFJUWQQvdgBv7fnOBtxQxwdBk2Sk40,1789
-src/updater.py,sha256=JEzyGu6pcdrKDziCSU8iM-yjStC-3ii6o76GUHfj3Zw,5886
-src/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-src/ui/help_screen.py,sha256=tjbokXhwyzLnkOC0S56NbpX-78hcFQnvsQMpNU1wt0c,1862
-src/ui/issue_app.py,sha256=8MdBcOVdCHPFx6EUhs80CiZ2G-29KulskkCz9qMZ_Lg,4737
-gitpr_cli-0.0.25.dist-info/METADATA,sha256=EcoI5mi-eX_wE8qpmmN1AuVC6RGDDVzparNEIUPyVwQ,15488
-gitpr_cli-0.0.25.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-gitpr_cli-0.0.25.dist-info/entry_points.txt,sha256=mh_4F_idM4cj0XhfRGBDQb5Nnku93YJ-dyKh5SufwlE,39
-gitpr_cli-0.0.25.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
-gitpr_cli-0.0.25.dist-info/RECORD,,