akitallm 0.1.0__py3-none-any.whl → 1.0.3__py3-none-any.whl

akita/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.0"
+__version__ = "0.1.1"

akita/cli/main.py

@@ -2,12 +2,14 @@ import typer
 from rich.console import Console
 from rich.panel import Panel
 from akita.reasoning.engine import ReasoningEngine
+from akita.core.indexing import CodeIndexer
 from akita.models.base import get_model
 from akita.core.config import load_config, save_config, reset_config, CONFIG_FILE
 from rich.table import Table
 from rich.markdown import Markdown
 from rich.syntax import Syntax
 from dotenv import load_dotenv
+from akita.tools.diff import DiffApplier
 
 # Load environment variables from .env file
 load_dotenv()
@@ -119,27 +121,53 @@ def review(
 @app.command()
 def solve(
     query: str,
+    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.")
 ):
     """
-    Generate a solution for the given query.
+    Generate and apply a solution for the given query.
     """
     model = get_model()
     engine = ReasoningEngine(model)
     console.print(Panel(f"[bold blue]Akita[/] is thinking about: [italic]{query}[/]", title="Solve Mode"))
     
+    current_query = query
+    session = None
+    
     try:
-        diff_output = engine.run_solve(query)
-        
-        console.print(Panel("[bold green]Suggested Code Changes (Unified Diff):[/]"))
-        syntax = Syntax(diff_output, "diff", theme="monokai", line_numbers=True)
-        console.print(syntax)
-        
+        while True:
+            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):[/]"))
+            syntax = Syntax(diff_output, "diff", theme="monokai", line_numbers=True)
+            console.print(syntax)
+            
+            if interactive:
+                action = typer.prompt("\n[A]pprove, [R]efine with feedback, or [C]ancel?", default="A").upper()
+                if action == "A":
+                    break
+                elif action == "R":
+                    current_query = typer.prompt("Enter your feedback/refinement")
+                    continue
+                else:
+                    console.print("[yellow]Operation cancelled.[/]")
+                    return
+            else:
+                break
+
         if not dry_run:
             confirm = typer.confirm("\nDo you want to apply these changes?")
             if confirm:
-                console.print("[bold yellow]Applying changes... (DiffApplier to be implemented next)[/]")
-                # We will implement DiffApplier in the next step
+                console.print("[bold yellow]🚀 Applying changes...[/]")
+                success = DiffApplier.apply_unified_diff(diff_output)
+                if success:
+                    console.print("[bold green]✅ Changes applied successfully![/]")
+                else:
+                    console.print("[bold red]❌ Failed to apply changes.[/]")
             else:
                 console.print("[bold yellow]Changes discarded.[/]")
     except Exception as e:
