sentinel-ai-os 1.0__py3-none-any.whl

sentinel/tools/calendar_ops.py

@@ -0,0 +1,163 @@
+# sentinel/tools/calendar_ops.py
+
+import datetime
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+import tzlocal
+
+from sentinel.paths import CREDENTIALS_PATH as CREDS_FILE, TOKEN_PATH as TOKEN_FILE
+
+# If modifying these scopes, delete token.json
+SCOPES = [
+    'https://www.googleapis.com/auth/gmail.readonly',
+    'https://www.googleapis.com/auth/gmail.send',
+    'https://www.googleapis.com/auth/calendar'
+]
+
+
+def get_service():
+    """Handles Authentication for both Gmail and Calendar."""
+    creds = None
+
+    # Load existing token
+    if TOKEN_FILE.exists():
+        creds = Credentials.from_authorized_user_file(str(TOKEN_FILE), SCOPES)
+
+    # Refresh or login
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            creds.refresh(Request())
+        else:
+            if not CREDS_FILE.exists():
+                return None
+
+            flow = InstalledAppFlow.from_client_secrets_file(
+                str(CREDS_FILE),
+                SCOPES
+            )
+            creds = flow.run_local_server(port=0)
+
+        # Save token
+        with open(TOKEN_FILE, "w") as token:
+            token.write(creds.to_json())
+
+    return build('calendar', 'v3', credentials=creds)
+
+
+def list_upcoming_events(max_results=10):
+    try:
+        service = get_service()
+        if not service:
+            return f"Error: credentials.json missing.\nPlace it at:\n{CREDS_FILE}"
+
+        now = datetime.datetime.utcnow().isoformat() + 'Z'
+
+        events_result = service.events().list(
+            calendarId='primary',
+            timeMin=now,
+            maxResults=max_results,
+            singleEvents=True,
+            orderBy='startTime'
+        ).execute()
+
+        events = events_result.get('items', [])
+        if not events:
+            return "No upcoming events found."
+
+        output = []
+        for event in events:
+            start = event['start'].get('dateTime', event['start'].get('date'))
+            summary = event.get('summary', 'No Title')
+            output.append(f"- {start}: {summary}")
+
+        return "\n".join(output)
+
+    except Exception as e:
+        return f"Calendar Error: {e}"
+
+
+def get_events_in_frame(start_iso, end_iso):
+    try:
+        service = get_service()
+        if not service:
+            return f"Error: credentials.json missing.\nPlace it at:\n{CREDS_FILE}"
+
+        if not start_iso.endswith("Z"):
+            start_iso += "Z"
+        if not end_iso.endswith("Z"):
+            end_iso += "Z"
+
+        events_result = service.events().list(
+            calendarId='primary',
+            timeMin=start_iso,
+            timeMax=end_iso,
+            singleEvents=True,
+            orderBy='startTime'
+        ).execute()
+
+        events = events_result.get('items', [])
+        if not events:
+            return "No events in that range."
+
+        return "\n".join([
+            f"- {e['start'].get('dateTime', e['start'].get('date'))}: {e.get('summary')}"
+            for e in events
+        ])
+
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def create_event(summary, start_time, duration_mins=60, description=""):
+    try:
+        service = get_service()
+        if not service:
+            return f"Error: credentials.json missing.\nPlace it at:\n{CREDS_FILE}"
+
+        start_time = start_time.replace("Z", "")
+        start_dt = datetime.datetime.fromisoformat(start_time)
+        end_dt = start_dt + datetime.timedelta(minutes=int(duration_mins))
+
+        local_tz = tzlocal.get_localzone_name()
+
+        event = {
+            'summary': summary,
+            'description': description,
+            'start': {
+                'dateTime': start_dt.isoformat(),
+                'timeZone': local_tz,
+            },
+            'end': {
+                'dateTime': end_dt.isoformat(),
+                'timeZone': local_tz,
+            },
+        }
+
+        event = service.events().insert(
+            calendarId='primary',
+            body=event
+        ).execute()
+
+        return f"Event created: {event.get('htmlLink')}"
+
+    except Exception as e:
+        return f"Error creating event: {e}"
+
+
+def quick_add(text):
+    try:
+        service = get_service()
+        if not service:
+            return f"Error: credentials.json missing.\nPlace it at:\n{CREDS_FILE}"
+
+        created_event = service.events().quickAdd(
+            calendarId='primary',
+            text=text
+        ).execute()
+
+        return f"Quick event created: {created_event.get('htmlLink')}"
+
+    except Exception as e:
+        return f"Error: {e}"

