astraagent 2.25.6 → 2.26.0

package/astra/cli.py

@@ -2,16 +2,16 @@
 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
+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
@@ -54,21 +54,21 @@ def create_parser() -> argparse.ArgumentParser:
                            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")
+    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")
@@ -116,37 +116,37 @@ def create_parser() -> argparse.ArgumentParser:
     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")
+    # 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)")
+    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")
@@ -196,21 +196,182 @@ def build_config(args) -> AgentConfig:
         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
+    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 show_interactive_help():
+    """Show help for interactive CLI mode."""
+    print("\n" + "="*50)
+    print("⌨️  ASTRA INTERACTIVE COMMANDS")
+    print("="*50)
+    print("""
+GENERAL COMMANDS:
+  help or /h      Show this help
+  settings or /s  Open interactive settings
+  status          Show current agent status
+  tools           List enabled tools
+  exit or q       Exit the agent
+
+SLASH COMMANDS (Direct execution):
+  /open <path>        Open file/app
+  /folder <path>      Open folder in explorer
+  /ls [path]          List directory contents
+  /delete <path>      Delete file
+  /mkdir <path>       Create folder
+  /info <path>        Get file/folder info
+
+Any other text will be handled by the AI agent.
+""")
+    print("="*50 + "\n")
+
+
+
+def handle_interactive_settings(agent, config):
+    """Handle interactive settings menu."""
+    from astra.chat import APIKeyManager
+    from astra.llm.providers import PROVIDERS
+    
+    while True:
+        print("\n[⚙️] AstraAgent Settings & Configuration")
+        print("-" * 60)
+        print(f"Current Provider:  {config.llm.provider}")
+        print(f"Current Model:     {config.llm.model}")
+        print("-" * 60)
+        
+        # List all providers and their status
+        print(f"{'  Provider':<20} {'Status':<15} {'API KEY'}")
+        all_keys = APIKeyManager.get_all_keys()
+        
+        for p_key, p_data in PROVIDERS.items():
+            is_current = "--> " if p_key == config.llm.provider else "    "
+            key_status = all_keys.get(p_key, "NOT SET")
+            status_icon = "✅ Ready" if key_status != "NOT SET" or p_data.get("free") else "❌ No Key"
+            
+            print(f"{is_current}{p_key:<16} {status_icon:<15} {key_status}")
+            
+        print("-" * 60)
+        print("Commands:")
+        print("  use <provider>        Switch provider (e.g., 'use openai', 'use gemini')")
+        print("  model <name>          Set model for current provider")
+        print("  key <provider> <key>  Set API key (e.g., 'key openai sk-...')")
+        print("  view-env              View .env file")
+        print("  back                  Return to main menu")
+        print("-" * 60)
+    
+        try:
+            cmd_input = input("Settings > ").strip()
+        except (EOFError, KeyboardInterrupt):
+            break
+            
+        if not cmd_input or cmd_input.lower() in ['back', 'exit', 'q']:
+            break
+
+        parts = cmd_input.split(' ')
+        cmd = parts[0].lower()
+        args = parts[1:]
+        
+        if cmd == 'use':
+            if not args:
+                print("❌ Usage: use <provider>")
+                continue
+            new_provider = args[0].lower()
+            if new_provider == 'google':
+                new_provider = 'gemini'
+                
+            if new_provider not in PROVIDERS:
+                print(f"❌ Unknown provider: {new_provider}")
+                continue
+            
+            config.llm.provider = new_provider
+            # Set default model for this provider if available
+            defaults = PROVIDERS[new_provider].get("models", [])
+            if defaults:
+                config.llm.model = defaults[0]
+            
+            if agent:
+                agent.config.llm.provider = new_provider
+                agent.config.llm.model = config.llm.model
+                
+                # Update API Key for the new provider
+                env_keys = PROVIDERS[new_provider].get("env_keys", [])
+                if env_keys:
+                    env_var = env_keys[0]
+                    new_key = os.getenv(env_var)
+                    if new_key:
+                        agent.config.llm.api_key = new_key
+                        config.llm.api_key = new_key
+                    else:
+                        print(f"⚠️  No API key found for {new_provider} (Expected {env_var})")
+                        agent.config.llm.api_key = ""
+                        config.llm.api_key = ""
+                
+                agent.llm = None # Force re-init with new config
+            
+            print(f"✅ Switched to {new_provider} (Model: {config.llm.model})")
+            continue
+
+        if cmd == 'key':
+            if len(args) < 2:
+                print("❌ Usage: key <provider> <your-api-key>")
+                continue
+            p_key = args[0].lower()
+            if p_key == 'google':
+                p_key = 'gemini'
+                
+            if p_key not in PROVIDERS:
+                print(f"❌ Unknown provider: {p_key}")
+                continue
+            
+            try:
+                if APIKeyManager.set_key(p_key, api_key):
+                    # If we just set the key for the current or new provider
+                    if p_key == config.llm.provider:
+                        config.llm.api_key = api_key
+                        if agent:
+                            agent.config.llm.api_key = api_key
+                            agent.llm = None
+                    print(f"✅ Key updated for {p_key}")
+            except Exception as e:
+                print(f"❌ Error setting key: {e}")
+            continue
+
+        if cmd == 'model':
+            if not args:
+                print("❌ Usage: model <model_name>")
+                continue
+            new_model = args[0]
+            config.llm.model = new_model
+            if agent:
+                agent.config.llm.model = new_model
+                agent.llm = None
+            print(f"✅ Model set to {new_model}")
+            continue
+            
+        if cmd == 'view-env':
+            env_file = os.path.join(os.getcwd(), ".env")
+            if os.path.exists(env_file):
+                print("\n📄 .env file contents:\n")
+                with open(env_file, 'r') as ef:
+                    print(ef.read())
+            else:
+                print("❌ .env file not found")
+            continue
+            
+        print("Unknown settings command. Type 'back' to exit settings.")
+
+
 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")
