akitallm 1.0.3__tar.gz → 1.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akitallm
-Version: 1.0.3
+Version: 1.1.0
 Summary: AkitaLLM: An open-source local-first AI system for programming.
 Author: KerubinDev
 License: MIT

akitallm-1.1.0/akita/__init__.py

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

{akitallm-1.0.3 → akitallm-1.1.0}/akita/cli/main.py

@@ -1,4 +1,5 @@
 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
@@ -10,6 +11,8 @@ 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()
@@ -42,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(
@@ -193,6 +234,29 @@ 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.")

{akitallm-1.0.3 → 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/providers.py

@@ -0,0 +1,181 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional
+import requests
+from pydantic import BaseModel
+
+class ModelInfo(BaseModel):
+    id: str
+    name: Optional[str] = None
+
+class BaseProvider(ABC):
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    @abstractmethod
+    def validate_key(self, api_key: str) -> bool:
+        pass
+
+    @abstractmethod
+    def list_models(self, api_key: str) -> List[ModelInfo]:
+        pass
+
+class OpenAIProvider(BaseProvider):
+    @property
+    def name(self) -> str:
+        return "openai"
+
+    def validate_key(self, api_key: str) -> bool:
+        if not api_key.startswith("sk-"):
+            return False
+        # Simple validation request
+        try:
+            response = requests.get(
+                "https://api.openai.com/v1/models",
+                headers={"Authorization": f"Bearer {api_key}"},
+                timeout=5
+            )
+            return response.status_code == 200
+        except Exception:
+            return False
+
+    def list_models(self, api_key: str) -> List[ModelInfo]:
+        response = requests.get(
+            "https://api.openai.com/v1/models",
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=10
+        )
+        response.raise_for_status()
+        data = response.json()
+        exclude_keywords = ["vision", "instruct", "audio", "realtime", "tts", "dall-e", "embedding", "moderation", "davinci", "babbage", "curie", "ada"]
+        
+        models = []
+        for m in data["data"]:
+            model_id = m["id"]
+            if not any(kw in model_id.lower() for kw in exclude_keywords):
+                if model_id.startswith("gpt-") or model_id.startswith("o1") or model_id.startswith("o3"):
+                    models.append(ModelInfo(id=model_id))
+        return sorted(models, key=lambda x: x.id)
+
+class AnthropicProvider(BaseProvider):
+    @property
+    def name(self) -> str:
+        return "anthropic"
+
+    def validate_key(self, api_key: str) -> bool:
+        if not api_key.startswith("sk-ant-"):
+            return False
+        # Anthropic validation usually requires a full request, but we'll check prefix for now
+        # or do a no-op call if possible.
+        return True
+
+    def list_models(self, api_key: str) -> List[ModelInfo]:
+        # Anthropic doesn't have a public models list API like OpenAI
+        return [
+            ModelInfo(id="claude-3-5-sonnet-latest", name="Claude 3.5 Sonnet (Latest)"),
+            ModelInfo(id="claude-3-5-haiku-latest", name="Claude 3.5 Haiku (Latest)"),
+            ModelInfo(id="claude-3-opus-20240229", name="Claude 3 Opus"),
+            ModelInfo(id="claude-3-sonnet-20240229", name="Claude 3 Sonnet"),
+            ModelInfo(id="claude-3-haiku-20240307", name="Claude 3 Haiku"),
+        ]
+
+class OllamaProvider(BaseProvider):
+    @property
+    def name(self) -> str:
+        return "ollama"
+
+    def validate_key(self, api_key: str) -> bool:
+        # Ollama doesn't use keys by default, we just check if it's reachable
+        try:
+            response = requests.get("http://localhost:11434/api/tags", timeout=2)
+            return response.status_code == 200
+        except Exception:
+            return False
+
+    def list_models(self, api_key: str) -> List[ModelInfo]:
+        response = requests.get("http://localhost:11434/api/tags", timeout=5)
+        response.raise_for_status()
+        data = response.json()
+        return [ModelInfo(id=m["name"]) for m in data["models"]]
+
+class GeminiProvider(BaseProvider):
+    @property
+    def name(self) -> str:
+        return "gemini"
+
+    def validate_key(self, api_key: str) -> bool:
+        if not api_key.startswith("AIza"):
+            return False
+        return True
+
+    def list_models(self, api_key: str) -> List[ModelInfo]:
+        # Gemini API URL for listing models
+        url = f"https://generativelanguage.googleapis.com/v1beta/models?key={api_key}"
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        
+        exclude_keywords = ["nano", "banana", "vision", "embedding", "aqa", "learnlm"]
+        
+        models = []
+        for m in data["models"]:
+            model_id = m["name"].split("/")[-1]
+            display_name = m["displayName"]
+            
+            # Check if it supports generation and doesn't have excluded keywords
+            if "generateContent" in m["supportedGenerationMethods"]:
+                if not any(kw in model_id.lower() or kw in display_name.lower() for kw in exclude_keywords):
+                    models.append(ModelInfo(id=model_id, name=display_name))
+        
+        return models
+
+class GroqProvider(BaseProvider):
+    @property
+    def name(self) -> str:
+        return "groq"
+
+    def validate_key(self, api_key: str) -> bool:
+        if not api_key.startswith("gsk_"):
+            return False
+        return True
+
+    def list_models(self, api_key: str) -> List[ModelInfo]:
+        # Groq uses OpenAI-compatible models endpoint
+        response = requests.get(
+            "https://api.groq.com/openai/v1/models",
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=10
+        )
+        response.raise_for_status()
+        data = response.json()
+        
+        # Filter for text models
+        exclude_keywords = ["vision", "audio"]
+        models = []
+        for m in data["data"]:
+            model_id = m["id"]
+            if not any(kw in model_id.lower() for kw in exclude_keywords):
+                models.append(ModelInfo(id=model_id))
+        return sorted(models, key=lambda x: x.id)
+
+def detect_provider(api_key: str) -> Optional[BaseProvider]:
+    """
+    Attempts to detect the provider based on the API key or environment.
+    """
+    if api_key.lower() == "ollama":
+        return OllamaProvider()
+    
+    if api_key.startswith("sk-ant-"):
+        return AnthropicProvider()
+    
+    if api_key.startswith("gsk_"):
+        return GroqProvider()
+    
+    if api_key.startswith("sk-"):
+        return OpenAIProvider()
+    
+    if api_key.startswith("AIza"):
+        return GeminiProvider()
+        
+    return None

{akitallm-1.0.3 → akitallm-1.1.0}/akita/models/base.py

@@ -35,14 +35,19 @@ def get_model(model_name: Optional[str] = None) -> AIModel:
     """
     Get an AIModel instance based on config or provided name.
     """
+    provider = get_config_value("model", "provider", "openai")
+    api_key = get_config_value("model", "api_key")
+    
     if model_name is None:
         model_name = get_config_value("model", "name", "gpt-4o-mini")
     
-    provider = get_config_value("model", "provider", "openai")
-    
-    # LiteLLM usually wants "provider/model_name" for some providers 
-    # but for OpenAI it handles "gpt-3.5-turbo" directly.
-    # If it's a custom provider, we might need to prepend it.
-    full_model_name = f"{provider}/{model_name}" if provider != "openai" else model_name
+    # LiteLLM wants "provider/model_name" for non-OpenAI providers
+    if provider == "openai":
+        full_model_name = model_name
+    elif provider == "gemini":
+        full_model_name = f"gemini/{model_name}"
+    else:
+        full_model_name = f"{provider}/{model_name}"
     
-    return AIModel(model_name=full_model_name)
+    # For Ollama, we might need a base_url, but for now we assume default
+    return AIModel(model_name=full_model_name, api_key=api_key)

akitallm-1.1.0/akita/tools/git.py

@@ -0,0 +1,79 @@
+import os
+import pathlib
+import subprocess
+from typing import Tuple, Optional
+from urllib.parse import urlparse
+from akita.core.config import CONFIG_DIR
+
+class GitTool:
+    """
+    Utility for managing Git repositories within the Akita ecosystem.
+    """
+    REPOS_DIR = CONFIG_DIR / "repos"
+
+    @staticmethod
+    def parse_repo_url(url: str) -> Tuple[str, str]:
+        """
+        Extracts owner and repo name from a git URL.
+        Supports HTTPS and SSH formats.
+        """
+        # Clean URL
+        clean_url = url.strip().rstrip("/")
+        if clean_url.endswith(".git"):
+            clean_url = clean_url[:-4]
+
+        host = None
+        path_part = None
+
+        # Handle SCP-like SSH syntax: git@github.com:owner/repo
+        if "@" in clean_url and ":" in clean_url.split("@", 1)[1]:
+            user_host, path_part = clean_url.split("@", 1)[1].split(":", 1)
+            host = user_host
+        else:
+            parsed = urlparse(clean_url)
+            host = parsed.hostname
+            path_part = parsed.path.lstrip("/") if parsed.path else ""
+
+        if host and (host == "github.com" or host.endswith(".github.com")):
+            parts = [p for p in path_part.split("/") if p]
+            if len(parts) >= 2:
+                return parts[0], parts[1]
+        
+        # Fallback for other providers or generic paths
+        parts = clean_url.split("/")
+        if len(parts) >= 2:
+            return parts[-2], parts[-1]
+            
+        raise ValueError(f"Could not parse repository owner and name from URL: {url}")
+
+    @classmethod
+    def clone_repo(cls, url: str, branch: Optional[str] = None, depth: Optional[int] = None) -> str:
+        """
+        Clones a repository to ~/.akita/repos/<owner>/<repo>.
+        Returns the local path.
+        """
+        owner, repo = cls.parse_repo_url(url)
+        target_path = cls.REPOS_DIR / owner / repo
+        
+        if target_path.exists():
+            raise FileExistsError(f"Repository already exists at: {target_path}. Please delete it first if you want to re-clone.")
+            
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        cmd = ["git", "clone"]
+        if branch:
+            cmd += ["--branch", branch]
+        if depth:
+            cmd += ["--depth", str(depth)]
+            
+        cmd += [url, str(target_path)]
+        
+        result = subprocess.run(cmd, capture_all=True if hasattr(subprocess, 'capture_all') else False, text=True, check=False)
+        
+        if result.returncode != 0:
+            # Clean up parent if it was empty
+            if not any(target_path.parent.iterdir()):
+                target_path.parent.rmdir()
+            raise RuntimeError(f"Git clone failed: {result.stderr or 'Unknown error'}")
+            
+        return str(target_path)

{akitallm-1.0.3 → akitallm-1.1.0}/akitallm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akitallm
-Version: 1.0.3
+Version: 1.1.0
 Summary: AkitaLLM: An open-source local-first AI system for programming.
 Author: KerubinDev
 License: MIT

{akitallm-1.0.3 → akitallm-1.1.0}/akitallm.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ akita/core/ast_utils.py
 akita/core/config.py
 akita/core/indexing.py
 akita/core/plugins.py
+akita/core/providers.py
 akita/core/trace.py
 akita/models/base.py
 akita/plugins/__init__.py
@@ -17,6 +18,7 @@ akita/schemas/review.py
 akita/tools/base.py
 akita/tools/context.py
 akita/tools/diff.py
+akita/tools/git.py
 akitallm.egg-info/PKG-INFO
 akitallm.egg-info/SOURCES.txt
 akitallm.egg-info/dependency_links.txt

{akitallm-1.0.3 → akitallm-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "akitallm"
-version = "1.0.3"
+version = "1.1.0"
 description = "AkitaLLM: An open-source local-first AI system for programming."
 authors = [{ name = "KerubinDev" }]
 readme = "README.md"

akitallm-1.0.3/akita/__init__.py

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