supyagent 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

supyagent/cli/main.py

@@ -21,13 +21,15 @@ 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()
+console_err = Console(stderr=True)
 
 
 @click.group()
-@click.version_option(version="0.2.0", prog_name="supyagent")
+@click.version_option(version="0.2.2", prog_name="supyagent")
 def cli():
     """
     Supyagent - LLM agents powered by supypowers.
@@ -37,12 +39,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(
@@ -636,15 +708,14 @@ def run(
     try:
         config = load_agent_config(agent_name)
     except AgentNotFoundError as e:
-        console.print(f"[red]Error:[/red] {e}", err=True)
+        console_err.print(f"[red]Error:[/red] {e}")
         sys.exit(1)
 
     # Warn if using interactive agent in execution mode
     if config.type != "execution" and not quiet:
-        console.print(
+        console_err.print(
             f"[yellow]Note:[/yellow] '{agent_name}' is an interactive agent. "
-            "Consider using 'chat' for interactive use.",
-            err=True,
+            "Consider using 'chat' for interactive use."
         )
 
     # Parse secrets
@@ -659,9 +730,7 @@ def run(
         else:
             input_path = Path(input_file)
             if not input_path.exists():
-                console.print(
-                    f"[red]Error:[/red] File not found: {input_file}", err=True
-                )
+                console_err.print(f"[red]Error:[/red] File not found: {input_file}")
                 sys.exit(1)
             task_content = input_path.read_text().strip()
     elif task:
@@ -675,22 +744,21 @@ def run(
         if not sys.stdin.isatty():
             task_content = sys.stdin.read().strip()
         else:
-            console.print(
+            console_err.print(
                 "[red]Error:[/red] No task provided. "
-                "Use positional argument, --input, or pipe to stdin.",
-                err=True,
+                "Use positional argument, --input, or pipe to stdin."
             )
             sys.exit(1)
 
     if not task_content:
-        console.print("[red]Error:[/red] Empty task", err=True)
+        console_err.print("[red]Error:[/red] Empty task")
         sys.exit(1)
 
     # Run the agent
     runner = ExecutionRunner(config)
 
     if not quiet:
-        console.print(f"[dim]Running {agent_name}...[/dim]", err=True)
+        console_err.print(f"[dim]Running {agent_name}...[/dim]")
 
     result = runner.run(task_content, secrets=secrets_dict, output_format=output_format)
 
@@ -700,7 +768,7 @@ def run(
     elif result["ok"]:
         click.echo(result["data"])
     else:
-        console.print(f"[red]Error:[/red] {result['error']}", err=True)
+        console_err.print(f"[red]Error:[/red] {result['error']}")
         sys.exit(1)
 
 
@@ -756,7 +824,7 @@ def batch(
     try:
         config = load_agent_config(agent_name)
     except AgentNotFoundError as e:
-        console.print(f"[red]Error:[/red] {e}", err=True)
+        console_err.print(f"[red]Error:[/red] {e}")
         sys.exit(1)
 
     # Parse secrets

supyagent/core/llm.py

@@ -4,9 +4,13 @@ LiteLLM wrapper for unified LLM access.
 
 from typing import Any
 
+import litellm
 from litellm import completion
 from litellm.types.utils import ModelResponse
 
+# Suppress LiteLLM debug messages (e.g., "Provider List: ...")
+litellm.suppress_debug_info = True
+
 
 class LLMClient:
     """

supyagent/core/tools.py