sentinel/tools/clock.py

@@ -0,0 +1,25 @@
+import time
+import threading
+from plyer import notification
+from datetime import datetime, timedelta
+
+def get_time():
+    return datetime.now().strftime("%A, %Y-%m-%d %H:%M:%S")
+
+def _notify(msg, wait_sec):
+    time.sleep(wait_sec)
+    notification.notify(title='Sentinel', message=msg, app_name='Sentinel', timeout=10)
+
+def set_timer(minutes, message="Timer Done"):
+    threading.Thread(target=_notify, args=(message, minutes*60), daemon=True).start()
+    return f"Timer set for {minutes} mins."
+
+def set_alarm(time_str, message="Alarm"):
+    try:
+        now = datetime.now()
+        tgt = datetime.strptime(time_str, "%H:%M").replace(year=now.year, month=now.month, day=now.day)
+        if tgt < now: tgt += timedelta(days=1)
+        wait = (tgt - now).total_seconds()
+        threading.Thread(target=_notify, args=(message, wait), daemon=True).start()
+        return f"Alarm set for {tgt.strftime('%H:%M')}."
+    except: return "Invalid format. Use HH:MM."

sentinel/tools/context.py

@@ -0,0 +1,40 @@
+import pygetwindow as gw
+import platform
+import psutil
+import time
+
+
+def get_active_app():
+    """
+    Returns the title and process name of the currently focused window.
+    """
+    try:
+        if platform.system() == "Windows":
+            window = gw.getActiveWindow()
+            if not window:
+                return "No active window detected."
+
+            return {
+                "title": window.title,
+                "app_name": "Unknown (Window API limitation)",
+                # Getting precise .exe from window is complex in pure python without win32gui
+                "status": "Active"
+            }
+        else:
+            return "Active app detection is currently Windows-optimized."
+
+    except Exception as e:
+        return f"Context Error: {e}"
+
+
+def watch_app_switch(interval=5):
+    """
+    Monitors for app switches (For the 'digital twin' log).
+    """
+    last_window = ""
+    while True:
+        curr = get_active_app()
+        if isinstance(curr, dict) and curr['title'] != last_window:
+            print(f"[Context] User switched to: {curr['title']}")
+            last_window = curr['title']
+        time.sleep(interval)

sentinel/tools/desktop.py

