@leejungkiin/awkit 1.7.0 → 1.7.4

package/skills/ios-simulator-skill/scripts/simulator_selector.py

@@ -0,0 +1,375 @@
+#!/usr/bin/env python3
+"""
+Intelligent Simulator Selector
+
+Suggests the best available iOS simulators based on:
+- Recently used (from config)
+- Latest iOS version
+- Common models for testing
+- Boot status
+
+Usage Examples:
+    # Get suggestions for user selection
+    python scripts/simulator_selector.py --suggest
+
+    # List all available simulators
+    python scripts/simulator_selector.py --list
+
+    # Boot a specific simulator
+    python scripts/simulator_selector.py --boot "67A99DF0-27BD-4507-A3DE-B7D8C38F764A"
+
+    # Get suggestions as JSON for programmatic use
+    python scripts/simulator_selector.py --suggest --json
+"""
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+# Try to import config from build_and_test if available
+try:
+    from xcode.config import Config
+except ImportError:
+    Config = None
+
+
+class SimulatorInfo:
+    """Information about an iOS simulator."""
+
+    def __init__(
+        self,
+        name: str,
+        udid: str,
+        ios_version: str,
+        status: str,
+    ):
+        """Initialize simulator info."""
+        self.name = name
+        self.udid = udid
+        self.ios_version = ios_version
+        self.status = status
+        self.reasons: list[str] = []
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "device": self.name,
+            "udid": self.udid,
+            "ios": self.ios_version,
+            "status": self.status,
+            "reasons": self.reasons,
+        }
+
+
+class SimulatorSelector:
+    """Intelligent simulator selection."""
+
+    # Common iPhone models ranked by testing priority
+    COMMON_MODELS = [
+        "iPhone 16 Pro",
+        "iPhone 16",
+        "iPhone 15 Pro",
+        "iPhone 15",
+        "iPhone SE (3rd generation)",
+    ]
+
+    def __init__(self):
+        """Initialize selector."""
+        self.simulators: list[SimulatorInfo] = []
+        self.config: dict | None = None
+        self.last_used_simulator: str | None = None
+
+        # Load config if available
+        if Config:
+            try:
+                config = Config.load()
+                self.last_used_simulator = config.get_preferred_simulator()
+            except Exception:
+                pass
+
+    def list_simulators(self) -> list[SimulatorInfo]:
+        """
+        List all available simulators.
+
+        Returns:
+            List of SimulatorInfo objects
+        """
+        try:
+            result = subprocess.run(
+                ["xcrun", "simctl", "list", "devices", "--json"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            data = json.loads(result.stdout)
+            simulators = []
+
+            # Parse devices by iOS version
+            for runtime, devices in data.get("devices", {}).items():
+                # Extract iOS version from runtime (e.g., "com.apple.CoreSimulator.SimRuntime.iOS-18-0")
+                ios_version_match = re.search(r"iOS-(\d+-\d+)", runtime)
+                if not ios_version_match:
+                    continue
+
+                ios_version = ios_version_match.group(1).replace("-", ".")
+
+                for device in devices:
+                    name = device.get("name", "")
+                    udid = device.get("udid", "")
+                    is_available = device.get("isAvailable", False)
+
+                    if not is_available or "iPhone" not in name:
+                        continue
+
+                    status = device.get("state", "").capitalize()
+                    sim_info = SimulatorInfo(name, udid, ios_version, status)
+                    simulators.append(sim_info)
+
+            self.simulators = simulators
+            return simulators
+
+        except subprocess.CalledProcessError as e:
+            print(f"Error listing simulators: {e.stderr}", file=sys.stderr)
+            return []
+        except json.JSONDecodeError as e:
+            print(f"Error parsing simulator list: {e}", file=sys.stderr)
+            return []
+
+    def get_suggestions(self, count: int = 4) -> list[SimulatorInfo]:
+        """
+        Get top N suggested simulators.
+
+        Ranking factors:
+        1. Recently used (from config)
+        2. Latest iOS version
+        3. Common models
+        4. Boot status (Booted preferred)
+
+        Args:
+            count: Number of suggestions to return
+
+        Returns:
+            List of suggested SimulatorInfo objects
+        """
+        if not self.simulators:
+            return []
+
+        # Score each simulator
+        scored = []
+        for sim in self.simulators:
+            score = self._score_simulator(sim)
+            scored.append((score, sim))
+
+        # Sort by score (descending)
+        scored.sort(key=lambda x: x[0], reverse=True)
+
+        # Return top N
+        suggestions = [sim for _, sim in scored[:count]]
+
+        # Add reasons to each suggestion
+        for i, sim in enumerate(suggestions, 1):
+            if i == 1:
+                sim.reasons.append("Recommended")
+
+            # Check if recently used
+            if self.last_used_simulator and self.last_used_simulator == sim.name:
+                sim.reasons.append("Recently used")
+
+            # Check if latest iOS
+            latest_ios = max(s.ios_version for s in self.simulators)
+            if sim.ios_version == latest_ios:
+                sim.reasons.append("Latest iOS")
+
+            # Check if common model
+            for j, model in enumerate(self.COMMON_MODELS):
+                if model in sim.name:
+                    sim.reasons.append(f"#{j+1} common model")
+                    break
+
+            # Check if booted
+            if sim.status == "Booted":
+                sim.reasons.append("Currently running")
+
+        return suggestions
+
+    def _score_simulator(self, sim: SimulatorInfo) -> float:
+        """
+        Score a simulator for ranking.
+
+        Higher score = better recommendation.
+
+        Args:
+            sim: Simulator to score
+
+        Returns:
+            Score value
+        """
+        score = 0.0
+
+        # Recently used gets highest priority (100 points)
+        if self.last_used_simulator and self.last_used_simulator == sim.name:
+            score += 100
+
+        # Latest iOS version (50 points)
+        latest_ios = max(s.ios_version for s in self.simulators)
+        if sim.ios_version == latest_ios:
+            score += 50
+
+        # Common models (30-20 points based on ranking)
+        for i, model in enumerate(self.COMMON_MODELS):
+            if model in sim.name:
+                score += 30 - (i * 2)  # Higher ranking models get more points
+                break
+
+        # Currently booted (10 points)
+        if sim.status == "Booted":
+            score += 10
+
+        # iOS version number (minor factor for breaking ties)
+        ios_numeric = float(sim.ios_version.replace(".", ""))
+        score += ios_numeric * 0.1
+
+        return score
+
+    def boot_simulator(self, udid: str) -> bool:
+        """
+        Boot a simulator.
+
+        Args:
+            udid: Simulator UDID
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            subprocess.run(
+                ["xcrun", "simctl", "boot", udid],
+                capture_output=True,
+                check=True,
+            )
+            return True
+        except subprocess.CalledProcessError as e:
+            print(f"Error booting simulator: {e.stderr}", file=sys.stderr)
+            return False
+
+
+def format_suggestions(suggestions: list[SimulatorInfo], json_format: bool = False) -> str:
+    """
+    Format suggestions for output.
+
+    Args:
+        suggestions: List of suggestions
+        json_format: If True, output as JSON
+
+    Returns:
+        Formatted string
+    """
+    if json_format:
+        data = {"suggestions": [s.to_dict() for s in suggestions]}
+        return json.dumps(data, indent=2)
+
+    if not suggestions:
+        return "No simulators available"
+
+    lines = ["Available Simulators:\n"]
+    for i, sim in enumerate(suggestions, 1):
+        lines.append(f"{i}. {sim.name} (iOS {sim.ios_version})")
+        if sim.reasons:
+            lines.append(f"   {', '.join(sim.reasons)}")
+        lines.append(f"   UDID: {sim.udid}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Intelligent iOS simulator selector",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Get suggestions for user selection
+  python scripts/simulator_selector.py --suggest
+
+  # List all available simulators
+  python scripts/simulator_selector.py --list
+
+  # Boot a specific simulator
+  python scripts/simulator_selector.py --boot <UDID>
+
+  # Get suggestions as JSON
+  python scripts/simulator_selector.py --suggest --json
+        """,
+    )
+
+    parser.add_argument(
+        "--suggest",
+        action="store_true",
+        help="Get top simulator suggestions",
+    )
+    parser.add_argument(
+        "--list",
+        action="store_true",
+        help="List all available simulators",
+    )
+    parser.add_argument(
+        "--boot",
+        metavar="UDID",
+        help="Boot specific simulator by UDID",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output as JSON",
+    )
+    parser.add_argument(
+        "--count",
+        type=int,
+        default=4,
+        help="Number of suggestions (default: 4)",
+    )
+
+    args = parser.parse_args()
+
+    selector = SimulatorSelector()
+
+    if args.boot:
+        # Boot specific simulator
+        success = selector.boot_simulator(args.boot)
+        if success:
+            print(f"Booted simulator: {args.boot}")
+            return 0
+        return 1
+
+    if args.list:
+        # List all simulators
+        simulators = selector.list_simulators()
+        output = format_suggestions(simulators, args.json)
+        print(output)
+        return 0
+
+    if args.suggest:
+        # Get suggestions
+        selector.list_simulators()
+        suggestions = selector.get_suggestions(args.count)
+        output = format_suggestions(suggestions, args.json)
+        print(output)
+        return 0
+
+    # Default: show suggestions
+    selector.list_simulators()
+    suggestions = selector.get_suggestions(args.count)
+    output = format_suggestions(suggestions, args.json)
+    print(output)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/ios-simulator-skill/scripts/status_bar.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""
+iOS Status Bar Controller
+
+Override simulator status bar for clean screenshots and testing.
+Control time, network, wifi, battery display.
+
+Usage: python scripts/status_bar.py --preset clean
+"""
+
+import argparse
+import subprocess
+import sys
+
+from common import resolve_udid
+
+
+class StatusBarController:
+    """Controls iOS simulator status bar appearance."""
+
+    # Preset configurations
+    PRESETS = {
+        "clean": {
+            "time": "9:41",
+            "data_network": "5g",
+            "wifi_mode": "active",
+            "battery_state": "charged",
+            "battery_level": 100,
+        },
+        "testing": {
+            "time": "11:11",
+            "data_network": "4g",
+            "wifi_mode": "active",
+            "battery_state": "discharging",
+            "battery_level": 50,
+        },
+        "low_battery": {
+            "time": "9:41",
+            "data_network": "5g",
+            "wifi_mode": "active",
+            "battery_state": "discharging",
+            "battery_level": 20,
+        },
+        "airplane": {
+            "time": "9:41",
+            "data_network": "none",
+            "wifi_mode": "failed",
+            "battery_state": "charged",
+            "battery_level": 100,
+        },
+    }
+
+    def __init__(self, udid: str | None = None):
+        """Initialize status bar controller.
+
+        Args:
+            udid: Optional device UDID (auto-detects booted simulator if None)
+        """
+        self.udid = udid
+
+    def override(
+        self,
+        time: str | None = None,
+        data_network: str | None = None,
+        wifi_mode: str | None = None,
+        battery_state: str | None = None,
+        battery_level: int | None = None,
+    ) -> bool:
+        """
+        Override status bar appearance.
+
+        Args:
+            time: Time in HH:MM format (e.g., "9:41")
+            data_network: Network type (none, 1x, 3g, 4g, 5g, lte, lte-a)
+            wifi_mode: WiFi state (active, searching, failed)
+            battery_state: Battery state (charging, charged, discharging)
+            battery_level: Battery percentage (0-100)
+
+        Returns:
+            Success status
+        """
+        cmd = ["xcrun", "simctl", "status_bar"]
+
+        if self.udid:
+            cmd.append(self.udid)
+        else:
+            cmd.append("booted")
+
+        cmd.append("override")
+
+        # Add parameters if provided
+        if time:
+            cmd.extend(["--time", time])
+        if data_network:
+            cmd.extend(["--dataNetwork", data_network])
+        if wifi_mode:
+            cmd.extend(["--wifiMode", wifi_mode])
+        if battery_state:
+            cmd.extend(["--batteryState", battery_state])
+        if battery_level is not None:
+            cmd.extend(["--batteryLevel", str(battery_level)])
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def clear(self) -> bool:
+        """
+        Clear status bar override and restore defaults.
+
+        Returns:
+            Success status
+        """
+        cmd = ["xcrun", "simctl", "status_bar"]
+
+        if self.udid:
+            cmd.append(self.udid)
+        else:
+            cmd.append("booted")
+
+        cmd.append("clear")
+
+        try:
+            subprocess.run(cmd, capture_output=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Override iOS simulator status bar for screenshots and testing"
+    )
+
+    # Preset option
+    parser.add_argument(
+        "--preset",
+        choices=list(StatusBarController.PRESETS.keys()),
+        help="Use preset configuration (clean, testing, low-battery, airplane)",
+    )
+
+    # Custom options
+    parser.add_argument(
+        "--time",
+        help="Override time (HH:MM format, e.g., '9:41')",
+    )
+    parser.add_argument(
+        "--data-network",
+        choices=["none", "1x", "3g", "4g", "5g", "lte", "lte-a"],
+        help="Data network type",
+    )
+    parser.add_argument(
+        "--wifi-mode",
+        choices=["active", "searching", "failed"],
+        help="WiFi state",
+    )
+    parser.add_argument(
+        "--battery-state",
+        choices=["charging", "charged", "discharging"],
+        help="Battery state",
+    )
+    parser.add_argument(
+        "--battery-level",
+        type=int,
+        help="Battery level 0-100",
+    )
+
+    # Other options
+    parser.add_argument(
+        "--clear",
+        action="store_true",
+        help="Clear status bar override and restore defaults",
+    )
+    parser.add_argument(
+        "--udid",
+        help="Device UDID (auto-detects booted simulator if not provided)",
+    )
+
+    args = parser.parse_args()
+
+    # Resolve UDID with auto-detection
+    try:
+        udid = resolve_udid(args.udid)
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    controller = StatusBarController(udid=udid)
+
+    # Clear mode
+    if args.clear:
+        if controller.clear():
+            print("Status bar override cleared - defaults restored")
+        else:
+            print("Failed to clear status bar override")
+            sys.exit(1)
+
+    # Preset mode
+    elif args.preset:
+        preset = StatusBarController.PRESETS[args.preset]
+        if controller.override(**preset):
+            print(f"Status bar: {args.preset} preset applied")
+            print(
+                f"  Time: {preset['time']}, "
+                f"Network: {preset['data_network']}, "
+                f"Battery: {preset['battery_level']}%"
+            )
+        else:
+            print(f"Failed to apply {args.preset} preset")
+            sys.exit(1)
+
+    # Custom mode
+    elif any(
+        [
+            args.time,
+            args.data_network,
+            args.wifi_mode,
+            args.battery_state,
+            args.battery_level is not None,
+        ]
+    ):
+        if controller.override(
+            time=args.time,
+            data_network=args.data_network,
+            wifi_mode=args.wifi_mode,
+            battery_state=args.battery_state,
+            battery_level=args.battery_level,
+        ):
+            output = "Status bar override applied:"
+            if args.time:
+                output += f" Time={args.time}"
+            if args.data_network:
+                output += f" Network={args.data_network}"
+            if args.battery_level is not None:
+                output += f" Battery={args.battery_level}%"
+            print(output)
+        else:
+            print("Failed to override status bar")
+            sys.exit(1)
+
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()