sicily 0.2.3__py3-none-any.whl

Auth/gmail_auth.py

@@ -0,0 +1,71 @@
+import os
+import socket
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+
+SCOPES = [
+    "https://www.googleapis.com/auth/gmail.modify",
+    "https://www.googleapis.com/auth/gmail.send",
+    "https://www.googleapis.com/auth/gmail.readonly",
+]
+
+CREDENTIALS_FILE = "google_credentials.json"
+PORT = 8080
+
+
+async def get_gmail_token() -> str:
+    """Get Gmail token, handling stale port from cancelled auth flows."""
+
+    token_file = "gmail_token.json"
+    creds = None
+
+    if os.path.exists(token_file):
+        creds = Credentials.from_authorized_user_file(token_file, SCOPES)
+
+    if creds and creds.expired and creds.refresh_token:
+        creds.refresh(Request())
+
+    elif not creds or not creds.valid:
+        if not os.path.exists(CREDENTIALS_FILE):
+            raise FileNotFoundError(f"❌ {CREDENTIALS_FILE} not found!")
+
+        # --- Free the port if it's stuck from a previous cancelled flow ---
+        if _is_port_in_use(PORT):
+            print(f"⚠️  Port {PORT} already in use — freeing it...")
+            _free_port(PORT)
+
+        flow = InstalledAppFlow.from_client_secrets_file(CREDENTIALS_FILE, SCOPES)
+        creds = flow.run_local_server(
+            port=PORT,
+            prompt='consent'
+        )
+
+    with open(token_file, "w") as f:
+        f.write(creds.to_json())
+
+    return creds.token
+
+
+def _is_port_in_use(port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex(("localhost", port)) == 0
+
+
+def _free_port(port: int):
+    """Kill whatever process is holding the port."""
+    import subprocess, sys
+    if sys.platform == "win32":
+        result = subprocess.run(
+            f"for /f \"tokens=5\" %a in ('netstat -aon ^| find \":{port}\"') do taskkill /F /PID %a",
+            shell=True, capture_output=True
+        )
+    else:
+        # Linux / macOS
+        result = subprocess.run(
+            f"fuser -k {port}/tcp",
+            shell=True, capture_output=True
+        )
+    # Give the OS a moment to release the port
+    import time
+    time.sleep(0.5)

Auth/swiggy_auth.py

@@ -0,0 +1,54 @@
+import asyncio
+import hashlib, secrets, base64, time, webbrowser
+import httpx
+from urllib.parse import urlencode
+import os
+
+CLIENT_ID    = os.getenv("SWIGGY_CLIENT_ID")
+REDIRECT_URI = "http://localhost:8000/callback"
+_oauth_code_future = None
+
+_cache = {"token": None, "expires_at": 0}
+
+async def get_valid_token() -> str:
+    """Returns a cached token, or re-runs OAuth if expired."""
+    if _cache["token"] and time.time() < _cache["expires_at"] - 60:
+        return _cache["token"]
+
+    # PKCE
+    verifier  = secrets.token_urlsafe(32)
+    digest    = hashlib.sha256(verifier.encode()).digest()
+    challenge = base64.urlsafe_b64encode(digest).rstrip(b"=").decode()
+
+    # Open browser for phone + OTP
+    params = urlencode({
+        "response_type":         "code",
+        "client_id":             CLIENT_ID,
+        "redirect_uri":          REDIRECT_URI,
+        "code_challenge":        challenge,
+        "code_challenge_method": "S256",
+        "state":                 secrets.token_urlsafe(16),
+        "scope":                 "mcp:tools",
+    })
+    webbrowser.open(f"https://mcp.swiggy.com/auth/authorize?{params}")
+
+    global _oauth_code_future
+
+    loop = asyncio.get_running_loop()
+    _oauth_code_future = loop.create_future()
+    print("⏳ Waiting for OAuth redirect on http://localhost:8000/callback ...", flush=True)
+    code = await _oauth_code_future
+
+    async with httpx.AsyncClient() as client:
+        resp = await client.post("https://mcp.swiggy.com/auth/token", json={
+            "grant_type":    "authorization_code",
+            "code":          code,
+            "code_verifier": verifier,
+            "client_id":     CLIENT_ID,
+            "redirect_uri":  REDIRECT_URI,
+        })
+    
+    token = resp.json()["access_token"]
+    _cache["token"]      = token
+    _cache["expires_at"] = time.time() + 432000  # 5 days
+    return token

Auth/tavily_auth.py

@@ -0,0 +1,10 @@
+import os
+
+async def get_tavily_config() -> dict:
+    env = os.environ.copy()
+    
+    env.update({
+        "TAVILY_API_KEY": os.environ["TAVILY_API_KEY"],
+    })
+
+    return env

Auth/telegram_auth.py

@@ -0,0 +1,12 @@
+import os
+
+async def get_telegram_config() -> dict:
+    env = os.environ.copy()
+    
+    env.update({
+        "TELEGRAM_API_ID":         os.environ["TELEGRAM_API_ID"],
+        "TELEGRAM_API_HASH":       os.environ["TELEGRAM_API_HASH"],
+        "TELEGRAM_SESSION_STRING": os.environ["TELEGRAM_SESSION_STRING"],
+    })
+
+    return env

Recurring_Tasks/recurring_tasks.py

@@ -0,0 +1,239 @@
+import asyncio
+import re
+import yaml
+from pathlib import Path
+
+from datetime import datetime, timedelta
+
+YAML_FILE = Path.cwd() / "Recurring_Tasks" / "recurring_tasks.yaml"
+
+_dispatch = None
+
+def set_dispatch(fn):
+    global _dispatch
+    _dispatch = fn
+
+VALID_DAYS = {
+    "mon", "tue", "wed", "thu", "fri", "sat", "sun"
+}
+
+WEEKDAY_MAP = {
+    0: "mon",
+    1: "tue",
+    2: "wed",
+    3: "thu",
+    4: "fri",
+    5: "sat",
+    6: "sun",
+}
+
+
+# PUBLIC ENTRYPOINT
+async def start_recurring_tasks():
+
+    tasks = load_and_validate_yaml()
+
+    enabled_tasks = [t for t in tasks if t["enabled"]]
+
+    print(f"🔁 Starting {len(enabled_tasks)} recurring task(s)...")
+
+    for task_config in enabled_tasks:
+        asyncio.create_task(task_runner(task_config))
+
+
+# YAML LOADING + VALIDATION
+def load_and_validate_yaml():
+
+    with open(YAML_FILE, "r") as f:
+        data = yaml.safe_load(f)
+
+    if not data or "tasks" not in data:
+        raise ValueError("Missing 'tasks' in YAML.")
+
+    tasks = data["tasks"]
+
+    if not isinstance(tasks, list):
+        raise ValueError("'tasks' must be a list.")
+
+    seen_ids = set()
+
+    for task in tasks:
+
+        required_fields = ["id", "enabled", "task", "schedule"]
+
+        for field in required_fields:
+            if field not in task:
+                raise ValueError(f"Task missing required field: {field}")
+
+        task_id = task["id"]
+
+        if task_id in seen_ids:
+            raise ValueError(f"Duplicate task id: {task_id}")
+
+        seen_ids.add(task_id)
+
+        validate_schedule(task_id, task["schedule"])
+
+    return tasks
+
+
+def validate_schedule(task_id, schedule):
+
+    if "mode" not in schedule:
+        raise ValueError(f"[{task_id}] Missing schedule.mode")
+
+    mode = schedule["mode"]
+
+    if mode not in ["daily", "interval"]:
+        raise ValueError(f"[{task_id}] Invalid mode: {mode}")
+
+    # ── DAILY ────────────────────────────────────────────────
+    if mode == "daily":
+
+        if "at" not in schedule:
+            raise ValueError(f"[{task_id}] daily mode requires 'at'")
+
+        validate_time(schedule["at"], task_id)
+
+    # ── INTERVAL ─────────────────────────────────────────────
+    elif mode == "interval":
+
+        if "every" not in schedule:
+            raise ValueError(f"[{task_id}] interval mode requires 'every'")
+
+        validate_interval(schedule["every"], task_id)
+
+        if "start" in schedule:
+            validate_time(schedule["start"], task_id)
+
+    # ── DAYS ────────────────────────────────────────────────
+    if "days" in schedule:
+
+        if not isinstance(schedule["days"], list):
+            raise ValueError(f"[{task_id}] days must be a list")
+
+        for d in schedule["days"]:
+            if d not in VALID_DAYS:
+                raise ValueError(f"[{task_id}] Invalid day: {d}")
+
+
+def validate_time(value, task_id):
+
+    if not re.fullmatch(r"\d{2}:\d{2}", value):
+        raise ValueError(f"[{task_id}] Invalid time format: {value}")
+
+    hour, minute = map(int, value.split(":"))
+
+    if not (0 <= hour <= 23 and 0 <= minute <= 59):
+        raise ValueError(f"[{task_id}] Invalid time: {value}")
+
+
+def validate_interval(value, task_id):
+
+    if not re.fullmatch(r"\d+[mh]", value):
+        raise ValueError(f"[{task_id}] Invalid interval: {value}")
+
+
+# TASK RUNNER
+async def task_runner(task_config):
+
+    task_id = task_config["id"]
+    task_text = task_config["task"]
+    schedule = task_config["schedule"]
+
+    mode = schedule["mode"]
+
+    print(f"✅ Task loaded: {task_id}")
+
+    while True:
+
+        now = datetime.now()
+
+        # DAILY MODE
+        if mode == "daily":
+
+            run_time = build_today_datetime(schedule["at"])
+
+            if run_time <= now:
+                run_time += timedelta(days=1)
+
+            wait_seconds = (run_time - now).total_seconds()
+
+            await asyncio.sleep(wait_seconds)
+
+            if should_run_today(schedule):
+                await execute_task(task_id, task_text)
+
+        # INTERVAL MODE
+        elif mode == "interval":
+
+            if "start" in schedule:
+
+                first_run = build_today_datetime(schedule["start"])
+
+                if first_run > now:
+                    wait_seconds = (first_run - now).total_seconds()
+                    await asyncio.sleep(wait_seconds)
+
+            if should_run_today(schedule):
+                await execute_task(task_id, task_text)
+
+            interval_seconds = parse_interval(schedule["every"])
+
+            await asyncio.sleep(interval_seconds)
+
+
+# HELPERS
+async def execute_task(task_id, task_text):
+
+    print(
+        f"\n🔁 TASK EXECUTED"
+        f"\n🆔 ID   : {task_id}"
+        f"\n📝 Task : {task_text}"
+        f"\n🕒 Time : {datetime.now()}\n",
+        flush=True
+    )
+
+    if _dispatch is None:
+        print(f"⚠️  No dispatch set — skipping task {task_id}")
+        return
+
+    await _dispatch(task_id, task_text)
+
+
+def build_today_datetime(time_str):
+
+    hour, minute = map(int, time_str.split(":"))
+
+    now = datetime.now()
+
+    return now.replace(
+        hour=hour,
+        minute=minute,
+        second=0,
+        microsecond=0
+    )
+
+
+def parse_interval(value):
+
+    amount = int(value[:-1])
+    unit = value[-1]
+
+    if unit == "m":
+        return amount * 60
+
+    if unit == "h":
+        return amount * 60 * 60
+
+    raise ValueError(f"Invalid interval unit: {value}")
+
+
+def should_run_today(schedule):
+
+    if "days" not in schedule:
+        return True
+
+    today = WEEKDAY_MAP[datetime.now().weekday()]
+
+    return today in schedule["days"]

Recurring_Tasks/recurring_tasks.yaml

@@ -0,0 +1,32 @@
+tasks:
+
+  - id: morning_news
+    enabled: false
+    task: "Summarize the top AI news headlines"
+    schedule:
+      mode: daily
+      at: "08:00"
+      days: [mon, tue, wed, thu, fri]
+
+  - id: email_check
+    enabled: false
+    task: "Check unread emails and notify if anything important arrives"
+    schedule:
+      mode: interval
+      every: 30m
+      days: [mon, tue, wed]
+
+  - id: server_health
+    enabled: false
+    task: "Monitor server CPU and memory usage"
+    schedule:
+      mode: interval
+      every: 2h
+      start: "09:00"
+
+  - id: disabled_task
+    enabled: false
+    task: "Generate a weekly expense summary"
+    schedule:
+      mode: daily
+      at: "21:00"

Souls/eval_llm.md

@@ -0,0 +1,35 @@
+# User Preference & Behavior Extractor
+
+You are a user preference extractor.
+
+Analyze the full agent session and extract:
+
+## User Preferences
+
+- preferred products, services, brands, or categories
+- recurring interests or usage patterns
+- stated likes, dislikes, and priorities
+- dietary, accessibility, budgetary, or other explicit constraints
+
+## Decision-Making & Risk Behavior
+
+- risk tolerance, especially around irreversible actions
+- how the user responds to confirmations or approvals
+- sensitivity to side effects, costs, or external actions
+
+## Interaction Patterns
+
+- notable communication habits
+- preferred instruction style or level of detail
+- patterns in how the user approves, rejects, or modifies tool calls
+
+## Output Requirements
+
+- extract only information supported by the session
+- do not invent preferences or assumptions
+- keep the output concise
+- return clean Markdown
+- avoid repeating semantically identical information
+- prefer stable long-term behavioural patterns over temporary context
+- do not store temporary objectives or one-time requests
+- avoid storing information unlikely to matter in future sessions

Souls/main_llm.md

@@ -0,0 +1,35 @@
+# AI Assistant
+You are a capable, action-oriented AI assistant with access to tools 
+from a variety of connected external services (productivity, 
+communication, e-commerce, logistics, finance, health, smart home, 
+and more).
+
+## Core Behaviour
+- Understand the user's request and act on it directly.
+- Use the right tool for the right service based on the user's intent.
+- Never fabricate information that a tool can provide — fetch it.
+- Never ask the user "should I search?" or "shall I do that?" — just do it.
+
+## Tool Usage
+Call tools immediately and directly whenever they can fulfill the request.
+Do not narrate what you are about to do — just do it.
+
+## Search & Retry
+- If a search returns no results, try 1–2 semantically close alternative queries before telling the user nothing was found.
+- Do not ask permission to retry.
+- Do not repeat results the user can already see.
+
+## Multi-Service Awareness
+- Multiple services may be connected simultaneously.
+- Pick the correct service's tools based on the user's stated intent.
+- If the user names a specific service, prioritise its tools.
+- If it is genuinely unclear which service applies, ask one short clarifying question.
+
+## Error Handling
+- If a tool fails, explain the issue in one sentence and continue.
+- Do not apologise repeatedly or go into technical detail.
+
+## Response Style
+- Be concise and action-oriented.
+- Confirm completed actions briefly (e.g. "Done — item added.").
+- Do not list options or ask clarifying questions for things you can infer from context.

Souls/safety_llm.md

@@ -0,0 +1,22 @@
+# Tool Call Safety Classifier
+You are a safety classifier for AI agent tool calls.
+
+## SAFE — auto-execute without user confirmation
+A tool call is **SAFE** if it is:
+- Read-only (fetching, searching, listing, viewing data)
+- Has no side effects on external systems
+- Fully reversible or produces no lasting change
+
+## UNSAFE — requires user confirmation before execution
+A tool call is **UNSAFE** if it:
+- Sends messages, emails, or notifications
+- Places orders, initiates payments, or moves money
+- Creates, modifies, or deletes data
+- Triggers automations or scheduled actions
+- Changes settings or state in any external system
+
+## Decision Rule
+When in doubt, classify as UNSAFE.
+
+## Output
+Return only structured output — no explanation.

Tests/conftest.py

@@ -0,0 +1,57 @@
+import ast
+import sys
+from pathlib import Path
+
+# Paths — adjust here if your folder layout differs
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+CONNECTORS_PATH        = PROJECT_ROOT / "connectors.py"
+TELEGRAM_COMMANDS_PATH = PROJECT_ROOT / "telegram_commands.py"
+SETTINGS_EXAMPLE_PATH  = PROJECT_ROOT / "settings.example.json"
+AGENT_PATH = PROJECT_ROOT / "agent.py"
+SOULS_DIR  = PROJECT_ROOT / "Souls"
+
+# AST helpers — read source as text, no project imports required
+def parse(path: Path) -> ast.Module:
+    return ast.parse(path.read_text(encoding="utf-8"))
+
+
+def get_function_node(tree: ast.Module, func_name: str):
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name == func_name:
+            return node
+    return None
+
+
+def all_function_names(tree: ast.Module) -> set[str]:
+    return {
+        node.name for node in ast.walk(tree)
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+    }
+
+
+def get_dict_literal(tree: ast.Module, var_name: str):
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name) and target.id == var_name and isinstance(node.value, ast.Dict):
+                    return node.value
+    return None
+
+
+def dict_str_keys(dict_node: ast.Dict) -> list[str]:
+    return [k.value for k in dict_node.keys if isinstance(k, ast.Constant) and isinstance(k.value, str)]
+
+
+def extract_call_first_arg_strings(scope_node, call_name: str) -> list[str]:
+    """Within a given AST node, find all calls to `call_name` and return the
+    first positional argument when it's a string literal."""
+    results = []
+    for node in ast.walk(scope_node):
+        if isinstance(node, ast.Call):
+            fn = node.func
+            name = fn.id if isinstance(fn, ast.Name) else (fn.attr if isinstance(fn, ast.Attribute) else None)
+            if name == call_name and node.args and isinstance(node.args[0], ast.Constant) and isinstance(node.args[0].value, str):
+                results.append(node.args[0].value)
+    return results

