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

sentinel/tools/gmail_auth.py

@@ -0,0 +1,47 @@
+import os.path
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+
+# --- FIX: IMPORT PATHS FROM CENTRAL MODULE ---
+from sentinel.paths import CREDENTIALS_PATH, TOKEN_PATH
+
+# The permissions the AI needs
+SCOPES = [
+    'https://www.googleapis.com/auth/gmail.readonly',
+    'https://www.googleapis.com/auth/gmail.send'
+]
+
+
+def get_gmail_service():
+    creds = None
+
+    # 1. Check if we already logged in (using the centralized token path)
+    if os.path.exists(TOKEN_PATH):
+        creds = Credentials.from_authorized_user_file(TOKEN_PATH, SCOPES)
+
+    # 2. If not logged in or token expired, log in
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            creds.refresh(Request())
+        else:
+            # Check if credentials file exists in the user data folder
+            if not os.path.exists(CREDENTIALS_PATH):
+                print(f"Error: credentials.json not found at {CREDENTIALS_PATH}")
+                return None
+
+            # This opens your browser to login
+            flow = InstalledAppFlow.from_client_secrets_file(
+                CREDENTIALS_PATH, SCOPES)
+            creds = flow.run_local_server(port=0)
+
+        # Save the token for next time
+        # Ensure the directory exists
+        TOKEN_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(TOKEN_PATH, 'w') as token:
+            token.write(creds.to_json())
+
+    # 3. Return the API Service
+    from googleapiclient.discovery import build
+    return build('gmail', 'v1', credentials=creds)

sentinel/tools/indexer.py

