pascal-agent 0.3.0__py3-none-any.whl

pascal/capability.py

@@ -0,0 +1,218 @@
+"""Capability tracking for Pascal's domain-level trust map."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from dataclasses import dataclass, field
+from typing import Any, ClassVar, Literal
+
+
+DEFAULT_DOMAINS: dict[str, float] = {
+    "email": 0.5,
+    "scheduling": 0.5,
+    "file_ops": 0.5,
+    "communication": 0.5,
+    "analysis": 0.5,
+    "planning": 0.5,
+}
+
+_CAPABILITY_SCHEMA = """
+CREATE TABLE IF NOT EXISTS capability (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+);
+"""
+
+_CAPABILITY_KEY = "trust_map"
+_SUCCESS_DELTA = 0.02
+_JUDGMENT_FAILURE_DELTA = 0.10
+_NEUTRAL_TRUST = 0.5
+_HIGH_ERROR_STREAK = 3
+_VERY_HIGH_ERROR_STREAK = 5
+_HIGH_ERROR_PENALTY = 0.15
+_VERY_HIGH_ERROR_PENALTY = 0.25
+
+Decision = Literal["go", "caution", "block"]
+
+
+def infer_domain(action_type: str | None, tool_name: str | None) -> str:
+    """Infer a capability domain from an action and tool name."""
+    haystack = f"{action_type or ''} {tool_name or ''}".lower()
+
+    if _contains_any(haystack, ("email", "gmail", "mail", "inbox")):
+        return "email"
+    if _contains_any(haystack, ("schedule", "calendar", "meeting", "reminder", "cron")):
+        return "scheduling"
+    if _contains_any(haystack, ("file", "filesystem", "directory", "path", "read", "write", "edit")):
+        return "file_ops"
+    if _contains_any(haystack, ("telegram", "message", "chat", "notify", "slack", "discord", "sms")):
+        return "communication"
+    if _contains_any(haystack, ("plan", "todo", "task", "roadmap", "outline", "planner")):
+        return "planning"
+    return "analysis"
+
+
+@dataclass
+class TrustMap:
+    """Domain-specific trust scores with asymmetric learning."""
+
+    domains: dict[str, float] = field(default_factory=lambda: dict(DEFAULT_DOMAINS))
+
+    DOMAIN_NAMES: ClassVar[tuple[str, ...]] = tuple(DEFAULT_DOMAINS)
+
+    def __post_init__(self) -> None:
+        merged_domains = dict(DEFAULT_DOMAINS)
+        merged_domains.update(self.domains)
+        self.domains = {name: _clamp_score(score) for name, score in merged_domains.items()}
+
+    @property
+    def overall(self) -> float:
+        """Average domain score for backward compatibility."""
+        return sum(self.domains.values()) / len(self.domains)
+
+    def update_on_success(self, domain: str) -> float:
+        """Increase trust slowly after a successful action."""
+        key = _require_domain(domain)
+        self.domains[key] = _clamp_score(self.domains[key] + _SUCCESS_DELTA)
+        return self.domains[key]
+
+    def update_on_failure(self, domain: str, is_judgment_error: bool) -> float:
+        """Penalize only Pascal's judgment mistakes, not tool or env failures."""
+        key = _require_domain(domain)
+        if is_judgment_error:
+            self.domains[key] = _clamp_score(self.domains[key] - _JUDGMENT_FAILURE_DELTA)
+        return self.domains[key]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"domains": dict(self.domains)}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any] | None) -> "TrustMap":
+        if not isinstance(data, dict):
+            return cls()
+        domains = data.get("domains")
+        return cls(
+            domains=domains if isinstance(domains, dict) else dict(DEFAULT_DOMAINS),
+        )
+
+    def save(self, conn: sqlite3.Connection) -> None:
+        """Persist the trust map as JSON in the capability table."""
+        _ensure_capability_table(conn)
+        payload = json.dumps(self.to_dict(), ensure_ascii=False, sort_keys=True)
+        conn.execute(
+            """INSERT INTO capability (key, value, updated_at)
+               VALUES (?, ?, strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+               ON CONFLICT(key) DO UPDATE SET
+                   value = excluded.value,
+                   updated_at = strftime('%Y-%m-%dT%H:%M:%fZ','now')""",
+            (_CAPABILITY_KEY, payload),
+        )
+        conn.commit()
+
+    @classmethod
+    def load(cls, conn: sqlite3.Connection) -> "TrustMap":
+        """Load the persisted trust map or return defaults."""
+        _ensure_capability_table(conn)
+        row = conn.execute(
+            "SELECT value FROM capability WHERE key = ?",
+            (_CAPABILITY_KEY,),
+        ).fetchone()
+        if row is None:
+            return cls()
+        try:
+            return cls.from_dict(json.loads(row[0]))
+        except (json.JSONDecodeError, TypeError):
+            return cls()
+
+
+def compute_threshold(
+    effect_level: str,
+    *,
+    trust_map: TrustMap | None = None,
+    domain: str | None = None,
+    recent_error_streak: int = 0,
+) -> Decision:
+    """Return a simple action gate from effect level, trust, and recent failures.
+
+    This heuristic intentionally ignores any LLM self-reported confidence.
+    """
+    level = _normalize_effect_level(effect_level)
+    if level == "E0":
+        return "go"
+    if level == "E5":
+        return "block"
+
+    readiness_score = _readiness_score(
+        trust_map=trust_map,
+        domain=domain,
+        recent_error_streak=recent_error_streak,
+    )
+
+    if level == "E1":
+        return "go" if readiness_score >= 0.3 else "caution"
+    if level == "E2":
+        return "go" if readiness_score >= 0.4 else "caution"
+    if level == "E3":
+        return "go" if readiness_score >= 0.6 else "caution"
+    if readiness_score < 0.4:
+        return "block"
+    return "caution"
+
+
+def _ensure_capability_table(conn: sqlite3.Connection) -> None:
+    conn.execute(_CAPABILITY_SCHEMA)
+    conn.commit()
+
+
+def _normalize_effect_level(effect_level: str) -> str:
+    if effect_level in {"E0", "E1", "E2", "E3", "E4", "E5"}:
+        return effect_level
+    return "E2"
+
+
+def _readiness_score(
+    *,
+    trust_map: TrustMap | None,
+    domain: str | None,
+    recent_error_streak: int,
+) -> float:
+    trust_score = _domain_trust(trust_map, domain)
+    penalty = _error_streak_penalty(recent_error_streak)
+    return _clamp_score(trust_score - penalty)
+
+
+def _domain_trust(trust_map: TrustMap | None, domain: str | None) -> float:
+    if trust_map is None:
+        return _NEUTRAL_TRUST
+    if domain is not None and domain in trust_map.domains:
+        return trust_map.domains[domain]
+    return trust_map.overall
+
+
+def _error_streak_penalty(recent_error_streak: int) -> float:
+    streak = max(0, int(recent_error_streak))
+    if streak >= _VERY_HIGH_ERROR_STREAK:
+        return _VERY_HIGH_ERROR_PENALTY
+    if streak >= _HIGH_ERROR_STREAK:
+        return _HIGH_ERROR_PENALTY
+    return 0.0
+
+
+def _require_domain(domain: str) -> str:
+    if domain not in DEFAULT_DOMAINS:
+        raise KeyError(f"Unknown capability domain: {domain}")
+    return domain
+
+
+def _contains_any(text: str, needles: tuple[str, ...]) -> bool:
+    return any(needle in text for needle in needles)
+
+
+def _clamp_score(value: Any) -> float:
+    try:
+        number = float(value)
+    except (TypeError, ValueError):
+        number = 0.0
+    return round(min(1.0, max(0.0, number)), 6)

