akitallm 0.1.1__py3-none-any.whl → 1.1.0__py3-none-any.whl

akita/__init__.py

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

akita/cli/main.py

@@ -1,13 +1,18 @@
 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()
@@ -40,27 +45,65 @@ def main(
 
 def run_onboarding():
     console.print(Panel(
-        "[bold cyan]AkitaLLM[/]\n\n[italic]Understanding the internals...[/]",
+        "[bold cyan]AkitaLLM Configuration[/]\n\n[italic]API-first setup...[/]",
         title="Onboarding"
     ))
     
-    console.print("1) Use default project model (GPT-4o Mini)")
-    console.print("2) Configure my own model")
+    api_key = typer.prompt("🔑 Paste your API Key (or type 'ollama' for local)", hide_input=False)
     
-    choice = typer.prompt("\nChoose an option", type=int, default=1)
+    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 choice == 1:
-        config = {"model": {"provider": "openai", "name": "gpt-4o-mini"}}
-        save_config(config)
-        console.print("[bold green]✅ Default model (GPT-4o Mini) selected and saved![/]")
+    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:
-        provider = typer.prompt("Enter model provider (e.g., openai, ollama, anthropic)", default="openai")
-        name = typer.prompt("Enter model name (e.g., gpt-4o, llama3, claude-3-opus)", default="gpt-4o-mini")
-        config = {"model": {"provider": provider, "name": name}}
-        save_config(config)
-        console.print(f"[bold green]✅ Model configured: {provider}/{name}[/]")
+        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)
     
-    console.print("\n[dim]Configuration saved at ~/.akita/config.toml[/]\n")
+    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(
@@ -119,27 +162,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 +234,52 @@ def plan(
         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"))
+    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 +289,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/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)

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