@@ -0,0 +1,156 @@
+# FILE: tools/indexer.py
+import os
+import sqlite3
+import time
+import logging
+from pypdf import PdfReader
+from docx import Document
+from openpyxl import load_workbook
+from pathlib import Path
+
+BASE_DIR = Path.home() / ".sentinel-1"
+BASE_DIR.mkdir(exist_ok=True)
+DB_FILE = BASE_DIR / "file_index.db"
+MAX_FILE_SIZE_MB = 10  # Skip files larger than this to save RAM
+THROTTLE_SEC = 0.05  # Sleep time between files (Smoothness)
+
+SKIP_DIRS = {
+    "node_modules", "venv", ".venv", ".git", "__pycache__",
+    "AppData", "site-packages", "Program Files", "Windows", "Library"
+}
+
+SKIP_EXT = {'.exe', '.dll', '.bin', '.iso', '.zip', '.tar', '.gz'}
+
+
+def _get_text_from_file(path, ext):
+    """Safely extracts text with memory limits."""
+    try:
+        # 1. Check file size first (Fast fail)
+        size_mb = os.path.getsize(path) / (1024 * 1024)
+        if size_mb > MAX_FILE_SIZE_MB:
+            return f"[Skipped: Too Large ({size_mb:.1f}MB)]"
+
+        if ext == '.pdf':
+            reader = PdfReader(path)
+            # Limit to first 50 pages to prevent freezing on 1000-page books
+            return " ".join([page.extract_text() for page in reader.pages[:50] if page.extract_text()])
+
+        elif ext == '.docx':
+            doc = Document(path)
+            return "\n".join([p.text for p in doc.paragraphs])
+
+        elif ext == '.xlsx':
+            wb = load_workbook(path, read_only=True, data_only=True)
+            content = []
+            for sheet in wb.worksheets:
+                # Limit rows per sheet
+                for i, row in enumerate(sheet.iter_rows(values_only=True)):
+                    if i > 1000: break
+                    row_text = " ".join([str(c) for c in row if c is not None])
+                    content.append(row_text)
+            return "\n".join(content)
+
+        elif ext == '.csv':
+            with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+                # Read only first 10k bytes
+                return f.read(10000)
+        else:
+            with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+                return f.read(20000)  # Limit text files too
+
+    except Exception:
+        return ""
+
+
+def build_index(root=None, verbose=False):
+    """
+    Runs smoothly in background without hogging CPU.
+    """
+    if not root: root = os.path.expanduser("~")
+
+    conn = sqlite3.connect(DB_FILE)
+    c = conn.cursor()
+
+    # Enable FTS5
+    c.execute('CREATE VIRTUAL TABLE IF NOT EXISTS files USING fts5(path, name, content)')
+    c.execute('CREATE TABLE IF NOT EXISTS file_meta (path TEXT PRIMARY KEY, mtime REAL)')
+
+    # Cache existing files to avoid unnecessary disk reads
+    c.execute("SELECT path, mtime FROM file_meta")
+    existing_meta = {row[0]: row[1] for row in c.fetchall()}
+
+    count = 0
+    updated = 0
+
+    # We scan these specific user folders to stay efficient
+    target_dirs = [
+        os.path.join(root, "Documents"),
+        os.path.join(root, "Desktop"),
+        os.path.join(root, "Downloads")
+    ]
+
+    for target in target_dirs:
+        if not os.path.exists(target): continue
+
+        for r, dirs, files in os.walk(target):
+            # Clean skip dirs in-place
+            dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith(".")]
+
+            for file in files:
+                # CPU BREATHING ROOM
+                time.sleep(THROTTLE_SEC)
+
+                ext = os.path.splitext(file)[1].lower()
+                if ext in SKIP_EXT: continue
+                if ext not in ['.txt', '.md', '.py', '.json', '.pdf', '.docx', '.xlsx', '.csv']:
+                    continue
+
+                path = os.path.join(r, file)
+
+                try:
+                    stats = os.stat(path)
+                    current_mtime = stats.st_mtime
+
+                    # Skip unchanged
+                    if path in existing_meta and existing_meta[path] == current_mtime:
+                        continue
+
+                    content = _get_text_from_file(path, ext)
+                    if not content or len(content) < 5: continue
+
+                    # Update Database
+                    c.execute("DELETE FROM files WHERE path = ?", (path,))
+                    c.execute("INSERT INTO files (path, name, content) VALUES (?,?,?)", (path, file, content))
+                    c.execute("INSERT OR REPLACE INTO file_meta (path, mtime) VALUES (?,?)", (path, current_mtime))
+                    conn.commit()  # Commit often to save progress
+
+                    updated += 1
+                    count += 1
+
+                    # LOGGING: Only print every 10th file to reduce spam
+                    if verbose and updated % 10 == 0:
+                        print(f"   [Indexer] Indexed: {file} ({updated} total)")
+
+                except Exception:
+                    continue
+
+    conn.close()
+    if verbose and updated > 0:
+        print(f"   [Indexer] Batch complete. {updated} new files added.")
+    return f"Indexed {updated} files."
+
+
+def search_index(query):
+    if not os.path.exists(DB_FILE): return "Index missing."
+    conn = sqlite3.connect(DB_FILE)
+    try:
+        # Search content and return snippets
+        res = conn.execute(
+            "SELECT path, snippet(files, 2, '[', ']', '...', 10) FROM files WHERE files MATCH ? LIMIT 5",
+            (query,)
+        ).fetchall()
+    except Exception:
+        return "No matches."
+    conn.close()
+    if not res: return "No text matches found."
+    return "\n".join([f"📄 {r[0]}\n   Snippet: \"{r[1]}\"\n" for r in res])

sentinel/tools/installer.py