pascal/channels/telegram.py

@@ -0,0 +1,108 @@
+"""Telegram channel adapter -- aiogram 3.x, DM-only, single user."""
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def load_telegram_config() -> dict[str, Any]:
+    """Load bot_token and owner_chat_id from ~/.pascal/telegram.json."""
+    config_path = Path.home() / ".pascal" / "telegram.json"
+    if not config_path.exists():
+        raise FileNotFoundError(
+            f"Telegram config not found at {config_path}. "
+            'Create it with: {"bot_token": "...", "owner_chat_id": 12345}'
+        )
+    return json.loads(config_path.read_text(encoding="utf-8"))
+
+
+def create_telegram_bot(store, wake_event, config: dict[str, Any]):
+    """Create aiogram Bot + Dispatcher. Returns (bot, start_coro, send_approval, owner_chat_id).
+
+    start_coro is an async function that runs the long poll loop.
+    send_approval is an async function for approval request buttons.
+    """
+    from aiogram import Bot, Dispatcher, Router, F
+    from aiogram.types import (
+        Message, CallbackQuery,
+        InlineKeyboardMarkup, InlineKeyboardButton,
+    )
+
+    bot_token = config["bot_token"]
+    owner_chat_id = int(config["owner_chat_id"])
+
+    bot = Bot(token=bot_token)
+    dp = Dispatcher()
+    router = Router()
+    dp.include_router(router)
+
+    @router.message()
+    async def on_message(message: Message):
+        if message.chat.id != owner_chat_id:
+            return
+        if not message.text:
+            return
+        # Immediate ack -- user knows we received it
+        try:
+            from aiogram.types import ReactionTypeEmoji
+            await message.react([ReactionTypeEmoji(emoji="👀")])
+        except Exception:
+            pass
+        store.push_conversation_turn("telegram", "user", message.text)
+        store.push_notification(
+            source="telegram",
+            message=message.text,
+            priority="normal",
+            metadata={
+                "chat_id": str(message.chat.id),
+                "message_id": str(message.message_id),
+                "user": message.from_user.full_name if message.from_user else "unknown",
+            },
+        )
+        wake_event.set()
+        logger.info("Telegram message -> notification: %s", message.text[:80])
+
+    @router.callback_query(F.data.startswith("approve:") | F.data.startswith("deny:"))
+    async def on_approval(callback: CallbackQuery):
+        if callback.message and callback.message.chat.id != owner_chat_id:
+            return
+        parts = (callback.data or "").split(":", 1)
+        if len(parts) != 2:
+            return
+        action_type, task_id = parts
+        approved = action_type == "approve"
+        store.push_notification(
+            source="approval",
+            message=f"{'approved' if approved else 'denied'}: {task_id}",
+            priority="urgent",
+            metadata={"task_id": task_id, "approved": approved},
+        )
+        await callback.answer("Approved!" if approved else "Denied.")
+        try:
+            msg = callback.message
+            if msg is not None and hasattr(msg, "edit_reply_markup"):
+                await msg.edit_reply_markup(reply_markup=None)
+        except Exception:
+            pass
+        wake_event.set()
+        logger.info("Approval %s for task %s", action_type, task_id)
+
+    async def send_approval_request(chat_id: int, task_id: str, question: str):
+        keyboard = InlineKeyboardMarkup(inline_keyboard=[[
+            InlineKeyboardButton(text="Approve", callback_data=f"approve:{task_id}"),
+            InlineKeyboardButton(text="Deny", callback_data=f"deny:{task_id}"),
+        ]])
+        await bot.send_message(chat_id, f"Approval needed:\n{question}", reply_markup=keyboard)
+
+    async def start_polling():
+        logger.info("Telegram bot starting (owner: %d)", owner_chat_id)
+        try:
+            await dp.start_polling(bot, handle_signals=False)
+        finally:
+            await bot.session.close()
+
+    return bot, start_polling, send_approval_request, owner_chat_id