@@ -0,0 +1,116 @@
+import pyautogui
+import pygetwindow as gw
+import screen_brightness_control as sbc
+import platform
+import pyttsx3
+
+# Fail-safe
+pyautogui.FAILSAFE = True
+
+_ENGINE = None
+
+
+def _safe_str(x):
+    """Force any output to be a string (prevents Anthropic crashes)."""
+    try:
+        return str(x)
+    except:
+        return "Unknown result"
+
+
+def set_volume(level):
+    system = platform.system()
+
+    try:
+        target = int(level)
+
+        # Mute first to calibrate
+        pyautogui.press('volumedown', presses=50)
+
+        clicks = int(target / 2)
+        if clicks > 0:
+            pyautogui.press('volumeup', presses=clicks)
+
+        return _safe_str(f"Volume adjusted to approx {target}% (OS: {system}).")
+
+    except Exception as e:
+        return _safe_str(f"Volume control failed: {e}")
+
+
+def set_brightness(level):
+    try:
+        sbc.set_brightness(int(level))
+        return _safe_str(f"Brightness set to {level}%.")
+    except Exception as e:
+        return _safe_str(f"Error setting brightness: {e}")
+
+
+def _find_window_fuzzy(name):
+    """Find first window containing name (case-insensitive)."""
+    name = name.lower()
+    for w in gw.getAllWindows():
+        if name in w.title.lower():
+            return w
+    return None
+
+
+def minimize_window(app_name=None):
+    try:
+        if not app_name:
+            win = gw.getActiveWindow()
+        else:
+            win = _find_window_fuzzy(app_name)
+
+        if not win:
+            return _safe_str(f"No window found for '{app_name}'.")
+
+        win.minimize()
+        return _safe_str(f"Minimized: {win.title}")
+
+    except Exception as e:
+        return _safe_str(f"Minimize error: {e}")
+
+
+def maximize_window(app_name=None):
+    try:
+        if not app_name:
+            win = gw.getActiveWindow()
+        else:
+            win = _find_window_fuzzy(app_name)
+
+        if not win:
+            return _safe_str(f"No window found for '{app_name}'.")
+
+        win.maximize()
+        return _safe_str(f"Maximized: {win.title}")
+
+    except Exception as e:
+        return _safe_str(f"Maximize error: {e}")
+
+
+def type_text(text):
+    try:
+        pyautogui.write(str(text), interval=0.001)
+        return _safe_str("Typed text successfully.")
+    except Exception as e:
+        return _safe_str(f"Typing error: {e}")
+
+
+def take_screenshot(filename="screenshot.png"):
+    try:
+        pyautogui.screenshot(filename)
+        return _safe_str(f"Screenshot saved to {filename}")
+    except Exception as e:
+        return _safe_str(f"Screenshot failed: {e}")
+
+
+def speak(text):
+    global _ENGINE
+    try:
+        if _ENGINE is None:
+            _ENGINE = pyttsx3.init()
+        _ENGINE.say(str(text))
+        _ENGINE.runAndWait()
+        return _safe_str("Spoken.")
+    except Exception as e:
+        return _safe_str(f"TTS Error: {e}")

sentinel/tools/email_ops.py

@@ -0,0 +1,62 @@
+import base64
+from email.message import EmailMessage
+from sentinel.tools.gmail_auth import get_gmail_service
+import os
+
+
+
+def send_email(to, subject, body):
+    if not os.path.exists('credentials.json') and not os.path.exists('token.json'):
+        return "Error: Missing 'credentials.json'. Please setup Google OAuth first."
+
+    try:
+        service = get_gmail_service()
+
+        # Create the email
+        message = EmailMessage()
+        message.set_content(body)
+        message['To'] = to
+        message['Subject'] = subject
+
+        # Encode the message (Base64 required by Gmail API)
+        encoded_message = base64.urlsafe_b64encode(message.as_bytes()).decode()
+        create_message = {'raw': encoded_message}
+
+        # Send
+        send_message = (service.users().messages().send(userId="me", body=create_message).execute())
+        return f"Email sent! ID: {send_message['id']}"
+    except Exception as e:
+        return f"Error sending email: {e}"
+
+
+def read_emails(limit=5):
+    if not os.path.exists('credentials.json') and not os.path.exists('token.json'):
+        return "Error: Missing 'credentials.json'. Please setup Google OAuth first."
+
+    try:
+        service = get_gmail_service()
+
+        # List messages (INBOX only)
+        results = service.users().messages().list(userId='me', labelIds=['INBOX'], maxResults=limit).execute()
+        messages = results.get('messages', [])
+
+        if not messages:
+            return "No emails found."
+
+        email_summaries = []
+        for msg in messages:
+            # Fetch full details for each ID
+            txt = service.users().messages().get(userId='me', id=msg['id']).execute()
+
+            # Extract Headers
+            headers = txt['payload']['headers']
+            subject = next((h['value'] for h in headers if h['name'] == 'Subject'), "No Subject")
+            sender = next((h['value'] for h in headers if h['name'] == 'From'), "Unknown")
+            snippet = txt.get('snippet', '')
+
+            email_summaries.append(f"FROM: {sender}\nSUBJECT: {subject}\nSNIPPET: {snippet}\n")
+
+        return "\n---\n".join(email_summaries)
+
+    except Exception as e:
+        return f"Error reading emails: {e}"

sentinel/tools/factory.py

