astraagent 2.25.6

package/astra/cli.py

@@ -0,0 +1,913 @@
+"""
+AstraAgent CLI - Command Line Interface for the Autonomous Agent.
+"""
+
+import asyncio
+import argparse
+import sys
+import os
+import json
+import shutil
+import fnmatch
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Optional, List, Dict, Any, Tuple
+
+from astra.core.agent import AstraAgent
+from astra.core.config import AgentConfig, ExecutionMode, LogLevel
+
+
+BANNER = r"""
+    ___           __              ___                    __ 
+   /   |  _____  / /__________ _ /   |  ____ ____  ____  / /_
+  / /| | / ___/ / __/ ___/ __ `// /| | / __ `/ _ \/ __ \/ __/
+ / ___ |(__  ) / /_/ /  / /_/ // ___ |/ /_/ /  __/ / / / /_  
+/_/  |_/____/  \__/_/   \__,_//_/  |_|\__, /\___/_/ /_/\__/  
+                                     /____/                   
+                                     
+    [*] Autonomous AI Agent v2.25.6
+    ============================================
+"""
+
+
+def print_banner():
+    """Print the ASCII banner."""
+    print(BANNER)
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="astra",
+        description="AstraAgent - Autonomous AI Agent",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    
+    # Main commands
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+    
+    # Run command
+    run_parser = subparsers.add_parser("run", help="Run agent with a goal")
+    run_parser.add_argument("goal", nargs="?", help="Goal to accomplish")
+    run_parser.add_argument("-i", "--interactive", action="store_true", help="Interactive mode")
+    run_parser.add_argument("-m", "--mode", choices=["autonomous", "supervised", "dry_run"],
+                           default="autonomous", help="Execution mode")
+    run_parser.add_argument("--model", default=None, help="LLM model to use")
+    run_parser.add_argument("--provider", default="openai", help="LLM provider")
+    run_parser.add_argument("--max-iterations", type=int, default=50, help="Max iterations")
+    run_parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    run_parser.add_argument("-w", "--workspace", default="./", help="Workspace directory")
+
+    # Start command (friendly alias for run)
+    start_parser = subparsers.add_parser("start", help="Start the agent quickly")
+    start_parser.add_argument("goal", nargs="?", help="Optional goal to run")
+    start_parser.add_argument("-i", "--interactive", action="store_true", help="Interactive mode")
+    start_parser.add_argument("-m", "--mode", choices=["autonomous", "supervised", "dry_run"],
+                              default="autonomous", help="Execution mode")
+    start_parser.add_argument("--model", default=None, help="LLM model to use")
+    start_parser.add_argument("--provider", default="openai", help="LLM provider")
+    start_parser.add_argument("--max-iterations", type=int, default=50, help="Max iterations")
+    start_parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    start_parser.add_argument("-w", "--workspace", default="./", help="Workspace directory")
+    
+    # Config command
+    config_parser = subparsers.add_parser("config", help="Manage configuration")
+    config_parser.add_argument("--show", action="store_true", help="Show current config")
+    config_parser.add_argument("--save", help="Save config to file")
+    config_parser.add_argument("--load", help="Load config from file")
+    config_parser.add_argument("--set-key", help="Set API key")
+    
+    # Tools command
+    tools_parser = subparsers.add_parser("tools", help="List available tools")
+    tools_parser.add_argument("--info", help="Show info about a specific tool")
+    
+    # Memory command
+    memory_parser = subparsers.add_parser("memory", help="Manage agent memory")
+    memory_parser.add_argument("--list", action="store_true", help="List recent memories")
+    memory_parser.add_argument("--search", help="Search memories")
+    memory_parser.add_argument("--clear", action="store_true", help="Clear all memories")
+    
+    # Chat command (multi-provider interactive chat)
+    chat_parser = subparsers.add_parser("chat", help="Interactive chat with LLM providers")
+    chat_parser.add_argument("-p", "--provider", help="LLM provider (openai, gemini, anthropic, groq, openrouter, local)")
+    chat_parser.add_argument("-m", "--model", help="Model to use")
+    chat_parser.add_argument("-k", "--api-key", help="API key for provider")
+    chat_parser.add_argument("--list-providers", action="store_true", help="List available providers")
+    
+    # Settings command
+    settings_parser = subparsers.add_parser("settings", help="Manage chat settings and API keys")
+    settings_parser.add_argument("--list-keys", action="store_true", help="View all API keys status")
+    settings_parser.add_argument("--set-key", metavar="PROVIDER", help="Set API key for provider")
+    settings_parser.add_argument("--view-env", action="store_true", help="View .env file contents")
+    settings_parser.add_argument("--reset-all", action="store_true", help="Reset all API keys")
+    
+    # Keys command (shortcut to view keys)
+    keys_parser = subparsers.add_parser("keys", help="View and manage API keys")
+    keys_parser.add_argument("--list", action="store_true", help="List all API keys")
+    keys_parser.add_argument("--set", metavar="PROVIDER", help="Set API key for provider")
+    keys_parser.add_argument("--get", metavar="PROVIDER", help="Get masked status of API key")
+    
+    # Providers command
+    providers_parser = subparsers.add_parser("providers", help="List available LLM providers")
+    providers_parser.add_argument("--info", metavar="PROVIDER", help="Show info about specific provider")
+    
+    # List models for a provider
+    models_parser = subparsers.add_parser("models", help="List models for a provider")
+    models_parser.add_argument("provider", help="Provider name (openai, gemini, etc.)")
+    models_parser.add_argument("--info", action="store_true", help="Show provider info")
+
+    # Search command - device-wide search
+    search_parser = subparsers.add_parser("search", help="Search files across the device")
+    search_parser.add_argument("query", nargs="?", help="Search query or filename (supports wildcards)")
+    search_parser.add_argument("--root", help="Root directory to search (default: all device roots)")
+    search_parser.add_argument("--ext", help="Search by extension (e.g. .py)")
+    search_parser.add_argument("--type", help="Search by type (code, image, document)")
+    search_parser.add_argument("--recent", action="store_true", help="Search recently modified files")
+    search_parser.add_argument("--days", type=int, default=7, help="Recent window in days (with --recent)")
+    search_parser.add_argument("--content", help="Search file contents for text")
+    search_parser.add_argument("--limit", type=int, default=100, help="Maximum results to show")
+    search_parser.add_argument("--max-depth", type=int, default=-1, help="Maximum directory depth (-1 for unlimited)")
+    search_parser.add_argument("--show-hidden", action="store_true", help="Include hidden files/directories")
+
+    # Tasks command - perform file operations
+    tasks_parser = subparsers.add_parser("tasks", help="Perform file/folder tasks from CLI (single or batch)")
+    tasks_parser.add_argument("action", nargs="?", help="Action (copy, move, delete, info, mkdir, list, rename)")
+    tasks_parser.add_argument("src", nargs="?", help="Source path")
+    tasks_parser.add_argument("dest", nargs="?", help="Destination path")
+    tasks_parser.add_argument("--overwrite", action="store_true", help="Overwrite destination when supported")
+    tasks_parser.add_argument("--recursive", action="store_true", help="Recursive operation for delete/list")
+    tasks_parser.add_argument("--yes", action="store_true", help="Skip confirmation prompts")
+    tasks_parser.add_argument("--batch", help="JSON array of tasks, e.g. '[{\"action\":\"mkdir\",\"src\":\"C:/tmp\"}]'")
+    tasks_parser.add_argument("--batch-file", help="Path to JSON file containing task array")
+
+    # Updater command
+    updater_parser = subparsers.add_parser("update", help="Check and apply updates")
+    updater_parser.add_argument("--check", action="store_true", help="Check for updates")
+    updater_parser.add_argument("--npm", action="store_true", help="Update via npm")
+    updater_parser.add_argument("--pip", action="store_true", help="Update via pip")
+    updater_parser.add_argument("--github", action="store_true", help="Download from GitHub releases")
+    updater_parser.add_argument("--auto", action="store_true", help="Check and automatically install latest (npm preferred)")
+    
+    # Version
+    parser.add_argument("--version", action="version", version="AstraAgent 1.0.0")
+    
+    return parser
+
+
+def build_config(args) -> AgentConfig:
+    """Build configuration from arguments and config file."""
+    # First try to load from config.json if it exists
+    config_file = Path("config.json")
+    if config_file.exists():
+        try:
+            config = AgentConfig.load(str(config_file))
+        except Exception:
+            config = AgentConfig()
+    else:
+        config = AgentConfig()
+    
+    # Then apply environment variables (they override config file)
+    env_config = AgentConfig.from_env()
+    if env_config.llm.api_key:
+        config.llm.api_key = env_config.llm.api_key
+        config.llm.provider = env_config.llm.provider
+        config.llm.model = env_config.llm.model
+    
+    # Apply CLI arguments (only if explicitly provided)
+    if hasattr(args, 'workspace') and args.workspace:
+        config.workspace_path = args.workspace
+    
+    if hasattr(args, 'mode') and args.mode:
+        mode_map = {
+            "autonomous": ExecutionMode.AUTONOMOUS,
+            "supervised": ExecutionMode.SUPERVISED,
+            "dry_run": ExecutionMode.DRY_RUN
+        }
+        config.mode = mode_map.get(args.mode, ExecutionMode.AUTONOMOUS)
+    
+    # Only override provider if explicitly passed (not default)
+    if hasattr(args, 'provider') and args.provider and args.provider != "openai":
+        config.llm.provider = args.provider
+    
+    if hasattr(args, 'model') and args.model:
+        config.llm.model = args.model
+    
+    if hasattr(args, 'max_iterations'):
+        config.max_iterations = args.max_iterations
+    
+    # Default to ERROR level for clean output, DEBUG if verbose
+    if hasattr(args, 'verbose') and args.verbose:
+        config.logging.level = LogLevel.DEBUG
+    elif hasattr(args, 'command') and args.command in ('run', 'start'):
+        # For run command, only show errors by default
+        config.logging.level = LogLevel.ERROR
+    
+    return config
+
+
+def cli_interactive_session(config: AgentConfig):
+    """Interactive CLI session - text-based."""
+    import asyncio as aio
+    
+    print("\n[*] AstraAgent Interactive Mode")
+    print("Type your goals/commands. Type 'exit' to quit.\n")
+    
+    agent = AstraAgent(config)
+    
+    try:
+        while True:
+            try:
+                user_input = input("You > ").strip()
+            except EOFError:
+                break
+            except KeyboardInterrupt:
+                print("\n[*] Exiting...")
+                break
+            
+            if not user_input:
+                continue
+            
+            if user_input.lower() in ['exit', 'quit', 'q']:
+                print("Goodbye!")
+                break
+            
+            if user_input.lower() == 'status':
+                try:
+                    print(agent.state.get_summary())
+                except:
+                    print("No status available")
+                continue
+            
+            if user_input.lower() == 'tools':
+                try:
+                    tools = agent.tools.list_enabled()
+                    print(f"Available tools: {', '.join(tools)}")
+                except:
+                    print("Could not list tools")
+                continue
+            
+            print("\n[...] Working on your request...\n")
+            try:
+                result = aio.run(agent.run(user_input))
+                print(f"\n{result}\n")
+            except ValueError as e:
+                print(f"❌ Configuration Error: {e}\n")
+            except Exception as e:
+                print(f"❌ Error: {e}\n")
+            
+            # Reset for next goal
+            agent.state = agent.state.__class__()
+            agent.messages = []
+            
+    finally:
+        agent.shutdown()
+
+
+async def run_agent(goal: str, config: AgentConfig) -> str:
+    """Run the agent with a goal."""
+    agent = AstraAgent(config)
+    try:
+        result = await agent.run(goal)
+        
+        # Check if agent encountered an error
+        if agent.state.last_error:
+            error_msg = agent.state.last_error
+            if "Cannot connect" in error_msg or "timeout" in error_msg.lower():
+                return f"❌ Connection Error: Cannot reach LLM server.\n\nRun: ollama serve (or use LM Studio)\nThen try again or see SETUP.md"
+            else:
+                return f"❌ Error: {error_msg}"
+        
+        # Success - return summary only if non-empty
+        if result and not result.startswith("==="):
+            return result
+        elif result.startswith("==="):
+            # Extract key info from summary
+            return f"✅ Goal '{goal}' processed.\nCheck logs for details."
+        
+        return "✅ Done"
+        
+    except ValueError as e:
+        # Configuration errors
+        return f"❌ Configuration Error: {str(e)}\n\nSee SETUP.md for instructions."
+    except RuntimeError as e:
+        # Runtime errors (connection, API errors)
+        error_msg = str(e)
+        if "Cannot connect" in error_msg or "timeout" in error_msg.lower():
+            return f"❌ Connection Error: Cannot reach LLM server.\n\nRun: ollama serve (or use LM Studio)\nThen try again or see SETUP.md"
+        return f"❌ Error: {error_msg}"
+    except Exception as e:
+        return f"❌ Unexpected Error: {str(e)}"
+    finally:
+        agent.shutdown()
+
+
+def show_tools(tool_name: Optional[str] = None):
+    """Show available tools."""
+    from astra.tools.base import create_default_registry
+    
+    registry = create_default_registry()
+    
+    if tool_name:
+        tool = registry.get(tool_name)
+        if tool:
+            info = tool.get_info()
+            print(f"\nTool: {info['name']}")
+            print(f"Description: {info['description']}")
+            print(f"Category: {info['category']}")
+            print(f"Risk Level: {info['risk_level']}")
+            print("\nParameters:")
+            for param in tool.parameters:
+                req = "required" if param.required else "optional"
+                print(f"  - {param.name} ({param.type}, {req}): {param.description}")
+        else:
+            print(f"Tool not found: {tool_name}")
+    else:
+        print("\nAvailable Tools:")
+        for name in registry.list_enabled():
+            tool = registry.get(name)
+            print(f"  - {name}: {tool.description[:60]}...")
+
+
+FILE_TYPE_EXTENSIONS: Dict[str, set] = {
+    "code": {".py", ".js", ".ts", ".java", ".cpp", ".c", ".cs", ".go", ".rs", ".php", ".rb", ".swift", ".kt"},
+    "image": {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".svg", ".ico"},
+    "document": {".txt", ".md", ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".rtf", ".csv"},
+    "archive": {".zip", ".rar", ".7z", ".tar", ".gz"},
+    "media": {".mp3", ".wav", ".mp4", ".mkv", ".avi", ".mov"},
+}
+
+
+def _format_size(size_bytes: int) -> str:
+    """Format file size in a human-readable form."""
+    size = float(size_bytes)
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if size < 1024:
+            return f"{size:.1f}{unit}"
+        size /= 1024
+    return f"{size:.1f}PB"
+
+
+def _resolve_search_roots(root: Optional[str]) -> List[Path]:
+    """Resolve search roots. Defaults to full device roots."""
+    if root:
+        root_path = Path(root).resolve()
+        return [root_path] if root_path.exists() else []
+
+    if os.name == "nt":
+        roots: List[Path] = []
+        for drive_letter in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
+            drive = Path(f"{drive_letter}:\\")
+            if drive.exists():
+                roots.append(drive)
+        return roots
+
+    return [Path("/")]
+
+
+def _is_hidden(path: Path) -> bool:
+    """Best-effort hidden file detection."""
+    if path.name.startswith("."):
+        return True
+    if os.name != "nt":
+        return False
+    try:
+        import stat
+        attrs = path.stat().st_file_attributes
+        return bool(attrs & stat.FILE_ATTRIBUTE_HIDDEN)
+    except Exception:
+        return False
+
+
+def _iter_files(root: Path, max_depth: int = -1, show_hidden: bool = False):
+    """Iterate files with optional depth limit."""
+    stack: List[Tuple[Path, int]] = [(root, 0)]
+
+    while stack:
+        current, depth = stack.pop()
+        if not current.exists():
+            continue
+
+        try:
+            entries = list(current.iterdir())
+        except (PermissionError, OSError):
+            continue
+
+        for entry in entries:
+            if not show_hidden and _is_hidden(entry):
+                continue
+
+            if entry.is_dir():
+                if max_depth < 0 or depth < max_depth:
+                    stack.append((entry, depth + 1))
+            elif entry.is_file():
+                yield entry
+
+
+def _query_matches(path: Path, query: Optional[str]) -> bool:
+    """Match filename against substring or wildcard query."""
+    if not query:
+        return True
+    name = path.name
+    if any(ch in query for ch in "*?[]"):
+        return fnmatch.fnmatch(name.lower(), query.lower())
+    return query.lower() in name.lower()
+
+
+def _content_matches(path: Path, content_query: Optional[str]) -> bool:
+    """Search content in text-like files with safe limits."""
+    if not content_query:
+        return True
+    try:
+        with open(path, "r", encoding="utf-8", errors="ignore") as f:
+            chunk = f.read(1024 * 1024)
+        return content_query.lower() in chunk.lower()
+    except Exception:
+        return False
+
+
+def run_device_search(args) -> int:
+    """Run filesystem-wide search from CLI command arguments."""
+    if not args.query and not args.ext and not args.type and not args.content and not args.recent:
+        print("Provide at least one filter: query, --ext, --type, --content, or --recent")
+        return 1
+
+    roots = _resolve_search_roots(args.root)
+    if not roots:
+        print(f"No valid search root found for: {args.root}")
+        return 1
+
+    ext_filter = args.ext.lower() if args.ext else None
+    if ext_filter and not ext_filter.startswith("."):
+        ext_filter = f".{ext_filter}"
+
+    type_filter = args.type.lower() if args.type else None
+    if type_filter and type_filter not in FILE_TYPE_EXTENSIONS:
+        valid = ", ".join(sorted(FILE_TYPE_EXTENSIONS.keys()))
+        print(f"Invalid --type '{args.type}'. Valid types: {valid}")
+        return 1
+
+    recent_cutoff = None
+    if args.recent:
+        recent_cutoff = datetime.now() - timedelta(days=max(1, args.days))
+
+    results: List[Path] = []
+    scanned_files = 0
+
+    for root in roots:
+        for file_path in _iter_files(root, max_depth=args.max_depth, show_hidden=args.show_hidden):
+            scanned_files += 1
+
+            if not _query_matches(file_path, args.query):
+                continue
+            if ext_filter and file_path.suffix.lower() != ext_filter:
+                continue
+            if type_filter and file_path.suffix.lower() not in FILE_TYPE_EXTENSIONS[type_filter]:
+                continue
+            if recent_cutoff:
+                try:
+                    if datetime.fromtimestamp(file_path.stat().st_mtime) < recent_cutoff:
+                        continue
+                except (PermissionError, OSError):
+                    continue
+            if not _content_matches(file_path, args.content):
+                continue
+
+            results.append(file_path)
+            if len(results) >= args.limit:
+                break
+
+        if len(results) >= args.limit:
+            break
+
+    if not results:
+        print(f"No matching files found. Scanned {scanned_files} files.")
+        return 0
+
+    print(f"\nFound {len(results)} file(s) (scanned {scanned_files} files):\n")
+    for idx, file_path in enumerate(results, start=1):
+        try:
+            stat = file_path.stat()
+            modified = datetime.fromtimestamp(stat.st_mtime).strftime("%Y-%m-%d %H:%M")
+            size = _format_size(stat.st_size)
+            print(f"{idx:3}. {file_path}  [{size}, {modified}]")
+        except (PermissionError, OSError):
+            print(f"{idx:3}. {file_path}")
+
+    if len(results) == args.limit:
+        print(f"\nResult limit reached ({args.limit}). Increase with --limit.")
+
+    return 0
+
+
+def _execute_task(action: str, src: Optional[str], dest: Optional[str], overwrite: bool,
+                  recursive: bool, assume_yes: bool) -> Tuple[bool, str]:
+    """Execute one filesystem task."""
+    action = action.lower().strip()
+
+    try:
+        if action == "mkdir":
+            if not src:
+                return False, "mkdir requires src path"
+            Path(src).mkdir(parents=True, exist_ok=True)
+            return True, f"Created directory: {Path(src).resolve()}"
+
+        if action == "info":
+            if not src:
+                return False, "info requires src path"
+            target = Path(src).resolve()
+            if not target.exists():
+                return False, f"Path not found: {target}"
+            stat = target.stat()
+            kind = "directory" if target.is_dir() else "file"
+            details = (
+                f"Path: {target}\n"
+                f"Type: {kind}\n"
+                f"Size: {_format_size(stat.st_size)}\n"
+                f"Modified: {datetime.fromtimestamp(stat.st_mtime)}"
+            )
+            return True, details
+
+        if action == "list":
+            if not src:
+                return False, "list requires src directory"
+            target = Path(src).resolve()
+            if not target.is_dir():
+                return False, f"Not a directory: {target}"
+            entries = sorted(target.rglob("*") if recursive else target.iterdir(), key=lambda p: p.name.lower())
+            entries = [p for p in entries if p != target]
+            lines = [f"Listing: {target}", f"Items: {len(entries)}"]
+            for p in entries[:500]:
+                suffix = "/" if p.is_dir() else ""
+                lines.append(f"- {p}{suffix}")
+            if len(entries) > 500:
+                lines.append(f"... and {len(entries) - 500} more")
+            return True, "\n".join(lines)
+
+        if action == "copy":
+            if not src or not dest:
+                return False, "copy requires src and dest"
+            src_path = Path(src).resolve()
+            dest_path = Path(dest).resolve()
+            if not src_path.exists():
+                return False, f"Source not found: {src_path}"
+            if dest_path.exists() and not overwrite:
+                return False, f"Destination exists: {dest_path} (use --overwrite)"
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+            if src_path.is_dir():
+                if dest_path.exists():
+                    shutil.rmtree(dest_path)
+                shutil.copytree(src_path, dest_path)
+            else:
+                shutil.copy2(src_path, dest_path)
+            return True, f"Copied {src_path} -> {dest_path}"
+
+        if action == "move":
+            if not src or not dest:
+                return False, "move requires src and dest"
+            src_path = Path(src).resolve()
+            dest_path = Path(dest).resolve()
+            if not src_path.exists():
+                return False, f"Source not found: {src_path}"
+            if dest_path.exists() and not overwrite:
+                return False, f"Destination exists: {dest_path} (use --overwrite)"
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.move(str(src_path), str(dest_path))
+            return True, f"Moved {src_path} -> {dest_path}"
+
+        if action == "rename":
+            if not src or not dest:
+                return False, "rename requires src and dest"
+            src_path = Path(src).resolve()
+            dest_path = src_path.with_name(dest)
+            if not src_path.exists():
+                return False, f"Source not found: {src_path}"
+            if dest_path.exists() and not overwrite:
+                return False, f"Destination exists: {dest_path} (use --overwrite)"
+            src_path.rename(dest_path)
+            return True, f"Renamed {src_path.name} -> {dest_path.name}"
+
+        if action == "delete":
+            if not src:
+                return False, "delete requires src path"
+            target = Path(src).resolve()
+            if not target.exists():
+                return False, f"Path not found: {target}"
+            if not assume_yes:
+                confirm = input(f"Delete '{target}'? (y/N): ").strip().lower()
+                if confirm != "y":
+                    return False, "Delete cancelled"
+            if target.is_dir():
+                if recursive:
+                    shutil.rmtree(target)
+                else:
+                    target.rmdir()
+            else:
+                target.unlink()
+            return True, f"Deleted: {target}"
+
+        return False, f"Unknown action: {action}"
+
+    except Exception as e:
+        return False, str(e)
+
+
+def _load_batch_tasks(batch_json: Optional[str], batch_file: Optional[str]) -> List[Dict[str, Any]]:
+    """Load task list from JSON string or file."""
+    if batch_json:
+        payload = json.loads(batch_json)
+    elif batch_file:
+        payload = json.loads(Path(batch_file).read_text(encoding="utf-8-sig"))
+    else:
+        return []
+
+    if not isinstance(payload, list):
+        raise ValueError("Batch payload must be a JSON array")
+    return payload
+
+
+def run_tasks_command(args) -> int:
+    """Run single or batch file tasks."""
+    tasks: List[Dict[str, Any]] = []
+
+    if args.batch or args.batch_file:
+        try:
+            tasks = _load_batch_tasks(args.batch, args.batch_file)
+        except Exception as e:
+            print(f"Failed to load batch tasks: {e}")
+            return 1
+    else:
+        if not args.action:
+            print("tasks requires action, or use --batch/--batch-file")
+            return 1
+        tasks = [{
+            "action": args.action,
+            "src": args.src,
+            "dest": args.dest,
+            "overwrite": args.overwrite,
+            "recursive": args.recursive,
+            "yes": args.yes,
+        }]
+
+    success_count = 0
+    for idx, task in enumerate(tasks, start=1):
+        action = str(task.get("action", "")).strip()
+        src = task.get("src")
+        dest = task.get("dest")
+        overwrite = bool(task.get("overwrite", args.overwrite))
+        recursive = bool(task.get("recursive", args.recursive))
+        assume_yes = bool(task.get("yes", args.yes))
+
+        ok, message = _execute_task(action, src, dest, overwrite, recursive, assume_yes)
+        status = "OK" if ok else "FAIL"
+        print(f"[{idx}/{len(tasks)}] {status} {action}: {message}")
+        if ok:
+            success_count += 1
+
+    print(f"\nTask summary: {success_count}/{len(tasks)} succeeded")
+    return 0 if success_count == len(tasks) else 1
+
+
+def run_update_command(args) -> int:
+    """Check and/or install updates using updater module."""
+    def _safe_print(text: str):
+        try:
+            print(text)
+        except UnicodeEncodeError:
+            print(text.encode("ascii", "replace").decode("ascii"))
+
+    try:
+        from astra.updater import UpdateManager, format_update_info
+    except Exception as e:
+        print(f"Update module unavailable: {e}")
+        return 1
+
+    manager = UpdateManager()
+
+    # Default behavior: check for updates if no install option chosen.
+    if args.auto or args.check or not any([args.npm, args.pip, args.github, args.auto]):
+        info = manager.check_for_updates(force=True)
+        _safe_print(format_update_info(info))
+
+        if not args.auto and not any([args.npm, args.pip, args.github]):
+            return 0
+
+        # Auto mode only proceeds when update exists
+        if args.auto and not info.get("update_available"):
+            return 0
+
+    source = None
+    if args.npm:
+        source = "npm"
+    elif args.pip:
+        source = "pip"
+    elif args.github:
+        source = "github"
+    elif args.auto:
+        # Prefer npm when available, fallback to pip.
+        source = "npm" if manager.get_version_info().get("npm_available") else "pip"
+
+    if not source:
+        return 0
+
+    result = manager.download_update(source=source)
+    if result.get("success"):
+        _safe_print(result.get("message", "Update completed"))
+        return 0
+
+    _safe_print(result.get("message", "Update failed"))
+    if result.get("error"):
+        _safe_print(result["error"])
+    return 1
+
+
+def main():
+    """Main entry point."""
+    parser = create_parser()
+    args = parser.parse_args()
+    
+    if args.command is None:
+        print_banner()
+        parser.print_help()
+        return
+    
+    if args.command in ("run", "start"):
+        print_banner()
+        
+        if args.interactive or not getattr(args, "goal", None):
+            config = build_config(args)
+            cli_interactive_session(config)
+        else:
+            config = build_config(args)
+            result = asyncio.run(run_agent(args.goal, config))
+            # Only show result if it's not empty and not a verbose success message
+            if result and not result.startswith("==="):
+                print(result)
+    
+    elif args.command == "tools":
+        show_tools(args.info if hasattr(args, 'info') else None)
+    
+    elif args.command == "config":
+        config = AgentConfig.from_env()
+        if args.show:
+            import json
+            print(json.dumps(config.to_dict(), indent=2, default=str))
+        elif args.save:
+            config.save(args.save)
+            print(f"Config saved to {args.save}")
+        elif args.load:
+            config = AgentConfig.load(args.load)
+            print(f"Config loaded from {args.load}")
+    
+    elif args.command == "memory":
+        from astra.core.memory import MemoryManager
+        memory = MemoryManager(persistence_path="./.astra_memory")
+        
+        if args.list:
+            if hasattr(memory, "get_recent"):
+                recent = memory.get_recent(10)
+            else:
+                recent = memory.get_recent_conversations(10)
+            if recent:
+                for item in recent:
+                    print(f"[{item.memory_type}] {item.content[:100]}...")
+            else:
+                print("No memories found")
+        elif args.search:
+            results = memory.search(query=args.search)
+            for item in results:
+                print(f"[{item.id}] {item.content[:100]}...")
+
+    elif args.command == "search":
+        exit_code = run_device_search(args)
+        if exit_code != 0:
+            sys.exit(exit_code)
+
+    elif args.command == "tasks":
+        exit_code = run_tasks_command(args)
+        if exit_code != 0:
+            sys.exit(exit_code)
+
+    elif args.command == "update":
+        exit_code = run_update_command(args)
+        if exit_code != 0:
+            sys.exit(exit_code)
+    
+    elif args.command == "chat":
+        # Interactive chat mode with multiple providers
+        from astra.chat import start_chat_mode
+        from astra.llm import PROVIDERS
+        
+        # Show available providers if requested
+        if args.list_providers:
+            print("\n📦 Available LLM Providers:\n")
+            for key, info in PROVIDERS.items():
+                free_tag = "💰 Free" if info.get("free") else "💳 Paid"
+                print(f"  • {key:12} - {info['name']:20} [{free_tag}]")
+            print("\nRun: python main.py chat")
+            return
+        
+        # Start interactive chat
+        asyncio.run(start_chat_mode())
+    
+    elif args.command == "settings":
+        # Settings management
+        from astra.chat import APIKeyManager
+        
+        if args.list_keys:
+            APIKeyManager.view_keys()
+        elif args.set_key:
+            print(f"\nSetting API key for: {args.set_key}")
+            api_key = input("Enter API key: ").strip()
+            if api_key:
+                APIKeyManager.set_key(args.set_key, api_key)
+        elif args.view_env:
+            env_file = Path(".env")
+            if env_file.exists():
+                print("\n📄 .env file contents:\n")
+                print(env_file.read_text())
+            else:
+                print("❌ .env file not found")
+        elif args.reset_all:
+            confirm = input("⚠️  Clear ALL API keys from .env? (y/N): ").strip().lower()
+            if confirm == 'y':
+                env_file = Path(".env")
+                if env_file.exists():
+                    env_file.unlink()
+                print("✅ All keys cleared")
+        else:
+            # Default: show keys
+            APIKeyManager.view_keys()
+    
+    elif args.command == "keys":
+        # API key management shortcut
+        from astra.chat import APIKeyManager
+        
+        if args.list or not any([args.set, args.get]):
+            APIKeyManager.view_keys()
+        elif args.set:
+            print(f"\nSetting API key for: {args.set}")
+            api_key = input("Enter API key: ").strip()
+            if api_key:
+                APIKeyManager.set_key(args.set, api_key)
+        elif args.get:
+            from astra.llm import PROVIDERS
+            if args.get not in PROVIDERS:
+                print(f"❌ Unknown provider: {args.get}")
+                return
+            keys = APIKeyManager.get_all_keys()
+            status = keys.get(args.get, "NOT SET")
+            print(f"\n{args.get}: {status}")
+    
+    elif args.command == "providers":
+        # Show provider information
+        from astra.llm import PROVIDERS
+        
+        if args.info:
+            provider = PROVIDERS.get(args.info)
+            if not provider:
+                print(f"❌ Unknown provider: {args.info}")
+                return
+            
+            print(f"\n📦 Provider: {provider['name']}")
+            print(f"   Key: {args.info}")
+            print(f"   Type: {'💰 Free' if provider.get('free') else '💳 Paid'}")
+            print(f"   Website: {provider.get('website', 'N/A')}")
+            print(f"\n   Models: {len(provider['models'])} available")
+            for model in provider['models'][:10]:
+                print(f"     • {model}")
+            if len(provider['models']) > 10:
+                print(f"     ... and {len(provider['models']) - 10} more")
+        else:
+            # List all providers
+            print("\n📦 Available LLM Providers:\n")
+            for key, info in PROVIDERS.items():
+                free_tag = "💰 Free" if info.get("free") else "💳 Paid"
+                print(f"  {key:12} - {info['name']:20} [{free_tag}]  ({len(info['models'])} models)")
+            print("\nRun: python main.py providers --info <provider>")
+    
+    elif args.command == "models":
+        # Show models for a provider
+        from astra.llm import PROVIDERS
+        
+        provider = PROVIDERS.get(args.provider)
+        if not provider:
+            print(f"❌ Unknown provider: {args.provider}")
+            return
+        
+        if args.info:
+            print(f"\n📦 Provider: {provider['name']}")
+            print(f"   Website: {provider.get('website', 'N/A')}")
+            print(f"   Type: {'💰 Free' if provider.get('free') else '💳 Paid'}")
+        
+        print(f"\n🤖 Available models for {provider['name']}:\n")
+        for i, model in enumerate(provider['models'], 1):
+            print(f"  {i:2}. {model}")
+        
+        print(f"\nTotal: {len(provider['models'])} models")
+    
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()