+    print("Type your goals/commands. Type 'exit' to quit. Type 'help' for more.\n")
     
     agent = AstraAgent(config)
     
@@ -227,18 +388,40 @@ def cli_interactive_session(config: AgentConfig):
             if not user_input:
                 continue
             
-            if user_input.lower() in ['exit', 'quit', 'q']:
+            # Handle shortcuts and commands
+            lowered = user_input.lower()
+            
+            if lowered in ['exit', 'quit', 'q']:
                 print("Goodbye!")
                 break
             
-            if user_input.lower() == 'status':
+            if lowered in ['help', 'h', '?', '/help']:
+                show_interactive_help()
+                continue
+                
+            if lowered in ['settings', 's', '/settings', '/s', 'config']:
+                handle_interactive_settings(agent, config)
+                continue
+            
+            if lowered == 'status':
                 try:
                     print(agent.state.get_summary())
                 except:
                     print("No status available")
                 continue
             
-            if user_input.lower() == 'tools':
+            if lowered in ['/engineer', 'engineer', 'dev', 'continuous']:
+                config.max_iterations = 1000
+                config.mode = ExecutionMode.AUTONOMOUS
+                config.prompt_mode = "engineer"
+                # Modifying agent's config in place:
+                agent.config.max_iterations = 1000
+                agent.config.prompt_mode = "engineer"
+                print("\n👷 Engineer Mode ACTIVATED (24/7 autonomous loop, max 1000 steps)")
+                print("Type your high-level goal (e.g., 'Refactor the entire backend').")
+                continue
+
+            if lowered == 'tools':
                 try:
                     tools = agent.tools.list_enabled()
                     print(f"Available tools: {', '.join(tools)}")
@@ -246,14 +429,102 @@ def cli_interactive_session(config: AgentConfig):
                     print("Could not list tools")
                 continue
             
