pascal-agent 0.3.0__py3-none-any.whl

pascal/uia.py

@@ -0,0 +1,316 @@
+"""Windows UI Automation adapter -- access native app controls via Accessibility API.
+
+Uses pywinauto with UIA backend. Falls back gracefully on non-Windows platforms.
+Ref system: each snapshot assigns short IDs (e1, e2, ...) to controls so the LLM
+can refer to them in subsequent actions without needing coordinates.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class UIElement:
+    """Lightweight representation of a UIA control for LLM consumption."""
+    ref: str
+    control_type: str
+    name: str
+    value: str
+    is_enabled: bool
+    is_focused: bool
+
+    def to_text(self, indent: int = 0) -> str:
+        prefix = "  " * indent
+        parts = [f"{prefix}[{self.ref}] {self.control_type}"]
+        if self.name:
+            parts.append(f"'{self.name}'")
+        if self.value:
+            display_val = self.value[:100] + ("..." if len(self.value) > 100 else "")
+            parts.append(f'value="{display_val}"')
+        flags = []
+        if self.is_focused:
+            flags.append("focused")
+        if not self.is_enabled:
+            flags.append("disabled")
+        if flags:
+            parts.append(f"[{', '.join(flags)}]")
+        return " ".join(parts)
+
+
+_INTERACTIVE_TYPES = frozenset({
+    "Button", "Edit", "MenuItem", "ListItem", "ComboBox",
+    "CheckBox", "RadioButton", "Hyperlink", "Slider", "Spinner",
+    "Tab", "TabItem", "TreeItem", "DataItem",
+})
+
+
+class UIAutomationAdapter:
+    """Windows UI Automation API wrapper using pywinauto.
+
+    Public methods (7): snapshot, find, click, type_text, get_text, focus_window, wait_for.
+    """
+
+    def __init__(self) -> None:
+        self._ref_map: dict[str, Any] = {}
+        self._ref_counter: int = 0
+        self._desktop = None
+
+    def _get_desktop(self):
+        if self._desktop is None:
+            from pywinauto import Desktop
+            self._desktop = Desktop(backend="uia")
+        return self._desktop
+
+    # -- Exploration -----------------------------------------------
+
+    def snapshot(
+        self,
+        window_title: str | None = None,
+        *,
+        max_depth: int = 3,
+        interactive_only: bool = False,
+    ) -> list[UIElement]:
+        """Take an accessibility tree snapshot of a window."""
+        self.clear_refs()
+        win = self._find_window(window_title=window_title)
+        if win is None:
+            return []
+        elements: list[UIElement] = []
+        self._walk(win, elements, depth=0, max_depth=max_depth,
+                   interactive_only=interactive_only)
+        return elements
+
+    def find(
+        self,
+        *,
+        name: str | None = None,
+        control_type: str | None = None,
+        window_title: str | None = None,
+    ) -> list[UIElement]:
+        """Search for controls matching criteria (AND combination)."""
+        win = self._find_window(window_title=window_title)
+        if win is None:
+            if window_title:
+                return []
+            desktop = self._get_desktop()
+            results: list[UIElement] = []
+            for w in desktop.windows():
+                try:
+                    if not w.is_visible():
+                        continue
+                    results.extend(self._search_window(w, name=name, control_type=control_type))
+                except Exception:
+                    continue
+            return results
+        return self._search_window(win, name=name, control_type=control_type)
+
+    # -- Actions ---------------------------------------------------
+
+    def click(self, ref: str) -> dict:
+        """Click a control by ref ID."""
+        wrapper = self._resolve_ref(ref)
+        try:
+            wrapper.click_input()
+            return {"ok": True, "action": "click", "ref": ref}
+        except Exception as e:
+            return {"ok": False, "error": str(e), "ref": ref}
+
+    def type_text(self, ref: str, text: str, *, clear_first: bool = False) -> dict:
+        """Type text into an Edit control."""
+        wrapper = self._resolve_ref(ref)
+        try:
+            if clear_first:
+                wrapper.set_edit_text("")
+            wrapper.type_keys(text, with_spaces=True, pause=0.02)
+            return {"ok": True, "action": "type_text", "ref": ref, "chars": len(text)}
+        except Exception as e:
+            return {"ok": False, "error": str(e), "ref": ref}
+
+    def get_text(self, ref: str) -> str:
+        """Get the current text value of a control."""
+        wrapper = self._resolve_ref(ref)
+        try:
+            for method in ("window_text", "get_value", "texts"):
+                try:
+                    fn = getattr(wrapper, method, None)
+                    if fn is None:
+                        continue
+                    result = fn()
+                    if isinstance(result, list):
+                        return "\n".join(str(t) for t in result if t)
+                    if result:
+                        return str(result)
+                except Exception:
+                    continue
+            return ""
+        except Exception:
+            return ""
+
+    # -- Window management -----------------------------------------
+
+    def focus_window(self, window_title: str | None = None) -> dict:
+        """Bring a window to the foreground."""
+        win = self._find_window(window_title=window_title)
+        if win is None:
+            return {"ok": False, "error": f"Window not found: {window_title}"}
+        try:
+            win.set_focus()
+            return {"ok": True, "action": "focus_window", "title": win.window_text()}
+        except Exception as e:
+            return {"ok": False, "error": str(e)}
+
+    def wait_for(
+        self,
+        *,
+        name: str | None = None,
+        control_type: str | None = None,
+        window_title: str | None = None,
+        timeout: float = 10.0,
+    ) -> UIElement | None:
+        """Wait for a control to appear. For dialog popup handling."""
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            results = self.find(name=name, control_type=control_type, window_title=window_title)
+            if results:
+                return results[0]
+            time.sleep(0.3)
+        return None
+
+    # -- Internal --------------------------------------------------
+
+    def _assign_ref(self, wrapper) -> str:
+        self._ref_counter += 1
+        ref = f"e{self._ref_counter}"
+        self._ref_map[ref] = wrapper
+        return ref
+
+    def _resolve_ref(self, ref: str):
+        if ref not in self._ref_map:
+            raise KeyError(f"Unknown ref: {ref}. Run snapshot first.")
+        wrapper = self._ref_map[ref]
+        try:
+            wrapper.is_enabled()
+        except Exception:
+            raise KeyError(f"Stale ref: {ref}. Run snapshot again.")
+        return wrapper
+
+    def clear_refs(self) -> None:
+        self._ref_map.clear()
+        self._ref_counter = 0
+
+    def _find_window(self, window_title: str | None = None):
+        desktop = self._get_desktop()
+        if window_title:
+            title_lower = window_title.lower()
+            for win in desktop.windows():
+                try:
+                    wt = win.window_text() or ""
+                    if title_lower in wt.lower():
+                        return win
+                except Exception:
+                    continue
+            return None
+        # No filter: return the foreground window
+        import ctypes
+        fg_hwnd = ctypes.windll.user32.GetForegroundWindow()
+        if fg_hwnd:
+            for win in desktop.windows():
+                try:
+                    if win.handle == fg_hwnd:
+                        return win
+                except Exception:
+                    continue
+        return None
+
+    def _walk(self, wrapper, elements: list[UIElement], depth: int, max_depth: int, interactive_only: bool) -> None:
+        if depth > max_depth:
+            return
+        try:
+            ctrl_type = wrapper.element_info.control_type or "Unknown"
+            if interactive_only and ctrl_type not in _INTERACTIVE_TYPES and depth > 0:
+                for child in wrapper.children():
+                    self._walk(child, elements, depth + 1, max_depth, interactive_only)
+                return
+
+            name = ""
+            try:
+                name = wrapper.window_text() or ""
+            except Exception:
+                pass
+
+            value = ""
+            try:
+                if ctrl_type in ("Edit", "ComboBox", "Spinner"):
+                    for method in ("get_value", "window_text"):
+                        fn = getattr(wrapper, method, None)
+                        if fn:
+                            v = fn()
+                            if v:
+                                value = str(v)
+                                break
+            except Exception:
+                pass
+
+            ref = self._assign_ref(wrapper)
+            elements.append(UIElement(
+                ref=ref, control_type=ctrl_type, name=name, value=value,
+                is_enabled=wrapper.is_enabled() if hasattr(wrapper, "is_enabled") else True,
+                is_focused=wrapper.has_focus() if hasattr(wrapper, "has_focus") else False,
+            ))
+
+            for child in wrapper.children():
+                self._walk(child, elements, depth + 1, max_depth, interactive_only)
+        except Exception as e:
+            logger.debug("UIA walk error at depth %d: %s", depth, e)
+
+    def _search_window(self, win, *, name: str | None = None, control_type: str | None = None) -> list[UIElement]:
+        results: list[UIElement] = []
+        criteria: dict[str, Any] = {}
+        if control_type:
+            criteria["control_type"] = control_type
+        if name:
+            import re
+            criteria["title_re"] = f".*{re.escape(name)}.*"
+        try:
+            found = win.descendants(**criteria) if criteria else win.descendants()
+            for ctrl in found[:50]:
+                try:
+                    ct = ctrl.element_info.control_type or "Unknown"
+                    cn = ""
+                    try:
+                        cn = ctrl.window_text() or ""
+                    except Exception:
+                        pass
+                    value = ""
+                    try:
+                        if ct in ("Edit", "ComboBox"):
+                            v = ctrl.get_value() if hasattr(ctrl, "get_value") else ""
+                            value = str(v) if v else ""
+                    except Exception:
+                        pass
+                    ref = self._assign_ref(ctrl)
+                    results.append(UIElement(
+                        ref=ref, control_type=ct, name=cn, value=value,
+                        is_enabled=ctrl.is_enabled(), is_focused=False,
+                    ))
+                except Exception:
+                    continue
+        except Exception as e:
+            logger.debug("UIA search error: %s", e)
+        return results
+
+
+def render_snapshot(elements: list[UIElement], window_title: str = "") -> str:
+    lines = []
+    if window_title:
+        lines.append(f'Window: "{window_title}"')
+        lines.append("─" * 40)
+    for elem in elements:
+        lines.append(elem.to_text())
+    return "\n".join(lines)

pascal_agent-0.3.0.dist-info/METADATA

@@ -0,0 +1,262 @@
+Metadata-Version: 2.4
+Name: pascal-agent
+Version: 0.3.0
+Summary: Pascal — autonomous AI employee runtime with 4-layer safety
+Project-URL: Homepage, https://gitlab.com/laum0621/pascal
+Project-URL: Repository, https://gitlab.com/laum0621/pascal
+Project-URL: Issues, https://gitlab.com/laum0621/pascal/-/issues
+Author: laum0621
+License: MIT
+Keywords: agent,ai,autonomous,employee,llm,tool-use
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: openai>=1.0
+Provides-Extra: all
+Requires-Dist: aiogram>=3.0; extra == 'all'
+Requires-Dist: anthropic>=0.30; extra == 'all'
+Requires-Dist: mcp; extra == 'all'
+Requires-Dist: pillow; extra == 'all'
+Requires-Dist: pyautogui; extra == 'all'
+Requires-Dist: pyperclip; extra == 'all'
+Requires-Dist: pytest; extra == 'all'
+Requires-Dist: pytest-asyncio; extra == 'all'
+Requires-Dist: pywinauto>=0.6.8; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.30; extra == 'anthropic'
+Provides-Extra: browser
+Requires-Dist: playwright; extra == 'browser'
+Provides-Extra: clipboard
+Requires-Dist: pyperclip; extra == 'clipboard'
+Provides-Extra: desktop
+Requires-Dist: pillow; extra == 'desktop'
+Requires-Dist: pyautogui; extra == 'desktop'
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp; extra == 'mcp'
+Provides-Extra: ocr
+Requires-Dist: pytesseract; extra == 'ocr'
+Provides-Extra: telegram
+Requires-Dist: aiogram>=3.0; extra == 'telegram'
+Provides-Extra: uia
+Requires-Dist: pywinauto>=0.6.8; extra == 'uia'
+Description-Content-Type: text/markdown
+
+# Pascal — Autonomous AI Employee
+
+An autonomous AI agent that works like a real employee: receives tasks, plans, executes, and reports back.
+
+## Getting Started
+
+### Install
+
+```bash
+pip install pascal-agent
+```
+
+Or with all optional features:
+```bash
+pip install "pascal-agent[all]"
+```
+
+### Run
+
+```bash
+pascal
+```
+
+That's it. On first run, Pascal auto-detects your LLM provider or walks you through setup.
+
+### Manual setup (optional)
+
+```bash
+# Interactive setup
+pascal setup
+
+# Or set individually
+pascal config set provider openai
+pascal config set model gpt-5.4-mini
+pascal config
+```
+
+**Provider setup:**
+
+| Provider | Auth | How |
+|----------|------|-----|
+| OpenAI | API key | `export OPENAI_API_KEY=sk-...` |
+| Anthropic | API key | `export ANTHROPIC_API_KEY=sk-ant-...` |
+| Codex | ChatGPT Pro OAuth | `codex auth login` (free with Pro subscription) |
+
+## Usage
+
+```bash
+# Interactive mode (default)
+pascal
+> Summarize the files in this directory
+> Read README.md and explain the architecture
+> exit
+
+# One-shot task
+pascal "Write a Python script that downloads weather data"
+
+# Set a mission (persistent context)
+pascal --mission "You are a data analyst for the marketing team"
+
+# Check current state
+pascal --status
+
+# Always-on daemon with Telegram
+pascal --daemon
+
+# Resume a paused task
+pascal --resume task_abc123
+```
+
+## Configuration
+
+### Config file (`~/.pascal/pascal.toml`)
+
+```toml
+[pascal]
+model = "gpt-5.4-mini"
+provider = "openai"           # openai | anthropic | codex
+db_path = "~/.pascal/state.db"
+max_effect = "E2"             # E0=read E1=analyze E2=write E3=push E4=merge E5=delete
+max_tool_rounds = 10          # max tool calls per LLM turn
+```
+
+### CLI config commands
+
+```bash
+pascal config                          # Show all settings
+pascal config set model gpt-5.4-mini   # Set a value
+pascal config get provider             # Get a value
+```
+
+### Environment variables (override config file)
+
+```bash
+PASCAL_MODEL=gpt-5.4-mini
+PASCAL_PROVIDER=openai
+PASCAL_MAX_EFFECT=E2
+```
+
+API keys can be set as environment variables or saved to `~/.pascal/.env` (auto-loaded).
+
+### Optional integrations
+
+**Telegram bot** (`~/.pascal/telegram.json`):
+```json
+{"bot_token": "123:ABC...", "owner_chat_id": 12345}
+```
+
+**MCP tool servers** (`~/.pascal/mcp.json`):
+```json
+[{"name": "chrome", "command": "npx", "args": ["chrome-devtools-mcp@latest"]}]
+```
+
+**Custom skills** (`~/.pascal/skills/my-skill.md`):
+```yaml
+---
+name: my-skill
+description: What this skill does
+---
+Instructions for Pascal when this skill is activated...
+```
+
+## How It Works
+
+```
+pascal "Do something"
+    |
+    v
++---------------------------+
+|  Desk compiles state      |  SQLite -> text prompt
+|  LLM decides next action  |  22 action types via function calling
+|  Execute through safety   |  Effect Ladder + Trust Scanner + Sandbox
+|  Record to audit ledger   |  Hash-chained, append-only
+|  Repeat                   |
++---------------------------+
+    |
+    v
+Task complete / wait / escalate
+```
+
+**22 actions**: think, execute, plan, delegate, pick_task, create_task, create_subtask, complete_task, fail_task, pause_task, block_task, handle_notification, dismiss_notification, add_todo, complete_todo, memorize, add_rule, remove_rule, set_context, wait, escalate
+
+**3 LLM providers**: OpenAI, Anthropic Claude, Codex (ChatGPT Pro)
+
+**4-layer safety**: Effect Ladder (E0-E5) | Trust Scanner | Sandbox (Docker/Restricted) | TrustMap + Audit Ledger
+
+## Daemon Mode
+
+Always-on operation with Telegram integration:
+
+```bash
+# Setup Telegram first
+echo '{"bot_token": "YOUR_TOKEN", "owner_chat_id": YOUR_ID}' > ~/.pascal/telegram.json
+
+# Start daemon
+pascal --daemon
+```
+
+Features:
+- Telegram DM for tasks and approvals
+- Adaptive heartbeat (5min active, 30min idle)
+- Auto-restart on crash
+- STOP/PAUSE control (`~/.pascal/STOP` or `~/.pascal/PAUSE` file)
+
+## Development
+
+```bash
+git clone https://gitlab.com/laum0621/pascal.git
+cd pascal
+pip install -e ".[dev]"
+
+# Tests (245 pass)
+pytest
+
+# Lint (0 errors)
+ruff check src/ tests/
+
+# Type check (0 errors)
+mypy src/pascal/
+```
+
+## Project Structure
+
+```
+src/pascal/
+  loop.py ........... Core tool-use loop (LoopRunner)
+  actions.py ........ 22 action handlers (ActionContext)
+  state.py .......... SQLite persistence (9 tables, FTS5)
+  desk.py ........... State -> LLM prompt compiler
+  tools.py .......... Built-in tools (file, desktop, UIA, clipboard)
+  effect.py ......... Effect Ladder (E0-E5, hard regex rules)
+  trust.py .......... Input scanner (injection, credentials, destructive)
+  capability.py ..... Domain trust map (asymmetric learning)
+  sandbox.py ........ Docker + Restricted sandbox
+  receipts.py ....... Hash-chained audit ledger
+  scheduler.py ...... Cron tick + self-evolution
+  daemon.py ......... Always-on mode (Telegram + loop + scheduler)
+  config.py ......... Config loader (CLI > env > TOML > defaults)
+  schemas.py ........ Tool JSON schemas for LLM function calling
+  prompt.py ......... System prompt
+  types.py .......... Shared DTOs
+  llm/ .............. OpenAI, Anthropic, Codex providers
+  channels/ ......... Telegram adapter
+  uia.py ............ Windows UI Automation
+```
+
+## License
+
+MIT

pascal_agent-0.3.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+pascal/__init__.py,sha256=qoVW956gL56Q-xB9SincPJv7E-SJbFLOWCJZOD1P6xI,99
+pascal/__main__.py,sha256=_MvAcOD5REu2hGesPP1f-RozuJ0ZFUncO-d5ZIWfOd8,31261
+pascal/actions.py,sha256=KWaP24ibmu_gJrnEoYU7yiZ8zr_gWXifkNHyVuLApmk,45575
+pascal/capability.py,sha256=2K0sqrKwX0TB8BYC-jGZSfffaWhOEfvyunQOJOLAkAI,6976
+pascal/clipboard.py,sha256=8X_uzQv51crOgzaWUzbDi86YSK3Q4HC34oW6EaztIa8,1055
+pascal/config.py,sha256=UpaMpxuBvfugeyYrpOXfCJ2Vl_BFEJh9EWDvn_XwoN4,4555
+pascal/daemon.py,sha256=OsTLb2tFX72M6JM5gN8mwnjPFGNAgyFJVSgOTsL4Ids,8245
+pascal/desk.py,sha256=phQgVRlEaLMyKzftdzLGlySL8F7UrnHRu7dm73iX0w0,28530
+pascal/effect.py,sha256=1hRDksjfFGpYkaWpKGOC4VDNXYky-wPPsEZhlTYC00Q,6827
+pascal/loop.py,sha256=mZaWsCTro3QRwBTpp3zwDxq_V1PJyEWuQvEywWW8puQ,42991
+pascal/mcp.py,sha256=e9v0HhJdS5hK0fN1eUlQ0mM4V0AI8463QMiBsBNomT8,7726
+pascal/prompt.py,sha256=X-pAaXqZ-qRqy0unt0BjUNF3be1zR701-_Nenb5o_H4,8204
+pascal/receipts.py,sha256=7Ctuszf59jY6pYXhvzht9ymPdCbsk9R_pe7TOiBLvoc,5386
+pascal/sandbox.py,sha256=wF5HtUj84Lw87n6jYJ6Me53f4HhGdzPwfOkiajRW8jc,11593
+pascal/scheduler.py,sha256=soVTVWuRt0-0ogAh9Fkv-vwYUmDesZYcnsgzfCR7HYM,9372
+pascal/schemas.py,sha256=GuSFNeMNK31YJA-sdPU37Ipp1uzfJCuV79IU3AINVz0,6895
+pascal/state.py,sha256=9fi5dXZX0dXfmw4JvpwPaAhTKzhHC8VzON3Qcbjc5fQ,33988
+pascal/tools.py,sha256=iOSSNyI0AvyZ5WFqdMpa79DOij2YKK9UFkl82OhFZYE,25937
+pascal/trust.py,sha256=AXbIO1b2w-LLImf7AIcAdtULbfMxNKcOFJDbba3cMIA,6566
+pascal/types.py,sha256=RA5k_oX07WdvNr4fEHMF5TALW5X0GvlpScoADOU_bVk,11253
+pascal/uia.py,sha256=JIrjhPO94xMW1PdxAi-Qve6nBT7qMWNyfu5p8foz7WQ,11317
+pascal/channels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pascal/channels/telegram.py,sha256=YVKqcmfXpwbOKQGLd805ZetDL2N9AsyRdUPKjhSBH10,4176
+pascal/eval/__init__.py,sha256=BE0F0R1Uu2ISh4aBs28nvdlGOhir1jaXBut1N2A4zRM,38
+pascal/eval/smoke.py,sha256=A10fFDU3SeIJllO4CfSMROSZ0xpbyEEVDORLuTvi6ck,8163
+pascal/llm/__init__.py,sha256=aYJ4l4q9lT-Zp2sRcw023vt3kGXt8Wl4dQWq9kR74iA,30
+pascal/llm/anthropic.py,sha256=EZxQ6ebs0x9TQ5s2vTGOAGXHFeGc8zM9kUeDMan8xBo,8129
+pascal/llm/codex.py,sha256=zwAmjqhyLL6Iiz8Rn3OSo3i37yrkhBYP1Dc_LJqzJHg,13473
+pascal/llm/openai.py,sha256=hmMCqq6m0YyBm8A6oKGBJQR1S5kZgYtqJS6kbXOzAHg,8038
+pascal_agent-0.3.0.dist-info/METADATA,sha256=0yYpiWrTUeeKKIS6VZOKZG_p5g5aGLoR5D7jwo2W4ec,7188
+pascal_agent-0.3.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pascal_agent-0.3.0.dist-info/entry_points.txt,sha256=EfiOsglBJQ51v56-BCFIQ7LB0JKpuDCS3sRIjLm0zX8,48
+pascal_agent-0.3.0.dist-info/RECORD,,

pascal_agent-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pascal_agent-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pascal = pascal.__main__:main