@@ -0,0 +1,69 @@
+import subprocess
+import json
+
+
+def winget_search(name):
+    """Find best Winget package ID for a given name."""
+    try:
+        output = subprocess.check_output(
+            f'winget search "{name}" --output json',
+            shell=True
+        ).decode()
+
+        data = json.loads(output)
+
+        if "Data" in data and len(data["Data"]) > 0:
+            return data["Data"][0]["PackageIdentifier"]
+
+    except:
+        pass
+
+    return None
+
+
+def install_software(package_names):
+    """
+    Returns safe winget install commands.
+    The agent should pass this to run_cmd.
+    """
+
+    WINGET_MAP = {
+        "vscode": "Microsoft.VisualStudioCode",
+        "chrome": "Google.Chrome",
+        "discord": "Discord.Discord",
+        "git": "Git.Git",
+        "python": "Python.Python.3.11",
+        "node": "OpenJS.NodeJS",
+        "spotify": "Spotify.Spotify",
+        "zoom": "Zoom.Zoom",
+        "notion": "Notion.Notion",
+        "docker": "Docker.DockerDesktop"
+    }
+
+    commands = []
+
+    for pkg in package_names:
+        pkg_lower = pkg.lower()
+
+        # 1. Try curated aliases
+        target = WINGET_MAP.get(pkg_lower)
+
+        # 2. Live winget search
+        if not target:
+            target = winget_search(pkg)
+
+        # 3. Fallback
+        if not target:
+            target = pkg
+
+        cmd = f"winget install -e --id {target} --accept-source-agreements --accept-package-agreements"
+        commands.append(cmd)
+
+    return " && ".join(commands)
+
+
+def list_installed():
+    try:
+        return subprocess.check_output("winget list", shell=True).decode()
+    except:
+        return "Could not list apps. Ensure Winget is installed."

sentinel/tools/macros.py

@@ -0,0 +1,58 @@
+import webbrowser
+import os
+import time
+from sentinel.tools import apps, desktop
+
+# Define your personal workflows here
+WORKFLOWS = {
+    "work": {
+        "apps": ["code", "slack"],  # Add your specific app executable names
+        "urls": ["https://jira.atlassian.com", "https://github.com"],
+        "volume": 20,
+        "say": "Work mode activated. Focus."
+    },
+    "morning": {
+        "urls": ["https://news.ycombinator.com", "https://gmail.com", "https://calendar.google.com"],
+        "say": "Good morning. Here is your briefing."
+    },
+    "chill": {
+        "urls": ["https://youtube.com", "https://reddit.com"],
+        "volume": 50,
+        "say": "Relaxing."
+    }
+}
+
+
+def run_macro(name):
+    """
+    Executes a named workflow (work, morning, chill).
+    """
+    if name not in WORKFLOWS:
+        return f"Macro '{name}' not found. Available: {', '.join(WORKFLOWS.keys())}"
+
+    plan = WORKFLOWS[name]
+    log = []
+
+    # 1. Open Apps
+    if "apps" in plan:
+        for app in plan["apps"]:
+            apps.open_app(app)
+            log.append(f"Opened {app}")
+            time.sleep(1)  # Wait for launch
+
+    # 2. Open URLs
+    if "urls" in plan:
+        for url in plan["urls"]:
+            webbrowser.open(url)
+            log.append(f"Opened {url}")
+
+    # 3. System Settings
+    if "volume" in plan:
+        desktop.set_volume(plan["volume"])
+        log.append(f"Volume set to {plan['volume']}")
+
+    # 4. Voice
+    if "say" in plan:
+        desktop.speak(plan["say"])
+
+    return "\n".join(log)

sentinel/tools/memory_ops.py