@@ -0,0 +1,125 @@
+import os
+import platform
+import subprocess
+from docx import Document
+from docx.shared import Pt, Inches
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+
+def _convert_to_pdf(docx_path):
+    """
+    Converts a .docx file to .pdf using LibreOffice (if available) or basic fallback.
+    Note: Perfect .docx -> .pdf conversion usually requires Word installed or LibreOffice headless.
+    For this MVP, we will try a pure Python fallback if system tools aren't found.
+    """
+    try:
+        # 1. Try LibreOffice (Best Quality, Cross Platform)
+        # This requires LibreOffice to be in your PATH (soffice/libreoffice)
+        cmd = f"soffice --headless --convert-to pdf \"{docx_path}\" --outdir \"{os.path.dirname(docx_path)}\""
+        if os.system(cmd) == 0:
+            return docx_path.replace(".docx", ".pdf")
+
+        # 2. Try Microsoft Word (Windows Only, requires 'docx2pdf')
+        # pip install docx2pdf
+        try:
+            from docx2pdf import convert
+            convert(docx_path)
+            return docx_path.replace(".docx", ".pdf")
+        except:
+            pass
+
+        return "PDF conversion requires LibreOffice or MS Word installed."
+    except Exception as e:
+        return f"PDF Error: {e}"
+
+
+def create_document(filename, blocks):
+    """
+    Universal Document Generator.
+
+    Args:
+        filename (str): Output name (e.g. "Project_Plan")
+        blocks (list): A list of dictionaries defining the structure.
+
+    Block Types:
+        - {"type": "heading", "text": "My Title", "level": 1}
+        - {"type": "paragraph", "text": "Body content...", "bold": False}
+        - {"type": "list", "items": ["Bullet 1", "Bullet 2"], "ordered": False}
+        - {"type": "table", "rows": [["Header 1", "Header 2"], ["Cell A", "Cell B"]]}
+        - {"type": "page_break"}
+    """
+    try:
+        doc = Document()
+
+        # Set default style (Optional)
+        style = doc.styles['Normal']
+        font = style.font
+        font.name = 'Calibri'
+        font.size = Pt(11)
+
+        for block in blocks:
+            b_type = block.get("type", "paragraph")
+
+            # --- HEADING ---
+            if b_type == "heading":
+                text = block.get("text", "")
+                level = block.get("level", 1)
+                doc.add_heading(text, level)
+
+            # --- PARAGRAPH ---
+            elif b_type == "paragraph":
+                text = block.get("text", "")
+                p = doc.add_paragraph()
+                run = p.add_run(text)
+                if block.get("bold"): run.bold = True
+                if block.get("italic"): run.italic = True
+
+                align = block.get("align", "left").lower()
+                if align == "center":
+                    p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+                elif align == "right":
+                    p.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+                elif align == "justify":
+                    p.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+
+            # --- LISTS ---
+            elif b_type == "list":
+                items = block.get("items", [])
+                style = 'List Number' if block.get("ordered") else 'List Bullet'
+                for item in items:
+                    doc.add_paragraph(item, style=style)
+
+            # --- TABLES ---
+            elif b_type == "table":
+                rows = block.get("rows", [])
+                if rows:
+                    cols = len(rows[0])
+                    table = doc.add_table(rows=0, cols=cols)
+                    table.style = 'Table Grid'
+
+                    for row_data in rows:
+                        row_cells = table.add_row().cells
+                        for i, cell_text in enumerate(row_data):
+                            if i < len(row_cells):
+                                row_cells[i].text = str(cell_text)
+
+            # --- BREAKS ---
+            elif b_type == "page_break":
+                doc.add_page_break()
+
+        # Save Logic
+        if not os.path.exists("drafts"):
+            os.makedirs("drafts")
+
+        if not filename.endswith(".docx"): filename += ".docx"
+        docx_path = os.path.join("drafts", filename)
+
+        doc.save(docx_path)
+
+        # Try converting to PDF automatically
+        pdf_result = _convert_to_pdf(docx_path)
+
+        return f"Document created: {docx_path} (PDF Status: {pdf_result})"
+
+    except Exception as e:
+        return f"Document Factory Error: {e}"

sentinel/tools/file_ops.py

