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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitpr-cli
-Version: 0.0.25
+Version: 0.0.27
 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
@@ -16,8 +16,13 @@ Requires-Dist: textual
 Requires-Dist: requests
 Dynamic: license-file
 
+
 # **GitPR CLI 🚀**
 
+<p align="center">
+  <img src="docs/logo.png" alt="GitPR Logo" width="200">
+</p>
+
 GitPR CLI is a command-line automation tool that uses **Google Gemini** and **DeepSeek** artificial intelligence to analyze your code changes (git diff) or entire files. The tool automatically generates commit messages in the *Conventional Commits* standard, detailed Pull Request descriptions, and deep Code Reviews aimed at reducing technical debt.
 
 ## **🛠️ Technologies and Libraries Used**
@@ -126,7 +131,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.
@@ -138,6 +145,14 @@ You can pass the following *flags* for specific actions:
 * `-u` or `--update`: Checks and installs the latest version of GitPR (Auto-Updater).
 
 > **⚙️ Technical Note (--hook):** GitPR has a hidden flag `--hook <file>` that is triggered exclusively by the Git Hooks system in the background. It allows the AI to inject the suggested message directly into Git's temporary file, without cluttering your terminal.
+>
+> **⚙️ Technical Note (--pre-save):** GitPR has a hidden debug flag `--pre-save` that can be combined with any AI command (e.g.: `gitpr -c --pre-save`). Before each AI call, it saves the full payload that will be sent to the model (system instruction + prompt + character counters) to a `_{action}-{datetime}.json` file in the current folder, and then proceeds normally. Useful for inspecting very large prompts. Note: when the response comes from the local cache, no call is made and no file is generated.
+
+### 📦 Huge Diffs (Map-Reduce)
+
+When your diff is too large for a single AI call (over ~90k estimated tokens), GitPR automatically splits it into batches by file, asks the AI for a technical summary of each part (Map), and unifies everything into the final commit message, review, or PR description (Reduce). No flags needed — it activates on demand and shows the progress in the console.
+
+📚 Full documentation: [docs/map-reduce-diff.md](docs/map-reduce-diff.md)
 
 ## 🛡️ Local Linter (Static Analysis)
 
@@ -165,6 +180,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 +213,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.27.dist-info/RECORD

@@ -0,0 +1,25 @@
+gitpr_cli-0.0.27.dist-info/licenses/LICENSE,sha256=UQzLC6mwqb-ZNDkBBAqOxC-SMQcEID0gaM6oFcu6u48,27030
+src/__init__.py,sha256=U6ksarernNcryHO20aj4rNG7w0thT7xdMs5KzBJyPvE,28
+src/ai_providers.py,sha256=cxPuytZ9LfvhQbWFPBJ4dud3lHLpAQpa3cbY8bKESk8,10954
+src/blame_engine.py,sha256=z-uh8mHOF--JxY_nnbp5r_9y_a_IO4Zn42P0AeLBpto,10436
+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=M7dPzenRa7HtOVPvFXltwg3OR2ca2EsJFJY60ajUijg,24297
+src/i18n.py,sha256=QED7hTSdWCC1lSNJ-l6VuOba18OrWgFTMQcZ7cQmXbY,3599
+src/issue_engine.py,sha256=XJ7WNLoeg3wct079wS7OQqU62f_avn3A8LmMuPWchzE,3642
+src/linter_engine.py,sha256=D04wvOgRa-vZEYknm-z-Cg7V_3gnoQz_64PMorWnISo,4414
+src/main.py,sha256=s-7JO9MudWZ5mqurDtzTtcj8GoMNirlptgbTQ6y6-vU,31742
+src/security.py,sha256=Li0zM8ZURTK2nKRHIt49TWLO4DIddBEHzXPrVycv0Rs,1343
+src/spinner.py,sha256=16ngB2oT1t7O-c3D2DWCJbFb9nMyD-HWv6KcvhKTelQ,7651
+src/tui_issue.py,sha256=gcAJCIfMcdeMjrFJUWQQvdgBv7fnOBtxQxwdBk2Sk40,1789
+src/updater.py,sha256=QPvYVEBpORF37rfD2oB_vVKnfNIw5amlaJk3NDSckuA,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.27.dist-info/METADATA,sha256=RaWiAINchrmj4I8CpZxeaObnRVH4IwpEgneVOFCxkG4,18530
+gitpr_cli-0.0.27.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+gitpr_cli-0.0.27.dist-info/entry_points.txt,sha256=mh_4F_idM4cj0XhfRGBDQb5Nnku93YJ-dyKh5SufwlE,39
+gitpr_cli-0.0.27.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+gitpr_cli-0.0.27.dist-info/RECORD,,

