opalacoder 0.1.0__py3-none-any.whl

opalacoder/config.py

@@ -0,0 +1,215 @@
+"""Global configuration defaults for OpalaCoder."""
+
+import os
+import yaml
+import pathlib
+from dotenv import load_dotenv
+
+# Load local .env
+load_dotenv()
+
+# Suppress the non-fatal LiteLLM logging worker warning (coroutine never awaited)
+# which frequently occurs in asynchronous contexts on newer Python versions.
+import warnings
+warnings.filterwarnings(
+    "ignore",
+    category=RuntimeWarning,
+    message=".*coroutine 'Logging.async_success_handler' was never awaited.*"
+)
+
+# Load global .env
+global_env = pathlib.Path.home() / ".opalacoder" / ".env"
+if global_env.exists():
+    load_dotenv(dotenv_path=global_env)
+
+def _load_agents_config() -> dict:
+    # Search for agents.yaml next to this file (project root), then fall back to cwd.
+    candidates = [
+        pathlib.Path(__file__).parent / "agents.yaml",
+        pathlib.Path(__file__).parent.parent / "agents.yaml",
+        pathlib.Path(os.getcwd()) / "agents.yaml",
+    ]
+    for config_path in candidates:
+        if config_path.exists():
+            try:
+                with open(config_path, "r", encoding="utf-8") as f:
+                    return yaml.safe_load(f) or {}
+            except Exception as e:
+                print(f"Warning: Failed to parse {config_path}: {e}")
+    return {}
+
+_AGENTS_CONFIG = _load_agents_config()
+
+# Model used for all agents (can be overridden via CLI --model)
+DEFAULT_MODEL = _AGENTS_CONFIG.get("default", os.getenv("OPALA_MODEL", "ollama/mistral-nemo"))
+ALTERNATIVE_MODEL = _AGENTS_CONFIG.get("alternative", "gemini/gemini-3.1-flash-lite")
+
+# Global LLM defaults (temperature, max_tokens, num_ctx) — can be set in agents.yaml
+_LLM_DEFAULTS: dict = {
+    "temperature": 0.7,
+    "max_tokens": 4096,
+    "num_ctx": 8192,
+    **_AGENTS_CONFIG.get("llm_defaults", {}),
+}
+
+# Per-agent overrides loaded from agents.yaml
+_AGENT_OVERRIDES: dict[str, dict] = _AGENTS_CONFIG.get("agents", {})
+
+
+# Fields that are consumed outside of litellm kwargs and must not be forwarded.
+_NON_LITELLM_FIELDS = {"model", "max_heartbeats", "debug", "strategy"}
+
+
+from typing import Union
+
+def get_git_strategy() -> str:
+    """Return the git strategy configured in agents.yaml ('hybrid', 'agent_driven', 'auto', 'none')."""
+    return _AGENTS_CONFIG.get("git_strategy", "hybrid")
+
+def get_complexity_inference_mode() -> str:
+    """Return the complexity inference mode (simple or double)."""
+    return _AGENTS_CONFIG.get("complexity_inference_mode", "simple")
+
+def get_agent_max_heartbeats(agent_name: str, default: int) -> Union[int, str]:
+    """Return max_heartbeats configured for *agent_name* in agents.yaml (can be 'auto'), or *default*."""
+    val = _AGENT_OVERRIDES.get(agent_name, {}).get("max_heartbeats", default)
+    if val == "auto":
+        return "auto"
+    return int(val)
+
+
+def get_agent_debug(agent_name: str, default: bool = False) -> bool:
+    """Return debug flag configured for *agent_name* in agents.yaml, or *default*."""
+    return bool(_AGENT_OVERRIDES.get(agent_name, {}).get("debug", default))
+
+
+def get_agent_model(agent_name: str, default: str | None = None) -> str:
+    """Return the model configured for *agent_name* in agents.yaml, or *default*."""
+    override = _AGENT_OVERRIDES.get(agent_name, {}).get("model")
+    if override:
+        return override
+    return default if default is not None else DEFAULT_MODEL
+
+
+def get_agent_llm_kwargs(agent_name: str) -> dict:
+    """Return merged litellm kwargs for *agent_name*.
+
+    Priority (highest first):
+      1. Per-agent override in agents.yaml ``agents.<name>``
+      2. Global ``llm_defaults`` in agents.yaml
+      3. Hard-coded defaults above
+
+    Non-litellm fields (model, max_heartbeats) are excluded.
+    """
+    merged = dict(_LLM_DEFAULTS)
+    merged.update(_AGENT_OVERRIDES.get(agent_name, {}))
+    for field in _NON_LITELLM_FIELDS:
+        merged.pop(field, None)
+    return merged
+
+# Maximum retry attempts for a failing subplan step
+DEFAULT_MAX_RETRIES = 3
+
+# MemGPT heartbeat budget per planning turn
+DEFAULT_MAX_HEARTBEATS = 15
+
+# SQLite database file for session persistence
+DEFAULT_DB_PATH = os.path.join(
+    os.path.expanduser("~"), ".opalacoder", "sessions.db"
+)
+
+# Execution mode: "auto" | "plan" | "edit"
+DEFAULT_MODE = "plan"
+
+def _get_system_lang() -> str:
+    env_lang = os.getenv("OPALA_LANG")
+    if env_lang in ("en", "pt"):
+        return env_lang
+        
+    try:
+        for var in ("LC_ALL", "LC_CTYPE", "LANG"):
+            val = os.getenv(var)
+            if val and len(val) >= 2:
+                lang_code = val[:2].lower()
+                if lang_code in ("en", "pt"):
+                    return lang_code
+                    
+        import locale
+        loc, _ = locale.getdefaultlocale()
+        if loc and len(loc) >= 2:
+            lang_code = loc[:2].lower()
+            if lang_code in ("en", "pt"):
+                return lang_code
+    except Exception:
+        pass
+        
+    return "en"
+
+# Default Language
+DEFAULT_LANG = _get_system_lang()
+
+# Default litellm kwargs applied to all local model calls (kept for back-compat)
+LITELLM_DEFAULTS: dict = {"num_ctx": _LLM_DEFAULTS["num_ctx"]}
+
+# Sensitive operations that require user approval in "edit" mode
+SENSITIVE_OPS = {
+    "write_file", "delete_file", "run_shell",
+    "send_network_request", "create_user", "delete_user",
+}
+
+# ─── Debug Logging ────────────────────────────────────────────────────────────
+
+def setup_litellm_debug():
+    import litellm
+    import logging
+    from datetime import datetime
+    
+    log_dir = os.path.join(os.path.expanduser("~"), ".opalacoder", "logs")
+    os.makedirs(log_dir, exist_ok=True)
+    log_file = os.path.join(log_dir, "llm_debug.log")
+    
+    # Configure litellm to use our logger
+    litellm.set_verbose = True
+    
+    logger = logging.getLogger("LiteLLM")
+    logger.setLevel(logging.DEBUG)
+    
+    # File handler
+    fh = logging.FileHandler(log_file, encoding='utf-8')
+    fh.setLevel(logging.DEBUG)
+    
+    # Formatter
+    formatter = logging.Formatter('\n' + '='*80 + '\n[%(asctime)s] %(message)s\n' + '='*80)
+    fh.setFormatter(formatter)
+    
+    # Remove existing handlers to avoid duplicates if called multiple times
+    if logger.handlers:
+        logger.handlers.clear()
+        
+    logger.addHandler(fh)
+    
+    # Custom callback to capture inputs and outputs cleanly
+    def custom_callback(
+        kwargs, completion_response, start_time, end_time
+    ):
+        messages = kwargs.get("messages", [])
+        model = kwargs.get("model", "unknown")
+        
+        log_text = f"MODEL: {model}\n\n=== PROMPT ===\n"
+        for msg in messages:
+            role = msg.get("role", "unknown").upper()
+            content = msg.get("content", "")
+            log_text += f"[{role}]:\n{content}\n\n"
+            
+        if completion_response:
+            try:
+                response_text = completion_response.choices[0].message.content
+                log_text += f"=== RESPONSE ===\n{response_text}"
+            except Exception:
+                log_text += f"=== RAW RESPONSE ===\n{completion_response}"
+                
+        logger.debug(log_text)
+
+    litellm.success_callback = [custom_callback]
+    litellm.failure_callback = [custom_callback]
+

