uacc 0.1.0__py3-none-any.whl

uacc/__init__.py

@@ -0,0 +1,8 @@
+"""
+UACC — Universal AI Computer Control
+Let any LLM control a computer with pixel-precise UI interactions.
+"""
+
+__version__ = "0.1.0"
+
+from uacc.config import config  # noqa: F401

uacc/actions/__init__.py

@@ -0,0 +1 @@
+"""UACC Actions — action schema, execution, and human mimicry."""

uacc/actions/artistic_painter.py

@@ -0,0 +1,390 @@
+"""
+Artistic Painter — turn UACC into an AI painter that can paint images or preset designs
+directly on screen in Microsoft Paint using precise drag-and-drop stroke trajectories.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+import time
+from typing import Any, Dict, List, Optional, Tuple
+
+from PIL import Image, ImageFilter, ImageOps
+import pyautogui
+
+from uacc.actions.schema import DragAction, MouseButton, ClickAction, HotkeyAction
+from uacc.actions.executor import ActionExecutor
+
+logger = logging.getLogger(__name__)
+
+
+class ArtisticPainter:
+    """Converts images or geometric presets into vector stroke paths and paints
+    them in Microsoft Paint using the UACC ActionExecutor."""
+
+    def __init__(self, executor: Optional[ActionExecutor] = None):
+        self.executor = executor or ActionExecutor(human_mimicry=False, action_delay_ms=5)
+
+    def draw_preset(self, preset_name: str, canvas_center: Tuple[int, int]) -> Dict[str, Any]:
+        """Paint a built-in masterpiece design by name.
+
+        Presets: "rose", "galaxy", "peacock", "mountains".
+        """
+        preset_name = preset_name.lower().strip()
+        cx, cy = canvas_center
+
+        logger.info("Painting preset art: '%s' around (%d, %d)", preset_name, cx, cy)
+
+        if preset_name == "rose":
+            strokes = self._generate_rose(cx, cy)
+        elif preset_name == "galaxy":
+            strokes = self._generate_galaxy(cx, cy)
+        elif preset_name == "mountains":
+            strokes = self._generate_mountains(cx, cy)
+        elif preset_name == "peacock":
+            return self._draw_peacock_direct(cx, cy)
+        else:
+            return {"success": False, "message": f"Unknown preset: '{preset_name}'"}
+
+        return self._execute_strokes(strokes)
+
+    def draw_image(
+        self,
+        image_path: str,
+        canvas_bounds: Tuple[int, int, int, int],  # (left, top, right, bottom)
+        max_strokes: int = 150,
+        edge_threshold: int = 100,
+    ) -> Dict[str, Any]:
+        """Load an image, extract its outline contours, and paint it on screen.
+
+        Args:
+            image_path: Path to the image file to paint.
+            canvas_bounds: Screen coordinates of Paint's drawing canvas (left, top, right, bottom).
+            max_strokes: Cap on number of strokes to avoid infinite execution.
+            edge_threshold: Threshold to detect edges (higher = fewer lines, faster).
+        """
+        try:
+            img = Image.open(image_path)
+        except Exception as exc:
+            return {"success": False, "message": f"Failed to load image: {exc}"}
+
+        # Step 1: Image Processing (Resize to fit canvas and extract edges)
+        canvas_w = canvas_bounds[2] - canvas_bounds[0]
+        canvas_h = canvas_bounds[3] - canvas_bounds[1]
+
+        # Preserve aspect ratio
+        img.thumbnail((canvas_w - 40, canvas_h - 40))
+        img_w, img_h = img.size
+
+        # Offset to center within the canvas
+        offset_x = canvas_bounds[0] + (canvas_w - img_w) // 2
+        offset_y = canvas_bounds[1] + (canvas_h - img_h) // 2
+
+        # Grayscale + find edges
+        gray = ImageOps.grayscale(img)
+        edges = gray.filter(ImageFilter.FIND_EDGES)
+        
+        # Binary thresholding
+        binary_edges = edges.point(lambda p: 255 if p > edge_threshold else 0)
+        width, height = binary_edges.size
+        pixels = binary_edges.load()
+
+        # Step 2: Path Tracing (Contiguous DFS tracking of edge pixels)
+        visited = set()
+        strokes = []
+
+        def get_neighbors(x, y):
+            neighbors = []
+            for dx in [-1, 0, 1]:
+                for dy in [-1, 0, 1]:
+                    if dx == 0 and dy == 0:
+                        continue
+                    nx, ny = x + dx, y + dy
+                    if 0 <= nx < width and 0 <= ny < height:
+                        neighbors.append((nx, ny))
+            return neighbors
+
+        # Traverse and find contiguous lines
+        for y in range(0, height, 2):  # Step 2 to downsample slightly
+            for x in range(0, width, 2):
+                if pixels[x, y] == 255 and (x, y) not in visited:
+                    # Start a new stroke path
+                    path = []
+                    curr_x, curr_y = x, y
+                    path.append((curr_x, curr_y))
+                    visited.add((curr_x, curr_y))
+
+                    # Follow the line
+                    while True:
+                        next_pixel = None
+                        for nx, ny in get_neighbors(curr_x, curr_y):
+                            if pixels[nx, ny] == 255 and (nx, ny) not in visited:
+                                next_pixel = (nx, ny)
+                                break
+                        if next_pixel:
+                            curr_x, curr_y = next_pixel
+                            path.append((curr_x, curr_y))
+                            visited.add((curr_x, curr_y))
+                            if len(path) > 30:  # Cap single path length to avoid huge vectors
+                                break
+                        else:
+                            break
+
+                    if len(path) > 3:  # Filter out short noise dots
+                        strokes.append(path)
+
+        # Cap the total strokes
+        strokes = strokes[:max_strokes]
+        logger.info("Generated %d outline paths from image", len(strokes))
+
+        # Step 3: Convert paths to DragActions (downsampled for 6x speed-up)
+        drag_actions = []
+        for path in strokes:
+            simplified_path = []
+            step = 6  # Take every 6th point along the path
+            for idx in range(0, len(path), step):
+                simplified_path.append(path[idx])
+            if path[-1] not in simplified_path:
+                simplified_path.append(path[-1])
+
+            for i in range(len(simplified_path) - 1):
+                x1, y1 = simplified_path[i]
+                x2, y2 = simplified_path[i + 1]
+                drag_actions.append(
+                    DragAction(
+                        start_x=int(x1 + offset_x),
+                        start_y=int(y1 + offset_y),
+                        end_x=int(x2 + offset_x),
+                        end_y=int(y2 + offset_y),
+                        button=MouseButton.LEFT,
+                        duration_ms=40,  # Fast drawing strokes
+                        reasoning="Tracing edge outline",
+                    )
+                )
+
+        return self._execute_strokes(drag_actions)
+
+    # ── Masterpiece Preset Generators ─────────────────────────
+
+    def _generate_rose(self, cx: int, cy: int) -> List[DragAction]:
+        """Generate a mathematical rose curve (Rhodonea curve)."""
+        actions = []
+        n, d = 5, 1  # 5-lobed rose
+        k = n / d
+        a = 150     # Radius/size
+        steps = 180
+
+        points = []
+        for i in range(steps + 1):
+            theta = (2 * math.pi * i) / steps
+            r = a * math.cos(k * theta)
+            x = cx + r * math.cos(theta)
+            y = cy + r * math.sin(theta)
+            points.append((int(x), int(y)))
+
+        for i in range(len(points) - 1):
+            actions.append(
+                DragAction(
+                    start_x=points[i][0],
+                    start_y=points[i][1],
+                    end_x=points[i+1][0],
+                    end_y=points[i+1][1],
+                    button=MouseButton.LEFT,
+                    duration_ms=50,
+                    reasoning="Drawing rose petal curve",
+                )
+            )
+        return actions
+
+    def _generate_galaxy(self, cx: int, cy: int) -> List[DragAction]:
+        """Generate a double spiral galaxy pattern."""
+        actions = []
+        arms = 2
+        rotations = 3.5
+        max_r = 180
+        steps = 150
+
+        # Arm 1 & Arm 2
+        for arm in range(arms):
+            points = []
+            angle_offset = arm * math.pi
+            for i in range(steps):
+                t = i / steps
+                r = t * max_r
+                theta = t * rotations * 2 * math.pi + angle_offset
+                x = cx + r * math.cos(theta)
+                y = cy + r * math.sin(theta)
+                points.append((int(x), int(y)))
+
+            for i in range(len(points) - 1):
+                actions.append(
+                    DragAction(
+                        start_x=points[i][0],
+                        start_y=points[i][1],
+                        end_x=points[i+1][0],
+                        end_y=points[i+1][1],
+                        button=MouseButton.LEFT,
+                        duration_ms=40,
+                        reasoning="Drawing galaxy arm spiral",
+                    )
+                )
+        return actions
+
+    def _generate_mountains(self, cx: int, cy: int) -> List[DragAction]:
+        """Generate a mountain range silhouette with a rising sun."""
+        actions = []
+        
+        # 1. Draw Sun (ellipse)
+        sun_r = 50
+        sun_cx = cx
+        sun_cy = cy - 60
+        sun_pts = []
+        for i in range(21):
+            theta = math.pi * i / 20  # Half circle top
+            x = sun_cx + sun_r * math.cos(theta)
+            y = sun_cy - sun_r * math.sin(theta)
+            sun_pts.append((int(x), int(y)))
+        
+        for i in range(len(sun_pts) - 1):
+            actions.append(
+                DragAction(
+                    start_x=sun_pts[i][0],
+                    start_y=sun_pts[i][1],
+                    end_x=sun_pts[i+1][0],
+                    end_y=sun_pts[i+1][1],
+                    button=MouseButton.LEFT,
+                    duration_ms=60,
+                    reasoning="Drawing sun",
+                )
+            )
+
+        # 2. Draw Mountain ridges
+        peaks = [
+            (cx - 200, cy + 80),
+            (cx - 100, cy - 20),
+            (cx, cy + 40),
+            (cx + 120, cy - 50),
+            (cx + 220, cy + 80)
+        ]
+        
+        for i in range(len(peaks) - 1):
+            actions.append(
+                DragAction(
+                    start_x=peaks[i][0],
+                    start_y=peaks[i][1],
+                    end_x=peaks[i+1][0],
+                    end_y=peaks[i+1][1],
+                    button=MouseButton.LEFT,
+                    duration_ms=100,
+                    reasoning="Drawing mountain ridge line",
+                )
+            )
+            
+        # Draw second background ridge
+        peaks2 = [
+            (cx - 150, cy + 80),
+            (cx - 40, cy + 10),
+            (cx + 60, cy - 10),
+            (cx + 170, cy + 80)
+        ]
+        for i in range(len(peaks2) - 1):
+            actions.append(
+                DragAction(
+                    start_x=peaks2[i][0],
+                    start_y=peaks2[i][1],
+                    end_x=peaks2[i+1][0],
+                    end_y=peaks2[i+1][1],
+                    button=MouseButton.LEFT,
+                    duration_ms=100,
+                    reasoning="Drawing background mountain ridge",
+                )
+            )
+
+        return actions
+
+    def _draw_peacock_direct(self, cx: int, cy: int) -> Dict[str, Any]:
+        """Robust direct drawing of the famous peacock preset."""
+        # Standard utility helpers
+        def curve_points(x0, y0, x1, y1, cx, cy, n=8):
+            pts = []
+            for i in range(n + 1):
+                t = i / n
+                x = (1 - t) ** 2 * x0 + 2 * (1 - t) * t * cx + t**2 * x1
+                y = (1 - t) ** 2 * y0 + 2 * (1 - t) * t * cy + t**2 * y1
+                pts.append((int(x), int(y)))
+            return pts
+
+        def connect_points(pts):
+            acts = []
+            for i in range(len(pts) - 1):
+                acts.append(
+                    DragAction(
+                        start_x=pts[i][0], start_y=pts[i][1],
+                        end_x=pts[i+1][0], end_y=pts[i+1][1],
+                        button=MouseButton.LEFT, duration_ms=100,
+                        reasoning="Peacock drawing path"
+                    )
+                )
+            return acts
+
+        def ellipse(ecx, ecy, rx, ry, steps=16):
+            pts = []
+            for i in range(steps + 1):
+                theta = 2 * math.pi * i / steps
+                pts.append((int(ecx + rx * math.cos(theta)), int(ecy + ry * math.sin(theta))))
+            return connect_points(pts)
+
+        all_actions = []
+        tail_origin_x, tail_origin_y = cx - 40, cy + 20
+
+        # Draw tail feathers
+        feather_angles = [(-45, 200), (-25, 170), (25, 170), (45, 200)]
+        for angle_deg, length in feather_angles:
+            angle = math.radians(angle_deg)
+            tx = tail_origin_x + length * math.cos(angle)
+            ty = tail_origin_y + length * math.sin(angle)
+
+            shaft = curve_points(
+                tail_origin_x, tail_origin_y, tx, ty,
+                tail_origin_x + 30 * math.cos(angle + 0.1),
+                tail_origin_y + 30 * math.sin(angle + 0.1),
+                n=8
+            )
+            all_actions.extend(connect_points(shaft))
+            all_actions.extend(ellipse(tx, ty, 15, 8, steps=12))
+
+        # Body
+        all_actions.extend(ellipse(cx + 10, cy + 20, 30, 50, steps=20))
+        # Neck
+        neck = curve_points(cx + 10, cy - 20, cx + 50, cy - 100, cx + 40, cy - 60, n=8)
+        all_actions.extend(connect_points(neck))
+        # Head
+        all_actions.extend(ellipse(cx + 50, cy - 100, 10, 12, steps=12))
+
+        return self._execute_strokes(all_actions)
+
+    def _execute_strokes(self, strokes: List[DragAction]) -> Dict[str, Any]:
+        """Execute a list of DragActions sequentially."""
+        total = len(strokes)
+        if total == 0:
+            return {"success": False, "message": "No paths or lines generated."}
+
+        logger.info("Executing %d drawing strokes...", total)
+        success_count = 0
+
+        # Hold mouse click down safety checks in pyautogui
+        for idx, action in enumerate(strokes, 1):
+            res = self.executor.execute(action)
+            if res.get("success"):
+                success_count += 1
+            # Add small pause so user can abort if necessary
+            time.sleep(0.01)
+
+        pct = (success_count / total) * 100
+        return {
+            "success": success_count > 0,
+            "message": f"Successfully completed {success_count}/{total} strokes ({pct:.1f}%)",
+            "total_strokes": total,
+            "success_strokes": success_count,
+        }

uacc/actions/executor.py

@@ -0,0 +1,292 @@
+"""
+Action Executor — translate typed Action objects into real mouse / keyboard events.
+
+Uses pyautogui for cross-platform input simulation, with optional
+human-like movement from the mimicry module.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Optional
+
+import pyautogui
+
+from uacc.actions.human_mimicry import move_mouse_human, type_human
+from uacc.actions.schema import (
+    Action,
+    ClickAction,
+    DoneAction,
+    DragAction,
+    HotkeyAction,
+    HoverAction,
+    ScrollAction,
+    ScreenshotAction,
+    TypeAction,
+    WaitAction,
+    is_potentially_destructive,
+    LaunchAction,
+    ClipboardAction,
+    FocusWindowAction,
+)
+from uacc.config import config
+
+logger = logging.getLogger(__name__)
+
+# Safety: disable pyautogui's fail-safe (move mouse to corner to abort)
+pyautogui.FAILSAFE = config.uacc.pyautogui_failsafe
+pyautogui.PAUSE = 0.05  # Small pause between pyautogui calls
+
+
+class ActionExecutor:
+    """Dispatches Action objects to real input events."""
+
+    def __init__(
+        self,
+        human_mimicry: Optional[bool] = None,
+        action_delay_ms: Optional[int] = None,
+        safe_mode: Optional[bool] = None,
+    ):
+        self.human_mimicry = (
+            human_mimicry if human_mimicry is not None else config.uacc.human_mimicry
+        )
+        self.action_delay_ms = (
+            action_delay_ms if action_delay_ms is not None else config.uacc.action_delay_ms
+        )
+        self.safe_mode = safe_mode if safe_mode is not None else config.uacc.safe_mode
+        self._last_action_time = 0.0
+
+    def execute(self, action: Action) -> dict:
+        """Execute a single action and return a result dict.
+
+        Returns:
+            {"success": bool, "message": str, "action": str}
+        """
+        # Safety check
+        if self.safe_mode and is_potentially_destructive(action):
+            logger.warning("Destructive action detected: %s", action)
+            return {
+                "success": False,
+                "message": "Action blocked by safe mode (potentially destructive)",
+                "action": getattr(action, "action", "unknown"),
+            }
+
+        # Inter-action delay
+        elapsed = (time.time() - self._last_action_time) * 1000
+        if elapsed < self.action_delay_ms:
+            time.sleep((self.action_delay_ms - elapsed) / 1000)
+
+        try:
+            result = self._dispatch(action)
+            self._last_action_time = time.time()
+            return result
+        except Exception as exc:
+            logger.error("Action execution failed: %s", exc)
+            return {
+                "success": False,
+                "message": f"Execution error: {exc}",
+                "action": getattr(action, "action", "unknown"),
+            }
+
+    def _dispatch(self, action: Action) -> dict:
+        """Route to the appropriate handler."""
+        if isinstance(action, ClickAction):
+            return self._click(action)
+        elif isinstance(action, DragAction):
+            return self._drag(action)
+        elif isinstance(action, TypeAction):
+            return self._type(action)
+        elif isinstance(action, HotkeyAction):
+            return self._hotkey(action)
+        elif isinstance(action, ScrollAction):
+            return self._scroll(action)
+        elif isinstance(action, HoverAction):
+            return self._hover(action)
+        elif isinstance(action, WaitAction):
+            return self._wait(action)
+        elif isinstance(action, ScreenshotAction):
+            return self._screenshot(action)
+        elif isinstance(action, DoneAction):
+            return self._done(action)
+        elif isinstance(action, LaunchAction):
+            return self._launch(action)
+        elif isinstance(action, ClipboardAction):
+            return self._clipboard(action)
+        elif isinstance(action, FocusWindowAction):
+            return self._focus_window(action)
+        else:
+            return {"success": False, "message": f"Unknown action: {action}", "action": "unknown"}
+
+    # ── Handlers ─────────────────────────────────────────────
+
+    def _click(self, action: ClickAction) -> dict:
+        """Execute a click action."""
+        # Move to position
+        if self.human_mimicry:
+            current = pyautogui.position()
+            move_mouse_human(current, (action.x, action.y))
+        else:
+            pyautogui.moveTo(action.x, action.y, duration=0.1)
+
+        # Apply modifiers
+        for mod in action.modifiers:
+            pyautogui.keyDown(mod)
+
+        # Click
+        button = action.button.value
+        if action.count == 2:
+            pyautogui.doubleClick(action.x, action.y, button=button)
+        else:
+            for _ in range(action.count):
+                pyautogui.click(action.x, action.y, button=button)
+
+        # Release modifiers
+        for mod in reversed(action.modifiers):
+            pyautogui.keyUp(mod)
+
+        logger.info(
+            "Click: (%d, %d) button=%s count=%d", action.x, action.y, button, action.count
+        )
+        return {
+            "success": True,
+            "message": f"Clicked at ({action.x}, {action.y})",
+            "action": "click",
+        }
+
+    def _drag(self, action: DragAction) -> dict:
+        """Execute a drag action with smooth movement."""
+        if self.human_mimicry:
+            current = pyautogui.position()
+            move_mouse_human(current, (action.start_x, action.start_y))
+
+        duration = action.duration_ms / 1000
+        pyautogui.moveTo(action.start_x, action.start_y, duration=0.1)
+        pyautogui.mouseDown(button=action.button.value)
+
+        if self.human_mimicry:
+            move_mouse_human(
+                (action.start_x, action.start_y),
+                (action.end_x, action.end_y),
+                duration_ms=action.duration_ms,
+            )
+        else:
+            pyautogui.moveTo(action.end_x, action.end_y, duration=duration)
+
+        pyautogui.mouseUp(button=action.button.value)
+
+        logger.info(
+            "Drag: (%d,%d) → (%d,%d)",
+            action.start_x, action.start_y, action.end_x, action.end_y,
+        )
+        return {
+            "success": True,
+            "message": f"Dragged ({action.start_x},{action.start_y}) → ({action.end_x},{action.end_y})",
+            "action": "drag",
+        }
+
+    def _type(self, action: TypeAction) -> dict:
+        """Type text."""
+        if self.human_mimicry and action.delay_ms == 0:
+            type_human(action.text)
+        elif action.delay_ms > 0:
+            pyautogui.typewrite(action.text, interval=action.delay_ms / 1000)
+        else:
+            # Use write() for fast typing — handles special characters
+            pyautogui.write(action.text)
+
+        logger.info("Typed: %s", action.text[:50])
+        return {
+            "success": True,
+            "message": f"Typed {len(action.text)} characters",
+            "action": "type",
+        }
+
+    def _hotkey(self, action: HotkeyAction) -> dict:
+        """Press a hotkey combination."""
+        pyautogui.hotkey(*action.keys)
+        combo = "+".join(action.keys)
+        logger.info("Hotkey: %s", combo)
+        return {"success": True, "message": f"Pressed {combo}", "action": "hotkey"}
+
+    def _scroll(self, action: ScrollAction) -> dict:
+        """Scroll at a position."""
+        pyautogui.moveTo(action.x, action.y, duration=0.05)
+        if action.direction.value in ("up", "down"):
+            clicks = action.amount if action.direction.value == "up" else -action.amount
+            pyautogui.scroll(clicks, action.x, action.y)
+        else:
+            clicks = action.amount if action.direction.value == "right" else -action.amount
+            pyautogui.hscroll(clicks, action.x, action.y)
+
+        logger.info("Scroll: %s ×%d at (%d,%d)", action.direction.value, action.amount, action.x, action.y)
+        return {
+            "success": True,
+            "message": f"Scrolled {action.direction.value} ×{action.amount}",
+            "action": "scroll",
+        }
+
+    def _hover(self, action: HoverAction) -> dict:
+        """Hover at a position."""
+        if self.human_mimicry:
+            current = pyautogui.position()
+            move_mouse_human(current, (action.x, action.y))
+        else:
+            pyautogui.moveTo(action.x, action.y, duration=0.15)
+
+        time.sleep(action.duration_ms / 1000)
+        logger.info("Hover: (%d,%d) for %dms", action.x, action.y, action.duration_ms)
+        return {
+            "success": True,
+            "message": f"Hovered at ({action.x}, {action.y}) for {action.duration_ms}ms",
+            "action": "hover",
+        }
+
+    def _wait(self, action: WaitAction) -> dict:
+        """Wait for a fixed duration."""
+        time.sleep(action.duration_ms / 1000)
+        logger.info("Waited: %dms", action.duration_ms)
+        return {
+            "success": True,
+            "message": f"Waited {action.duration_ms}ms",
+            "action": "wait",
+        }
+
+    def _screenshot(self, action: ScreenshotAction) -> dict:
+        """Signal that a screenshot should be taken (handled by controller)."""
+        logger.info("Screenshot requested")
+        return {
+            "success": True,
+            "message": "Screenshot requested — will be captured by controller",
+            "action": "screenshot",
+        }
+
+    def _done(self, action: DoneAction) -> dict:
+        """Signal task completion."""
+        logger.info("Task done: success=%s result=%s", action.success, action.result)
+        return {
+            "success": action.success,
+            "message": action.result or "Task completed",
+            "action": "done",
+        }
+
+    def _launch(self, action: LaunchAction) -> dict:
+        """Launch an application."""
+        from uacc.core.window_manager import launch_application
+        res = launch_application(action.name_or_path, action.arguments)
+        return {**res, "action": "launch"}
+
+    def _clipboard(self, action: ClipboardAction) -> dict:
+        """Read from or write to the clipboard."""
+        from uacc.core.clipboard import read_clipboard, write_clipboard
+        if action.mode == "write":
+            res = write_clipboard(action.text)
+        else:
+            res = read_clipboard()
+        return {**res, "action": "clipboard"}
+
+    def _focus_window(self, action: FocusWindowAction) -> dict:
+        """Focus a window."""
+        from uacc.core.window_manager import focus_window
+        res = focus_window(action.title)
+        return {**res, "action": "focus_window"}