akitallm 0.1.1__tar.gz → 1.1.0__tar.gz

{akitallm-0.1.1 → akitallm-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akitallm
-Version: 0.1.1
+Version: 1.1.0
 Summary: AkitaLLM: An open-source local-first AI system for programming.
 Author: KerubinDev
 License: MIT
@@ -28,17 +28,11 @@ 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
 
-```text
-     _      _   _ _        _     _     __  __ 
-    / \    | | _(_) |_ __ _| |   | |   |  \/  |
-   / _ \   | |/ / | __/ _` | |   | |   | |\/| |
-  / ___ \  |   <| | || (_| | |___| |___| |  | |
- /_/   \_\ |_|\_\_|\__\__,_|_____|_____|_|  |_|
-                                               
-```
-
 # AkitaLLM
 ### A deterministic, local-first AI orchestrator for software engineers.
 
@@ -132,7 +126,10 @@ akita solve "Improve error handling in the reasoning engine to prevent silent fa
 
 ---
 
-## Contributing
+### 🔌 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.
 

{akitallm-0.1.1 → akitallm-1.1.0}/README.md

@@ -1,12 +1,3 @@
-```text
-     _      _   _ _        _     _     __  __ 
-    / \    | | _(_) |_ __ _| |   | |   |  \/  |
-   / _ \   | |/ / | __/ _` | |   | |   | |\/| |
-  / ___ \  |   <| | || (_| | |___| |___| |  | |
- /_/   \_\ |_|\_\_|\__\__,_|_____|_____|_|  |_|
-                                               
-```
-
 # AkitaLLM
 ### A deterministic, local-first AI orchestrator for software engineers.
 
@@ -100,7 +91,10 @@ akita solve "Improve error handling in the reasoning engine to prevent silent fa
 
 ---
 
-## Contributing
+### 🔌 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.
 

akitallm-1.1.0/akita/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.1.0"

akitallm-1.1.0/akita/cli/main.py

@@ -0,0 +1,346 @@
+import typer
+from typing import Optional, List, Dict, Any
+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
+from akita.tools.git import GitTool
+from akita.core.providers import detect_provider
+
+# Load environment variables from .env file
+load_dotenv()
+
+app = typer.Typer(
+    name="akita",
+    help="AkitaLLM: Local-first AI orchestrator for programmers.",
+    add_completion=False,
+)
+console = Console()
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    dry_run: bool = typer.Option(False, "--dry-run", help="Run without making any changes.")
+):
+    """
+    AkitaLLM orchestrates LLMs to help you code with confidence.
+    """
+    # Skip onboarding for the config command itself
+    if ctx.invoked_subcommand == "config":
+        return
+
+    if dry_run:
+        console.print("[bold yellow]⚠️ Running in DRY-RUN mode. No changes will be applied.[/]")
+
+    # Onboarding check
+    if not CONFIG_FILE.exists():
+        run_onboarding()
+
+def run_onboarding():
+    console.print(Panel(
+        "[bold cyan]AkitaLLM Configuration[/]\n\n[italic]API-first setup...[/]",
+        title="Onboarding"
+    ))
+    
+    api_key = typer.prompt("🔑 Paste your API Key (or type 'ollama' for local)", hide_input=False)
+    
+    provider = detect_provider(api_key)
+    if not provider:
+        console.print("[bold red]❌ Could not detect provider from the given key.[/]")
+        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()}")
+    
+    with console.status(f"[bold blue]Consulting {provider.name} API for available models..."):
+        try:
+            models = provider.list_models(api_key)
+        except Exception as e:
+            console.print(f"[bold red]❌ Failed to list models:[/] {e}")
+            raise typer.Abort()
+    
+    if not models:
+        console.print("[bold yellow]⚠️ No models found for this provider.[/]")
+        raise typer.Abort()
+
+    console.print("\n[bold]Select a 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)
+    if 1 <= choice <= len(models):
+        selected_model = models[choice-1].id
+    else:
+        console.print("[bold red]Invalid choice.[/]")
+        raise typer.Abort()
+
+    # 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)
+    
+    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.[/]")
+        final_key_ref = f"env:{env_var_name}"
+
+    config = {
+        "model": {
+            "provider": provider.name,
+            "name": selected_model,
+            "api_key": final_key_ref
+        }
+    }
+    
+    save_config(config)
+    console.print(f"\n[bold green]✨ Configuration 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")
+
+@app.command()
+def review(
+    path: str = typer.Argument(".", help="Path to review."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Run in dry-run mode.")
+):
+    """
+    Review code in the specified path.
+    """
+    model = get_model()
+    engine = ReasoningEngine(model)
+    console.print(Panel(f"[bold blue]Akita[/] is reviewing: [yellow]{path}[/]", title="Review Mode"))
+    
+    if dry_run:
+        console.print("[yellow]Dry-run: Context would be built and LLM would be called.[/]")
+        return
+
+    try:
+        result = engine.run_review(path)
+        
+        # Display Results
+        console.print(Panel(result.summary, title="[bold blue]Review Summary[/]"))
+        
+        if result.issues:
+            table = Table(title="[bold red]Identified Issues[/]", show_header=True, header_style="bold magenta")
+            table.add_column("File")
+            table.add_column("Type")
+            table.add_column("Description")
+            table.add_column("Severity")
+            
+            for issue in result.issues:
+                color = "red" if issue.severity == "high" else "yellow" if issue.severity == "medium" else "blue"
+                table.add_row(issue.file, issue.type, issue.description, f"[{color}]{issue.severity}[/]")
+            
+            console.print(table)
+        else:
+            console.print("[bold green]No issues identified! ✨[/]")
+
+        if result.strengths:
+            console.print("\n[bold green]💪 Strengths:[/]")
+            for s in result.strengths:
+                console.print(f"  - {s}")
+
+        if result.suggestions:
+            console.print("\n[bold cyan]💡 Suggestions:[/]")
+            for s in result.suggestions:
+                console.print(f"  - {s}")
+
+        color = "red" if result.risk_level == "high" else "yellow" if result.risk_level == "medium" else "green"
+        console.print(Panel(f"Resulting Risk Level: [{color} bold]{result.risk_level.upper()}[/]", expand=False))
+
+    except Exception as e:
+        console.print(f"[bold red]Review failed:[/] {e}")
+        raise typer.Exit(code=1)
+
+@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 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:
+        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...[/]")
+                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:
+        console.print(f"[bold red]Solve failed:[/] {e}")
+        raise typer.Exit(code=1)
+
+@app.command()
+def plan(
+    goal: str,
+    dry_run: bool = typer.Option(False, "--dry-run", help="Run in dry-run mode.")
+):
+    """
+    Generate a step-by-step plan for a goal.
+    """
+    model = get_model()
+    engine = ReasoningEngine(model)
+    console.print(Panel(f"[bold blue]Akita[/] is planning: [yellow]{goal}[/]", title="Plan Mode"))
+    
+    try:
+        plan_output = engine.run_plan(goal)
+        console.print(Markdown(plan_output))
+    except Exception as e:
+        console.print(f"[bold red]Planning failed:[/] {e}")
+        raise typer.Exit(code=1)
+
+@app.command()
+def clone(
+    url: str = typer.Argument(..., help="Git repository URL to clone."),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Specific branch to clone."),
+    depth: Optional[int] = typer.Option(None, "--depth", "-d", help="Create a shallow clone with a history truncated to the specified number of commits.")
+):
+    """
+    Clone a remote Git repository into the Akita workspace (~/.akita/repos/).
+    """
+    console.print(Panel(f"🌐 [bold blue]Akita[/] is cloning: [yellow]{url}[/]", title="Clone Mode"))
+    
+    try:
+        with console.status("[bold green]Cloning repository..."):
+            local_path = GitTool.clone_repo(url, branch=branch, depth=depth)
+        
+        console.print(f"\n[bold green]✅ Repository cloned successfully![/]")
+        console.print(f"📍 Local path: [cyan]{local_path}[/]")
+    except FileExistsError as e:
+        console.print(f"[bold yellow]⚠️ {e}[/]")
+    except Exception as e:
+        console.print(f"[bold red]❌ Clone 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"))
+    from akita.tools.base import ShellTools
+    result = ShellTools.execute("pytest")
+    if result.success:
+        console.print("[bold green]Tests passed![/]")
+        console.print(result.output)
+    else:
+        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")
+
+@config_app.command("model")
+def config_model(
+    reset: bool = typer.Option(False, "--reset", help="Reset configuration to defaults.")
+):
+    """
+    View or change the model configuration.
+    """
+    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.[/]")
+        return
+
+    config = load_config()
+    if not config:
+        console.print("[yellow]No configuration found. Running setup...[/]")
+        run_onboarding()
+        config = load_config()
+
+    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()
+
+if __name__ == "__main__":
+    app()

akitallm-1.1.0/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])

{akitallm-0.1.1 → akitallm-1.1.0}/akita/core/config.py

@@ -43,9 +43,19 @@ def reset_config():
     if CONFIG_FILE.exists():
         CONFIG_FILE.unlink()
 
+def resolve_config_value(value: Any) -> Any:
+    """
+    Resolves values like 'env:VAR_NAME' to their environment variable content.
+    """
+    if isinstance(value, str) and value.startswith("env:"):
+        env_var = value[4:]
+        return os.getenv(env_var, value)
+    return value
+
 def get_config_value(section: str, key: str, default: Any = None) -> Any:
-    """Get a specific value from the config."""
+    """Get a specific value from the config and resolve env refs."""
     config = load_config()
     if not config:
         return default
-    return config.get(section, {}).get(key, default)
+    val = config.get(section, {}).get(key, default)
+    return resolve_config_value(val)

akitallm-1.1.0/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]]

akitallm-1.1.0/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