supyagent 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

supyagent/cli/main.py

@@ -17,16 +17,18 @@ from rich.table import Table
 from typing import Any
 
 from supyagent.core.agent import Agent
+from supyagent.core.config import ConfigManager, load_config
 from supyagent.core.executor import ExecutionRunner
 from supyagent.core.registry import AgentRegistry
 from supyagent.core.session_manager import SessionManager
+from supyagent.default_tools import install_default_tools, list_default_tools
 from supyagent.models.agent_config import AgentNotFoundError, load_agent_config
 
 console = Console()
 
 
 @click.group()
-@click.version_option(version="0.1.0", prog_name="supyagent")
+@click.version_option(version="0.2.1", prog_name="supyagent")
 def cli():
     """
     Supyagent - LLM agents powered by supypowers.
@@ -36,12 +38,82 @@ def cli():
     Quick start:
 
     \b
+        supyagent init            # Set up default tools
+        supyagent config set      # Configure API keys
         supyagent new myagent     # Create an agent
         supyagent chat myagent    # Start chatting
     """
     pass
 
 
+@cli.command()
+@click.option(
+    "--tools-dir",
+    "-t",
+    default="supypowers",
+    help="Directory for tools (default: supypowers/)",
+)
+@click.option(
+    "--force",
+    "-f",
+    is_flag=True,
+    help="Overwrite existing files",
+)
+def init(tools_dir: str, force: bool):
+    """
+    Initialize supyagent in the current directory.
+
+    This sets up:
+    - Default tools in supypowers/ (shell commands, file operations)
+    - agents/ directory for agent configurations
+
+    \b
+    Examples:
+        supyagent init
+        supyagent init --tools-dir my_tools
+    """
+    console.print("[bold]Initializing supyagent...[/bold]")
+    console.print()
+
+    # Create agents directory
+    agents_dir = Path("agents")
+    if not agents_dir.exists():
+        agents_dir.mkdir(parents=True)
+        console.print(f"  [green]✓[/green] Created {agents_dir}/")
+    else:
+        console.print(f"  [dim]○[/dim] {agents_dir}/ already exists")
+
+    # Install default tools
+    tools_path = Path(tools_dir)
+
+    if force:
+        # Remove and reinstall
+        import shutil
+
+        if tools_path.exists():
+            shutil.rmtree(tools_path)
+
+    if tools_path.exists() and any(tools_path.glob("*.py")):
+        console.print(f"  [dim]○[/dim] {tools_dir}/ already has tools")
+    else:
+        count = install_default_tools(tools_path)
+        console.print(
+            f"  [green]✓[/green] Installed {count} default tools to {tools_dir}/"
+        )
+
+    # Show available tools
+    console.print()
+    console.print("[bold]Available tools:[/bold]")
+    for tool in list_default_tools():
+        console.print(f"  • [cyan]{tool['name']}[/cyan]: {tool['description']}")
+
+    console.print()
+    console.print("[bold]Next steps:[/bold]")
+    console.print("  1. Configure your API key:  [cyan]supyagent config set[/cyan]")
+    console.print("  2. Create an agent:         [cyan]supyagent new myagent[/cyan]")
+    console.print("  3. Start chatting:          [cyan]supyagent chat myagent[/cyan]")
+
+
 @cli.command()
 @click.argument("name")
 @click.option(
@@ -175,6 +247,9 @@ def chat(agent_name: str, new_session: bool, session_id: str | None):
     By default, resumes the most recent session. Use --new to start fresh,
     or --session <id> to resume a specific session.
     """
+    # Load global config (API keys) into environment
+    load_config()
+
     # Load agent config
     try:
         config = load_agent_config(agent_name)
@@ -625,6 +700,9 @@ def run(
         echo "text" | supyagent run summarizer
         supyagent run api-caller '{"endpoint": "/users"}' --secrets API_KEY=xxx
     """
+    # Load global config (API keys) into environment
+    load_config()
+
     # Load agent config
     try:
         config = load_agent_config(agent_name)
@@ -742,6 +820,9 @@ def batch(
         supyagent batch summarizer inputs.jsonl --output results.jsonl
         supyagent batch summarizer data.csv --format csv
     """
+    # Load global config (API keys) into environment
+    load_config()
+
     # Load agent config
     try:
         config = load_agent_config(agent_name)
@@ -879,6 +960,9 @@ def plan(task: str, planner: str, new_session: bool):
         supyagent plan "Create a Python library for data validation"
         supyagent plan "Write a blog post about AI" --planner my-planner
     """
+    # Load global config (API keys) into environment
+    load_config()
+
     # Load planner config
     try:
         config = load_agent_config(planner)
@@ -942,5 +1026,171 @@ def cleanup():
         console.print(f"[green]✓[/green] Cleaned up {count} instance(s)")
 
 
+# =============================================================================
+# Config Commands
+# =============================================================================
+
+
+@cli.group()
+def config():
+    """Manage API keys and global configuration."""
+    pass
+
+
+@config.command("set")
+@click.argument("key_name", required=False)
+@click.option(
+    "--value",
+    "-v",
+    help="Set value directly (use with caution - visible in shell history)",
+)
+def config_set(key_name: str | None, value: str | None):
+    """
+    Set an API key.
+
+    If KEY_NAME is not provided, shows an interactive menu of common keys.
+
+    \b
+    Examples:
+        supyagent config set                    # Interactive menu
+        supyagent config set OPENAI_API_KEY     # Set specific key
+        supyagent config set MY_KEY -v "value"  # Set with value (not recommended)
+    """
+    config_mgr = ConfigManager()
+
+    if value:
+        if not key_name:
+            console.print("[red]Error:[/red] KEY_NAME required when using --value")
+            sys.exit(1)
+        config_mgr.set(key_name, value)
+        console.print(f"[green]✓[/green] Saved {key_name}")
+    else:
+        config_mgr.set_interactive(key_name)
+
+
+@config.command("list")
+def config_list():
+    """List all configured API keys."""
+    config_mgr = ConfigManager()
+    config_mgr.show_status()
+
+
+@config.command("delete")
+@click.argument("key_name")
+def config_delete(key_name: str):
+    """Delete a stored API key."""
+    config_mgr = ConfigManager()
+
+    if config_mgr.delete(key_name):
+        console.print(f"[green]✓[/green] Deleted {key_name}")
+    else:
+        console.print(f"[yellow]Key not found:[/yellow] {key_name}")
+
+
+@config.command("import")
+@click.argument("file_path", type=click.Path(exists=True))
+@click.option(
+    "--filter",
+    "-f",
+    "key_filter",
+    help="Only import keys matching this prefix (e.g., 'OPENAI')",
+)
+def config_import(file_path: str, key_filter: str | None):
+    """
+    Import API keys from a .env file.
+
+    The file should contain KEY=VALUE pairs, one per line.
+    Lines starting with # are ignored.
+
+    \b
+    Examples:
+        supyagent config import .env
+        supyagent config import secrets.env --filter OPENAI
+    """
+    config_mgr = ConfigManager()
+
+    try:
+        # If filter is specified, we need custom handling
+        if key_filter:
+            from pathlib import Path
+            import re
+
+            path = Path(file_path)
+            pattern = re.compile(r"^(?:export\s+)?([A-Z_][A-Z0-9_]*)=(.+)$")
+            imported = 0
+
+            with open(path) as f:
+                for line in f:
+                    line = line.strip()
+                    if not line or line.startswith("#"):
+                        continue
+
+                    match = pattern.match(line)
+                    if match:
+                        name, value = match.groups()
+                        if name.startswith(key_filter.upper()):
+                            if (value.startswith('"') and value.endswith('"')) or (
+                                value.startswith("'") and value.endswith("'")
+                            ):
+                                value = value[1:-1]
+                            config_mgr.set(name, value)
+                            console.print(f"  [green]✓[/green] {name}")
+                            imported += 1
+        else:
+            imported = config_mgr.set_from_file(file_path)
+
+        if imported == 0:
+            console.print("[yellow]No keys found in file[/yellow]")
+        else:
+            console.print(f"\n[green]✓[/green] Imported {imported} key(s)")
+
+    except FileNotFoundError:
+        console.print(f"[red]Error:[/red] File not found: {file_path}")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        sys.exit(1)
+
+
+@config.command("export")
+@click.argument("file_path", type=click.Path())
+@click.option("--force", "-f", is_flag=True, help="Overwrite existing file")
+def config_export(file_path: str, force: bool):
+    """
+    Export stored API keys to a .env file.
+
+    \b
+    Example:
+        supyagent config export backup.env
+    """
+    config_mgr = ConfigManager()
+    path = Path(file_path)
+
+    if path.exists() and not force:
+        console.print(f"[red]Error:[/red] File exists: {file_path}")
+        console.print("Use --force to overwrite")
+        sys.exit(1)
+
+    keys = config_mgr._load_keys()
+
+    if not keys:
+        console.print("[yellow]No keys to export[/yellow]")
+        return
+
+    with open(path, "w") as f:
+        f.write("# Supyagent API Keys\n")
+        f.write("# Generated export - keep this file secure!\n\n")
+        for name, value in sorted(keys.items()):
+            f.write(f"{name}={value}\n")
+
+    # Set restrictive permissions
+    try:
+        path.chmod(0o600)
+    except OSError:
+        pass
+
+    console.print(f"[green]✓[/green] Exported {len(keys)} key(s) to {file_path}")
+
+
 if __name__ == "__main__":
     cli()

supyagent/core/__init__.py

@@ -1,6 +1,7 @@
 """Core module for supyagent."""
 
 from supyagent.core.agent import Agent
+from supyagent.core.config import ConfigManager, load_config
 from supyagent.core.context import DelegationContext
 from supyagent.core.credentials import CredentialManager
 from supyagent.core.delegation import DelegationManager
@@ -12,10 +13,12 @@ from supyagent.core.session_manager import SessionManager
 __all__ = [
     "Agent",
     "AgentRegistry",
+    "ConfigManager",
     "CredentialManager",
     "DelegationContext",
     "DelegationManager",
     "ExecutionRunner",
     "LLMClient",
     "SessionManager",
+    "load_config",
 ]

supyagent/core/config.py

@@ -0,0 +1,352 @@
+"""
+Configuration manager for global settings like LLM API keys.
+
+Stores encrypted configuration in ~/.supyagent/config/ that is shared
+across all agents and projects.
+"""
+
+import getpass
+import json
+import os
+import re
+from pathlib import Path
+
+from cryptography.fernet import Fernet, InvalidToken
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+from rich.table import Table
+
+console = Console()
+
+# Common LLM provider API key names
+KNOWN_LLM_KEYS = {
+    "OPENAI_API_KEY": "OpenAI (GPT-4, GPT-3.5)",
+    "ANTHROPIC_API_KEY": "Anthropic (Claude)",
+    "GOOGLE_API_KEY": "Google (Gemini)",
+    "AZURE_API_KEY": "Azure OpenAI",
+    "AZURE_API_BASE": "Azure OpenAI endpoint",
+    "COHERE_API_KEY": "Cohere",
+    "HUGGINGFACE_API_KEY": "Hugging Face",
+    "REPLICATE_API_KEY": "Replicate",
+    "TOGETHER_API_KEY": "Together AI",
+    "GROQ_API_KEY": "Groq",
+    "MISTRAL_API_KEY": "Mistral AI",
+    "PERPLEXITY_API_KEY": "Perplexity AI",
+    "DEEPSEEK_API_KEY": "DeepSeek",
+    "FIREWORKS_API_KEY": "Fireworks AI",
+    "OLLAMA_API_BASE": "Ollama (local) base URL",
+}
+
+
+class ConfigManager:
+    """
+    Manages global configuration including LLM API keys.
+
+    Configuration is stored encrypted in ~/.supyagent/config/
+    and automatically loaded into environment variables when
+    agents are run.
+
+    Directory structure:
+        ~/.supyagent/config/.key     # Encryption key
+        ~/.supyagent/config/keys.enc # Encrypted API keys
+    """
+
+    def __init__(self, base_dir: Path | None = None):
+        """
+        Initialize the config manager.
+
+        Args:
+            base_dir: Base directory for config storage.
+                      Defaults to ~/.supyagent/config/
+        """
+        if base_dir is None:
+            base_dir = Path.home() / ".supyagent" / "config"
+
+        self.base_dir = base_dir
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+        self._fernet = self._get_fernet()
+        self._cache: dict[str, str] | None = None
+
+    def _get_fernet(self) -> Fernet:
+        """Get or create the encryption key."""
+        key_file = self.base_dir / ".key"
+
+        if key_file.exists():
+            key = key_file.read_bytes()
+        else:
+            key = Fernet.generate_key()
+            key_file.write_bytes(key)
+            try:
+                key_file.chmod(0o600)
+            except OSError:
+                pass
+
+        return Fernet(key)
+
+    def _keys_path(self) -> Path:
+        """Get path to the encrypted keys file."""
+        return self.base_dir / "keys.enc"
+
+    def _load_keys(self) -> dict[str, str]:
+        """Load and decrypt stored keys."""
+        if self._cache is not None:
+            return self._cache
+
+        path = self._keys_path()
+        if not path.exists():
+            self._cache = {}
+            return {}
+
+        try:
+            encrypted = path.read_bytes()
+            decrypted = self._fernet.decrypt(encrypted)
+            keys = json.loads(decrypted)
+            self._cache = keys
+            return keys
+        except (InvalidToken, json.JSONDecodeError):
+            self._cache = {}
+            return {}
+
+    def _save_keys(self, keys: dict[str, str]) -> None:
+        """Encrypt and save keys."""
+        encrypted = self._fernet.encrypt(json.dumps(keys).encode())
+        path = self._keys_path()
+        path.write_bytes(encrypted)
+        try:
+            path.chmod(0o600)
+        except OSError:
+            pass
+        self._cache = keys
+
+    def get(self, name: str) -> str | None:
+        """
+        Get a config value.
+
+        Checks environment first, then stored config.
+
+        Args:
+            name: Key name
+
+        Returns:
+            Value or None
+        """
+        # Environment takes precedence
+        if name in os.environ:
+            return os.environ[name]
+
+        keys = self._load_keys()
+        return keys.get(name)
+
+    def set(self, name: str, value: str) -> None:
+        """
+        Set a config value.
+
+        Args:
+            name: Key name
+            value: Key value
+        """
+        keys = self._load_keys()
+        keys[name] = value
+        self._save_keys(keys)
+
+    def delete(self, name: str) -> bool:
+        """
+        Delete a stored key.
+
+        Args:
+            name: Key name
+
+        Returns:
+            True if deleted, False if not found
+        """
+        keys = self._load_keys()
+        if name in keys:
+            del keys[name]
+            self._save_keys(keys)
+            return True
+        return False
+
+    def list_keys(self) -> list[str]:
+        """List all stored key names."""
+        return list(self._load_keys().keys())
+
+    def load_into_environment(self) -> int:
+        """
+        Load all stored keys into environment variables.
+
+        Only sets variables that aren't already in the environment.
+
+        Returns:
+            Number of keys loaded
+        """
+        keys = self._load_keys()
+        loaded = 0
+
+        for name, value in keys.items():
+            if name not in os.environ:
+                os.environ[name] = value
+                loaded += 1
+
+        return loaded
+
+    def set_interactive(self, name: str | None = None) -> bool:
+        """
+        Interactively prompt user to set a key.
+
+        Args:
+            name: Key name, or None to show a menu of common keys
+
+        Returns:
+            True if key was set
+        """
+        if name is None:
+            # Show menu of common keys
+            console.print()
+            console.print("[bold]Common LLM API Keys:[/bold]")
+            console.print()
+
+            items = list(KNOWN_LLM_KEYS.items())
+            for i, (key, desc) in enumerate(items, 1):
+                status = "[green]✓[/green]" if self.get(key) else "[dim]○[/dim]"
+                console.print(f"  {status} [{i}] {key}")
+                console.print(f"      [dim]{desc}[/dim]")
+
+            console.print()
+            console.print(f"  [0] Enter custom key name")
+            console.print()
+
+            choice = input("Select key to set (number or name): ").strip()
+
+            if choice == "0":
+                name = input("Enter key name: ").strip()
+                if not name:
+                    return False
+            elif choice.isdigit():
+                idx = int(choice) - 1
+                if 0 <= idx < len(items):
+                    name = items[idx][0]
+                else:
+                    console.print("[red]Invalid selection[/red]")
+                    return False
+            else:
+                # Treat as key name
+                name = choice.upper()
+
+        # Get the value
+        description = KNOWN_LLM_KEYS.get(name, "API key")
+        console.print()
+        console.print(
+            Panel(
+                f"[bold]{name}[/bold]\n{description}",
+                title="🔑 Set API Key",
+                border_style="blue",
+            )
+        )
+
+        value = getpass.getpass("Enter value (or press Enter to cancel): ")
+
+        if not value:
+            console.print("[dim]Cancelled[/dim]")
+            return False
+
+        self.set(name, value)
+        console.print(f"[green]✓[/green] Saved {name}")
+        return True
+
+    def set_from_file(self, file_path: str | Path) -> int:
+        """
+        Load keys from a .env file.
+
+        File format (one per line):
+            KEY_NAME=value
+            # comments are ignored
+            export KEY_NAME=value  # export prefix is stripped
+
+        Args:
+            file_path: Path to .env file
+
+        Returns:
+            Number of keys imported
+        """
+        path = Path(file_path)
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        imported = 0
+        pattern = re.compile(r"^(?:export\s+)?([A-Z_][A-Z0-9_]*)=(.+)$")
+
+        with open(path) as f:
+            for line in f:
+                line = line.strip()
+
+                # Skip empty lines and comments
+                if not line or line.startswith("#"):
+                    continue
+
+                match = pattern.match(line)
+                if match:
+                    name, value = match.groups()
+
+                    # Strip quotes if present
+                    if (value.startswith('"') and value.endswith('"')) or \
+                       (value.startswith("'") and value.endswith("'")):
+                        value = value[1:-1]
+
+                    self.set(name, value)
+                    imported += 1
+
+        return imported
+
+    def show_status(self) -> None:
+        """Display current configuration status."""
+        keys = self._load_keys()
+
+        if not keys:
+            console.print("[dim]No API keys configured[/dim]")
+            console.print()
+            console.print("Run [cyan]supyagent config set[/cyan] to add keys")
+            return
+
+        table = Table(title="Configured API Keys")
+        table.add_column("Key", style="cyan")
+        table.add_column("Provider")
+        table.add_column("Status")
+
+        for name in sorted(keys.keys()):
+            provider = KNOWN_LLM_KEYS.get(name, "Custom")
+            # Show if it's overridden by environment
+            if name in os.environ and os.environ[name] != keys[name]:
+                status = "[yellow]env override[/yellow]"
+            else:
+                status = "[green]stored[/green]"
+
+            table.add_row(name, provider, status)
+
+        console.print(table)
+        console.print()
+        console.print(f"[dim]Config location: {self.base_dir}[/dim]")
+
+
+# Global config manager instance
+_config_manager: ConfigManager | None = None
+
+
+def get_config_manager() -> ConfigManager:
+    """Get the global config manager instance."""
+    global _config_manager
+    if _config_manager is None:
+        _config_manager = ConfigManager()
+    return _config_manager
+
+
+def load_config() -> int:
+    """
+    Load global config into environment.
+
+    Call this at the start of any agent execution.
+
+    Returns:
+        Number of keys loaded
+    """
+    return get_config_manager().load_into_environment()