Tests/test_connectors.py

@@ -0,0 +1,34 @@
+from Tests.conftest import (
+    parse,
+    get_dict_literal,
+    dict_str_keys,
+    all_function_names,
+    CONNECTORS_PATH,
+    TELEGRAM_COMMANDS_PATH,
+)
+
+
+# connectors.py <-> telegram_commands.py consistency
+def test_each_connector_has_connect_and_disconnect_commands():
+    """
+    For every key in CONNECTORS (connectors.py), telegram_commands.py must
+    define a connect_<key>_command and a disconnect_<key>_command function.
+    """
+    connectors_tree = parse(CONNECTORS_PATH)
+    commands_tree   = parse(TELEGRAM_COMMANDS_PATH)
+
+    connectors_dict = get_dict_literal(connectors_tree, "CONNECTORS")
+    assert connectors_dict is not None, "Could not find a `CONNECTORS = {...}` dict in connectors.py"
+
+    connector_keys = dict_str_keys(connectors_dict)
+    assert connector_keys, "CONNECTORS dict has no string keys — check it's defined as expected"
+
+    defined_functions = all_function_names(commands_tree)
+
+    missing = []
+    for key in connector_keys:
+        for fn_name in (f"connect_{key}_command", f"disconnect_{key}_command"):
+            if fn_name not in defined_functions:
+                missing.append(fn_name)
+
+    assert not missing, f"telegram_commands.py is missing: {missing}"