@@ -165,12 +193,29 @@ def plan(
         console.print(f"[bold red]Planning failed:[/] {e}")
         raise typer.Exit(code=1)
 
+@app.command()
+def index(
+    path: str = typer.Argument(".", help="Path to index for RAG.")
+):
+    """
+    Build a local vector index (RAG) for the project.
+    """
+    console.print(Panel(f"🔍 [bold blue]Akita[/] is indexing: [yellow]{path}[/]", title="Index Mode"))
+    try:
+        indexer = CodeIndexer(path)
+        with console.status("[bold green]Indexing project files..."):
+            indexer.index_project()
+        console.print("[bold green]✅ Indexing complete! Semantic search is now active.[/]")
+    except Exception as e:
+        console.print(f"[bold red]Indexing failed:[/] {e}")
+        raise typer.Exit(code=1)
+
 @app.command()
 def test():
     """
     Run automated tests in the project.
     """
-    console.print(Panel("🐶 [bold blue]Akita[/] is running tests...", title="Test Mode"))
+    console.print(Panel("[bold blue]Akita[/] is running tests...", title="Test Mode"))
     from akita.tools.base import ShellTools
     result = ShellTools.execute("pytest")
     if result.success:
@@ -180,6 +225,26 @@ def test():
         console.print("[bold red]Tests failed![/]")
         console.print(result.error or result.output)
 
+@app.command()
+def docs():
+    """
+    Start the local documentation server.
+    """
+    import subprocess
+    import sys
+    
+    console.print(Panel("[bold blue]Akita[/] Documentation", title="Docs Mode"))
+    console.print("[dim]Starting MkDocs server...[/]")
+    console.print("[bold green]Open your browser at: http://127.0.0.1:8000[/]")
+    
+    try:
+        subprocess.run([sys.executable, "-m", "mkdocs", "serve"], check=True)
+    except FileNotFoundError:
+        console.print("[red]MkDocs not found. Install it with: pip install mkdocs-material[/]")
+        raise typer.Exit(code=1)
+    except KeyboardInterrupt:
+        console.print("[yellow]Documentation server stopped.[/]")
+
 # Config Command Group
 config_app = typer.Typer(help="Manage AkitaLLM configuration.")
 app.add_typer(config_app, name="config")

akita/core/ast_utils.py

@@ -0,0 +1,77 @@
+import tree_sitter_python as tspython
+from tree_sitter import Language, Parser
+import pathlib
+from typing import List, Dict, Any, Optional
+
+class ASTParser:
+    def __init__(self):
+        self.language = Language(tspython.language())
+        self.parser = Parser(self.language)
+
+    def parse_file(self, file_path: str) -> Optional[Any]:
+        path = pathlib.Path(file_path)
+        if not path.exists():
+            return None
+        
+        with open(path, "rb") as f:
+            content = f.read()
+        
+        return self.parser.parse(content)
+
+    def get_definitions(self, file_path: str) -> List[Dict[str, Any]]:
+        """Extract classes and functions with their line ranges using recursive traversal."""
+        tree = self.parse_file(file_path)
+        if not tree:
+            return []
+
+        with open(file_path, "rb") as f:
+            content = f.read()
+
+        definitions = []
+        
+        def explore(node):
+            # Check for definitions
+            if node.type in ["class_definition", "function_definition", "decorated_definition"]:
+                # Find name
+                name_node = node.child_by_field_name("name")
+                if not name_node and node.type == "decorated_definition":
+                    # For decorated definitions, the name is in the class/function child
+                    inner = node.child_by_field_name("definition")
+                    if inner:
+                        name_node = inner.child_by_field_name("name")
+                
+                name = content[name_node.start_byte:name_node.end_byte].decode("utf-8") if name_node else "anonymous"
+                
+                # Docstring extraction
+                docstring = None
+                body = node.child_by_field_name("body")
+                if body and body.children:
+                    for stmt in body.children:
+                        if stmt.type == "expression_statement":
+                            child = stmt.children[0]
+                            if child.type == "string":
+                                docstring = content[child.start_byte:child.end_byte].decode("utf-8").strip('"\' \n')
+                        break # Only first statement
+
+                definitions.append({
+                    "name": name,
+                    "type": "class" if "class" in node.type else "function",
+                    "start_line": node.start_point[0] + 1,
+                    "end_line": node.end_point[0] + 1,
+                    "docstring": docstring
+                })
+
+            # Always explore children regardless of current node type
+            for child in node.children:
+                explore(child)
+
+        explore(tree.root_node)
+        return definitions
+
+    def get_source_segment(self, file_path: str, start_line: int, end_line: int) -> str:
+        """Extract a segment of code from a file by line numbers."""
+        with open(file_path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+        
+        # Lines are 1-indexed in our definitions, but 0-indexed in the list
+        return "".join(lines[start_line-1 : end_line])

akita/core/indexing.py

@@ -0,0 +1,94 @@
+import os
+import json
+import re
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from akita.core.ast_utils import ASTParser
+
+class CodeIndexer:
+    """
+    A lightweight, zero-dependency semantic-keyword indexer.
+    Uses basic TF-IDF principles and AST-aware keyword weighting.
+    Works perfectly even in restricted environments like Python 3.14.
+    """
+    def __init__(self, project_path: str):
+        self.project_path = Path(project_path)
+        self.index_file = self.project_path / ".akita" / "index.json"
+        self.ast_parser = ASTParser()
+        self.data: List[Dict[str, Any]] = []
+        self.load_index()
+
+    def load_index(self):
+        if self.index_file.exists():
+            try:
+                with open(self.index_file, "r", encoding="utf-8") as f:
+                    self.data = json.load(f)
+            except Exception:
+                self.data = []
+
+    def save_index(self):
+        self.index_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.index_file, "w", encoding="utf-8") as f:
+            json.dump(self.data, f, indent=2)
+
+    def index_project(self):
+        """Index all Python files in the project."""
+        self.data = []
+        for root, _, files in os.walk(self.project_path):
+            if ".akita" in root or ".git" in root or "__pycache__" in root:
+                continue
+                
+            for file in files:
+                if file.endswith(".py"):
+                    full_path = Path(root) / file
+                    rel_path = full_path.relative_to(self.project_path)
+                    self._index_file(full_path, str(rel_path))
+        self.save_index()
+
+    def _index_file(self, file_path: Path, rel_path: str):
+        try:
+            definitions = self.ast_parser.get_definitions(str(file_path))
+            for d in definitions:
+                source = self.ast_parser.get_source_segment(
+                    str(file_path), d["start_line"], d["end_line"]
+                )
+                
+                # Create a searchable representation (keyword rich)
+                # We normalize case and extract meaningful words
+                search_blob = f"{d['name']} {d['type']} {d['docstring'] or ''} {source}"
+                keywords = set(re.findall(r'\w+', search_blob.lower()))
+                
+                self.data.append({
+                    "path": rel_path,
+                    "name": d["name"],
+                    "type": d["type"],
+                    "start_line": d["start_line"],
+                    "end_line": d["end_line"],
+                    "keywords": list(keywords),
+                    "content": source[:500] # Store snippet preview
+                })
+        except Exception:
+            pass
+
+    def search(self, query: str, n_results: int = 5) -> List[Dict[str, Any]]:
+        """Search using Jaccard Similarity on keywords (Lite Contextual Search)."""
+        query_keywords = set(re.findall(r'\w+', query.lower()))
+        if not query_keywords:
+            return []
+
+        scores = []
+        for item in self.data:
+            item_keywords = set(item["keywords"])
+            intersection = query_keywords.intersection(item_keywords)
+            # Simple intersection count as score, weighted by name match
+            score = len(intersection)
+            if any(qk in item["name"].lower() for qk in query_keywords):
+                score += 5 # Boost explicit name matches
+                
+            if score > 0:
+                scores.append((score, item))
+
+        # Sort by score descending
+        scores.sort(key=lambda x: x[0], reverse=True)
+        
+        return [s[1] for s in scores[:n_results]]

akita/core/plugins.py

@@ -0,0 +1,81 @@
+import abc
+import importlib
+import importlib.metadata
+import inspect
+import pkgutil
+from pathlib import Path
+from typing import List, Dict, Any, Type, Optional
+
+class AkitaPlugin(abc.ABC):
+    """Base class for all AkitaLLM plugins."""
+    
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        """Unique name of the plugin."""
+        pass
+
+    @property
+    @abc.abstractmethod
+    def description(self) -> str:
+        """Brief description of what the plugin does."""
+        pass
+
+    @abc.abstractmethod
+    def get_tools(self) -> List[Dict[str, Any]]:
+        """Return a list of tools (functions) provided by this plugin."""
+        pass
+
+class PluginManager:
+    def __init__(self, internal_plugins_path: Optional[str] = None):
+        self.plugins: Dict[str, AkitaPlugin] = {}
+        self.internal_path = internal_plugins_path or str(Path(__file__).parent.parent / "plugins")
+
+    def discover_all(self):
+        """Discover both internal and external plugins."""
+        self._discover_internal()
+        self._discover_external()
+
+    def _discover_internal(self):
+        """Load plugins from the akita/plugins directory."""
+        path = Path(self.internal_path)
+        if not path.exists():
+            return
+
+        for loader, module_name, is_pkg in pkgutil.iter_modules([str(path)]):
+            full_module_name = f"akita.plugins.{module_name}"
+            try:
+                module = importlib.import_module(full_module_name)
+                self._load_from_module(module)
+            except Exception as e:
+                print(f"Error loading internal plugin {module_name}: {e}")
+
+    def _discover_external(self):
+        """Load plugins registered via entry_points (akitallm.plugins)."""
+        try:
+            # Python 3.10+
+            eps = importlib.metadata.entry_points(group='akitallm.plugins')
+            for entry_point in eps:
+                try:
+                    plugin_class = entry_point.load()
+                    if inspect.isclass(plugin_class) and issubclass(plugin_class, AkitaPlugin):
+                        instance = plugin_class()
+                        self.plugins[instance.name] = instance
+                except Exception as e:
+                    print(f"Error loading external plugin {entry_point.name}: {e}")
+        except Exception:
+            pass
+
+    def _load_from_module(self, module):
+        """Extract AkitaPlugin classes from a module and instantiate them."""
+        for name, obj in inspect.getmembers(module):
+            if inspect.isclass(obj) and issubclass(obj, AkitaPlugin) and obj is not AkitaPlugin:
+                instance = obj()
+                self.plugins[instance.name] = instance
+
+    def get_all_tools(self) -> List[Dict[str, Any]]:
+        """Collect all tools from all loaded plugins."""
+        all_tools = []
+        for plugin in self.plugins.values():
+            all_tools.extend(plugin.get_tools())
+        return all_tools

akita/core/trace.py

@@ -0,0 +1,18 @@
+from typing import List, Dict, Any
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+class TraceStep(BaseModel):
+    timestamp: datetime = Field(default_factory=datetime.now)
+    action: str
+    details: str
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+class ReasoningTrace(BaseModel):
+    steps: List[TraceStep] = Field(default_factory=list)
+
+    def add_step(self, action: str, details: str, metadata: Dict[str, Any] = None):
+        self.steps.append(TraceStep(action=action, details=details, metadata=metadata or {}))
+
+    def __str__(self):
+        return "\n".join([f"[{s.timestamp.strftime('%H:%M:%S')}] {s.action}: {s.details}" for s in self.steps])

akita/plugins/__init__.py

@@ -0,0 +1 @@
+# Official AkitaLLM Plugins

akita/plugins/files.py

@@ -0,0 +1,34 @@
+from akita.core.plugins import AkitaPlugin
+from akita.tools.base import FileSystemTools
+from typing import List, Dict, Any
+
+class FilesPlugin(AkitaPlugin):
+    @property
+    def name(self) -> str:
+        return "files"
+
+    @property
+    def description(self) -> str:
+        return "Standard filesystem operations (read, write, list)."
+
+    def get_tools(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "read_file",
+                "description": "Read content from a file.",
+                "parameters": {"path": "string"},
+                "func": FileSystemTools.read_file
+            },
+            {
+                "name": "write_file",
+                "description": "Write content to a file.",
+                "parameters": {"path": "string", "content": "string"},
+                "func": FileSystemTools.write_file
+            },
+            {
+                "name": "list_dir",
+                "description": "List files in a directory.",
+                "parameters": {"path": "string"},
+                "func": FileSystemTools.list_dir
+            }
+        ]