@@ -0,0 +1,81 @@
+# FILE: tools/file_ops.py
+import os
+import fitz  # PyMuPDF
+import pandas as pd
+from docx import Document
+from sentinel.tools.smart_index import index_file
+
+
+def read_file(path):
+    """
+    Reads a file from a specific path.
+    Supports: PDF, DOCX, XLSX, CSV, TXT, PY, MD, JSON.
+    """
+    index_file(path)
+
+    if not os.path.exists(path):
+        return "Error: File not found."
+
+    ext = os.path.splitext(path)[1].lower()
+
+    try:
+        # --- PDF (Smart Read using PyMuPDF) ---
+        if ext == '.pdf':
+            text = ""
+            try:
+                with fitz.open(path) as doc:
+                    # Limit to first 20 pages to avoid overloading the LLM context
+                    for page in doc[:20]:
+                        text += page.get_text() + "\n"
+                return text if text.strip() else "[PDF contains no selectable text (Scanned?)]"
+            except Exception as e:
+                return f"[Error reading PDF: {e}]"
+
+        # --- Word Docs ---
+        elif ext == '.docx':
+            try:
+                doc = Document(path)
+                return "\n".join([p.text for p in doc.paragraphs])
+            except Exception as e:
+                return f"[Error reading DOCX: {e}]"
+
+        # --- Excel (Data View) ---
+        elif ext in ['.xlsx', '.xls']:
+            try:
+                # Read first sheet, max 50 rows to keep it readable
+                df = pd.read_excel(path, nrows=50)
+                return df.to_markdown(index=False)
+            except Exception as e:
+                return f"[Error reading Excel: {e}]"
+
+        # --- CSV ---
+        elif ext == '.csv':
+            try:
+                df = pd.read_csv(path, nrows=50)
+                return df.to_markdown(index=False)
+            except Exception as e:
+                return f"[Error reading CSV: {e}]"
+
+        # --- Code / Text ---
+        else:
+            with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+                return f.read(10000)  # Limit to first 10k characters to prevent lag
+
+    except Exception as e:
+        return f"Error reading file: {e}"
+
+
+def write_file(path, content):
+    index_file(path)
+
+    try:
+        # Ensure directory exists
+        folder = os.path.dirname(path)
+        if folder and not os.path.exists(folder):
+            os.makedirs(folder)
+
+        with open(path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        return f"Saved to {path}"
+    except Exception as e:
+        return str(e)

sentinel/tools/flights.py

@@ -0,0 +1,62 @@
+import requests
+from sentinel.core.config import ConfigManager
+
+
+def search_flights(departure_id, arrival_id, date, travel_type=2):
+    cfg = ConfigManager()
+    key = cfg.get_key("serp_api")
+
+    if not key:
+        return "Error: SerpAPI key missing."
+
+    params = {
+        "api_key": key,
+        "engine": "google_flights",
+        "departure_id": departure_id,
+        "arrival_id": arrival_id,
+        "outbound_date": date,
+        "type": travel_type,
+        "hl": "en",
+        "currency": "USD"
+    }
+
+    try:
+        response = requests.get(
+            "https://serpapi.com/search",
+            params=params,
+            timeout=15
+        )
+
+        if response.status_code != 200:
+            return f"SerpAPI HTTP Error: {response.status_code}"
+
+        data = response.json()
+
+        if "error" in data:
+            return f"API Error: {data['error']}"
+
+        flights = data.get("best_flights") or data.get("other_flights")
+        if not flights:
+            return "No flights found."
+
+        summary = [f"Found {len(flights)} flights (Top 5 shown):"]
+
+        for i, f in enumerate(flights[:5], 1):
+            price = f.get("price", "N/A")
+            duration = f.get("total_duration", "N/A")  # FIXED
+
+            leg = f["flights"][0]
+            airline = leg.get("airline", "Unknown")
+            dep_time = leg["departure_airport"]["time"]
+            arr_time = leg["arrival_airport"]["time"]
+
+            summary.append(
+                f"{i}. {airline} | ${price} | {duration} min\n"
+                f"   Departs: {dep_time} ({departure_id}) -> "
+                f"Arrives: {arr_time} ({arrival_id})"
+            )
+
+        return "\n".join(summary)
+
+    except Exception as e:
+        return f"Flight search failed: {e}"