alita-sdk 0.3.257__py3-none-any.whl → 0.3.584__py3-none-any.whl

alita_sdk/cli/toolkit_loader.py

@@ -0,0 +1,85 @@
+"""
+Toolkit configuration loading and management.
+
+Handles loading toolkit configurations from JSON/YAML files.
+"""
+
+import json
+import yaml
+from pathlib import Path
+from typing import Dict, Any, List
+
+from .config import substitute_env_vars
+
+
+# All available tools in the inventory toolkit
+INVENTORY_TOOLS = [
+    "search_graph",
+    "get_entity",
+    "get_entity_content",
+    "impact_analysis",
+    "get_related_entities",
+    "get_stats",
+    "get_citations",
+    "list_entities_by_type",
+    "list_entities_by_layer",
+]
+
+
+def load_toolkit_config(file_path: str) -> Dict[str, Any]:
+    """Load toolkit configuration from JSON or YAML file with env var substitution."""
+    path = Path(file_path)
+    
+    if not path.exists():
+        raise FileNotFoundError(f"Toolkit configuration not found: {file_path}")
+    
+    with open(path) as f:
+        content = f.read()
+    
+    # Apply environment variable substitution
+    content = substitute_env_vars(content)
+    
+    # Parse based on file extension
+    if path.suffix in ['.yaml', '.yml']:
+        return yaml.safe_load(content)
+    else:
+        return json.loads(content)
+
+
+def load_toolkit_configs(agent_def: Dict[str, Any], toolkit_config_paths: tuple) -> List[Dict[str, Any]]:
+    """Load all toolkit configurations from agent definition and CLI options.
+    
+    Args:
+        agent_def: Agent definition dictionary
+        toolkit_config_paths: Tuple of file paths or dict configs from CLI options
+        
+    Returns:
+        List of toolkit configuration dictionaries
+    """
+    toolkit_configs = []
+    
+    # Load from agent definition if present
+    if 'toolkit_configs' in agent_def:
+        for tk_config in agent_def['toolkit_configs']:
+            if isinstance(tk_config, dict):
+                if 'file' in tk_config:
+                    config = load_toolkit_config(tk_config['file'])
+                    toolkit_configs.append(config)
+                elif 'config' in tk_config:
+                    toolkit_configs.append(tk_config['config'])
+                elif 'type' in tk_config:
+                    # Direct toolkit config (e.g., {'type': 'inventory', ...})
+                    toolkit_configs.append(tk_config)
+    
+    # Load from CLI options - can be file paths (str) or dict configs
+    if toolkit_config_paths:
+        for config_item in toolkit_config_paths:
+            if isinstance(config_item, dict):
+                # Direct config dict (e.g., from /inventory command)
+                toolkit_configs.append(config_item)
+            elif isinstance(config_item, str):
+                # File path
+                config = load_toolkit_config(config_item)
+                toolkit_configs.append(config)
+    
+    return toolkit_configs

alita_sdk/cli/tools/__init__.py

@@ -0,0 +1,43 @@
+"""
+CLI tools package.
+
+Contains specialized tools for CLI agents.
+"""
+
+from .filesystem import get_filesystem_tools, FilesystemApiWrapper
+from .terminal import get_terminal_tools, create_default_blocked_patterns_file
+from .planning import (
+    get_planning_tools, 
+    PlanState, 
+    list_sessions, 
+    generate_session_id,
+    create_session_memory,
+    save_session_metadata,
+    load_session_metadata,
+    update_session_metadata,
+    get_session_dir,
+    to_portable_path,
+    from_portable_path,
+)
+from .approval import create_approval_wrapper, ApprovalToolWrapper, prompt_approval
+
+__all__ = [
+    'get_filesystem_tools',
+    'FilesystemApiWrapper',
+    'get_terminal_tools',
+    'create_default_blocked_patterns_file',
+    'get_planning_tools',
+    'PlanState',
+    'list_sessions',
+    'generate_session_id',
+    'create_session_memory',
+    'save_session_metadata',
+    'load_session_metadata',
+    'update_session_metadata',
+    'get_session_dir',
+    'to_portable_path',
+    'from_portable_path',
+    'create_approval_wrapper',
+    'ApprovalToolWrapper',
+    'prompt_approval',
+]