Tests/test_memory_and_context.py

@@ -0,0 +1,78 @@
+import numpy as np
+
+
+# memory_and_context.py — pure-logic checks
+# (functions copied verbatim — see module docstring note at top of file)
+def _parse_preference_lines(text: str) -> list[str]:
+    lines = []
+    for raw in text.splitlines():
+        line = raw.strip()
+
+        if not line:
+            continue
+        if line.startswith("#"):
+            continue
+        if set(line) <= set("-_* "):
+            continue
+
+        for marker in ("-", "*", "•", "–"):
+            if line.startswith(marker):
+                line = line[len(marker):].strip()
+                break
+
+        if line:
+            lines.append(line)
+
+    return lines
+
+
+# --- copied verbatim from memory_and_context.py ---
+def _cosine_similarity(query_vec: np.ndarray, matrix: np.ndarray) -> np.ndarray:
+    q     = query_vec / (np.linalg.norm(query_vec) + 1e-9)
+    norms = np.linalg.norm(matrix, axis=1, keepdims=True) + 1e-9
+    return (matrix / norms) @ q
+
+
+def test_parse_preference_lines_strips_markers_and_skips_noise():
+    text = """
+# Header — should be skipped
+Plain preference line
+- Hyphen bullet
+* Star bullet
+• Round bullet
+- En-dash bullet
+---
+
+Another plain line
+""".strip()
+
+    result = _parse_preference_lines(text)
+
+    assert result == [
+        "Plain preference line",
+        "Hyphen bullet",
+        "Star bullet",
+        "Round bullet",
+        "En-dash bullet",
+        "Another plain line",
+    ]
+
+
+def test_parse_preference_lines_empty_input_returns_empty_list():
+    assert _parse_preference_lines("") == []
+    assert _parse_preference_lines("   \n\n   ") == []
+
+
+def test_cosine_similarity_known_values():
+    query  = np.array([1.0, 0.0])
+    matrix = np.array([
+        [1.0, 0.0],   # identical direction -> ~1.0
+        [0.0, 1.0],   # orthogonal          -> ~0.0
+        [1.0, 1.0],   # 45 degrees          -> ~0.7071
+    ])
+
+    scores = _cosine_similarity(query, matrix)
+
+    assert np.isclose(scores[0], 1.0, atol=1e-6)
+    assert np.isclose(scores[1], 0.0, atol=1e-6)
+    assert np.isclose(scores[2], 1 / np.sqrt(2), atol=1e-6)