akita/reasoning/engine.py

@@ -1,16 +1,23 @@
 from typing import List, Dict, Any, Optional
 from akita.models.base import AIModel, get_model
-from akita.tools.base import ShellTools, FileSystemTools
+from akita.tools.base import ShellTools
+from akita.core.plugins import PluginManager
 from akita.tools.context import ContextBuilder
 from akita.schemas.review import ReviewResult
+from akita.core.trace import ReasoningTrace
+from akita.reasoning.session import ConversationSession
 import json
 from rich.console import Console
 
 console = Console()
-
+ 
 class ReasoningEngine:
     def __init__(self, model: AIModel):
         self.model = model
+        self.plugin_manager = PluginManager()
+        self.plugin_manager.discover_all()
+        self.trace = ReasoningTrace()
+        self.session: Optional[ConversationSession] = None
 
     def run_review(self, path: str) -> ReviewResult:
         """
@@ -91,27 +98,46 @@ class ReasoningEngine:
         ])
         return response.content
 
-    def run_solve(self, query: str, path: str = ".") -> str:
+    def run_solve(self, query: str, path: str = ".", session: Optional[ConversationSession] = None) -> str:
         """
         Generates a Unified Diff solution for the given query.
+        Supports iterative refinement if a session is provided.
         """
-        console.print(f"🔍 [bold]Building context for solution...[/]")
-        builder = ContextBuilder(path)
-        snapshot = builder.build()
-        
-        files_str = "\n---\n".join([f"FILE: {f.path}\nCONTENT:\n{f.content}" for f in snapshot.files[:10]]) # Limit for solve
+        self.trace.add_step("Solve", f"Starting solve for query: {query}")
         
-        system_prompt = (
-            "You are an Expert Programmer. Solve the requested task by providing code changes in Unified Diff format. "
-            "Respond ONLY with the Diff block. Use +++ and --- with file paths relative to project root."
-        )
-        user_prompt = f"Task: {query}\n\nContext:\n{files_str}\n\nGenerate the Unified Diff."
+        if not session:
+            self.trace.add_step("Context", f"Building context for {path}")
+            builder = ContextBuilder(path)
+            snapshot = builder.build(query=query)
+            
+            files_str = "\n---\n".join([f"FILE: {f.path}\nCONTENT:\n{f.content}" for f in snapshot.files[:10]])
+            
+            rag_str = ""
+            if snapshot.rag_snippets:
+                rag_str = "\n\nRELEVANT SNIPPETS (RAG):\n" + "\n".join([
+                    f"- {s['path']} ({s['name']}):\n{s['content']}" for s in snapshot.rag_snippets
+                ])
+
+            tools_info = "\n".join([f"- {t['name']}: {t['description']}" for t in self.plugin_manager.get_all_tools()])
+            
+            system_prompt = (
+                "You are an Expert Programmer. Solve the requested task by providing code changes in Unified Diff format. "
+                "Respond ONLY with the Diff block. Use +++ and --- with file paths relative to project root.\n\n"
+                f"Available Tools:\n{tools_info}"
+            )
+            
+            session = ConversationSession()
+            session.add_message("system", system_prompt)
+            session.add_message("user", f"Task: {query}\n\nContext:\n{files_str}{rag_str}")
+            self.session = session
+        else:
+            session.add_message("user", query)
+
+        console.print("🤖 [bold green]Thinking...[/]")
+        response = self.model.chat(session.get_messages_dict())
+        session.add_message("assistant", response.content)
         
-        console.print("🤖 [bold green]Generating solution...[/]")
-        response = self.model.chat([
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_prompt}
-        ])
+        self.trace.add_step("LLM Response", "Received solution from model")
         return response.content
 
     def run_pipeline(self, task: str):

akita/reasoning/session.py

@@ -0,0 +1,15 @@
+from typing import List, Dict, Any
+from pydantic import BaseModel, Field
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+class ConversationSession(BaseModel):
+    messages: List[ChatMessage] = Field(default_factory=list)
+
+    def add_message(self, role: str, content: str):
+        self.messages.append(ChatMessage(role=role, content=content))
+
+    def get_messages_dict(self) -> List[Dict[str, str]]:
+        return [m.model_dump() for m in self.messages]

akita/tools/base.py

@@ -15,7 +15,12 @@ class FileSystemTools:
             return f.read()
 
     @staticmethod
-    def list_files(path: str) -> List[str]:
+    def write_file(path: str, content: str):
+        with open(path, 'w', encoding='utf-8') as f:
+            f.write(content)
+
+    @staticmethod
+    def list_dir(path: str) -> List[str]:
         return os.listdir(path)
 
 class ShellTools:

akita/tools/context.py

@@ -1,16 +1,18 @@
 import os
 from pathlib import Path
-from typing import List, Dict, Optional
+from typing import Any, List, Dict, Optional
 from pydantic import BaseModel
 
 class FileContext(BaseModel):
     path: str
     content: str
     extension: str
+    summary: Optional[str] = None # New field for semantic summary
 
 class ContextSnapshot(BaseModel):
     files: List[FileContext]
     project_structure: List[str]
+    rag_snippets: Optional[List[Dict[str, Any]]] = None
 
 class ContextBuilder:
     def __init__(
@@ -19,26 +21,49 @@ class ContextBuilder:
         extensions: Optional[List[str]] = None,
         exclude_dirs: Optional[List[str]] = None,
         max_file_size_kb: int = 50,
-        max_files: int = 50
+        max_files: int = 50,
+        use_semantical_context: bool = True
     ):
         self.base_path = Path(base_path)
         self.extensions = extensions or [".py", ".js", ".ts", ".cpp", ".h", ".toml", ".md", ".json"]
         self.exclude_dirs = exclude_dirs or [".git", ".venv", "node_modules", "__pycache__", "dist", "build"]
         self.max_file_size_kb = max_file_size_kb
         self.max_files = max_files
+        self.use_semantical_context = use_semantical_context
+        
+        if self.use_semantical_context:
+            try:
+                from akita.core.ast_utils import ASTParser
+                from akita.core.indexing import CodeIndexer
+                self.ast_parser = ASTParser()
+                self.indexer = CodeIndexer(str(self.base_path))
+            except ImportError:
+                self.ast_parser = None
+                self.indexer = None
 
-    def build(self) -> ContextSnapshot:
-        """Scan the path and build a context snapshot."""
+    def build(self, query: Optional[str] = None) -> ContextSnapshot:
+        """
+        Scan the path and build a context snapshot.
+        If a query is provided and indexer is available, it includes RAG snippets.
+        """
         files_context = []
         project_structure = []
+        rag_snippets = None
         
+        if query and self.indexer:
+            try:
+                # Ensure index exists (lazy indexing for now)
+                # In production, we'd have a separate command or check timestamps
+                rag_snippets = self.indexer.search(query, n_results=10)
+            except Exception:
+                pass
+
         if self.base_path.is_file():
             if self._should_include_file(self.base_path):
                 files_context.append(self._read_file(self.base_path))
                 project_structure.append(str(self.base_path.name))
         else:
             for root, dirs, files in os.walk(self.base_path):
-                # Filter out excluded directories
                 dirs[:] = [d for d in dirs if d not in self.exclude_dirs]
                 
                 rel_root = os.path.relpath(root, self.base_path)
@@ -54,7 +79,11 @@ class ContextBuilder:
                                 files_context.append(context)
                                 project_structure.append(os.path.join(rel_root, file))
         
-        return ContextSnapshot(files=files_context, project_structure=project_structure)
+        return ContextSnapshot(
+            files=files_context, 
+            project_structure=project_structure,
+            rag_snippets=rag_snippets
+        )
 
     def _should_include_file(self, path: Path) -> bool:
         if path.name == ".env" or path.suffix == ".env":
@@ -66,8 +95,12 @@ class ContextBuilder:
         if not path.exists():
             return False
             
-        # Check size
-        if path.stat().st_size > self.max_file_size_kb * 1024:
+        # Check size (we can be more lenient if using semantic summaries)
+        size_limit = self.max_file_size_kb * 1024
+        if self.use_semantical_context:
+            size_limit *= 2 # Allow larger files if we can summarize them
+            
+        if path.stat().st_size > size_limit:
             return False
             
         return True
@@ -76,10 +109,22 @@ class ContextBuilder:
         try:
             with open(path, 'r', encoding='utf-8') as f:
                 content = f.read()
+                
+                summary = None
+                if self.use_semantical_context and self.ast_parser and path.suffix == ".py":
+                    try:
+                        defs = self.ast_parser.get_definitions(str(path))
+                        if defs:
+                            summary_lines = [f"{d['type'].upper()} {d['name']} (L{d['start_line']}-L{d['end_line']})" for d in defs]
+                            summary = "\n".join(summary_lines)
+                    except Exception:
+                        pass
+
                 return FileContext(
                     path=str(path.relative_to(self.base_path) if self.base_path.is_dir() else path.name),
                     content=content,
-                    extension=path.suffix
+                    extension=path.suffix,
+                    summary=summary
                 )
         except Exception:
             return None

akita/tools/diff.py

@@ -1,35 +1,110 @@
 import os
+import shutil
+import pathlib
 from pathlib import Path
-import re
+import whatthepatch
+from typing import List, Tuple, Optional
 
 class DiffApplier:
     @staticmethod
-    def apply_unified_diff(diff_text: str, base_path: str = "."):
+    def apply_unified_diff(diff_text: str, base_path: str = ".") -> bool:
         """