opalacoder/embeddings.py

@@ -0,0 +1,85 @@
+import os
+import numpy as np
+from typing import Optional
+
+# Singleton pattern for the embedding model to avoid reloading it
+_model = None
+
+def _get_model():
+    global _model
+    if _model is None:
+        try:
+            from sentence_transformers import SentenceTransformer
+        except ImportError:
+            raise ImportError("Please install sentence-transformers: pip install sentence-transformers")
+        
+        # We use a lightweight multilingual model
+        # It downloads ~470MB on first use and caches it locally
+        model_name = "paraphrase-multilingual-MiniLM-L12-v2"
+        _model = SentenceTransformer(model_name)
+    return _model
+
+def get_embedding(text: str) -> np.ndarray:
+    """Returns the embedding vector for the given text."""
+    if not text.strip():
+        # Return a zero vector of size 384 (standard for MiniLM)
+        return np.zeros(384, dtype=np.float32)
+    model = _get_model()
+    # encode() returns a numpy array
+    return model.encode(text)
+
+def cosine_similarity(vec1: np.ndarray, vec2: np.ndarray) -> float:
+    """Computes the cosine similarity between two vectors."""
+    norm1 = np.linalg.norm(vec1)
+    norm2 = np.linalg.norm(vec2)
+    if norm1 == 0 or norm2 == 0:
+        return 0.0
+    return float(np.dot(vec1, vec2) / (norm1 * norm2))
+
+# Intent Anchors (Multilingual)
+INTENT_ANCHORS = {
+    "chat": [
+        "hello", "hi", "how are you", "what are the commands", "list", "help", "clear",
+        "olá", "oi", "quais os comandos", "listar", "ajuda", "limpar", "tudo bem",
+        "hola", "ayuda", "comandos"
+    ],
+    "plan": [
+        "create an app", "write code", "build a website", "refactor the function", "make a script",
+        "crie um aplicativo", "escreva o código", "faça um script", "construa um site", "refatorar",
+        "crea una aplicación", "escribe el código", "construye"
+    ],
+    "question": [
+        "how does python work", "what is a closure", "explain react hooks", "why is this happening",
+        "como o python funciona", "o que é isso", "explique", "por que isso acontece",
+        "cómo funciona", "qué es", "explica"
+    ]
+}
+
+_intent_embeddings = {}
+
+def classify_intent_embedded(text: str) -> str:
+    """Classifies intent using cosine similarity against multilingual anchors."""
+    global _intent_embeddings
+    if not _intent_embeddings:
+        # Lazy initialization
+        for intent, phrases in INTENT_ANCHORS.items():
+            _intent_embeddings[intent] = [get_embedding(p) for p in phrases]
+            
+    text_vec = get_embedding(text)
+    
+    best_intent = "chat"
+    highest_sim = -1.0
+    
+    for intent, vec_list in _intent_embeddings.items():
+        for anchor_vec in vec_list:
+            sim = cosine_similarity(text_vec, anchor_vec)
+            if sim > highest_sim:
+                highest_sim = sim
+                best_intent = intent
+                
+    # If the highest similarity is very low, default to chat
+    if highest_sim < 0.2:
+        return "chat"
+        
+    return best_intent
+

