akitallm 1.1.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

akita/__init__.py

@@ -1 +1 @@
-__version__ = "1.1.1"
+__version__ = "1.2.0"

akita/cli/main.py

@@ -13,6 +13,7 @@ from dotenv import load_dotenv
 from akita.tools.diff import DiffApplier
 from akita.tools.git import GitTool
 from akita.core.providers import detect_provider
+from akita.core.i18n import t
 
 # Load environment variables from .env file
 load_dotenv()
@@ -24,7 +25,7 @@ app = typer.Typer(
 )
 console = Console()
 
-@app.callback()
+@app.callback(invoke_without_command=True)
 def main(
     ctx: typer.Context,
     dry_run: bool = typer.Option(False, "--dry-run", help="Run without making any changes.")
@@ -39,17 +40,31 @@ def main(
     if dry_run:
         console.print("[bold yellow]⚠️ Running in DRY-RUN mode. No changes will be applied.[/]")
 
-    # Onboarding check
+    # Proactive Onboarding / Welcome Logic
     if not CONFIG_FILE.exists():
+        # If no config, always run onboarding (except for help/version which are handled by Typer earlier)
         run_onboarding()
+        # After onboarding, if it was a bare command, show welcome
+        if ctx.invoked_subcommand is None:
+            console.print(Panel(
+                f"{t('welcome.subtitle')}\n\n{t('welcome.commands')}\n\n{t('welcome.help_hint')}",
+                title=t("welcome.title")
+            ))
+    elif ctx.invoked_subcommand is None:
+        # Config exists, bare command -> Show Welcome Banner
+        console.print(Panel(
+            f"{t('welcome.subtitle')}\n\n{t('welcome.commands')}\n\n{t('welcome.help_hint')}",
+            title=t("welcome.title")
+        ))
+
 
 def run_onboarding():
     console.print(Panel(
-        "[bold cyan]AkitaLLM Configuration[/]\n\n[italic]API-first setup...[/]",
+        t("onboarding.welcome"),
         title="Onboarding"
     ))
     
-    api_key = typer.prompt("🔑 Paste your API Key (or type 'ollama' for local)", hide_input=False)
+    api_key = typer.prompt(t("onboarding.api_key_prompt"), hide_input=False)
     
     provider = detect_provider(api_key)
     if not provider:
@@ -57,53 +72,61 @@ def run_onboarding():
         console.print("Make sure you are using a valid OpenAI (sk-...) or Anthropic (sk-ant-...) key.")
         raise typer.Abort()
 
-    console.print(f"[bold green]✅ Detected Provider:[/] {provider.name.upper()}")
+    console.print(t("onboarding.provider_detected", provider=provider.name.upper()))
     
-    with console.status(f"[bold blue]Consulting {provider.name} API for available models..."):
+    with console.status(t("onboarding.models_consulting", provider=provider.name)):
         try:
             models = provider.list_models(api_key)
         except Exception as e:
-            console.print(f"[bold red]❌ Failed to list models:[/] {e}")
+            console.print(t("onboarding.models_failed", error=e))
             raise typer.Abort()
     
     if not models:
-        console.print("[bold yellow]⚠️ No models found for this provider.[/]")
+        console.print(t("onboarding.no_models"))
         raise typer.Abort()
 
-    console.print("\n[bold]Select a model:[/]")
+    console.print(t("onboarding.select_model"))
     for i, model in enumerate(models):
         name_display = f" ({model.name})" if model.name else ""
         console.print(f"{i+1}) [cyan]{model.id}[/]{name_display}")
     
-    choice = typer.prompt("\nChoose a model number", type=int, default=1)
+    choice = typer.prompt(t("onboarding.choice_prompt"), type=int, default=1)
     if 1 <= choice <= len(models):
         selected_model = models[choice-1].id
     else:
-        console.print("[bold red]Invalid choice.[/]")
+        console.print(t("onboarding.invalid_choice"))
         raise typer.Abort()
 
+    # New: Preferred Language for UI (Visual Sync Test)
+    lang_choice = typer.prompt(t("onboarding.lang_choice"), default="en")
+
+    # New: Creativity (Temperature) setting
+    creativity = typer.prompt(t("onboarding.creativity_prompt"), default=0.7, type=float)
+
     # Determine if we should save the key or use an env ref
-    use_env = typer.confirm("Would you like to use an environment variable for the API key? (Recommended)", default=True)
+    use_env = typer.confirm(t("onboarding.env_confirm"), default=True)
     
     final_key_ref = api_key
     if use_env and provider.name != "ollama":
         env_var_name = f"{provider.name.upper()}_API_KEY"
-        console.print(f"[dim]Please ensure you set [bold]{env_var_name}[/] in your .env or shell.[/]")
+        console.print(t("onboarding.env_instruction", env_var=env_var_name))
         final_key_ref = f"env:{env_var_name}"
 
     config = {
         "model": {
             "provider": provider.name,
             "name": selected_model,
-            "api_key": final_key_ref
+            "api_key": final_key_ref,
+            "language": lang_choice,
+            "temperature": creativity
         }
     }
     
     save_config(config)
-    console.print(f"\n[bold green]✨ Configuration saved![/]")
+    console.print(t("onboarding.saved"))
     console.print(f"Model: [bold]{selected_model}[/]")
     console.print(f"Key reference: [dim]{final_key_ref}[/]")
-    console.print("\n[dim]Configuration stored at ~/.akita/config.toml[/]\n")
+    console.print(t("onboarding.saved_location", path="~/.akita/config.toml"))
 
 @app.command()
 def review(
@@ -161,7 +184,7 @@ def review(
 
 @app.command()
 def solve(
-    query: str,
+    query: Optional[str] = typer.Argument(None, help="The task for Akita to solve."),
     interactive: bool = typer.Option(False, "--interactive", "-i", help="Run in interactive mode to refine the solution."),
     trace: bool = typer.Option(False, "--trace", help="Show the internal reasoning trace."),
     dry_run: bool = typer.Option(False, "--dry-run", help="Run in dry-run mode.")
@@ -169,50 +192,71 @@ def solve(
     """
     Generate and apply a solution for the given query.
     """
+    # Interactive Input if no query provided
+    if not query:
+        console.print(t("solve.input_prompt"))
+        lines = []
+        try:
+            while True:
+                line = input()
+                lines.append(line)
+        except EOFError:
+            pass
+        query = "\n".join(lines).strip()
+        
+        if not query:
+            console.print("[yellow]Empty query. Exiting.[/]")
+            raise typer.Exit()
+
     model = get_model()
     engine = ReasoningEngine(model)
-    console.print(Panel(f"[bold blue]Akita[/] is thinking about: [italic]{query}[/]", title="Solve Mode"))
+    console.print(Panel(f"[bold blue]Akita[/] is thinking about: [italic]{query}[/]", title=t("solve.mode_title")))
     
     current_query = query
     session = None
     
     try:
         while True:
+            # Pass interactive session if reusing context
             diff_output = engine.run_solve(current_query, session=session)
             session = engine.session
             
             if trace:
-                console.print(Panel(str(engine.trace), title="[bold cyan]Reasoning Trace[/]", border_style="cyan"))
-            console.print(Panel("[bold green]Suggested Code Changes (Unified Diff):[/]"))
+                console.print(Panel(str(engine.trace), title=t("solve.trace_title"), border_style="cyan"))
+            
+            console.print(Panel(t("solve.diff_title")))
             syntax = Syntax(diff_output, "diff", theme="monokai", line_numbers=True)
             console.print(syntax)
             
+            # If explicit interactive flag OR we just captured input interactively, we probably want to offer refinement?
+            # The spec said "interactive solve", usually implies refinement loop.
+            # Let's keep the logic: if --interactive flag is used, prompt.
             if interactive:
-                action = typer.prompt("\n[A]pprove, [R]efine with feedback, or [C]ancel?", default="A").upper()
+                action = typer.prompt(t("solve.interactive_prompt"), default="A").upper()
                 if action == "A":
                     break
                 elif action == "R":
-                    current_query = typer.prompt("Enter your feedback/refinement")
+                    current_query = typer.prompt(t("solve.refine_prompt"))
                     continue
                 else:
-                    console.print("[yellow]Operation cancelled.[/]")
+                    console.print(t("solve.cancelled"))
                     return
             else:
                 break
 
         if not dry_run:
-            confirm = typer.confirm("\nDo you want to apply these changes?")
+            confirm = typer.confirm(t("solve.confirm_apply"))
             if confirm:
-                console.print("[bold yellow]🚀 Applying changes...[/]")
+                console.print(t("solve.applying"))
                 success = DiffApplier.apply_unified_diff(diff_output)
                 if success:
-                    console.print("[bold green]✅ Changes applied successfully![/]")
+                    console.print(t("solve.success"))
                 else:
-                    console.print("[bold red]❌ Failed to apply changes.[/]")
+                    console.print(t("solve.failed"))
             else:
-                console.print("[bold yellow]Changes discarded.[/]")
+                console.print(t("solve.discarded"))
     except Exception as e:
-        console.print(f"[bold red]Solve failed:[/] {e}")
+        console.print(t("error.solve_failed", error=e))
         raise typer.Exit(code=1)
 
 @app.command()
@@ -313,34 +357,59 @@ def docs():
 config_app = typer.Typer(help="Manage AkitaLLM configuration.")
 app.add_typer(config_app, name="config")
 
-@config_app.command("model")
-def config_model(
-    reset: bool = typer.Option(False, "--reset", help="Reset configuration to defaults.")
-):
+@config_app.callback(invoke_without_command=True)
+def main_config(ctx: typer.Context):
     """
-    View or change the model configuration.
+    Manage AkitaLLM configuration via interactive menu.
     """
-    if reset:
-        if typer.confirm("Are you sure you want to delete your configuration?"):
-            reset_config()
-            console.print("[bold green]✅ Configuration reset. Onboarding will run on next command.[/]")
+    if ctx.invoked_subcommand:
         return
 
-    config = load_config()
-    if not config:
-        console.print("[yellow]No configuration found. Running setup...[/]")
-        run_onboarding()
-        config = load_config()
+    while True:
+        console.print(Panel(
+            f"{t('config.menu.option.model')}\n"
+            f"{t('config.menu.option.language')}\n"
+            f"{t('config.menu.option.show')}\n"
+            f"{t('config.menu.option.exit')}",
+            title=t("config.menu.title")
+        ))
+        
+        choice = typer.prompt(t("config.menu.prompt"), default="3")
+        
+        if choice == "1":
+            # Model
+            if typer.confirm("Re-run model setup setup?"):
+                run_onboarding()
+        elif choice == "2":
+            # Language
+            lang = typer.prompt(t("onboarding.lang_choice"), default="en")
+            config = load_config() or {}
+            if "model" not in config: config["model"] = {}
+            config["model"]["language"] = lang
+            save_config(config)
+            console.print(t("onboarding.saved"))
+        elif choice == "3":
+            # Show
+            config = load_config()
+            if not config:
+                console.print("[yellow]No config.[/]")
+                continue
+            console.print(Panel(
+                f"Provider: [yellow]{config.get('model', {}).get('provider')}[/]\n"
+                f"Name: [yellow]{config.get('model', {}).get('name')}[/]\n"
+                f"Language: [yellow]{config.get('model', {}).get('language')}[/]",
+                title=t("config.current_title")
+            ))
+            typer.prompt("Press Enter to continue")
+        elif choice == "4":
+            break
+        else:
+            console.print(t("onboarding.invalid_choice"))
 
-    console.print(Panel(
-        f"[bold blue]Current Model Configuration[/]\n\n"
-        f"Provider: [yellow]{config['model']['provider']}[/]\n"
-        f"Name: [yellow]{config['model']['name']}[/]",
-        title="Settings"
-    ))
-    
-    if typer.confirm("Do you want to change these settings?"):
-        run_onboarding()
+@config_app.command("model")
+def config_model_legacy():
+    """Legacy command for scripting."""
+    run_onboarding()
 
 if __name__ == "__main__":
     app()

akita/core/config.py

@@ -14,6 +14,7 @@ DEFAULT_CONFIG = {
     "model": {
         "provider": "openai",
         "name": "gpt-4o-mini",
+        "language": "en",
     }
 }
 

akita/core/i18n.py

@@ -0,0 +1,123 @@
+from typing import Dict, Any, Optional
+from akita.core.config import get_config_value
+
+TRANSLATIONS = {
+    "en": {
+        "onboarding.welcome": "[bold cyan]AkitaLLM Configuration[/]\n\n[italic]API-first setup...[/]",
+        "onboarding.api_key_prompt": "🔑 Paste your API Key (or type 'ollama' for local)",
+        "onboarding.provider_detected": "[bold green]✅ Detected Provider:[/] {provider}",
+        "onboarding.models_consulting": "[bold blue]Consulting {provider} API for available models...",
+        "onboarding.models_failed": "[bold red]❌ Failed to list models:[/] {error}",
+        "onboarding.no_models": "[bold yellow]⚠️ No models found for this provider.[/]",
+        "onboarding.select_model": "\n[bold]Select a model:[/]",
+        "onboarding.choice_prompt": "\nChoose a model number",
+        "onboarding.invalid_choice": "[bold red]Invalid choice.[/]",
+        "onboarding.lang_choice": "🌍 Select preferred UI language (en/pt/es)",
+        "onboarding.creativity_prompt": "🎨 Creativity level (0.0=precise, 1.0=creative)",
+        "onboarding.env_confirm": "Would you like to use an environment variable for the API key? (Recommended)",
+        "onboarding.env_instruction": "[dim]Please ensure you set [bold]{env_var}[/] in your .env or shell.[/]",
+        "onboarding.saved": "\n[bold green]✨ Configuration saved![/]",
+        "onboarding.saved_location": "\n[dim]Configuration stored at {path}[/]\n",
+        
+        "solve.thinking": "🤖 [bold green]Thinking...[/]",
+        "solve.mode_title": "Solve Mode",
+        "solve.trace_title": "[bold cyan]Reasoning Trace[/]",
+        "solve.diff_title": "[bold green]Suggested Code Changes (Unified Diff):[/]",
+        "solve.interactive_prompt": "\n[A]pprove, [R]efine with feedback, or [C]ancel?",
+        "solve.refine_prompt": "Enter your feedback/refinement",
+        "solve.cancelled": "[yellow]Operation cancelled.[/]",
+        "solve.applying": "[bold yellow]🚀 Applying changes...[/]",
+        "solve.success": "[bold green]✅ Changes applied successfully![/]",
+        "solve.failed": "[bold red]❌ Failed to apply changes.[/]",
+        "solve.discarded": "[bold yellow]Changes discarded.[/]",
+        "solve.confirm_apply": "\nDo you want to apply these changes?",
+        "solve.input_prompt": "[bold cyan]Describe your task (Ctrl+D to finish):[/]",
+        
+        "error.solve_failed": "[bold red]Solve failed:[/] {error}",
+        "error.validation": "Solve aborted: Model returned invalid content ({type}).",
+        
+        "config.menu.title": "Configuration Menu",
+        "config.menu.option.model": "1. Change Model",
+        "config.menu.option.language": "2. Change Language",
+        "config.menu.option.show": "3. Show Current Config",
+        "config.menu.option.exit": "4. Exit",
+        "config.menu.prompt": "Select an option",
+        "config.current_title": "Current Configuration",
+        
+        "welcome.title": "[bold cyan]Welcome to AkitaLLM[/]",
+        "welcome.subtitle": "A deterministic AI orchestrator for programmers.",
+        "welcome.help_hint": "[dim]Run [bold]akita --help[/] to see all commands.[/]",
+        "welcome.commands": "[bold]Common Commands:[/]\n- [cyan]akita solve[/]: Solve a coding task\n- [cyan]akita review[/]: Audit current directory\n- [cyan]akita config[/]: Manage settings",
+    },
+    "pt": {
+        "onboarding.welcome": "[bold cyan]Configuração do AkitaLLM[/]\n\n[italic]Configuração API-first...[/]",
+        "onboarding.api_key_prompt": "🔑 Cole sua API Key (ou digite 'ollama' para local)",
+        "onboarding.provider_detected": "[bold green]✅ Provedor Detectado:[/] {provider}",
+        "onboarding.models_consulting": "[bold blue]Consultando API {provider} para modelos disponíveis...",
+        "onboarding.models_failed": "[bold red]❌ Falha ao listar modelos:[/] {error}",
+        "onboarding.no_models": "[bold yellow]⚠️ Nenhum modelo encontrado para este provedor.[/]",
+        "onboarding.select_model": "\n[bold]Selecione um modelo:[/]",
+        "onboarding.choice_prompt": "\nEscolha o número do modelo",
+        "onboarding.invalid_choice": "[bold red]Escolha inválida.[/]",
+        "onboarding.lang_choice": "🌍 Escolha o idioma da UI (en/pt/es)",
+        "onboarding.creativity_prompt": "🎨 Nível de criatividade (0.0=preciso, 1.0=criativo)",
+        "onboarding.env_confirm": "Deseja usar uma variável de ambiente para a API key? (Recomendado)",
+        "onboarding.env_instruction": "[dim]Por favor, certifique que [bold]{env_var}[/] está definida no seu .env ou shell.[/]",
+        "onboarding.saved": "\n[bold green]✨ Configuração salva![/]",
+        "onboarding.saved_location": "\n[dim]Configuração salva em {path}[/]\n",
+        
+        "solve.thinking": "🤖 [bold green]Pensando...[/]",
+        "solve.mode_title": "Modo Solução",
+        "solve.trace_title": "[bold cyan]Rastro de Racionalização[/]",
+        "solve.diff_title": "[bold green]Mudanças Sugeridas (Unified Diff):[/]",
+        "solve.interactive_prompt": "\n[A]provar, [R]efinar com feedback, ou [C]ancelar?",
+        "solve.refine_prompt": "Digite seu feedback/refinamento",
+        "solve.cancelled": "[yellow]Operação cancelada.[/]",
+        "solve.applying": "[bold yellow]🚀 Aplicando mudanças...[/]",
+        "solve.success": "[bold green]✅ Mudanças aplicadas com sucesso![/]",
+        "solve.failed": "[bold red]❌ Falha ao aplicar mudanças.[/]",
+        "solve.discarded": "[bold yellow]Mudanças descartadas.[/]",
+        "solve.confirm_apply": "\nDeseja aplicar essas mudanças?",
+        "solve.input_prompt": "[bold cyan]Descreva sua tarefa (Ctrl+D para finalizar):[/]",
+        
+        "error.solve_failed": "[bold red]Solução falhou:[/] {error}",
+        "error.validation": "Solução abortada: Modelo retornou conteúdo inválido ({type}).",
+        
+        "config.menu.title": "Menu de Configuração",
+        "config.menu.option.model": "1. Alterar Modelo",
+        "config.menu.option.language": "2. Alterar Idioma",
+        "config.menu.option.show": "3. Mostrar Config Atual",
+        "config.menu.option.exit": "4. Sair",
+        "config.menu.prompt": "Selecione uma opção",
+        "config.current_title": "Configuração Atual",
+        
+        "welcome.title": "[bold cyan]Bem-vindo ao AkitaLLM[/]",
+        "welcome.subtitle": "Um orquestrador de IA determinístico para programadores.",
+        "welcome.help_hint": "[dim]Execute [bold]akita --help[/] para ver todos os comandos.[/]",
+        "welcome.commands": "[bold]Comandos Comuns:[/]\n- [cyan]akita solve[/]: Resolver uma tarefa\n- [cyan]akita review[/]: Auditar diretório\n- [cyan]akita config[/]: Gerenciar configurações",
+    }
+}
+
+def t(key: str, **kwargs) -> str:
+    """
+    Get a translated string for the given key.
+    Uses 'model.language' from config, defaulting to 'en'.
+    Falls back to 'en' if key is missing in target language.
+    """
+    lang = get_config_value("model", "language", default="en")
+    
+    # Support 'es' mapping to 'en' or 'pt' or its own if added later. 
+    # For now, let's map unknown langs to 'en'.
+    if lang not in TRANSLATIONS:
+        lang = "en"
+        
+    text = TRANSLATIONS.get(lang, {}).get(key)
+    
+    # Fallback to English
+    if text is None:
+        text = TRANSLATIONS["en"].get(key, key)
+        
+    try:
+        return text.format(**kwargs)
+    except KeyError:
+        return text

akita/models/base.py

@@ -12,21 +12,26 @@ class ModelResponse(BaseModel):
     raw: Any
 
 class AIModel:
-    def __init__(self, model_name: str, api_key: Optional[str] = None, base_url: Optional[str] = None):
+    def __init__(self, model_name: str, api_key: Optional[str] = None, base_url: Optional[str] = None, temperature: float = 0.7):
         self.model_name = model_name
         self.api_key = api_key
         self.base_url = base_url
+        self.temperature = temperature
 
     def chat(self, messages: List[Dict[str, str]], **kwargs) -> ModelResponse:
         """
         Send a chat completion request.
         """
+        # Merge global temperature with specific kwargs if provided
+        request_kwargs = {"temperature": self.temperature}
+        request_kwargs.update(kwargs)
+
         response = litellm.completion(
             model=self.model_name,
             messages=messages,
             api_key=self.api_key,
             base_url=self.base_url,
-            **kwargs
+            **request_kwargs
         )
         content = response.choices[0].message.content
         return ModelResponse(content=content, raw=response)
@@ -37,6 +42,7 @@ def get_model(model_name: Optional[str] = None) -> AIModel:
     """
     provider = get_config_value("model", "provider", "openai")
     api_key = get_config_value("model", "api_key")
+    temperature = get_config_value("model", "temperature", 0.7)
     
     if model_name is None:
         model_name = get_config_value("model", "name", "gpt-4o-mini")
@@ -49,5 +55,5 @@ def get_model(model_name: Optional[str] = None) -> AIModel:
     else:
         full_model_name = f"{provider}/{model_name}"
     
-    # For Ollama, we might need a base_url, but for now we assume default
-    return AIModel(model_name=full_model_name, api_key=api_key)
+    # Pass temperature to the model
+    return AIModel(model_name=full_model_name, api_key=api_key, temperature=temperature)

akita/reasoning/engine.py

@@ -7,6 +7,8 @@ from akita.schemas.review import ReviewResult
 from akita.core.trace import ReasoningTrace
 from akita.reasoning.session import ConversationSession
 import json
+from akita.core.i18n import t
+import pydantic
 from rich.console import Console
 
 console = Console()
@@ -133,8 +135,37 @@ class ReasoningEngine:
         else:
             session.add_message("user", query)
 
-        console.print("🤖 [bold green]Thinking...[/]")
-        response = self.model.chat(session.get_messages_dict())
+        # --- ROBUST EXECUTION ---
+        try:
+            console.print(t("solve.thinking"))
+            response = self.model.chat(session.get_messages_dict())
+        except pydantic.ValidationError as e:
+            # Friendly error for output contract violations
+            error_msg = t("error.validation", type=str(e))
+            console.print(f"[bold red]{error_msg}[/]")
+            # Log debug info if needed
+            raise ValueError(error_msg)
+        except Exception as e:
+            if "validation error" in str(e).lower():
+                 error_msg = t("error.validation", type="ModelResponse")
+                 console.print(f"[bold red]{error_msg}[/]")
+                 raise ValueError(error_msg)
+            raise e
+        
+        # --- CONTRACT ENFORCEMENT ---
+        if not isinstance(response.content, str):
+            error_msg = t("error.validation", type=type(response.content))
+            console.print(f"[bold red]{error_msg}[/]")
+            raise ValueError(error_msg)
+            
+        if "+++" not in response.content or "---" not in response.content:
+             # Relaxed check: Sometimes it's a valid string but forgets headers? 
+             # No, strictly require headers for safety.
+             error_msg = "Solve aborted: Model returned content without Unified Diff headers (+++/---)."
+             console.print(f"[bold red]{error_msg}[/]")
+             console.print(f"[dim]Output start: {response.content[:100]}...[/]")
+             raise ValueError(error_msg)
+
         session.add_message("assistant", response.content)
         
         self.trace.add_step("LLM Response", "Received solution from model")

akita/tools/diff.py

@@ -3,107 +3,164 @@ import shutil
 import pathlib
 from pathlib import Path
 import whatthepatch
-from typing import List, Tuple, Optional
+from typing import List, Tuple, Optional, Any
 
 class DiffApplier:
+    @staticmethod
+    def validate_diff_context(patch: Any, file_content: str) -> bool:
+        """
+        Strictly validates that the context lines in the patch exist in the file content
+        at the expected locations.
+        """
+        if not patch.changes:
+            return True
+
+        file_lines = file_content.splitlines()
+        
+        # We need to simulate the patch application to check context
+        # whatthepatch.apply_diff does this, returning None if context doesn't match
+        try:
+            result = whatthepatch.apply_diff(patch, file_lines)
+            return result is not None
+        except Exception:
+            return False
+
     @staticmethod
     def apply_unified_diff(diff_text: str, base_path: str = ".") -> bool:
         """
         Applies a unified diff to files in the base_path.
-        Includes backup and rollback logic for atomicity.
+        Includes PRE-FLIGHT DRY-RUN, strict context checking, and then atomic application.
         """
-        patches = list(whatthepatch.parse_patch(diff_text))
+        try:
+            patches = list(whatthepatch.parse_patch(diff_text))
+        except Exception as e:
+            print(f"❌ ERROR: Failed to parse diff: {e}")
+            return False
+
         if not patches:
-            print("ERROR: No valid patches found in the diff text.")
+            print("❌ ERROR: No valid patches found in the diff text.")
             return False
 
-        backups: List[Tuple[Path, Path]] = []
         base = Path(base_path)
         backup_dir = base / ".akita" / "backups"
-        backup_dir.mkdir(parents=True, exist_ok=True)
+        
+        # --- PHASE 1: PRE-FLIGHT VALIDATION (DRY RUN) ---
+        print("🛡️  Running Structural Guard (Dry Run)...")
+        pending_changes: List[Tuple[Path, List[str]]] = []
+        
+        for patch in patches:
+            if not patch.header:
+                continue
+            
+            # Resolve path
+            rel_path = patch.header.new_path
+            is_new = (patch.header.old_path == "/dev/null")
+            is_delete = (patch.header.new_path == "/dev/null")
 
-        try:
-            for patch in patches:
-                if not patch.header:
-                    continue
-                
-                # whatthepatch identifies the target file in the header
-                # We usually want the 'new' filename (the +++ part)
+            if is_new:
                 rel_path = patch.header.new_path
-                is_new = (patch.header.old_path == "/dev/null")
-                is_delete = (patch.header.new_path == "/dev/null")
+            elif is_delete:
+                rel_path = patch.header.old_path
+            else:
+                rel_path = patch.header.new_path or patch.header.old_path
 
-                if is_new:
-                    rel_path = patch.header.new_path
-                elif is_delete:
-                    rel_path = patch.header.old_path
-                else:
-                    rel_path = patch.header.new_path or patch.header.old_path
-
-                if not rel_path or rel_path == "/dev/null":
-                    continue
-                
-                # Clean up path (sometimes they have a/ or b/ prefixes)
-                if rel_path.startswith("a/") or rel_path.startswith("b/"):
-                    rel_path = rel_path[2:]
+            if not rel_path or rel_path == "/dev/null":
+                continue
+            
+            # Clean up path
+            if rel_path.startswith("a/") or rel_path.startswith("b/"):
+                rel_path = rel_path[2:]
+            
+            target_file = (base / rel_path).resolve()
+            
+            # Check existence scenarios
+            if not is_new and not target_file.exists():
+                print(f"❌ ERROR: Target file {target_file} does not exist.")
+                return False
                 
-                target_file = (base / rel_path).resolve()
+            # Read content
+            content = ""
+            if target_file.exists():
+                try:
+                    with open(target_file, "r", encoding="utf-8") as f:
+                        content = f.read()
+                except UnicodeDecodeError:
+                     print(f"❌ ERROR: Could not verify context for binary/non-utf8 file: {rel_path}")
+                     return False
+            
+            # Strict Context Check & Dry Apply
+            if not is_new:
+                # This uses whatthepatch's internal context verification
+                # If it raises HunkApplyException or returns None, it means context mismatch
+                try:
+                    new_lines = whatthepatch.apply_diff(patch, content.splitlines())
+                except Exception as e:
+                    new_lines = None # Treat exception as failure
                 
-                if not is_new and not target_file.exists():
-                    print(f"ERROR: Target file {target_file} does not exist for patching.")
+                if new_lines is None:
+                    print(f"❌ ERROR: Context Mismatch in {rel_path}.")
+                    print("   The code the AI 'saw' does not match the file on disk.")
+                    print("   Action aborted to prevent corruption.")
                     return False
+                pending_changes.append((target_file, new_lines))
+            elif is_new:
+                 # valid new file
+                 # reconstruct from patch changes for new file
+                 new_lines = []
+                 for change in patch.changes:
+                     if change.line is not None: 
+                        new_lines.append(change.line)
+                 pending_changes.append((target_file, new_lines))
+            elif is_delete:
+                 # We mark for deletion by setting new_lines to None
+                 pending_changes.append((target_file, None))
+
+        print("✅ Structural Guard Passed. Applying changes...")
 
-                # 1. Create backup
+        # --- PHASE 2: ATOMIC APPLICATION ---
+        backups: List[Tuple[Path, Path]] = []
+        backup_dir.mkdir(parents=True, exist_ok=True)
+        
+        try:
+            for target_file, new_lines in pending_changes:
+                # 1. Backup
                 if target_file.exists():
                     backup_file = backup_dir / f"{target_file.name}.bak"
                     shutil.copy2(target_file, backup_file)
                     backups.append((target_file, backup_file))
                 else:
-                    backups.append((target_file, None)) # Mark for deletion on rollback if it's a new file
+                    backups.append((target_file, None))
 
-                # 2. Apply patch
-                content = ""
-                if target_file.exists():
-                    with open(target_file, "r", encoding="utf-8") as f:
-                        content = f.read()
-                
-                lines = content.splitlines()
-                # whatthepatch apply_diff returns a generator of lines
-                patched_lines = whatthepatch.apply_diff(patch, lines)
-                
-                if patched_lines is None:
-                    print(f"ERROR: Failed to apply patch to {rel_path}.")
-                    raise Exception(f"Patch failure on {rel_path}")
-
-                # 3. Write new content
-                target_file.parent.mkdir(parents=True, exist_ok=True)
-                with open(target_file, "w", encoding="utf-8") as f:
-                    f.write("\n".join(patched_lines) + "\n")
-
-            print(f"SUCCESS: Applied {len(patches)} patches successfully.")
+                # 2. Write (or delete)
+                if new_lines is None: # Delete
+                    target_file.unlink()
+                else:
+                    target_file.parent.mkdir(parents=True, exist_ok=True)
+                    with open(target_file, "w", encoding="utf-8") as f:
+                        f.write("\n".join(new_lines) + "\n")
+            
+            print(f"SUCCESS: Applied changes to {len(pending_changes)} files.")
             
-            # 4. Pre-flight Validation
-            # Run tests to ensure the patch didn't break anything
+            # 3. Post-flight Validation (Tests)
             if (base / "tests").exists():
-                print("🧪 Running pre-flight validation (pytest)...")
+                print("🧪 Running post-flight validation (pytest)...")
                 import subprocess
-                # Run pytest in the base_path
                 result = subprocess.run(["pytest"], cwd=str(base), capture_output=True, text=True)
                 if result.returncode != 0:
                     print(f"❌ Validation FAILED:\n{result.stdout}")
-                    raise Exception("Pre-flight validation failed. Tests are broken.")
+                    raise Exception("Post-flight validation failed. Tests are broken.")
                 else:
-                    print("✅ Pre-flight validation passed!")
+                    print("✅ Post-flight validation passed!")
             
             return True
 
         except Exception as e:
-            print(f"CRITICAL ERROR: {e}. Starting rollback...")
+            print(f"CRITICAL ERROR during write: {e}. Starting rollback...")
             for target, backup in backups:
                 if backup and backup.exists():
                     shutil.move(str(backup), str(target))
                 elif not backup and target.exists():
-                    target.unlink() # Delete newly created file
+                    target.unlink()
             return False
 
     @staticmethod

akitallm-1.2.0.dist-info/METADATA

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: akitallm
+Version: 1.2.0
+Summary: AkitaLLM: An open-source local-first AI system for programming.
+Author: KerubinDev
+License: MIT
+Project-URL: Homepage, https://github.com/KerubinDev/AkitaLLM
+Project-URL: Repository, https://github.com/KerubinDev/AkitaLLM
+Project-URL: Issues, https://github.com/KerubinDev/AkitaLLM/issues
+Keywords: ai,cli,programming,local-first,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]
+Requires-Dist: litellm
+Requires-Dist: pydantic
+Requires-Dist: rich
+Requires-Dist: python-dotenv
+Requires-Dist: pytest
+Requires-Dist: pytest-mock
+Requires-Dist: gitpython
+Requires-Dist: tomli-w
+Requires-Dist: tomli
+Requires-Dist: whatthepatch>=1.0.5
+Requires-Dist: tree-sitter>=0.21.3
+Requires-Dist: tree-sitter-python>=0.21.0
+Dynamic: license-file
+
+# AkitaLLM
+
+![PyPI](https://img.shields.io/pypi/v/akitallm)
+![Python](https://img.shields.io/pypi/pyversions/akitallm)
+![License](https://img.shields.io/github/license/KerubinDev/AkitaLLM)
+[![Tests](https://img.shields.io/github/actions/workflow/status/KerubinDev/AkitaLLM/tests.yml)](https://github.com/KerubinDev/AkitaLLM/actions)
+![Downloads](https://img.shields.io/pypi/dm/akitallm)
+
+
+```
+
+Analyze → Plan → Execute → Validate
+
+````
+
+**A deterministic, local-first AI orchestrator for software engineers.**
+
+AkitaLLM is not a chat interface.
+It is not autocomplete.
+It is not “AI magic”.
+
+It is an engineering tool.
+
+---
+
+## What AkitaLLM is (and what it is not)
+
+AkitaLLM treats Large Language Models as **non-deterministic execution engines** that must operate inside a **strict, auditable pipeline**.
+
+Instead of asking an AI *“please fix my code”*, you force it to:
+
+1. **Analyze** the real project structure
+2. **Plan** concrete technical steps
+3. **Execute** changes as reviewable diffs
+4. **Validate** results with real tooling
+
+No hidden prompts.  
+No blind edits.  
+No guessing.
+
+---
+
+## Why this project exists
+
+Most AI coding tools optimize for **speed of output**.
+
+Software engineering optimizes for:
+- correctness
+- predictability
+- debuggability
+- long-term maintainability
+
+That mismatch causes real problems:
+
+- Code is generated without understanding the project
+- Developers approve changes they don’t fully understand
+- Bugs are pushed faster, not fewer
+
+AkitaLLM exists to **slow AI down** and force it to behave like a junior engineer working under strict supervision.
+
+---
+
+## The core difference
+
+| Aspect | Typical AI Tools | AkitaLLM |
+|------|-----------------|----------|
+| Interaction | Chat / Autocomplete | Structured pipeline |
+| Control | Implicit | Explicit and reviewable |
+| Output | Raw code | Unified diffs |
+| Context | Prompt-limited | Project-aware |
+| Validation | Manual | Automated |
+| Philosophy | “Trust the model” | “Trust the process” |
+
+---
+
+## Design principles
+
+**Local-first**  
+Your code stays on your machine. AkitaLLM runs locally and only sends what is strictly necessary to the model.
+
+**No magic**  
+Every decision is logged. Every step is inspectable. Every change is explicit.
+
+**Tool-driven**  
+The AI uses tools (AST parsing, tests, linters). It does not replace them.
+
+**Human-in-the-loop**  
+Nothing is applied without your approval.
+
+---
+
+## What AkitaLLM can do today
+
+- 🔍 **Structural code reviews**  
+  Detect bugs, architectural risks, performance issues, and security problems.
+
+- 🧭 **Technical planning**  
+  Generate step-by-step implementation plans in Markdown.
+
+- 🧩 **Diff-based solutions**  
+  Propose changes as standard unified diffs — no direct file mutation.
+
+- 🧪 **Local validation**  
+  Run tests and tooling before applying changes.
+
+- 🔌 **Extensible architecture**  
+  Plugin system for custom tools and workflows.
+
+- 🤖 **Model agnostic**  
+  Works with OpenAI, Anthropic, Ollama, and any LiteLLM-compatible provider.
+
+---
+
+## Installation
+
+```bash
+pip install akitallm
+````
+
+Python 3.10+ required.
+
+---
+
+## Basic usage
+
+### Initialize / Review a project
+
+```bash
+akita review .
+```
+
+### Generate a technical plan
+
+```bash
+akita plan "Refactor authentication to use JWT with refresh tokens"
+```
+
+### Solve a concrete problem
+
+```bash
+akita solve "Fix silent failures in the reasoning engine error handling"
+```
+
+All commands follow the same pipeline:
+
+```
+Analyze → Plan → Execute → Validate
+```
+
+---
+
+## Extending AkitaLLM
+
+AkitaLLM is designed to be extended by engineers.
+
+* Custom tools
+* Custom validators
+* Custom reasoning steps
+
+See the [Plugin Development Guide](PLUGINS.md).
+
+---
+
+## Contributing
+
+AkitaLLM is not looking for volume.
+It is looking for **engineering-quality contributions**.
+
+If you care about:
+
+* clean abstractions
+* predictable systems
+* readable diffs
+* testable behavior
+
+You’ll fit right in.
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+---
+
+> “Understanding the internals is the first step to excellence.”

{akitallm-1.1.1.dist-info → akitallm-1.2.0.dist-info}/RECORD

@@ -1,24 +1,25 @@
-akita/__init__.py,sha256=q8_5C0f-8mHWNb6mMw02zlYPnEGXBqvOmP3z0CEwZKM,22
-akita/cli/main.py,sha256=6jR4Dfg0HpDGkrr8kdpF6AfzLm6-5nStvsPN1VZd5as,12820
+akita/__init__.py,sha256=MpAT5hgNoHnTtG1XRD_GV_A7QrHVU6vJjGSw_8qMGA4,22
+akita/cli/main.py,sha256=qjBRMVgdM4sNmE05llUYlKStAhiyun84kmCc-JMgne8,15313
 akita/core/ast_utils.py,sha256=8JrTZgfWjIvbzY5KzV2G9PuyOi8IxVdLMjDCPPLiz_I,3127
-akita/core/config.py,sha256=0nlA5AiGjm0Kv5yUxqaHV2zA4Ld1rU_j2s2IjnYBB_Y,1656
+akita/core/config.py,sha256=JlROCAxV3uHgKexClr3vr0Zrfmjg5BUa46bnCi_1K-M,1682
+akita/core/i18n.py,sha256=BQlzJ38DkHClCeeiQ1jad_yAfGhv2FbgfjQ9eI_A5s0,7446
 akita/core/indexing.py,sha256=2j_NK8buZ1ugH3foa9KFQEtGOD-Lgoo2Se3Lx6Q7ZO4,3686
 akita/core/plugins.py,sha256=P3azOFJ-yTw-kDdvjmHfNiU7nfvXQFadVPRnp1O7h-c,2951
 akita/core/providers.py,sha256=SwCb2aTYJ-iNtWdah9IYzLf3vfTDA472i5nhJmsaZLs,6168
 akita/core/trace.py,sha256=AxXUVZ7P8a0l5QTK5w9iSnUncUe62FGfRzDNN9xG5dg,692
-akita/models/base.py,sha256=GC3WB9kMXpg1GCAX5104uovgdOZBIVIHJBq2SO8aU00,1723
+akita/models/base.py,sha256=qIP7FxI8D5osZCHvosgd_64QgGoS_9bN4PJoBOs9NSM,2013
 akita/plugins/__init__.py,sha256=kfjmQqBhzhqQrH-Rd0jh0KxXyIT9T5DtEh-BETQD0FM,28
 akita/plugins/files.py,sha256=Ha4YxmCz2G7iafqdr2TRE_xRlq1oeOBo6By3_S86jkE,1113
-akita/reasoning/engine.py,sha256=w1gB-Y_Tzoan66T-EFd04X7V5mDcVOkSP2G6X3lmvxU,8634
+akita/reasoning/engine.py,sha256=GXw-2829O_ePnOKhGeiFw415ZUW3_C6-9Irw8hF7m1M,10081
 akita/reasoning/session.py,sha256=rcJxcJXNjObjRwfuCY8NQKpKCqxeIppqkUpN-3mVRpE,472
 akita/schemas/review.py,sha256=zzjLzTuiEpJfu4etS0NUBWfS3wyNobNDmDMhb5amWTI,905
 akita/tools/base.py,sha256=jDA3jTP2qo6TjoTF6BSIb71BSfCJGSqbueIQz6lxuCM,1235
 akita/tools/context.py,sha256=i6QjKMsKCZMIdCx82hkhMUzBQJolrcch2v1x-6nLy8U,5008
-akita/tools/diff.py,sha256=bVH6_vHWoC9oYoS1RU4eOEnZHh6eFNtt6HCCzeGb6wY,4805
+akita/tools/diff.py,sha256=d5Q3yRvCKvaCTHW3PibAu1n4AXuFq1zcEeIFD_jxhbo,6942
 akita/tools/git.py,sha256=58ZCI2ZL7NYUQdRIe3969t6gRpVmCPD8B-UbP7cPBNY,2798
-akitallm-1.1.1.dist-info/licenses/LICENSE,sha256=WE7_tfGR-IzkulSh6Pos02gucCXKboaXguAdr0bI9V0,1067
-akitallm-1.1.1.dist-info/METADATA,sha256=BfinRkQicqI9tshCIqPlFZxyxOwVNuXT6z_ZEL4mC9E,5500
-akitallm-1.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-akitallm-1.1.1.dist-info/entry_points.txt,sha256=Au1aAXCO2lX4kgElgknSVDpq7BcN5xAJJ0WvOAkhLzU,105
-akitallm-1.1.1.dist-info/top_level.txt,sha256=duGU-i6qCRLqjo_b1XUqfhlSQky3QIO0Hlvfn2OV3hU,6
-akitallm-1.1.1.dist-info/RECORD,,
+akitallm-1.2.0.dist-info/licenses/LICENSE,sha256=WE7_tfGR-IzkulSh6Pos02gucCXKboaXguAdr0bI9V0,1067
+akitallm-1.2.0.dist-info/METADATA,sha256=Z1U-G8xzeOOrNakY_aVO7kbqbn-Q5QuYWiaB4RrrOIQ,5274
+akitallm-1.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+akitallm-1.2.0.dist-info/entry_points.txt,sha256=Au1aAXCO2lX4kgElgknSVDpq7BcN5xAJJ0WvOAkhLzU,105
+akitallm-1.2.0.dist-info/top_level.txt,sha256=duGU-i6qCRLqjo_b1XUqfhlSQky3QIO0Hlvfn2OV3hU,6
+akitallm-1.2.0.dist-info/RECORD,,

akitallm-1.1.1.dist-info/METADATA

@@ -1,140 +0,0 @@
-Metadata-Version: 2.4
-Name: akitallm
-Version: 1.1.1
-Summary: AkitaLLM: An open-source local-first AI system for programming.
-Author: KerubinDev
-License: MIT
-Project-URL: Homepage, https://github.com/KerubinDev/AkitaLLM
-Project-URL: Repository, https://github.com/KerubinDev/AkitaLLM
-Project-URL: Issues, https://github.com/KerubinDev/AkitaLLM/issues
-Keywords: ai,cli,programming,local-first,llm
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: typer[all]
-Requires-Dist: litellm
-Requires-Dist: pydantic
-Requires-Dist: rich
-Requires-Dist: python-dotenv
-Requires-Dist: pytest
-Requires-Dist: pytest-mock
-Requires-Dist: gitpython
-Requires-Dist: tomli-w
-Requires-Dist: tomli
-Requires-Dist: whatthepatch>=1.0.5
-Requires-Dist: tree-sitter>=0.21.3
-Requires-Dist: tree-sitter-python>=0.21.0
-Dynamic: license-file
-
-# AkitaLLM
-### A deterministic, local-first AI orchestrator for software engineers.
-
----
-
-## What is AkitaLLM?
-
-AkitaLLM is not another "AI wrapper." It is a command-line utility designed for developers who value engineering rigor over generative "magic." It treats Large Language Models as non-deterministic execution engines that must be constrained within a strict, auditable pipeline: **Analyze → Plan → Execute → Validate**.
-
-Built as a local-first tool, it provides you with an AI-augmented workflow that respects your project's context, follows security best practices, and prioritizes structured output over conversational noise.
-
----
-
-## Why AkitaLLM exists
-
-Most current AI tools (ChatGPT, Copilot, Cursor) operate in a "black-box" conversational mode. They are excellent at text generation but often fail at **software engineering**, which requires:
-- **Project-Level Context**: Understanding how a change in `utils.py` affects `main.py`.
-- **Previsibilty**: Knowing exactly what the AI intends to do before it modifies a single byte.
-- **Verification**: Automatically ensuring that proposed changes don't break existing logic.
-
-AkitaLLM was built to bridge this gap, treating AI as a component of a larger, human-controlled engineering process.
-
----
-
-## The Engineering Difference
-
-| Feature | Generic AI Tools | AkitaLLM |
-| :--- | :--- | :--- |
-| **Logic** | Conversational / Guesswork | Analyze → Plan → Execute → Validate |
-| **Control** | Autocomplete / Chat | Explicit technical plans & reviewable Diffs |
-| **Security** | Cloud-heavy | Local-first, respects `.gitignore` and `.env` |
-| **Validation** | Post-facto manual review | Automated local test execution |
-| **Philosophy** | "It just works" (Hype) | "Understand the internals" (Engineering) |
-
----
-
-## Core Principles
-
-1. **Local-First**: Your code remains on your machine. AkitaLLM orchestrates local models (via Ollama) or remote APIs (via LiteLLM) through encrypted, controlled channels.
-2. **Contextual Awareness**: It uses recursive file scanning and structure analysis to build a high-fidelity map of your project before making suggestions.
-3. **No Magic**: No hidden prompts, no mysterious "thinking" phases. All actions are logged, auditable, and based on standard engineering patterns.
-4. **Tool-Driven**: AI is a user of tools (linters, test runners, AST parsers), not a replacement for them.
-
----
-
-## Key Features
-
-- **Structural Code Review**: Detailed analysis of bugs, style, performance, and security risks with prioritized severity levels.
-- **Technical Planning**: Generation of step-by-step implementation plans in Markdown for complex feature requests.
-- **Actionable Diffs**: Proposed changes are generated as standard Unified Diffs for human review before application.
-- **Environment Isolation**: Supports `.env` and local configuration storage (`~/.akita/`) to keep secrets safe.
-- **Model Agnostic**: Seamlessly switch between GPT-4o, Claude 3.5, Llama 3, and more.
-
----
-
-## Installation
-
-AkitaLLM is available on PyPI. You can install it directly using pip:
-
-```bash
-pip install akitallm
-```
-
----
-
-## Usage
-
-### 1. Project Initialization
-Run any command to trigger the initial configuration and onboarding.
-```bash
-akita review .
-```
-
-### 2. Strategic Code Review
-Analyze a directory for potential architectural risks and bugs.
-```bash
-akita review src/
-```
-
-### 3. Implementation Planning
-Generate a technical plan for a specific goal.
-```bash
-akita plan "Implement JWT authentication with Redis-based session storage"
-```
-
-### 4. Code Problem Solving
-Generate a diff to solve a precise issue or refactor a module.
-```bash
-akita solve "Improve error handling in the reasoning engine to prevent silent failures"
-```
-
----
-
-### 🔌 Extensibility
-AkitaLLM is built to be extended. You can create your own tools and plugins. Check the [Plugin Development Guide](PLUGINS.md) for more details.
-
-## 🤝 Contributing
-
-We are looking for engineers, not just coders. If you value robust abstractions, clean code, and predictable systems, your contribution is welcome.
-
-Review our [CONTRIBUTING.md](CONTRIBUTING.md) to understand our engineering standards and PR workflow. High-quality PRs with test coverage are prioritized.
-
----
-
-*“Understanding the internals is the first step to excellence.”*