-        Simplistic Unified Diff applier. 
-        In a real scenario, this would use a robust library like 'patch-py' or 'whatthepatch'.
-        For AkitaLLM, we keep it simple for now.
+        Applies a unified diff to files in the base_path.
+        Includes backup and rollback logic for atomicity.
         """
-        # Split by file
-        file_diffs = re.split(r'--- (.*?)\n\+\+\+ (.*?)\n', diff_text)
-        
-        # Pattern extraction is tricky with regex, let's try a safer approach
-        lines = diff_text.splitlines()
-        current_file = None
-        new_content = []
-        
-        # This is a VERY placeholder implementation for safety.
-        # Applying diffs manually is high risk without a dedicated library.
-        # For the MVP, we will log what would happen.
-        
-        print(f"DEBUG: DiffApplier would process {len(lines)} lines of diff.")
-        
-        # Real logic would:
-        # 1. Path identification (--- / +++)
-        # 2. Hunk identification (@@)
-        # 3. Line modification
-        
-        return True
+        patches = list(whatthepatch.parse_patch(diff_text))
+        if not patches:
+            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)
+
+        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)
+                rel_path = patch.header.new_path
+                is_new = (patch.header.old_path == "/dev/null")
+                is_delete = (patch.header.new_path == "/dev/null")
+
+                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:]
+                
+                target_file = (base / rel_path).resolve()
+                
+                if not is_new and not target_file.exists():
+                    print(f"ERROR: Target file {target_file} does not exist for patching.")
+                    return False
+
+                # 1. Create 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
+
+                # 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.")
+            
+            # 4. Pre-flight Validation
+            # Run tests to ensure the patch didn't break anything
+            if (base / "tests").exists():
+                print("🧪 Running pre-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.")
+                else:
+                    print("✅ Pre-flight validation passed!")
+            
+            return True
+
+        except Exception as e:
+            print(f"CRITICAL ERROR: {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
+            return False
 
     @staticmethod
     def apply_whole_file(file_path: str, content: str):

akitallm-1.0.3.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: akitallm
+Version: 1.0.3
+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.”*

akitallm-1.0.3.dist-info/RECORD

@@ -0,0 +1,22 @@
+akita/__init__.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+akita/cli/main.py,sha256=WOr-Z_PurjLxpHGT7gNpXwCv8Ghr0_vGjz4hbF6QunQ,10206
+akita/core/ast_utils.py,sha256=8JrTZgfWjIvbzY5KzV2G9PuyOi8IxVdLMjDCPPLiz_I,3127
+akita/core/config.py,sha256=GsfkKqg0SlMhsQ2fHsRATjzDy6BzVSX8efIyh8o8DZw,1312
+akita/core/indexing.py,sha256=2j_NK8buZ1ugH3foa9KFQEtGOD-Lgoo2Se3Lx6Q7ZO4,3686
+akita/core/plugins.py,sha256=P3azOFJ-yTw-kDdvjmHfNiU7nfvXQFadVPRnp1O7h-c,2951
+akita/core/trace.py,sha256=AxXUVZ7P8a0l5QTK5w9iSnUncUe62FGfRzDNN9xG5dg,692
+akita/models/base.py,sha256=eZGCT-R9WEBaf8WaiMAkpQTdACewl-1F2uDEhs6ocQ4,1584
+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/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
+akitallm-1.0.3.dist-info/licenses/LICENSE,sha256=WE7_tfGR-IzkulSh6Pos02gucCXKboaXguAdr0bI9V0,1067
+akitallm-1.0.3.dist-info/METADATA,sha256=RT2JGCtgRaip7AMajYySH9hIvAKnTCDq5TyvFBgUBHc,5500
+akitallm-1.0.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+akitallm-1.0.3.dist-info/entry_points.txt,sha256=Au1aAXCO2lX4kgElgknSVDpq7BcN5xAJJ0WvOAkhLzU,105
+akitallm-1.0.3.dist-info/top_level.txt,sha256=duGU-i6qCRLqjo_b1XUqfhlSQky3QIO0Hlvfn2OV3hU,6
+akitallm-1.0.3.dist-info/RECORD,,

akitallm-1.0.3.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[akitallm.plugins]
+files = akita.plugins.files:FilesPlugin
+
+[console_scripts]
+akita = akita.cli.main:app

akitallm-0.1.0.dist-info/METADATA

@@ -1,111 +0,0 @@
-Metadata-Version: 2.4
-Name: akitallm
-Version: 0.1.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
-Dynamic: license-file
-
-# AkitaLLM
-
-**AkitaLLM** is an open-source, local-first AI system designed for professional programming. It orchestrates existing LLMs (Ollama, OpenAI, Anthropic, etc.) through a strict **Plan-Execute-Validate** pipeline to ensure code quality and reliability.
-
-## What is AkitaLLM?
-
-AkitaLLM is a command-line interface (CLI) that helps you manage codebases with AI. Unlike simple chat interfaces, AkitaLLM:
-- **Analyzes** your project structure and file content before proposing changes.
-- **Plans** technical steps using a structured reasoning engine.
-- **Solves** problems by generating Unified Diffs that you can review.
-- **Validates** changes using local testing frameworks like `pytest`.
-
-## Key Features
-
-- **Local-First**: Developed with privacy and security in mind.
-- **Model Agnostic**: Use any model supported by LiteLLM (GPT-4o, Claude, Llama 3 via Ollama).
-- **Structured Output**: Code reviews and plans are presented in professional terminal tables and Markdown.
-- **Security by Default**: Diffs are only applied with your explicit confirmation.
-- **Support for .env**: Manage your API keys safely.
-
-## Installation
-
-```bash
-# Clone the repository
-git clone https://github.com/Your-Name/AkitaLLM.git
-cd AkitaLLM
-
-# Install in editable mode
-pip install -e .
-```
-
-## Usage
-
-### 1. Initial Setup
-The first time you run a command, AkitaLLM will guide you through choosing a model.
-```bash
-akita review .
-```
-
-### 2. Code Review
-Analyze files or directories for bugs, style, and security risks.
-```bash
-akita review src/
-```
-
-### 3. Solution Planning
-Generate a technical plan for a complex task.
-```bash
-akita plan "Refactor the authentication module to support JWT"
-```
-
-### 4. Problem Solving
-Generate a diff to solve a specific issue.
-```bash
-akita solve "Add error handling to the ReasoningEngine class"
-```
-
-## Configuration
-
-AkitaLLM stores its configuration in `~/.akita/config.toml`. You can manage it via:
-```bash
-# View and change model settings
-akita config model
-
-# Reset all settings
-akita config model --reset
-```
-
-## Contributing
-
-We welcome contributions! Please check [CONTRIBUTING.md](CONTRIBUTING.md) to understand our workflow and standards.
-
-## License
-
-This project is licensed under the **MIT License**. See [LICENSE](LICENSE) for details.
-
----
-
-*“Understanding the internals is the first step to excellence.”*

akitallm-0.1.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-akita/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
-akita/cli/main.py,sha256=BRtB4klB1y2zFeoYIQfwUdcg91mvsmPf3EV1A73T89s,7582
-akita/core/config.py,sha256=GsfkKqg0SlMhsQ2fHsRATjzDy6BzVSX8efIyh8o8DZw,1312
-akita/models/base.py,sha256=eZGCT-R9WEBaf8WaiMAkpQTdACewl-1F2uDEhs6ocQ4,1584
-akita/reasoning/engine.py,sha256=b436nuhli-87ADtgMK2VJCv1WE5LBtGFFJaNS5chiYw,7389
-akita/schemas/review.py,sha256=zzjLzTuiEpJfu4etS0NUBWfS3wyNobNDmDMhb5amWTI,905
-akita/tools/base.py,sha256=cufLJv8CtmzzNdmMlu-d8iC5QYXWXxc-X4mCYisChkU,1091
-akita/tools/context.py,sha256=Gryy9SjAIXkujWJdue5WH1tB_nSPc7ZAxC5o_r2Gnlg,3084
-akita/tools/diff.py,sha256=gPDOPCqxgjT8DWRc-x4GgNEtt2LOZvICtYyUaf_aSWM,1422
-akitallm-0.1.0.dist-info/licenses/LICENSE,sha256=WE7_tfGR-IzkulSh6Pos02gucCXKboaXguAdr0bI9V0,1067
-akitallm-0.1.0.dist-info/METADATA,sha256=CnXq6VjP9nv-VvXuq7VzhNq_KxrZd2l_PKncw0SLnq0,3435
-akitallm-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-akitallm-0.1.0.dist-info/entry_points.txt,sha256=JGjCc_PusPfOXSVmY5U5VxDDG-yMNcXySluxVKjn_QA,45
-akitallm-0.1.0.dist-info/top_level.txt,sha256=duGU-i6qCRLqjo_b1XUqfhlSQky3QIO0Hlvfn2OV3hU,6
-akitallm-0.1.0.dist-info/RECORD,,

akitallm-0.1.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-akita = akita.cli.main:app