-            print("\n[...] Working on your request...\n")
+            # Handle slash commands (direct filesystem/task operations)
+            if user_input.startswith('/'):
+                try:
+                    from astra.tasks import TaskExecutor, format_task_result
+                    parts = user_input[1:].split(' ', 1)
+                    cmd = parts[0].lower()
+                    arg = parts[1].strip() if len(parts) > 1 else ""
+                    
+                    if cmd == 'open':
+                        print(format_task_result(TaskExecutor.open_file(arg)))
+                        continue
+                    elif cmd == 'folder':
+                        print(format_task_result(TaskExecutor.open_folder(arg)))
+                        continue
+                    elif cmd in ['delete', 'rm']:
+                        if not arg:
+                            print("❌ Usage: /delete <path>")
+                        else:
+                            confirm = input(f"⚠️  Delete '{arg}'? (y/N): ").strip().lower()
+                            if confirm == 'y':
+                                print(format_task_result(TaskExecutor.delete_file(arg)))
+                        continue
+                    elif cmd == 'mkdir':
+                        print(format_task_result(TaskExecutor.create_folder(arg)))
+                        continue
+                    elif cmd in ['ls', 'dir', 'list']:
+                        print(format_task_result(TaskExecutor.list_directory(arg or ".")))
+                        continue
+                    elif cmd == 'info':
+                        print(format_task_result(TaskExecutor.get_file_info(arg)))
+                        continue
+                except Exception as e:
+                    print(f"❌ Error executing slash command: {e}")
+                    continue
+            
+            # Warn about missing API key for non-slash commands
+            if not config.llm.api_key:
+                print("\n⚠️  LOCAL_API_KEY is not set. Autonomous mode will fail.")
+                print("Type 'settings' to configure your API key or use slash commands (e.g., /open).\n")
+                continue
+                
+            # Enhanced Thinking Animation
+            from astra.chat import ThinkingIndicator
+            
+            # Run the agent with animation
             try:
-                result = aio.run(agent.run(user_input))
+                # We need to run the async generator or function in a loop
+                # Since agent.run returns a string summary, we wrap it
+                async def run_with_animation():
+                    async with ThinkingIndicator(f"Working on '{user_input[:20]}...'"):
+                        return await agent.run(user_input)
+
+                result = aio.run(run_with_animation())
+                
                 print(f"\n{result}\n")
+                
+                # Save session to user logs
+                from pathlib import Path
+                from datetime import datetime
+                import json
+                
+                log_dir = Path.home() / ".astra" / "logs" / "agent_sessions"
+                log_dir.mkdir(parents=True, exist_ok=True)
+                
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                log_file = log_dir / f"session_{timestamp}.json"
+                
+                session_data = {
+                    "goal": user_input,
+                    "result": result,
+                    "provider": config.llm.provider,
+                    "model": config.llm.model,
+                    "summary": agent.state.get_summary()
+                }
+                
+                with open(log_file, "w", encoding="utf-8") as f:
+                    json.dump(session_data, f, indent=2)
+
+            except KeyboardInterrupt:
+                print("\n🛑 Action stopped by user.")
+                # Reset state on manual stop
+                agent.state = agent.state.__class__()
+                agent.messages = []
+                continue
+                    
             except ValueError as e:
                 print(f"❌ Configuration Error: {e}\n")
+            except RuntimeError as e:
+                # Handle rate limits specifically if propagated
+                err_msg = str(e)
+                if "429" in err_msg or "rate limit" in err_msg.lower():
+                    print(f"\n⚠️  Rate limit hit. Please try again in a moment.\n")
+                else:
+                    print(f"\n❌ Runtime Error: {e}\n")
             except Exception as e:
-                print(f"❌ Error: {e}\n")
+                print(f"\n❌ Error: {e}\n")
             
             # Reset for next goal
             agent.state = agent.state.__class__()
@@ -301,7 +572,7 @@ async def run_agent(goal: str, config: AgentConfig) -> str:
         agent.shutdown()
 
 
-def show_tools(tool_name: Optional[str] = None):
+def show_tools(tool_name: Optional[str] = None):
     """Show available tools."""
     from astra.tools.base import create_default_registry
     
@@ -323,404 +594,404 @@ def show_tools(tool_name: Optional[str] = None):
             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():
+        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()
@@ -730,18 +1001,18 @@ def main():
         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)
+    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)
@@ -758,44 +1029,44 @@ def main():
             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
+    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: