droidrun 0.3.10.dev3__py3-none-any.whl → 0.3.10.dev5__py3-none-any.whl

droidrun/cli/main.py

@@ -8,15 +8,25 @@ import os
 import warnings
 from contextlib import nullcontext
 from functools import wraps
+from pathlib import Path
 
 import click
 from adbutils import adb
 from rich.console import Console
 
-from droidrun.agent.context.personas import BIG_AGENT, DEFAULT
 from droidrun.agent.droid import DroidAgent
 from droidrun.agent.utils.llm_picker import load_llm
 from droidrun.cli.logs import LogHandler
+from droidrun.config_manager.config_manager import (
+    AgentConfig,
+    CodeActConfig,
+    ManagerConfig,
+    ExecutorConfig,
+    DeviceConfig,
+    LoggingConfig,
+    ToolsConfig,
+    TracingConfig,
+)
 from droidrun.macro.cli import macro_cli
 from droidrun.portal import (
     PORTAL_PACKAGE_NAME,
@@ -28,8 +38,8 @@ from droidrun.portal import (
 )
 from droidrun.telemetry import print_telemetry_message
 from droidrun.tools import AdbTools, IOSTools
-from droidrun.config_manager import config
-from droidrun.config_manager.config_manager import VisionConfig
+from droidrun.config_manager import ConfigManager
+
 
 # Suppress all warnings
 warnings.filterwarnings("ignore")
@@ -39,11 +49,11 @@ os.environ["GRPC_ENABLE_FORK_SUPPORT"] = "false"
 console = Console()
 
 
-def configure_logging(goal: str, debug: bool):
+def configure_logging(goal: str, debug: bool, rich_text: bool = True):
     logger = logging.getLogger("droidrun")
     logger.handlers = []
 
-    handler = LogHandler(goal)
+    handler = LogHandler(goal, rich_text=rich_text)
     handler.setFormatter(
         logging.Formatter("%(levelname)s %(name)s %(message)s", "%H:%M:%S")
         if debug
@@ -74,20 +84,21 @@ def coro(f):
 @coro
 async def run_command(
     command: str,
-    device: str | None,
-    provider: str | None,
-    model: str | None,
-    steps: int | None,
-    base_url: str | None,
-    api_base: str | None,
-    vision: bool | None,
-    manager_vision: bool | None,
-    executor_vision: bool | None,
-    codeact_vision: bool | None,
-    reasoning: bool | None,
-    tracing: bool | None,
-    debug: bool | None,
-    use_tcp: bool | None,
+    config_path: str | None = None,
+    device: str | None = None,
+    provider: str | None = None,
+    model: str | None = None,
+    steps: int | None = None,
+    base_url: str | None = None,
+    api_base: str | None = None,
+    vision: bool | None = None,
+    manager_vision: bool | None = None,
+    executor_vision: bool | None = None,
+    codeact_vision: bool | None = None,
+    reasoning: bool | None = None,
+    tracing: bool | None = None,
+    debug: bool | None = None,
+    use_tcp: bool | None = None,
     save_trajectory: str | None = None,
     ios: bool = False,
     allow_drag: bool | None = None,
@@ -95,9 +106,11 @@ async def run_command(
     **kwargs,
 ):
     """Run a command on your Android device using natural language."""
+    # Load custom config if provided
+    config = ConfigManager(config_path)
     # Initialize logging first (use config default if debug not specified)
     debug_mode = debug if debug is not None else config.logging.debug
-    log_handler = configure_logging(command, debug_mode)
+    log_handler = configure_logging(command, debug_mode, config.logging.rich_text)
     logger = logging.getLogger("droidrun")
 
     log_handler.update_step("Initializing...")
@@ -108,115 +121,105 @@ async def run_command(
             print_telemetry_message()
 
             # ================================================================
-            # STEP 1: Load base configuration from config.yaml
+            # STEP 1: Build config objects with CLI overrides
             # ================================================================
-            
-            max_steps = config.agent.max_steps
-            reasoning_mode = config.agent.reasoning
-            vision_config = config.agent.vision
-            device_serial = config.device.serial
-            use_tcp_mode = config.device.use_tcp
-            debug_mode = config.logging.debug
-            save_traj = config.logging.save_trajectory
-            tracing_enabled = config.tracing.enabled
-            allow_drag_tool = config.tools.allow_drag
-            
-            # ================================================================
-            # STEP 2: Apply CLI overrides if explicitly specified
-            # ================================================================
-            
-            if steps is not None:
-                max_steps = steps
-                logger.debug(f"CLI override: max_steps={max_steps}")
-            
-            if reasoning is not None:
-                reasoning_mode = reasoning
-                logger.debug(f"CLI override: reasoning={reasoning_mode}")
-            
-            if debug is not None:
-                debug_mode = debug
-                logger.debug(f"CLI override: debug={debug_mode}")
-            
-            if tracing is not None:
-                tracing_enabled = tracing
-                logger.debug(f"CLI override: tracing={tracing_enabled}")
-            
-            if save_trajectory is not None:
-                save_traj = save_trajectory
-                logger.debug(f"CLI override: save_trajectory={save_traj}")
-            
-            if use_tcp is not None:
-                use_tcp_mode = use_tcp
-                logger.debug(f"CLI override: use_tcp={use_tcp_mode}")
-            
-            if device is not None:
-                device_serial = device
-                logger.debug(f"CLI override: device={device_serial}")
-            
-            if allow_drag is not None:
-                allow_drag_tool = allow_drag
-                logger.debug(f"CLI override: allow_drag={allow_drag_tool}")
-            
-            # Override vision settings
+
+            # Build agent-specific configs with vision overrides
             if vision is not None:
-                # User specified --vision, apply to all agents
-                vision_config = VisionConfig(manager=vision, executor=vision, codeact=vision)
+                # --vision flag overrides all agents
+                manager_vision_val = vision
+                executor_vision_val = vision
+                codeact_vision_val = vision
                 logger.debug(f"CLI override: vision={vision} (all agents)")
             else:
-                # Check for per-agent vision overrides
-                vision_config = VisionConfig(
-                    manager=vision_config.manager,
-                    executor=vision_config.executor,
-                    codeact=vision_config.codeact
-                )
-                if manager_vision is not None:
-                    vision_config.manager = manager_vision
-                    logger.debug(f"CLI override: manager_vision={manager_vision}")
-                
-                if executor_vision is not None:
-                    vision_config.executor = executor_vision
-                    logger.debug(f"CLI override: executor_vision={executor_vision}")
-                
-                if codeact_vision is not None:
-                    vision_config.codeact = codeact_vision
-                    logger.debug(f"CLI override: codeact_vision={codeact_vision}")
-            
+                # Use individual overrides or config defaults
+                manager_vision_val = manager_vision if manager_vision is not None else config.agent.manager.vision
+                executor_vision_val = executor_vision if executor_vision is not None else config.agent.executor.vision
+                codeact_vision_val = codeact_vision if codeact_vision is not None else config.agent.codeact.vision
+
+            manager_cfg = ManagerConfig(
+                vision=manager_vision_val,
+                system_prompt=config.agent.manager.system_prompt
+            )
+
+            executor_cfg = ExecutorConfig(
+                vision=executor_vision_val,
+                system_prompt=config.agent.executor.system_prompt
+            )
+
+            codeact_cfg = CodeActConfig(
+                vision=codeact_vision_val,
+                system_prompt=config.agent.codeact.system_prompt,
+                user_prompt=config.agent.codeact.user_prompt
+            )
+
+            agent_cfg = AgentConfig(
+                max_steps=steps if steps is not None else config.agent.max_steps,
+                reasoning=reasoning if reasoning is not None else config.agent.reasoning,
+                after_sleep_action=config.agent.after_sleep_action,
+                wait_for_stable_ui=config.agent.wait_for_stable_ui,
+                prompts_dir=config.agent.prompts_dir,
+                manager=manager_cfg,
+                executor=executor_cfg,
+                codeact=codeact_cfg,
+                app_cards=config.agent.app_cards,
+            )
+
+            device_cfg = DeviceConfig(
+                serial=device if device is not None else config.device.serial,
+                use_tcp=use_tcp if use_tcp is not None else config.device.use_tcp,
+            )
+
+            tools_cfg = ToolsConfig(
+                allow_drag=allow_drag if allow_drag is not None else config.tools.allow_drag,
+            )
+
+            logging_cfg = LoggingConfig(
+                debug=debug if debug is not None else config.logging.debug,
+                save_trajectory=save_trajectory if save_trajectory is not None else config.logging.save_trajectory,
+                rich_text=config.logging.rich_text,
+            )
+
+            tracing_cfg = TracingConfig(
+                enabled=tracing if tracing is not None else config.tracing.enabled,
+            )
+
             # ================================================================
             # STEP 3: Load LLMs
             # ================================================================
-            
+
             log_handler.update_step("Loading LLMs...")
-            
+
             # Check if user wants custom LLM for all agents
             if provider is not None or model is not None:
                 # User specified custom provider/model - use for all agents
                 logger.info("🔧 Using custom LLM for all agents")
-                
+
                 # Use provided values or fall back to first profile's defaults
                 if provider is None:
                     provider = list(config.llm_profiles.values())[0].provider
                 if model is None:
                     model = list(config.llm_profiles.values())[0].model
-                
+
                 # Build kwargs
                 llm_kwargs = {}
                 if temperature is not None:
                     llm_kwargs['temperature'] = temperature
                 else:
-                    llm_kwargs['temperature'] = kwargs.get('temperature', 1)
+                    llm_kwargs['temperature'] = kwargs.get('temperature', 0.3)
                 if base_url is not None:
                     llm_kwargs['base_url'] = base_url
                 if api_base is not None:
                     llm_kwargs['api_base'] = api_base
                 llm_kwargs.update(kwargs)
-                
+
                 # Load single LLM for all agents
                 custom_llm = load_llm(
                     provider_name=provider,
                     model=model,
                     **llm_kwargs
                 )
-                
+
                 # Use same LLM for all agents
                 llms = {
                     'manager': custom_llm,
@@ -229,87 +232,82 @@ async def run_command(
             else:
                 # No custom provider/model - use profiles from config
                 logger.info("📋 Loading LLMs from config profiles...")
-                
+
                 profile_names = ['manager', 'executor', 'codeact', 'text_manipulator', 'app_opener']
-                
+
                 # Apply temperature override to all profiles if specified
                 overrides = {}
                 if temperature is not None:
                     overrides = {name: {'temperature': temperature} for name in profile_names}
-                
+
                 llms = config.load_all_llms(profile_names=profile_names, **overrides)
                 logger.info(f"🧠 Loaded {len(llms)} agent-specific LLMs from profiles")
-            
+
             # ================================================================
             # STEP 4: Setup device and tools
             # ================================================================
-            
+
             log_handler.update_step("Setting up tools...")
-            
+
+            device_serial = device_cfg.serial
             if device_serial is None and not ios:
                 logger.info("🔍 Finding connected device...")
                 devices = adb.list()
                 if not devices:
                     raise ValueError("No connected devices found.")
                 device_serial = devices[0].serial
+                device_cfg = DeviceConfig(serial=device_serial, use_tcp=device_cfg.use_tcp)
                 logger.info(f"📱 Using device: {device_serial}")
             elif device_serial is None and ios:
-                raise ValueError(
-                    "iOS device not specified. Please specify device base url via --device"
-                )
+                raise ValueError("iOS device not specified. Please specify device base url via --device")
             else:
                 logger.info(f"📱 Using device: {device_serial}")
-            
+
             tools = (
                 AdbTools(
                     serial=device_serial,
-                    use_tcp=use_tcp_mode,
+                    use_tcp=device_cfg.use_tcp,
                     app_opener_llm=llms.get('app_opener'),
                     text_manipulator_llm=llms.get('text_manipulator')
                 )
                 if not ios
                 else IOSTools(url=device_serial)
             )
-            
-            # Set excluded tools based on config/CLI
-            excluded_tools = [] if allow_drag_tool else ["drag"]
-            
-            # Select personas based on drag flag
-            personas = [BIG_AGENT] if allow_drag_tool else [DEFAULT]
-            
+
+            excluded_tools = [] if tools_cfg.allow_drag else ["drag"]
+
             # ================================================================
             # STEP 5: Initialize DroidAgent with all settings
             # ================================================================
-            
+
             log_handler.update_step("Initializing DroidAgent...")
-            
-            mode = "planning with reasoning" if reasoning_mode else "direct execution"
+
+            mode = "planning with reasoning" if agent_cfg.reasoning else "direct execution"
             logger.info(f"🤖 Agent mode: {mode}")
-            logger.info(f"👁️  Vision settings: Manager={vision_config.manager}, "
-                       f"Executor={vision_config.executor}, CodeAct={vision_config.codeact}")
-            
-            if tracing_enabled:
+            logger.info(f"👁️  Vision settings: Manager={agent_cfg.manager.vision}, "
+                       f"Executor={agent_cfg.executor.vision}, CodeAct={agent_cfg.codeact.vision}")
+
+            if tracing_cfg.enabled:
                 logger.info("🔍 Tracing enabled")
-            
+
             droid_agent = DroidAgent(
                 goal=command,
                 llms=llms,
-                vision=vision_config,
                 tools=tools,
-                personas=personas,
+                config=config,
+                agent_config=agent_cfg,
+                device_config=device_cfg,
+                tools_config=tools_cfg,
+                logging_config=logging_cfg,
+                tracing_config=tracing_cfg,
                 excluded_tools=excluded_tools,
-                max_steps=max_steps,
                 timeout=1000,
-                reasoning=reasoning_mode,
-                enable_tracing=tracing_enabled,
-                debug=debug_mode,
-                save_trajectories=save_traj,
             )
-            
+
             # ================================================================
             # STEP 6: Run agent
             # ================================================================
-            
+
             logger.info("▶️  Starting agent execution...")
             logger.info("Press Ctrl+C to stop")
             log_handler.update_step("Running agent...")
@@ -332,24 +330,23 @@ async def run_command(
                 log_handler.is_success = False
                 log_handler.current_step = f"Error: {e}"
                 logger.error(f"💥 Error: {e}")
-                if debug_mode:
+                if logging_cfg.debug:
                     import traceback
-
                     logger.debug(traceback.format_exc())
 
         except Exception as e:
             log_handler.current_step = f"Error: {e}"
             logger.error(f"💥 Setup error: {e}")
+            debug_mode = debug if debug is not None else config.logging.debug
             if debug_mode:
                 import traceback
-
                 logger.debug(traceback.format_exc())
 
 
 class DroidRunCLI(click.Group):
     def parse_args(self, ctx, args):
         # If the first arg is not an option and not a known command, treat as 'run'
-        if args and """not args[0].startswith("-")""" and args[0] not in self.commands:
+        if args and """not args[0].startswith("-")""" and args[0] not in self.commands: # TODO: the string always evaluates to True
             args.insert(0, "run")
 
         return super().parse_args(ctx, args)
@@ -431,6 +428,7 @@ def cli(
 
 @cli.command()
 @click.argument("command", type=str)
+@click.option("--config", "-c", help="Path to custom config file", default=None)
 @click.option("--device", "-d", help="Device serial number or IP address", default=None)
 @click.option(
     "--provider",
@@ -512,6 +510,7 @@ def cli(
 @click.option("--ios", type=bool, default=None, help="Run on iOS device")
 def run(
     command: str,
+    config: str | None,
     device: str | None,
     provider: str | None,
     model: str | None,
@@ -532,9 +531,11 @@ def run(
     ios: bool | None,
 ):
     """Run a command on your Android device using natural language."""
+
     # Call our standalone function
     return run_command(
         command,
+        config,
         device,
         provider,
         model,
@@ -612,6 +613,23 @@ def disconnect(serial: str):
 )
 def setup(path: str | None, device: str | None, debug: bool):
     """Install and enable the DroidRun Portal on a device."""
+    from droidrun.config_manager.path_resolver import PathResolver
+
+    # Ensure config.yaml exists (check working dir, then project dir)
+    try:
+        config_path = PathResolver.resolve("config.yaml")
+        console.print(f"[blue]Using existing config: {config_path}[/]")
+    except FileNotFoundError:
+        # Config not found, try to create from example
+        try:
+            example_path = PathResolver.resolve("config_example.yaml")
+            config_path = PathResolver.resolve("config.yaml", create_if_missing=True)
+
+            import shutil
+            shutil.copy2(example_path, config_path)
+            console.print(f"[blue]Created config.yaml from example at: {config_path}[/]")
+        except FileNotFoundError:
+            console.print("[yellow]Warning: config_example.yaml not found, config.yaml not created[/]")
     try:
         if not device:
             devices = adb.list()
@@ -757,5 +775,5 @@ if __name__ == "__main__":
     save_trajectory = "none"
     allow_drag = False
     run_command(
-        command=command
+        command
     )

droidrun/config_manager/__init__.py

@@ -1,25 +1,27 @@
+from droidrun.config_manager.app_card_loader import AppCardLoader
 from droidrun.config_manager.config_manager import (
+    AgentConfig,
+    AppCardConfig,
     ConfigManager,
-    config,
+    DeviceConfig,
     DroidRunConfig,
     LLMProfile,
-    AgentConfig,
-    DeviceConfig,
-    TelemetryConfig,
-    TracingConfig,
     LoggingConfig,
+    TelemetryConfig,
     ToolsConfig,
+    TracingConfig,
 )
 
 __all__ = [
     "ConfigManager",
-    "config",
     "DroidRunConfig",
     "LLMProfile",
     "AgentConfig",
+    "AppCardConfig",
     "DeviceConfig",
     "TelemetryConfig",
     "TracingConfig",
     "LoggingConfig",
     "ToolsConfig",
-]
+    "AppCardLoader",
+]

droidrun/config_manager/app_card_loader.py

@@ -0,0 +1,148 @@
+"""
+App card loading utility for package-specific prompts.
+
+Supports flexible file path resolution and caches loaded content.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Optional
+
+from droidrun.config_manager.path_resolver import PathResolver
+
+
+class AppCardLoader:
+    """Load app cards based on package names with content caching."""
+
+    _mapping_cache: Optional[Dict[str, str]] = None
+    _cache_dir: Optional[str] = None
+    _content_cache: Dict[str, str] = {}
+
+    @staticmethod
+    def load_app_card(
+        package_name: str, app_cards_dir: str = "config/app_cards"
+    ) -> str:
+        """
+        Load app card for a package name.
+
+        Path resolution:
+        - Checks working directory first (for user overrides)
+        - Falls back to project directory (for default cards)
+        - Supports absolute paths (used as-is)
+
+        File loading from app_cards.json:
+        1. Relative to app_cards_dir (most common):
+           {"com.google.gm": "gmail.md"}
+           → {app_cards_dir}/gmail.md
+
+        2. Relative path (checks working dir, then project dir):
+           {"com.google.gm": "config/custom_cards/gmail.md"}
+
+        3. Absolute path:
+           {"com.google.gm": "/usr/share/droidrun/cards/gmail.md"}
+
+        Args:
+            package_name: Android package name (e.g., "com.google.android.gm")
+            app_cards_dir: Directory path (relative or absolute)
+
+        Returns:
+            App card content or empty string if not found
+        """
+        if not package_name:
+            return ""
+
+        # Check content cache first (key: package_name:app_cards_dir)
+        cache_key = f"{package_name}:{app_cards_dir}"
+        if cache_key in AppCardLoader._content_cache:
+            return AppCardLoader._content_cache[cache_key]
+
+        # Load mapping (with cache)
+        mapping = AppCardLoader._load_mapping(app_cards_dir)
+
+        # Get file path from mapping
+        if package_name not in mapping:
+            # Cache the empty result to avoid repeated lookups
+            AppCardLoader._content_cache[cache_key] = ""
+            return ""
+
+        file_path_str = mapping[package_name]
+        file_path = Path(file_path_str)
+
+        # Determine resolution strategy
+        if file_path.is_absolute():
+            # Absolute path: use as-is
+            app_card_path = file_path
+        elif file_path_str.startswith(("config/", "prompts/", "docs/")):
+            # Project-relative path: resolve with unified resolver
+            app_card_path = PathResolver.resolve(file_path_str)
+        else:
+            # App_cards-relative: resolve dir first, then append filename
+            cards_dir_resolved = PathResolver.resolve(app_cards_dir)
+            app_card_path = cards_dir_resolved / file_path_str
+
+        # Read file
+        try:
+            if not app_card_path.exists():
+                # Cache the empty result
+                AppCardLoader._content_cache[cache_key] = ""
+                return ""
+
+            content = app_card_path.read_text(encoding="utf-8")
+            # Cache the content
+            AppCardLoader._content_cache[cache_key] = content
+            return content
+        except Exception:
+            # Cache the empty result on error
+            AppCardLoader._content_cache[cache_key] = ""
+            return ""
+
+    @staticmethod
+    def _load_mapping(app_cards_dir: str) -> Dict[str, str]:
+        """Load and cache the app_cards.json mapping."""
+        # Cache invalidation: if dir changed, reload
+        if (
+            AppCardLoader._mapping_cache is not None
+            and AppCardLoader._cache_dir == app_cards_dir
+        ):
+            return AppCardLoader._mapping_cache
+
+        # Resolve app cards directory
+        cards_dir_resolved = PathResolver.resolve(app_cards_dir)
+        mapping_path = cards_dir_resolved / "app_cards.json"
+
+        try:
+            if not mapping_path.exists():
+                AppCardLoader._mapping_cache = {}
+                AppCardLoader._cache_dir = app_cards_dir
+                return {}
+
+            with open(mapping_path, "r", encoding="utf-8") as f:
+                mapping = json.load(f)
+
+            AppCardLoader._mapping_cache = mapping
+            AppCardLoader._cache_dir = app_cards_dir
+            return mapping
+        except Exception:
+            AppCardLoader._mapping_cache = {}
+            AppCardLoader._cache_dir = app_cards_dir
+            return {}
+
+    @staticmethod
+    def clear_cache() -> None:
+        """Clear all caches (useful for testing or runtime reloading)."""
+        AppCardLoader._mapping_cache = None
+        AppCardLoader._cache_dir = None
+        AppCardLoader._content_cache.clear()
+
+    @staticmethod
+    def get_cache_stats() -> Dict[str, int]:
+        """
+        Get cache statistics.
+
+        Returns:
+            Dict with cache stats (useful for debugging)
+        """
+        return {
+            "mapping_cached": 1 if AppCardLoader._mapping_cache is not None else 0,
+            "content_entries": len(AppCardLoader._content_cache),
+        }