opalacoder/i18n.py

@@ -0,0 +1,249 @@
+"""Internationalization support for OpalaCoder CLI."""
+
+_LANG = "en"
+
+_STRINGS = {
+    "en": {
+        "active_session": "Active Session: {name}",
+        "default_session_warning": "You are in the 'default' session. It is good practice to use '/rename <new_name>' to save it with a meaningful name.",
+        "type_help": "Type '/help' to see available commands.",
+        "pending_demand": "Session has an ongoing demand: '{request}...' \n[resume/clear]",
+        "resume_or_clear": "Do you want to resume execution or clear and start over?",
+        "resume": "Resume",
+        "clear": "Clear",
+        "available_commands": "Available Commands:",
+        "help_desc": "Shows this message",
+        "rename_desc": "Renames the current session",
+        "list_desc": "Lists all sessions",
+        "load_desc": "Loads another session",
+        "delete_desc": "Deletes a session",
+        "exit_desc": "Exits OpalaCoder",
+        "undo_desc": "Reverts the last change made by the agent",
+        "commit_desc": "Forces a commit to the local shadow git control",
+        "undo_success": "Last change successfully undone.",
+        "undo_fail": "Cannot undo: no previous checkpoints or VCS is disabled.",
+        "commit_success": "Changes successfully committed.",
+        "commit_fail": "Cannot commit: {err}",
+        "usage_rename": "Usage: /rename <new_name>",
+        "session_renamed": "Session renamed to '{name}'.",
+        "session_exists": "A session with the name '{name}' already exists.",
+        "no_sessions": "No sessions found.",
+        "existing_sessions": "Existing sessions:",
+        "usage_load": "Usage: /load <name>",
+        "session_not_found": "Session '{name}' not found.",
+        "session_loaded": "Session '{name}' loaded.",
+        "usage_delete": "Usage: /delete <name>",
+        "session_deleted": "Session '{name}' deleted.",
+        "current_deleted": "The current session was deleted. Loading 'default'.",
+        "exiting": "Exiting OpalaCoder. Goodbye!",
+        "unknown_command": "Unknown command: {cmd}. Type /help for help.",
+        "agent_thinking": "Agent thinking...",
+        "agent_plan_triggered": "The agent triggered the planning mode for the demand: '{req}'",
+        "repl_interrupted": "\nInterrupted by user. Session saved.",
+        "repl_cancelled": "\nOperation cancelled by user. Returning to REPL.",
+        "unexpected_error": "Unexpected error: {err}",
+        "resuming_session": "Resuming session with request: {req}",
+        "prev_session_plan": "Previous Session Plan",
+        "new_demand": "New Demand",
+        "phase1": "Phase 1 — Landscape",
+        "phase2": "Phase 2 — Plan Refinement",
+        "plan_auto_mode": "Plan (auto mode)",
+        "phase3": "Phase 3 — Decomposition",
+        "no_subplans": "No subplans extracted. Exiting.",
+        "identified_subplans": "Identified subplans: {ids}",
+        "phase4": "Phase 4 — Execution",
+        "phase5": "Phase 5 — Final Result",
+        "invalid_option": "Invalid option, try again.",
+        "table_id": "ID",
+        "table_objective": "Objective",
+        "table_status": "Status",
+        "generated_plan": "Generated Plan",
+        "final_result": "Final Result",
+        "exec_errors": "Execution Errors",
+        "subplan": "Subplan",
+        "error": "Error",
+        "plan_ok": "Is the plan OK? (answer 'yes' or 'y' to approve, or describe the desired changes)",
+        "evaluating_results": "Evaluating results...",
+        "exec_failed": "Execution failed: {err}",
+        "no_code_generated": "No code generated.",
+        "exec_success": "Execution completed successfully.",
+        "exec_error_occurred": "Error during execution: {err}",
+        "tool_start_planning": "Starts code planning and execution. Use this tool ONLY when the user explicitly asks to create code, a script, refactor, or execute a software project. Pass the description of what the user wants in the 'request' parameter.",
+        "tool_planning_activated": "Planning mode activated. Control will be transferred to the code orchestrator.",
+        "recent_history": "RECENT CONVERSATION HISTORY:",
+        "new_message": "NEW USER MESSAGE:",
+        "assistant": "Assistant",
+        "user": "User",
+        "yes_hints": ["y", "yes", "sim", "s"],
+        "generating_panorama": "Generating landscape plan...",
+        "plan_review": "Plan Review",
+        "plan_approved": "Plan approved!",
+        "interpreting_response": "Interpreting response...",
+        "refining_plan": "Refining plan based on your feedback...",
+        "refining": "Refining...",
+        "max_refinement_cycles": "Max refinement cycles reached. Using the last plan.",
+        "decomposing_plan": "Decomposing plan into subtasks...",
+        "decomposing": "Decomposing...",
+        "no_subplan_returned": "No subplan returned by the model.",
+        "refinement_prompt": "ORIGINAL REQUEST: {request}\nORIGINAL PLAN: {plan_text}\nUSER FEEDBACK: {feedback}",
+        "sensitive_op": "{id} contains sensitive operation: {obj}",
+        "execute_subplan": "Execute {id}?",
+        "skipped_by_user": "[SKIPPED by user]",
+        "executing_subplans": "Executing Subplans (AgenticBlocks WorkflowGraph)",
+        "completed": "completed",
+        "failed": "failed",
+        "aggregating_results": "Aggregating results...",
+        "synthesizing_final_result": "Synthesizing final result...",
+        "confirm_plan_execution": "Are you sure you want to start the planning phase? This might be an expensive operation.",
+        "plan_execution_cancelled": "Planning execution cancelled.",
+        "plan_execution_cancelled_msg": "I offered to start the planning phase, but you cancelled it. Let me know if you need anything else.",
+        "cancel_reminder": "💡 Tip: You can type /cancel at any time to abort the planning and return to the chat.",
+        "plan_saved_to_file": "Plan saved to '{path}'. Edit it in your editor, save it, and then come back here.",
+        "plan_confirm_after_edit": "Press Enter when you are done editing (or type your changes here, or 'yes'/'y' to approve as-is):",
+        "plan_file_read_error": "Could not read plan.md: {err}. Using the in-memory plan.",
+        "intent_unclear": "Your message wasn't clear enough. Could you please rephrase or provide more details?",
+        "command_hint_suggestion": "Did you mean [bold]/{cmd}[/bold]? Commands must be prefixed with [bold]/[/bold]. Type [bold]/help[/bold] to see all available commands.",
+        "evaluating_complexity": "Evaluating task complexity...",
+        "selecting_skills": "Selecting skills for this project...",
+        "routing_complex_task": "Complex task detected. Routing to alternative model ({model})...",
+        "api_key_missing_fallback": "API Key missing or skipped. Falling back to {model}.",
+        "alt_model_error": "Error using alternative model ({model}): {err}",
+        "fallback_to_model": "Falling back to {model}",
+        "using_model": "Using model: {model}",
+        "delete_dir_confirm": "Do you also want to delete the project directory ({path})?",
+        "dir_deleted": "Project directory '{path}' deleted.",
+        "dir_delete_failed": "Failed to delete directory: {err}",
+        "vcs_deleted": "Internal version control deleted.",
+        "vcs_delete_failed": "Failed to delete internal version control: {err}",
+    },
+    "pt": {
+        "active_session": "Sessão Ativa: {name}",
+        "default_session_warning": "Você está na sessão 'default'. É uma boa prática usar '/rename <novo_nome>' para salvar com um nome significativo.",
+        "type_help": "Digite '/help' para ver os comandos disponíveis.",
+        "pending_demand": "Sessão possui uma demanda em andamento: '{request}...'",
+        "resume_or_clear": "Deseja retomar a execução ou limpar e começar de novo?",
+        "resume": "Retomar",
+        "clear": "Limpar",
+        "available_commands": "Comandos Disponíveis:",
+        "help_desc": "Mostra esta mensagem",
+        "rename_desc": "Renomeia a sessão atual",
+        "list_desc": "Lista todas as sessões",
+        "load_desc": "Carrega outra sessão",
+        "delete_desc": "Apaga uma sessão",
+        "exit_desc": "Sai do OpalaCoder",
+        "undo_desc": "Desfaz a última alteração feita pelo agente",
+        "commit_desc": "Força o envio das alterações para o controle local",
+        "undo_success": "Última alteração desfeita com sucesso.",
+        "undo_fail": "Não foi possível desfazer: sem checkpoints anteriores ou controle de versão desativado.",
+        "commit_success": "Alterações enviadas com sucesso.",
+        "commit_fail": "Não foi possível enviar: {err}",
+        "usage_rename": "Uso: /rename <novo_nome>",
+        "session_renamed": "Sessão renomeada para '{name}'.",
+        "session_exists": "Já existe uma sessão com o nome '{name}'.",
+        "no_sessions": "Nenhuma sessão encontrada.",
+        "existing_sessions": "Sessões existentes:",
+        "usage_load": "Uso: /load <nome>",
+        "session_not_found": "Sessão '{name}' não encontrada.",
+        "session_loaded": "Sessão '{name}' carregada.",
+        "usage_delete": "Uso: /delete <nome>",
+        "session_deleted": "Sessão '{name}' apagada.",
+        "current_deleted": "A sessão atual foi apagada. Carregando 'default'.",
+        "exiting": "Encerrando OpalaCoder. Até logo!",
+        "unknown_command": "Comando desconhecido: {cmd}. Digite /help para ajuda.",
+        "agent_thinking": "Agente pensando...",
+        "agent_plan_triggered": "O agente acionou o modo de planejamento para a demanda: '{req}'",
+        "repl_interrupted": "\nInterrompido pelo usuário. Sessão salva.",
+        "repl_cancelled": "\nOperação cancelada pelo usuário. Retornando ao REPL.",
+        "unexpected_error": "Erro inesperado: {err}",
+        "resuming_session": "Retomando sessão com pedido: {req}",
+        "prev_session_plan": "Plano da Sessão Anterior",
+        "new_demand": "Nova Demanda",
+        "phase1": "Fase 1 — Panorama",
+        "phase2": "Fase 2 — Refinamento do Plano",
+        "plan_auto_mode": "Plano (modo auto)",
+        "phase3": "Fase 3 — Decomposição",
+        "no_subplans": "Nenhum subplano extraído. Encerrando.",
+        "identified_subplans": "Subplanos identificados: {ids}",
+        "phase4": "Fase 4 — Execução",
+        "phase5": "Fase 5 — Resultado Final",
+        "invalid_option": "Opção inválida, tente novamente.",
+        "table_id": "ID",
+        "table_objective": "Objetivo",
+        "table_status": "Status",
+        "generated_plan": "Plano Gerado",
+        "final_result": "Resultado Final",
+        "exec_errors": "Erros de Execução",
+        "subplan": "Subplano",
+        "error": "Erro",
+        "plan_ok": "O plano está ok? (responda 'sim' ou 's' para aprovar, ou descreva as alterações desejadas)",
+        "evaluating_results": "Avaliando resultados...",
+        "exec_failed": "Falhou: {err}",
+        "no_code_generated": "Nenhum código gerado.",
+        "exec_success": "Execução concluída com sucesso.",
+        "exec_error_occurred": "Erro durante a execução: {err}",
+        "tool_start_planning": "Inicia o planejamento e execução de código. Use esta ferramenta APENAS quando o usuário pedir explicitamente para criar código, um script, refatorar, ou executar um projeto de software. Passe a descrição do que o usuário quer no parâmetro 'request'.",
+        "tool_planning_activated": "Modo de planejamento ativado. O controle será transferido para o orquestrador de código.",
+        "recent_history": "HISTÓRICO RECENTE DA CONVERSA:",
+        "new_message": "NOVA MENSAGEM DO USUÁRIO:",
+        "assistant": "Assistente",
+        "user": "Usuário",
+        "yes_hints": ["s", "sim", "y", "yes"],
+        "generating_panorama": "Gerando panorama do plano...",
+        "plan_review": "Revisão do Plano",
+        "plan_approved": "Plano aprovado!",
+        "interpreting_response": "Interpretando resposta...",
+        "refining_plan": "Refinando plano com base no seu feedback...",
+        "refining": "Refinando...",
+        "max_refinement_cycles": "Número máximo de ciclos de refinamento atingido. Usando último plano.",
+        "decomposing_plan": "Decompondo plano em subetapas...",
+        "decomposing": "Decompondo...",
+        "no_subplan_returned": "Nenhum subplano retornado pelo modelo.",
+        "refinement_prompt": "PEDIDO ORIGINAL: {request}\nPLANO ORIGINAL: {plan_text}\nFEEDBACK DO USUÁRIO: {feedback}",
+        "sensitive_op": "{id} contém operação sensível: {obj}",
+        "execute_subplan": "Executar {id}?",
+        "skipped_by_user": "[PULADO pelo usuário]",
+        "executing_subplans": "Executando Subplanos (AgenticBlocks WorkflowGraph)",
+        "completed": "concluído",
+        "failed": "falhou",
+        "aggregating_results": "Agregando resultados...",
+        "synthesizing_final_result": "Sintetizando resultado final...",
+        "confirm_plan_execution": "Você tem certeza que deseja iniciar a fase de planejamento? Esta pode ser uma operação demorada/custosa.",
+        "plan_execution_cancelled": "Execução do planejamento cancelada.",
+        "plan_execution_cancelled_msg": "Eu ofereci iniciar a fase de planejamento, mas você cancelou. Me avise se precisar de mais alguma coisa.",
+        "cancel_reminder": "💡 Dica: Você pode digitar /cancel a qualquer momento para abortar o planejamento e voltar ao chat.",
+        "plan_saved_to_file": "Plano salvo em '{path}'. Edite-o no seu editor, salve e depois volte aqui.",
+        "plan_confirm_after_edit": "Pressione Enter quando terminar de editar (ou descreva as alterações aqui, ou 'sim'/'s' para aprovar como está):",
+        "plan_file_read_error": "Não foi possível ler plan.md: {err}. Usando o plano em memória.",
+        "intent_unclear": "Sua mensagem não ficou clara o suficiente. Poderia reformulá-la ou fornecer mais detalhes?",
+        "command_hint_suggestion": "Você quis dizer [bold]/{cmd}[/bold]? Comandos devem ser prefixados com [bold]/[/bold]. Digite [bold]/help[/bold] para ver todos os comandos disponíveis.",
+        "evaluating_complexity": "Avaliando complexidade da tarefa...",
+        "selecting_skills": "Selecionando skills para este projeto...",
+        "routing_complex_task": "Tarefa complexa detectada. Roteando para modelo alternativo ({model})...",
+        "api_key_missing_fallback": "API Key ausente ou ignorada. Usando {model} como fallback.",
+        "alt_model_error": "Erro ao usar modelo alternativo ({model}): {err}",
+        "fallback_to_model": "Usando {model} como fallback",
+        "using_model": "Usando o modelo: {model}",
+        "delete_dir_confirm": "Deseja deletar também o diretório do projeto ({path})?",
+        "dir_deleted": "Diretório do projeto '{path}' apagado.",
+        "dir_delete_failed": "Falha ao apagar o diretório: {err}",
+        "vcs_deleted": "Controle de versão interno apagado.",
+        "vcs_delete_failed": "Falha ao apagar controle de versão interno: {err}",
+    }
+}
+
+def set_lang(lang: str):
+    global _LANG
+    if lang in _STRINGS:
+        _LANG = lang
+
+def get_lang() -> str:
+    return _LANG
+
+def get_lang_name() -> str:
+    return "Portuguese" if _LANG == "pt" else "English"
+
+def _(key: str, **kwargs):
+    val = _STRINGS[_LANG].get(key, _STRINGS["en"].get(key, key))
+    if isinstance(val, str) and kwargs:
+        return val.format(**kwargs)
+    return val