alita_sdk/cli/tools/approval.py

@@ -0,0 +1,224 @@
+"""
+Tool approval wrapper for CLI.
+
+Wraps tools to require user approval before execution based on approval mode.
+Modes:
+- 'always': Always require approval for each tool call
+- 'auto': No approval required (automatic execution)
+- 'yolo': No approval and no safety checks (use with caution)
+"""
+
+import functools
+from typing import Any, Callable, Dict, List, Optional, Set
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich import box
+from rich.text import Text
+import json
+
+from langchain_core.tools import BaseTool, StructuredTool, Tool
+
+console = Console()
+
+# Tools that always require approval in 'always' mode (dangerous built-in operations)
+# These are the built-in CLI tools that modify the filesystem or execute commands
+DANGEROUS_TOOLS = {
+    'terminal_run_command',  # Shell command execution
+    'write_file',
+    'create_file', 
+    'delete_file',
+    'move_file',
+    'copy_file',
+    'create_directory',
+}
+
+# Note: Tools NOT in DANGEROUS_TOOLS are auto-approved, including:
+# - Read-only filesystem tools (read_file, list_directory, etc.)
+# - User-added toolkit tools (via --toolkit_config or /add_toolkit)
+# - MCP server tools (via --mcp or /add_mcp)
+# 
+# The assumption is that users explicitly add toolkits they trust.
+# Only built-in tools that can modify files or run commands require approval.
+
+
+def prompt_approval(tool_name: str, tool_args: Dict[str, Any], approval_mode: str) -> bool:
+    """
+    Prompt user for approval before executing a tool.
+    
+    Args:
+        tool_name: Name of the tool to execute
+        tool_args: Arguments to pass to the tool
+        approval_mode: Current approval mode ('always', 'auto', 'yolo')
+        
+    Returns:
+        True if approved, False if rejected
+    """
+    # Auto mode - always approve
+    if approval_mode == 'auto':
+        return True
+    
+    # Yolo mode - always approve, no questions asked
+    if approval_mode == 'yolo':
+        return True
+    
+    # Always mode - only prompt for dangerous built-in tools
+    # User-added toolkits and MCP tools are auto-approved (user explicitly added them)
+    if tool_name not in DANGEROUS_TOOLS:
+        return True
+    
+    # Create approval prompt panel for dangerous tools
+    console.print()
+    
+    # Build args display
+    args_content = []
+    for key, value in tool_args.items():
+        if isinstance(value, str) and len(value) > 100:
+            display_value = value[:100] + "..."
+        elif isinstance(value, (dict, list)):
+            try:
+                formatted = json.dumps(value, indent=2)
+                if len(formatted) > 200:
+                    formatted = formatted[:200] + "..."
+                display_value = formatted
+            except:
+                display_value = str(value)[:100]
+        else:
+            display_value = str(value)
+        args_content.append(f"  [cyan]{key}[/cyan]: {display_value}")
+    
+    args_text = "\n".join(args_content) if args_content else "  (no arguments)"
+    
+    # All tools reaching here are dangerous (in DANGEROUS_TOOLS)
+    icon = "⚠️"
+    border_style = "yellow"
+    title_style = "bold yellow"
+    
+    panel = Panel(
+        Text.from_markup(f"[bold]{tool_name}[/bold]\n\n[dim]Arguments:[/dim]\n{args_text}"),
+        title=f"[{title_style}]{icon} Approve Tool Call?[/{title_style}]",
+        title_align="left",
+        subtitle="[dim][y]es / [n]o / [a]uto-approve / [q]uit[/dim]",
+        subtitle_align="right",
+        border_style=border_style,
+        box=box.ROUNDED,
+        padding=(1, 2),
+    )
+    console.print(panel)
+    
+    # Get user input
+    while True:
+        try:
+            response = input("→ ").strip().lower()
+        except (KeyboardInterrupt, EOFError):
+            console.print("\n[yellow]Cancelled[/yellow]")
+            return False
+        
+        if response in ('y', 'yes', ''):
+            console.print("[green]✓ Approved[/green]")
+            return True
+        elif response in ('n', 'no'):
+            console.print("[red]✗ Rejected[/red]")
+            return False
+        elif response in ('a', 'auto'):
+            console.print("[cyan]→ Switching to auto mode for this session[/cyan]")
+            # Signal to switch to auto mode
+            return 'switch_auto'
+        elif response in ('q', 'quit'):
+            console.print("[yellow]Quitting...[/yellow]")
+            raise KeyboardInterrupt()
+        else:
+            console.print("[dim]Please enter y/n/a/q[/dim]")
+
+
+class ApprovalToolWrapper:
+    """
+    Wrapper that adds approval prompts to tools based on approval mode.
+    
+    This wrapper intercepts tool calls and prompts for user approval
+    before executing dangerous operations.
+    """
+    
+    def __init__(self, approval_mode_ref: List[str]):
+        """
+        Initialize the approval wrapper.
+        
+        Args:
+            approval_mode_ref: A mutable list containing the current approval mode.
+                              Using a list allows the mode to be changed externally.
+                              access as approval_mode_ref[0]
+        """
+        self.approval_mode_ref = approval_mode_ref
+    
+    @property
+    def approval_mode(self) -> str:
+        """Get current approval mode."""
+        return self.approval_mode_ref[0] if self.approval_mode_ref else 'always'
+    
+    def wrap_tool(self, tool: BaseTool) -> BaseTool:
+        """
+        Wrap a tool to add approval prompts.
+        
+        Args:
+            tool: The tool to wrap
+            
+        Returns:
+            Wrapped tool with approval logic
+        """
+        original_func = tool.func if hasattr(tool, 'func') else tool._run
+        tool_name = tool.name
+        wrapper_self = self
+        
+        @functools.wraps(original_func)
+        def wrapped_func(*args, **kwargs):
+            # Get approval
+            approval = prompt_approval(tool_name, kwargs, wrapper_self.approval_mode)
+            
+            if approval == 'switch_auto':
+                # Switch to auto mode
+                wrapper_self.approval_mode_ref[0] = 'auto'
+                console.print("[cyan]Mode switched to 'auto' - tools will auto-approve[/cyan]")
+            elif not approval:
+                return f"Tool execution rejected by user"
+            
+            # Execute the tool
+            return original_func(*args, **kwargs)
+        
+        # Create new tool with wrapped function
+        if isinstance(tool, StructuredTool):
+            return StructuredTool(
+                name=tool.name,
+                description=tool.description,
+                func=wrapped_func,
+                args_schema=tool.args_schema,
+                return_direct=tool.return_direct,
+            )
+        else:
+            # Clone the tool with wrapped function
+            tool.func = wrapped_func
+            return tool
+    
+    def wrap_tools(self, tools: List[BaseTool]) -> List[BaseTool]:
+        """
+        Wrap multiple tools with approval logic.
+        
+        Args:
+            tools: List of tools to wrap
+            
+        Returns:
+            List of wrapped tools
+        """
+        return [self.wrap_tool(tool) for tool in tools]
+
+
+def create_approval_wrapper(approval_mode_ref: List[str]) -> ApprovalToolWrapper:
+    """
+    Create an approval wrapper with a reference to the current mode.
+    
+    Args:
+        approval_mode_ref: Mutable list containing current approval mode [0]
+        
+    Returns:
+        ApprovalToolWrapper instance
+    """
+    return ApprovalToolWrapper(approval_mode_ref)