@@ -0,0 +1,281 @@
+# FILE: tools/memory_ops.py
+
+import sqlite3
+import datetime
+import chromadb
+import uuid
+import json
+import re
+import gc
+from chromadb.utils import embedding_functions
+from sentinel.core.config import ConfigManager
+from pathlib import Path
+
+# --- CONFIGURATION ---
+BASE_DIR = Path.home() / ".sentinel-1"
+BASE_DIR.mkdir(exist_ok=True)
+
+DB_FILE = BASE_DIR / "brain.db"
+CHROMA_PATH = BASE_DIR / "brain_vectors"
+
+# Global references for cleanup
+chroma_client = None
+collection = None
+
+def ensure_chroma():
+    global collection
+    if collection is None:
+        init_chroma()
+
+def init_chroma():
+    """Initializes ChromaDB (Safe re-init)"""
+    global chroma_client, collection
+    try:
+        chroma_client = chromadb.PersistentClient(path=CHROMA_PATH)
+    except Exception as e:
+        chroma_client = None
+        return
+
+    cfg = ConfigManager()
+    openai_key = cfg.get_key("openai")
+
+    if openai_key:
+        emb_fn = embedding_functions.OpenAIEmbeddingFunction(
+            api_key=openai_key, model_name="text-embedding-3-small"
+        )
+    else:
+        emb_fn = embedding_functions.DefaultEmbeddingFunction()
+
+    collection = chroma_client.get_or_create_collection(
+        name="sentinel_memory", embedding_function=emb_fn
+    )
+
+def delete_fact(subject, predicate=None, obj=None):
+    """
+    Delete matching facts from memory.
+    Any field can be None (acts as wildcard).
+    """
+    ensure_chroma()
+    if not collection:
+        return "Vector DB unavailable."
+
+    try:
+        results = collection.get(include=["metadatas", "documents"])
+
+        ids = results.get("ids", [])
+        metadatas = results.get("metadatas", [])
+        documents = results.get("documents", [])
+
+        to_delete = []
+
+        for i, meta in enumerate(metadatas):
+            text = documents[i]
+
+            match_subject = meta.get("subject") == subject
+            match_pred = predicate is None or predicate in text
+            match_obj = obj is None or obj in text
+
+            if match_subject and match_pred and match_obj:
+                to_delete.append(ids[i])
+
+        if not to_delete:
+            return "No matching memory found."
+
+        collection.delete(ids=to_delete)
+        return f"Deleted {len(to_delete)} memory entries."
+
+    except Exception as e:
+        return f"Delete error: {e}"
+
+
+# Initialize on import
+init_chroma()
+
+
+def teardown():
+    """Releases database locks for wiping."""
+    global chroma_client, collection
+    try:
+        if chroma_client:
+            chroma_client.reset()
+    except:
+        pass
+
+    chroma_client = None
+    collection = None
+    gc.collect()
+
+
+
+def _get_sql_conn():
+    conn = sqlite3.connect(DB_FILE, check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def init_memory():
+    conn = _get_sql_conn()
+    conn.execute('''
+        CREATE TABLE IF NOT EXISTS metadata (
+            id TEXT PRIMARY KEY, 
+            importance INTEGER,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+            last_accessed DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    conn.execute('''
+        CREATE TABLE IF NOT EXISTS logs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            action TEXT, details TEXT, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+
+init_memory()
+
+
+def _rate_importance(text):
+    return 5
+
+
+def store_fact(subject, predicate, obj, context="user_defined"):
+    ensure_chroma()
+    if not collection:
+        return "Vector DB unavailable."
+    fact_text = f"{subject} {predicate} {obj}"
+    mem_id = str(uuid.uuid4())
+    full_text = f"{fact_text}. Context: {context}"
+
+    collection.add(
+        documents=[full_text],
+        metadatas=[{"subject": subject, "type": "fact"}],
+        ids=[mem_id]
+    )
+
+    importance = _rate_importance(fact_text)
+    conn = _get_sql_conn()
+    conn.execute("INSERT INTO metadata (id, importance) VALUES (?, ?)", (mem_id, importance))
+    conn.commit()
+    conn.close()
+    return f"🧠 Memory Stored: {fact_text}"
+
+
+def retrieve_relevant_context(query, limit=5):
+    ensure_chroma()
+    if not collection:
+        return ""
+    try:
+        results = collection.query(query_texts=[query], n_results=20)
+    except:
+        return ""
+
+    if not results['ids'] or not results['ids'][0]: return ""
+
+    found_ids = results['ids'][0]
+    found_texts = results['documents'][0]
+    found_distances = results['distances'][0]
+
+    conn = _get_sql_conn()
+    placeholders = ','.join(['?'] * len(found_ids))
+    sql = f"SELECT * FROM metadata WHERE id IN ({placeholders})"
+    rows = conn.execute(sql, found_ids).fetchall()
+    conn.close()
+
+    meta_map = {row['id']: dict(row) for row in rows}
+    scored_memories = []
+
+    for i, mem_id in enumerate(found_ids):
+        meta = meta_map.get(mem_id, {'importance': 5, 'last_accessed': str(datetime.datetime.now())})
+        text = found_texts[i]
+        relevance = 1.0 - (found_distances[i] / 2.0)
+        try:
+            last_accessed = datetime.datetime.strptime(meta['last_accessed'], "%Y-%m-%d %H:%M:%S")
+            hours_diff = (datetime.datetime.now() - last_accessed).total_seconds() / 3600
+            recency_score = 0.99 ** hours_diff
+        except:
+            recency_score = 1.0
+
+        importance_score = meta['importance'] / 10.0
+        final_score = (relevance * 0.5) + (importance_score * 0.3) + (recency_score * 0.2)
+
+        if final_score > 0.4: scored_memories.append((final_score, mem_id, text))
+
+    scored_memories.sort(key=lambda x: x[0], reverse=True)
+    top_picks = scored_memories[:limit]
+
+    if top_picks:
+        conn = _get_sql_conn()
+        winner_ids = [x[1] for x in top_picks]
+        placeholders = ','.join(['?'] * len(winner_ids))
+        conn.execute(f"UPDATE metadata SET last_accessed = CURRENT_TIMESTAMP WHERE id IN ({placeholders})", winner_ids)
+        conn.commit()
+        conn.close()
+
+    if not top_picks:
+        return "No long-term memories found."
+
+    return "Relevant Memories:\n" + "\n".join([f"- {x[2]}" for x in top_picks])
+
+
+def log_activity(action, details):
+    try:
+        conn = _get_sql_conn()
+        conn.execute("INSERT INTO logs (action, details) VALUES (?, ?)", (action, details))
+        conn.commit()
+        conn.close()
+    except:
+        pass
+
+
+def reflect_on_day(date_str=None):
+    """
+    Retrieves activity logs for a specific day.
+    Required by registry.py and cognitive.py for Daily Briefings.
+    """
+    if not date_str:
+        date_str = datetime.datetime.now().strftime("%Y-%m-%d")
+
+    conn = _get_sql_conn()
+    c = conn.execute('''
+        SELECT time(timestamp) as t, action, details 
+        FROM logs 
+        WHERE date(timestamp) = ? 
+        ORDER BY timestamp ASC
+    ''', (date_str,))
+
+    logs = c.fetchall()
+    conn.close()
+
+    if not logs: return f"No activity recorded for {date_str}."
+
+    summary = f"Activity Log for {date_str}:\n"
+    for log in logs:
+        summary += f"[{log['t']}] {log['action']}: {log['details']}\n"
+
+    return summary
+
+
+def archive_interaction(user_text, ai_text):
+    from sentinel.core.llm import LLMEngine
+    if not user_text or not ai_text: return
+    if len(user_text) < 10 and len(ai_text) < 10: return
+
+    try:
+        cfg = ConfigManager()
+        brain = LLMEngine(cfg, verbose=False)
+
+        prompt = (
+            "Analyze interaction. Extract PERMANENT facts about user. "
+            "Return JSON list of strings. If none, return [].\n\n"
+            f"User: {user_text}\nAI: {ai_text}"
+        )
+        response = brain.query(prompt, [])
+        match = re.search(r'\[.*\]', response, re.DOTALL)
+        if match:
+            facts = json.loads(match.group(0))
+            for fact in facts:
+                store_fact("User", "context", fact, context="conversation_archive")
+    except Exception:
+        pass