src/ai_providers.py

@@ -1,18 +1,75 @@
 import json
 import time
+from datetime import datetime
 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
+
+
+# Hidden --pre-save debug flag: when enabled, every AI payload is dumped
+# to a JSON file in the current directory before being sent to the model.
+PRE_SAVE_ENABLED = False
+
+
+def set_pre_save(enabled):
+    """Enable/disable the pre-save payload dump (set once from the CLI)."""
+    global PRE_SAVE_ENABLED
+    PRE_SAVE_ENABLED = enabled
 
-def call_ai_model(provider, api_key, api_model, prompt, system_instruction, quiet=False):
+
+def _save_pre_save_payload(action, provider, api_model, system_instruction, prompt=None, chat_history=None, new_message=None):
+    """
+    Dump the full AI payload to a _{action}-{datetime}.json file in the current directory.
+    Returns the filename on success or None on failure (a debug dump must never break the flow).
+    """
+    filename = f"_{action}-{datetime.now().strftime('%Y%m%d%H%M%S%f')}.json"
+
+    payload = {
+        "datetime": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "action": action,
+        "provider": provider,
+        "model": api_model,
+        "system_instruction": system_instruction,
+        "system_instruction_chars": len(system_instruction) if system_instruction else 0,
+    }
+
+    if chat_history is not None:
+        payload["chat_history"] = chat_history
+        payload["new_message"] = new_message
+        payload["chat_history_chars"] = len(json.dumps(chat_history, ensure_ascii=False)) if chat_history else 0
+        payload["new_message_chars"] = len(new_message) if new_message else 0
+        payload["total_chars"] = payload["system_instruction_chars"] + payload["chat_history_chars"] + payload["new_message_chars"]
+    else:
+        payload["prompt"] = prompt
+        payload["prompt_chars"] = len(prompt) if prompt else 0
+        payload["total_chars"] = payload["system_instruction_chars"] + payload["prompt_chars"]
+
+    try:
+        with open(filename, "w", encoding="utf-8") as f:
+            json.dump(payload, f, ensure_ascii=False, indent=2)
+        return filename
+    except Exception:
+        return None
+
+
+def call_ai_model(provider, api_key, api_model, prompt, system_instruction, quiet=False, action="ai_call"):
     """
     Unified engine for AI calls.
     Supports 'gemini' and 'deepseek'.
     """
     max_retries = 3
     retry_delay = 2
+
+    if PRE_SAVE_ENABLED:
+        saved_file = _save_pre_save_payload(action, provider, api_model, system_instruction, prompt=prompt)
+        if saved_file and not quiet:
+            click.secho(__("📝 Pre-save: AI payload saved to {filename}", filename=saved_file), fg="yellow", dim=True)
+
     spinner = Spinner(quiet=quiet)
     spinner.start()
 
@@ -77,4 +134,122 @@ 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).
+    """
+    if PRE_SAVE_ENABLED:
+        saved_file = _save_pre_save_payload("chat", provider, api_model, system_instruction, chat_history=chat_history, new_message=new_message)
+        if saved_file and not quiet:
+            click.secho(__("📝 Pre-save: AI payload saved to {filename}", filename=saved_file), fg="yellow", dim=True)
+
+    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

@@ -83,7 +83,7 @@ def analyze_commit_with_ai(commit_hash, file_path):
 
     click.secho(__("  🤖 Consulting AI ({api_model}) about commit {commit_hash}...", api_model=api_model, commit_hash=commit_hash[:8]), fg="cyan", dim=True)
 
-    result_json = call_ai_model(provider, api_key, api_model, prompt, sys_inst)
+    result_json = call_ai_model(provider, api_key, api_model, prompt, sys_inst, action="blame")
 
     if result_json and "status" in result_json:
         return result_json
@@ -210,7 +210,7 @@ def run_blame_analysis(file_path, start_line, end_line, return_data=False):
     sys_inst = __('You are a Software Architect. Generate ONLY a JSON object in the format {"resumo": "summary text"}.')
 
     click.secho(__("  🤖 Consulting AI ({api_model}) for the Executive Summary...", api_model=api_model), fg="cyan", dim=True)
-    summary_json = call_ai_model(provider, api_key, api_model, summary_prompt, sys_inst)
+    summary_json = call_ai_model(provider, api_key, api_model, summary_prompt, sys_inst, action="blame_summary")
 
     resumo_texto = summary_json.get("resumo", __("Summary not available.")) if summary_json else __("Summary not available.")
 

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