pascal/clipboard.py

@@ -0,0 +1,38 @@
+"""Clipboard helper -- text-only get/set via pywin32 with pyperclip fallback."""
+
+from __future__ import annotations
+
+
+def get_text() -> str:
+    """Read text from clipboard."""
+    try:
+        import win32clipboard
+    except ImportError:
+        import pyperclip
+        return str(pyperclip.paste() or "")
+
+    win32clipboard.OpenClipboard()
+    try:
+        if win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_UNICODETEXT):
+            data = win32clipboard.GetClipboardData(win32clipboard.CF_UNICODETEXT)
+            return str(data) if data else ""
+        return ""
+    finally:
+        win32clipboard.CloseClipboard()
+
+
+def set_text(text: str) -> None:
+    """Write text to clipboard."""
+    try:
+        import win32clipboard
+    except ImportError:
+        import pyperclip
+        pyperclip.copy(text)
+        return
+
+    win32clipboard.OpenClipboard()
+    try:
+        win32clipboard.EmptyClipboard()
+        win32clipboard.SetClipboardText(text, win32clipboard.CF_UNICODETEXT)
+    finally:
+        win32clipboard.CloseClipboard()

pascal/config.py

@@ -0,0 +1,134 @@
+"""pascal/config.py -- PascalConfig 로드 (환경변수 + 기본값)."""
+
+from __future__ import annotations
+
+import os
+import tomllib
+from pathlib import Path
+
+from pascal.types import PascalConfig
+
+
+def _load_dotenv() -> None:
+    """Load ~/.pascal/.env into os.environ (won't overwrite existing vars)."""
+    env_path = Path.home() / ".pascal" / ".env"
+    if not env_path.is_file():
+        return
+    try:
+        for line in env_path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            key, _, value = line.partition("=")
+            key = key.strip()
+            value = value.strip().strip("'\"")
+            if key and key not in os.environ:  # don't overwrite
+                os.environ[key] = value
+    except OSError:
+        pass
+
+
+# Auto-load on import
+_load_dotenv()
+
+_ENV_MAP: dict[str, tuple[str, type]] = {
+    "model": ("PASCAL_MODEL", str),
+    "provider": ("PASCAL_PROVIDER", str),
+    "base_url": ("PASCAL_BASE_URL", str),
+    "db_path": ("PASCAL_DB_PATH", str),
+    "max_effect": ("PASCAL_MAX_EFFECT", str),
+}
+
+_EXTRA_ENV_MAP: dict[str, tuple[str, type]] = {
+    "max_inner_turns": ("PASCAL_MAX_INNER_TURNS", int),
+    "max_tool_rounds": ("PASCAL_MAX_TOOL_ROUNDS", int),
+}
+
+
+def _config_paths() -> list[Path]:
+    seen: set[Path] = set()
+    paths: list[Path] = []
+    for path in (Path.cwd() / "pascal.toml", Path.home() / ".pascal" / "pascal.toml"):
+        try:
+            key = path.resolve()
+        except OSError:
+            key = path.absolute()
+        if key in seen:
+            continue
+        seen.add(key)
+        paths.append(path)
+    return paths
+
+
+def _load_toml_config() -> dict[str, object]:
+    for path in _config_paths():
+        if not path.is_file():
+            continue
+        with path.open("rb") as f:
+            payload = tomllib.load(f)
+        section = payload.get("pascal")
+        if isinstance(section, dict):
+            return section
+    return {}
+
+
+def _load_typed_values(raw: dict[str, object], mapping: dict[str, tuple[str, type]]) -> dict[str, object]:
+    values: dict[str, object] = {}
+    for field_name, (_, conv) in mapping.items():
+        if field_name not in raw or raw[field_name] is None:
+            continue
+        values[field_name] = conv(raw[field_name])
+    return values
+
+
+def _resolve_extra_value(
+    name: str,
+    *,
+    toml_values: dict[str, object],
+    overrides: dict[str, object],
+) -> int | None:
+    value = toml_values.get(name)
+    env_key, conv = _EXTRA_ENV_MAP[name]
+    env_val = os.environ.get(env_key)
+    if env_val is not None:
+        value = conv(env_val)
+    if name in overrides and overrides[name] is not None:
+        value = overrides[name]
+    if value is None:
+        return None
+    return max(1, int(str(value)))
+
+
+def load_config(**overrides) -> PascalConfig:
+    """PascalConfig를 생성한다. 우선순위: overrides > 환경변수 > pascal.toml > 기본값."""
+    toml_values = _load_toml_config()
+    kwargs: dict[str, object] = _load_typed_values(toml_values, _ENV_MAP)
+    for field_name, (env_key, conv) in _ENV_MAP.items():
+        env_val = os.environ.get(env_key)
+        if env_val is not None:
+            kwargs[field_name] = conv(env_val)
+    kwargs.update({k: v for k, v in overrides.items() if k in _ENV_MAP and v is not None})
+
+    config = PascalConfig(**kwargs)  # type: ignore[arg-type]  # kwargs built from validated ENV_MAP
+    max_inner = _resolve_extra_value("max_inner_turns", toml_values=toml_values, overrides=overrides)
+    if max_inner is not None:
+        config.max_inner_turns = max_inner
+    max_tool = _resolve_extra_value("max_tool_rounds", toml_values=toml_values, overrides=overrides)
+    if max_tool is not None:
+        config.max_tool_rounds = max_tool
+    return config
+
+
+def create_llm(config: PascalConfig):
+    """Create an LLM provider from config. Avoids duplication between __main__ and daemon."""
+    if config.provider == "codex":
+        from pascal.llm.codex import CodexProvider
+        return CodexProvider(model=config.model)
+    elif config.provider == "openai":
+        from pascal.llm.openai import OpenAIProvider
+        return OpenAIProvider(model=config.model, base_url=config.base_url)
+    elif config.provider == "anthropic":
+        from pascal.llm.anthropic import AnthropicProvider
+        return AnthropicProvider(model=config.model, base_url=config.base_url)
+    else:
+        raise ValueError(f"Unknown provider: {config.provider}")