@@ -193,43 +193,61 @@ def supypowers_to_openai_tools(sp_tools: list[dict[str, Any]]) -> list[dict[str,
     Convert supypowers tool definitions to OpenAI function calling format.
 
     Supypowers docs output format:
-    {
-        "script": "hello",
-        "function": "hello",
-        "description": "...",
-        "input_schema": {...}
-    }
+    [
+        {
+            "script": "/path/to/script.py",
+            "functions": [
+                {
+                    "name": "function_name",
+                    "description": "...",
+                    "input_schema": {...}
+                }
+            ]
+        }
+    ]
 
     OpenAI format:
     {
         "type": "function",
         "function": {
-            "name": "hello__hello",
+            "name": "script__function_name",
             "description": "...",
             "parameters": {...}
         }
     }
     """
+    import os
+    
     openai_tools = []
 
-    for sp_tool in sp_tools:
-        script = sp_tool.get("script", "")
-        func = sp_tool.get("function", "")
-        description = sp_tool.get("description", "No description")
-        input_schema = sp_tool.get("input_schema", {"type": "object", "properties": {}})
-
-        # Use double underscore to join script:function (since : isn't allowed in function names)
-        name = f"{script}__{func}"
-
-        openai_tool = {
-            "type": "function",
-            "function": {
-                "name": name,
-                "description": description,
-                "parameters": input_schema,
-            },
-        }
+    for script_entry in sp_tools:
+        script_path = script_entry.get("script", "")
+        functions = script_entry.get("functions", [])
+        
+        # Extract script name from path (e.g., "files" from "/path/to/files.py")
+        script_name = os.path.splitext(os.path.basename(script_path))[0]
+        
+        # Skip __init__ files with no functions
+        if script_name == "__init__" and not functions:
+            continue
+        
+        for func_def in functions:
+            func_name = func_def.get("name", "")
+            description = func_def.get("description", "No description")
+            input_schema = func_def.get("input_schema", {"type": "object", "properties": {}})
+
+            # Use double underscore to join script:function (since : isn't allowed in function names)
+            name = f"{script_name}__{func_name}"
+
+            openai_tool = {
+                "type": "function",
+                "function": {
+                    "name": name,
+                    "description": description,
+                    "parameters": input_schema,
+                },
+            }
 
-        openai_tools.append(openai_tool)
+            openai_tools.append(openai_tool)
 
     return openai_tools

supyagent/default_tools/__init__.py

@@ -0,0 +1,74 @@
+"""
+Default supypowers tools bundled with supyagent.
+
+These tools are copied to the user's project when running `supyagent init`.
+"""
+
+import shutil
+from pathlib import Path
+
+# Path to the bundled default tools
+TOOLS_DIR = Path(__file__).parent
+
+
+def get_bundled_tools() -> list[Path]:
+    """Get list of bundled tool files."""
+    return [f for f in TOOLS_DIR.glob("*.py") if f.name != "__init__.py"]
+
+
+def install_default_tools(target_dir: Path | str = "supypowers") -> int:
+    """
+    Install default tools to a target directory.
+
+    Args:
+        target_dir: Directory to install tools to (default: supypowers/)
+
+    Returns:
+        Number of files installed
+    """
+    target = Path(target_dir)
+    target.mkdir(parents=True, exist_ok=True)
+
+    installed = 0
+    for tool_file in get_bundled_tools():
+        dest = target / tool_file.name
+        if not dest.exists():
+            shutil.copy(tool_file, dest)
+            installed += 1
+
+    # Create __init__.py if not exists
+    init_file = target / "__init__.py"
+    if not init_file.exists():
+        init_file.write_text('"""Supypowers tools for this project."""\n')
+        installed += 1
+
+    return installed
+
+
+def list_default_tools() -> list[dict]:
+    """
+    List available default tools.
+
+    Returns:
+        List of tool info dicts
+    """
+    tools = []
+    for tool_file in get_bundled_tools():
+        # Read first docstring
+        content = tool_file.read_text()
+        description = ""
+        if '"""' in content:
+            start = content.find('"""') + 3
+            end = content.find('"""', start)
+            if end > start:
+                description = content[start:end].strip().split("\n")[0]
+
+        tools.append(
+            {
+                "name": tool_file.stem,
+                "file": tool_file.name,
+                "description": description,
+            }
+        )
+
+    return tools

supyagent/default_tools/files.py

@@ -0,0 +1,439 @@
+# /// script
+# dependencies = ["pydantic"]
+# ///
+"""
+File system operation tools.
+
+Allows agents to read, write, and manage files and directories.
+"""
+
+import os
+import shutil
+from pathlib import Path
+from typing import Optional, List
+
+from pydantic import BaseModel, Field
+
+
+# =============================================================================
+# Read File
+# =============================================================================
+
+
+class ReadFileInput(BaseModel):
+    """Input for read_file function."""
+
+    path: str = Field(description="Path to the file to read")
+    encoding: str = Field(default="utf-8", description="File encoding")
+
+
+class ReadFileOutput(BaseModel):
+    """Output for read_file function."""
+
+    ok: bool
+    content: Optional[str] = None
+    size: Optional[int] = None
+    path: Optional[str] = None
+    error: Optional[str] = None
+
+
+def read_file(input: ReadFileInput) -> ReadFileOutput:
+    """
+    Read the contents of a file.
+
+    Examples:
+        >>> read_file({"path": "README.md"})
+        >>> read_file({"path": "data.txt", "encoding": "latin-1"})
+    """
+    try:
+        path = os.path.expanduser(input.path)
+        p = Path(path)
+
+        if not p.exists():
+            return ReadFileOutput(ok=False, error=f"File not found: {path}")
+
+        if not p.is_file():
+            return ReadFileOutput(ok=False, error=f"Not a file: {path}")
+
+        size = p.stat().st_size
+        if size > 10 * 1024 * 1024:
+            return ReadFileOutput(
+                ok=False,
+                error=f"File too large ({size} bytes). Maximum is 10MB.",
+            )
+
+        content = p.read_text(encoding=input.encoding)
+        return ReadFileOutput(
+            ok=True,
+            content=content,
+            size=size,
+            path=str(p.absolute()),
+        )
+
+    except UnicodeDecodeError:
+        return ReadFileOutput(
+            ok=False,
+            error=f"Cannot decode file as {input.encoding}",
+        )
+    except PermissionError:
+        return ReadFileOutput(ok=False, error=f"Permission denied: {input.path}")
+    except Exception as e:
+        return ReadFileOutput(ok=False, error=str(e))
+
+
+# =============================================================================
+# Write File
+# =============================================================================
+
+
+class WriteFileInput(BaseModel):
+    """Input for write_file function."""
+
+    path: str = Field(description="Path to the file to write")
+    content: str = Field(description="Content to write")
+    encoding: str = Field(default="utf-8", description="File encoding")
+    create_dirs: bool = Field(
+        default=True, description="Create parent directories if needed"
+    )
+
+
+class WriteFileOutput(BaseModel):
+    """Output for write_file function."""
+
+    ok: bool
+    path: Optional[str] = None
+    size: Optional[int] = None
+    error: Optional[str] = None
+
+
+def write_file(input: WriteFileInput) -> WriteFileOutput:
+    """
+    Write content to a file.
+
+    Examples:
+        >>> write_file({"path": "output.txt", "content": "Hello, world!"})
+        >>> write_file({"path": "data/results.json", "content": '{"status": "ok"}'})
+    """
+    try:
+        path = os.path.expanduser(input.path)
+        p = Path(path)
+
+        if input.create_dirs:
+            p.parent.mkdir(parents=True, exist_ok=True)
+
+        p.write_text(input.content, encoding=input.encoding)
+
+        return WriteFileOutput(
+            ok=True,
+            path=str(p.absolute()),
+            size=len(input.content.encode(input.encoding)),
+        )
+
+    except PermissionError:
+        return WriteFileOutput(ok=False, error=f"Permission denied: {input.path}")
+    except Exception as e:
+        return WriteFileOutput(ok=False, error=str(e))
+
+
+# =============================================================================
+# List Directory
+# =============================================================================
+
+
+class ListDirectoryInput(BaseModel):
+    """Input for list_directory function."""
+
+    path: str = Field(default=".", description="Directory path")
+    pattern: Optional[str] = Field(
+        default=None, description="Optional glob pattern (e.g., '*.py')"
+    )
+    recursive: bool = Field(default=False, description="List recursively")
+
+
+class FileInfo(BaseModel):
+    """Information about a single file/directory."""
+
+    name: str
+    path: str
+    type: str  # "file" or "directory"
+    size: Optional[int] = None
+
+
+class ListDirectoryOutput(BaseModel):
+    """Output for list_directory function."""
+
+    ok: bool
+    items: List[FileInfo] = []
+    count: int = 0
+    error: Optional[str] = None
+
+
+def list_directory(input: ListDirectoryInput) -> ListDirectoryOutput:
+    """
+    List files and directories.
+
+    Examples:
+        >>> list_directory({"path": "."})
+        >>> list_directory({"path": "src", "pattern": "*.py"})
+        >>> list_directory({"path": ".", "pattern": "*.md", "recursive": True})
+    """
+    try:
+        path = os.path.expanduser(input.path)
+        p = Path(path)
+
+        if not p.exists():
+            return ListDirectoryOutput(
+                ok=False, error=f"Directory not found: {path}"
+            )
+
+        if not p.is_dir():
+            return ListDirectoryOutput(ok=False, error=f"Not a directory: {path}")
+
+        items = []
+
+        if input.pattern:
+            matches = p.rglob(input.pattern) if input.recursive else p.glob(input.pattern)
+        else:
+            matches = p.iterdir()
+
+        for item in sorted(matches):
+            try:
+                stat = item.stat()
+                items.append(
+                    FileInfo(
+                        name=item.name,
+                        path=str(item),
+                        type="directory" if item.is_dir() else "file",
+                        size=stat.st_size if item.is_file() else None,
+                    )
+                )
+            except (PermissionError, OSError):
+                pass  # Skip inaccessible files
+
+        return ListDirectoryOutput(ok=True, items=items, count=len(items))
+
+    except Exception as e:
+        return ListDirectoryOutput(ok=False, error=str(e))
+
+
+# =============================================================================
+# File Info
+# =============================================================================
+
+
+class FileInfoInput(BaseModel):
+    """Input for file_info function."""
+
+    path: str = Field(description="Path to get info for")
+
+
+class FileInfoOutput(BaseModel):
+    """Output for file_info function."""
+
+    ok: bool
+    path: Optional[str] = None
+    name: Optional[str] = None
+    type: Optional[str] = None
+    size: Optional[int] = None
+    extension: Optional[str] = None
+    error: Optional[str] = None
+
+
+def file_info(input: FileInfoInput) -> FileInfoOutput:
+    """
+    Get detailed information about a file or directory.
+
+    Examples:
+        >>> file_info({"path": "README.md"})
+    """
+    try:
+        path = os.path.expanduser(input.path)
+        p = Path(path)
+
+        if not p.exists():
+            return FileInfoOutput(ok=False, error=f"Path not found: {path}")
+
+        stat = p.stat()
+
+        return FileInfoOutput(
+            ok=True,
+            path=str(p.absolute()),
+            name=p.name,
+            type="directory" if p.is_dir() else "file",
+            size=stat.st_size,
+            extension=p.suffix if p.is_file() else None,
+        )
+
+    except Exception as e:
+        return FileInfoOutput(ok=False, error=str(e))
+
+
+# =============================================================================
+# Delete File
+# =============================================================================
+
+
+class DeleteFileInput(BaseModel):
+    """Input for delete_file function."""
+
+    path: str = Field(description="Path to the file to delete")
+
+
+class DeleteFileOutput(BaseModel):
+    """Output for delete_file function."""
+
+    ok: bool
+    deleted: Optional[str] = None
+    error: Optional[str] = None
+
+
+def delete_file(input: DeleteFileInput) -> DeleteFileOutput:
+    """
+    Delete a file.
+
+    Examples:
+        >>> delete_file({"path": "temp.txt"})
+    """
+    try:
+        path = os.path.expanduser(input.path)
+        p = Path(path)
+
+        if not p.exists():
+            return DeleteFileOutput(ok=False, error=f"File not found: {path}")
+
+        if p.is_dir():
+            return DeleteFileOutput(
+                ok=False, error=f"Use delete_directory for directories: {path}"
+            )
+
+        p.unlink()
+        return DeleteFileOutput(ok=True, deleted=str(p))
+
+    except Exception as e:
+        return DeleteFileOutput(ok=False, error=str(e))
+
+
+# =============================================================================
+# Create Directory
+# =============================================================================
+
+
+class CreateDirectoryInput(BaseModel):
+    """Input for create_directory function."""
+
+    path: str = Field(description="Directory path to create")
+    parents: bool = Field(
+        default=True, description="Create parent directories if needed"
+    )
+
+
+class CreateDirectoryOutput(BaseModel):
+    """Output for create_directory function."""
+
+    ok: bool
+    path: Optional[str] = None
+    error: Optional[str] = None
+
+
+def create_directory(input: CreateDirectoryInput) -> CreateDirectoryOutput:
+    """
+    Create a directory.
+
+    Examples:
+        >>> create_directory({"path": "new_folder"})
+        >>> create_directory({"path": "a/b/c/deep"})
+    """
+    try:
+        path = os.path.expanduser(input.path)
+        p = Path(path)
+
+        p.mkdir(parents=input.parents, exist_ok=True)
+
+        return CreateDirectoryOutput(ok=True, path=str(p.absolute()))
+
+    except Exception as e:
+        return CreateDirectoryOutput(ok=False, error=str(e))
+
+
+# =============================================================================
+# Copy File
+# =============================================================================
+
+
+class CopyFileInput(BaseModel):
+    """Input for copy_file function."""
+
+    source: str = Field(description="Source file path")
+    destination: str = Field(description="Destination path")
+
+
+class CopyFileOutput(BaseModel):
+    """Output for copy_file function."""
+
+    ok: bool
+    source: Optional[str] = None
+    destination: Optional[str] = None
+    error: Optional[str] = None
+
+
+def copy_file(input: CopyFileInput) -> CopyFileOutput:
+    """
+    Copy a file.
+
+    Examples:
+        >>> copy_file({"source": "file.txt", "destination": "backup/file.txt"})
+    """
+    try:
+        source = os.path.expanduser(input.source)
+        destination = os.path.expanduser(input.destination)
+
+        # Create destination directory if needed
+        dest_path = Path(destination)
+        dest_path.parent.mkdir(parents=True, exist_ok=True)
+
+        shutil.copy2(source, destination)
+
+        return CopyFileOutput(ok=True, source=source, destination=destination)
+
+    except Exception as e:
+        return CopyFileOutput(ok=False, error=str(e))
+
+
+# =============================================================================
+# Move File
+# =============================================================================
+
+
+class MoveFileInput(BaseModel):
+    """Input for move_file function."""
+
+    source: str = Field(description="Source path")
+    destination: str = Field(description="Destination path")
+
+
+class MoveFileOutput(BaseModel):
+    """Output for move_file function."""
+
+    ok: bool
+    source: Optional[str] = None
+    destination: Optional[str] = None
+    error: Optional[str] = None
+
+
+def move_file(input: MoveFileInput) -> MoveFileOutput:
+    """
+    Move or rename a file or directory.
+
+    Examples:
+        >>> move_file({"source": "old.txt", "destination": "new.txt"})
+    """
+    try:
+        source = os.path.expanduser(input.source)
+        destination = os.path.expanduser(input.destination)
+
+        shutil.move(source, destination)
+
+        return MoveFileOutput(ok=True, source=source, destination=destination)
+
+    except Exception as e:
+        return MoveFileOutput(ok=False, error=str(e))

supyagent/default_tools/shell.py

@@ -0,0 +1,217 @@
+# /// script
+# dependencies = ["pydantic"]
+# ///
+"""
+Shell command execution tools.
+
+Allows agents to run bash/shell commands on the system.
+Use with caution - consider restricting via agent tool permissions.
+"""
+
+import os
+import subprocess
+import shutil
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class RunCommandInput(BaseModel):
+    """Input for run_command function."""
+
+    command: str = Field(description="The shell command to execute")
+    working_dir: Optional[str] = Field(
+        default=None, description="Working directory for the command"
+    )
+    timeout: int = Field(
+        default=60, description="Maximum seconds to wait for command"
+    )
+
+
+class RunCommandOutput(BaseModel):
+    """Output for run_command function."""
+
+    ok: bool
+    stdout: str
+    stderr: str
+    exit_code: int
+    command: str
+
+
+def run_command(input: RunCommandInput) -> RunCommandOutput:
+    """
+    Execute a shell command and return the result.
+
+    Examples:
+        >>> run_command({"command": "ls -la"})
+        >>> run_command({"command": "echo 'hello' | grep hello"})
+        >>> run_command({"command": "pwd", "working_dir": "/tmp"})
+    """
+    try:
+        working_dir = input.working_dir
+        if working_dir:
+            working_dir = os.path.expanduser(working_dir)
+            working_dir = os.path.expandvars(working_dir)
+
+        result = subprocess.run(
+            input.command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=input.timeout,
+            cwd=working_dir,
+        )
+
+        return RunCommandOutput(
+            ok=result.returncode == 0,
+            stdout=result.stdout,
+            stderr=result.stderr,
+            exit_code=result.returncode,
+            command=input.command,
+        )
+
+    except subprocess.TimeoutExpired:
+        return RunCommandOutput(
+            ok=False,
+            stdout="",
+            stderr=f"Command timed out after {input.timeout} seconds",
+            exit_code=-1,
+            command=input.command,
+        )
+    except Exception as e:
+        return RunCommandOutput(
+            ok=False,
+            stdout="",
+            stderr=str(e),
+            exit_code=-1,
+            command=input.command,
+        )
+
+
+class RunScriptInput(BaseModel):
+    """Input for run_script function."""
+
+    script: str = Field(description="Multi-line script content")
+    interpreter: str = Field(
+        default="/bin/bash", description="Script interpreter"
+    )
+    working_dir: Optional[str] = Field(
+        default=None, description="Working directory"
+    )
+    timeout: int = Field(default=120, description="Max seconds to wait")
+
+
+class RunScriptOutput(BaseModel):
+    """Output for run_script function."""
+
+    ok: bool
+    stdout: str
+    stderr: str
+    exit_code: int
+
+
+def run_script(input: RunScriptInput) -> RunScriptOutput:
+    """
+    Execute a multi-line shell script.
+
+    Examples:
+        >>> run_script({"script": "cd /tmp\\necho $(pwd)\\nls"})
+    """
+    try:
+        working_dir = input.working_dir
+        if working_dir:
+            working_dir = os.path.expanduser(working_dir)
+
+        result = subprocess.run(
+            [input.interpreter],
+            input=input.script,
+            capture_output=True,
+            text=True,
+            timeout=input.timeout,
+            cwd=working_dir,
+        )
+
+        return RunScriptOutput(
+            ok=result.returncode == 0,
+            stdout=result.stdout,
+            stderr=result.stderr,
+            exit_code=result.returncode,
+        )
+
+    except subprocess.TimeoutExpired:
+        return RunScriptOutput(
+            ok=False,
+            stdout="",
+            stderr=f"Script timed out after {input.timeout} seconds",
+            exit_code=-1,
+        )
+    except Exception as e:
+        return RunScriptOutput(
+            ok=False,
+            stdout="",
+            stderr=str(e),
+            exit_code=-1,
+        )
+
+
+class WhichInput(BaseModel):
+    """Input for which function."""
+
+    command: str = Field(description="Command name to look up")
+
+
+class WhichOutput(BaseModel):
+    """Output for which function."""
+
+    ok: bool
+    path: Optional[str] = None
+    error: Optional[str] = None
+
+
+def which(input: WhichInput) -> WhichOutput:
+    """
+    Find the path to an executable.
+
+    Examples:
+        >>> which({"command": "python"})
+        >>> which({"command": "git"})
+    """
+    path = shutil.which(input.command)
+    if path:
+        return WhichOutput(ok=True, path=path)
+    else:
+        return WhichOutput(ok=False, error=f"Command not found: {input.command}")
+
+
+class GetEnvInput(BaseModel):
+    """Input for get_env function."""
+
+    name: str = Field(description="Environment variable name")
+    default: Optional[str] = Field(
+        default=None, description="Default if not set"
+    )
+
+
+class GetEnvOutput(BaseModel):
+    """Output for get_env function."""
+
+    ok: bool
+    value: Optional[str] = None
+    error: Optional[str] = None
+
+
+def get_env(input: GetEnvInput) -> GetEnvOutput:
+    """
+    Get an environment variable value.
+
+    Examples:
+        >>> get_env({"name": "HOME"})
+        >>> get_env({"name": "MY_VAR", "default": "fallback"})
+    """
+    value = os.environ.get(input.name, input.default)
+    if value is not None:
+        return GetEnvOutput(ok=True, value=value)
+    else:
+        return GetEnvOutput(
+            ok=False, error=f"Environment variable not set: {input.name}"
+        )

{supyagent-0.2.0.dist-info → supyagent-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supyagent
-Version: 0.2.0
+Version: 0.2.2
 Summary: LLM agents powered by supypowers - build AI agents with tool use, multi-agent orchestration, and secure credential management
 Project-URL: Homepage, https://github.com/ergodic-ai/supyagent
 Project-URL: Documentation, https://github.com/ergodic-ai/supyagent#readme
@@ -68,6 +68,9 @@ uv pip install supyagent
 ## Quick Start
 
 ```bash
+# Initialize supyagent (sets up default tools)
+supyagent init
+
 # Set up your API key (stored securely)
 supyagent config set ANTHROPIC_API_KEY
 
@@ -229,6 +232,7 @@ delegates:
 
 | Command | Description |
 |---------|-------------|
+| `supyagent init` | Initialize project with default tools |
 | `supyagent new <name>` | Create a new agent |
 | `supyagent list` | List all agents |
 | `supyagent show <name>` | Show agent details |
@@ -281,6 +285,25 @@ While chatting, use these commands:
 | `/clear` | Clear conversation history |
 | `/quit` | Exit the chat |
 
+## Bundled Tools
+
+Running `supyagent init` installs these default tools:
+
+### Shell (`shell.py`)
+- `run_command` - Execute shell commands
+- `run_script` - Run multi-line bash scripts
+- `which` - Find executable paths
+- `get_env` - Get environment variables
+
+### Files (`files.py`)
+- `read_file` / `write_file` - File I/O
+- `list_directory` - List files with glob patterns
+- `copy_file` / `move_file` / `delete_file` - File operations
+- `create_directory` - Create directories
+- `file_info` - Get file metadata
+
+You can add your own tools by creating Python files in `supypowers/`.
+
 ## Project Structure
 
 ```
@@ -290,8 +313,9 @@ your-project/
 │   ├── planner.yaml
 │   └── researcher.yaml
 ├── supypowers/          # Tool definitions (Python)
-│   ├── hello.py
-│   └── web_search.py
+│   ├── shell.py         # Shell commands (bundled)
+│   ├── files.py         # File operations (bundled)
+│   └── my_tools.py      # Your custom tools
 └── .supyagent/          # Runtime data (gitignore this)
     ├── sessions/        # Conversation history
     ├── credentials/     # Encrypted secrets

{supyagent-0.2.0.dist-info → supyagent-0.2.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
 supyagent/__init__.py,sha256=JrrQbk1bmDhUb2qOqxqDGBq1V-oArwVS4f5f9Qu-VcM,77
 supyagent/__main__.py,sha256=szUvsccEIA428c2_5J_X1qzq4L44qLvDvHfuRPYoy7c,121
 supyagent/cli/__init__.py,sha256=7jb5kxHtzce4rNKd9zrAiATp3Zxj7UQvtpQsyA97BTc,32
-supyagent/cli/main.py,sha256=xV34tTDORoFnp-MU_l0e_RP675bWeUdh3ohVB9uVsBg,36328
+supyagent/cli/main.py,sha256=5YqOevjbDdGNhA_gIIqnSATWThxj87TB_59RHzyL5gQ,38434
 supyagent/core/__init__.py,sha256=7MI6K2-OR_Fg0wcMziC4u3gNa0YxWmzJXO0RtOCevUg,727
 supyagent/core/agent.py,sha256=mkiV6CnK6Vk0Wg-DiAMm29wAViMa52-1Yb33Y5-FvQY,12655
 supyagent/core/config.py,sha256=kuTpuxy-qr-fhou7rJ-JLF82cdzdHQTu46kCZccSw1Y,10041
@@ -9,17 +9,20 @@ supyagent/core/context.py,sha256=ywen6IjWxcudxtipeqA_PHpZKdjK52eqOb9xy7QKnTM,456
 supyagent/core/credentials.py,sha256=35JBrzMOEDzHnn3XuyGmRjXVdSICL3tups3BLO_NCXQ,7600
 supyagent/core/delegation.py,sha256=B6OYlLjkZaRTPMQsK9nIGeXVO9JeC7RDpxXsOk652xs,9391
 supyagent/core/executor.py,sha256=awJXseQKO0I-D-5YqGxJ9MEN1b2DTVk_8kOQZExFYhs,7893
-supyagent/core/llm.py,sha256=z16cjqjPfwRGtEpUhZe1XlzOXJdlgKHjckNdeJnEWYw,1898
+supyagent/core/llm.py,sha256=WpGGYARvVdnMGfZXNTf99bY7UqGJLPz0hdlIR4bb9Nk,2012
 supyagent/core/registry.py,sha256=1CGCPsOcrIc_63_oJaFmHY8WwMgJEvbwsv8mnsOBWtY,7326
 supyagent/core/session_manager.py,sha256=ngqrbofR8V0wZSuOfGHTtSYE0C9U6noDrzfDsO8wi24,7389
-supyagent/core/tools.py,sha256=exIynhwulsMJTzzW5NmDqBeXepULAt4FlVhGbtrvdXE,6627
+supyagent/core/tools.py,sha256=qpCKdP5DBYj_XlCvMTskgiMQcUYSRWbsTolKmjkBO3w,7289
+supyagent/default_tools/__init__.py,sha256=VwVjwNSPxjflmzJ-Mv_7L79Yjn9LdxyeXNUkWzu3wFo,1890
+supyagent/default_tools/files.py,sha256=tUpjkP7TKbcK75lQ6jzEDpVDBSeupzTSqx_g2-rkON0,12059
+supyagent/default_tools/shell.py,sha256=fYXdy693Nb0hsNLMzTFgj3zaHq0wFSQ3SxpqHbVayjM,5478
 supyagent/models/__init__.py,sha256=y7fIdzh-yD0LKAK0zfY_MZdtjJhxofwRWBqrHDU93h0,259
 supyagent/models/agent_config.py,sha256=sQ7S7zExoFs0g-IMgACsGH2SMiDRjJTnCVZwhN6DnkY,2570
 supyagent/models/session.py,sha256=_Dwuija_Uvt_KzcNp82ja8qP5ltNHHz43Llug1vq1ic,1136
 supyagent/utils/__init__.py,sha256=l4HdE3n8axphMInBex1J1dB_O1MjzbZz6ot1l8Syf0g,39
 supyagent/utils/paths.py,sha256=Xum9kX_UjRvmshifSq423QsAKynpnyAVfpWuFjlsdDQ,692
-supyagent-0.2.0.dist-info/METADATA,sha256=lnle2YIGJXssPNm8jllCvhA_202_j3DL9CUNFiRGHO0,9562
-supyagent-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-supyagent-0.2.0.dist-info/entry_points.txt,sha256=7dFXWtRewhLfA5XUckV7Yu1E5_c6c9lq8Gz-7BFs6TM,53
-supyagent-0.2.0.dist-info/licenses/LICENSE,sha256=35fw1cvTM-IhiR3xaUohbiFBc2OBNRjI5z1b1cF7vZI,1067
-supyagent-0.2.0.dist-info/RECORD,,
+supyagent-0.2.2.dist-info/METADATA,sha256=Fa3A8EH-0m7jeG1fMcHMunVogRK9iS0VFMf_0pM6Vf8,10387
+supyagent-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+supyagent-0.2.2.dist-info/entry_points.txt,sha256=7dFXWtRewhLfA5XUckV7Yu1E5_c6c9lq8Gz-7BFs6TM,53
+supyagent-0.2.2.dist-info/licenses/LICENSE,sha256=35fw1cvTM-IhiR3xaUohbiFBc2OBNRjI5z1b1cF7vZI,1067
+supyagent-0.2.2.dist-info/RECORD,,