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

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.1.dist-info/METADATA

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: akitallm
+Version: 1.2.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
+
+![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.1.dist-info}/RECORD

@@ -1,24 +1,26 @@
-akita/__init__.py,sha256=q8_5C0f-8mHWNb6mMw02zlYPnEGXBqvOmP3z0CEwZKM,22
-akita/cli/main.py,sha256=6jR4Dfg0HpDGkrr8kdpF6AfzLm6-5nStvsPN1VZd5as,12820
+akita/__init__.py,sha256=Mlm4Gvmb_6yQxwUbv2Ksc-BJFXLPg9H1Vt2iV7wXrA4,22
+akita/cli/doctor.py,sha256=7AgcxPz5i91XkAm6fEKEAjM-YHl-qAu87ArQiSPfJ80,5149
+akita/cli/main.py,sha256=rk0u4IhVD2_5rOBekuPlKGVRDsGJ1bIAPqiyLtxA2Zc,16764
 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=paM3tXuc6-gh9IB5KZwZ55a_s5vDt5ANrvOGnej23YY,9893
 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.1.dist-info/licenses/LICENSE,sha256=WE7_tfGR-IzkulSh6Pos02gucCXKboaXguAdr0bI9V0,1067
+akitallm-1.2.1.dist-info/METADATA,sha256=J91P4UIErpPmKWGGh-gGWUbIpTL3L3UP4bmU_SSCrFg,5274
+akitallm-1.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+akitallm-1.2.1.dist-info/entry_points.txt,sha256=Au1aAXCO2lX4kgElgknSVDpq7BcN5xAJJ0WvOAkhLzU,105
+akitallm-1.2.1.dist-info/top_level.txt,sha256=duGU-i6qCRLqjo_b1XUqfhlSQky3QIO0Hlvfn2OV3hU,6
+akitallm-1.2.1.dist-info/RECORD,,