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

sentinel/auth.py

@@ -0,0 +1,40 @@
+# sentinel/auth.py
+
+from google_auth_oauthlib.flow import InstalledAppFlow
+from sentinel.paths import CREDS_FILE, TOKEN_FILE
+
+SCOPES = [
+    'https://www.googleapis.com/auth/gmail.readonly',
+    'https://www.googleapis.com/auth/gmail.send',
+    'https://www.googleapis.com/auth/calendar'
+]
+
+
+def fix_authentication():
+    print("--- SENTINEL GOOGLE AUTH ---\n")
+
+    if not CREDS_FILE.exists():
+        print("❌ credentials.json not found.\n")
+        print("Download it from Google Cloud Console and place it here:\n")
+        print(CREDS_FILE)
+        return
+
+    if TOKEN_FILE.exists():
+        print("⚠ Found old token. Deleting...")
+        TOKEN_FILE.unlink()
+
+    print("Opening browser for Google login...\n")
+
+    flow = InstalledAppFlow.from_client_secrets_file(
+        str(CREDS_FILE),
+        SCOPES
+    )
+
+    creds = flow.run_local_server(port=0)
+
+    with open(TOKEN_FILE, "w") as f:
+        f.write(creds.to_json())
+
+    print("\n✅ Authentication complete.")
+    print("Token saved to:")
+    print(TOKEN_FILE)

sentinel/cli.py

@@ -0,0 +1,9 @@
+from sentinel.main import app
+from sentinel.core.config import ConfigManager
+from sentinel.core.setup import setup_wizard
+
+def main():
+    cfg = ConfigManager()
+    if not cfg.exists():
+        setup_wizard()
+    app()

sentinel/core/agent.py

@@ -0,0 +1,298 @@
+# FILE: core/agent.py
+
+import sys
+import json
+import os
+import shutil
+
+from sentinel.core.config import ConfigManager
+from sentinel.core.llm import LLMEngine
+from sentinel.core.registry import TOOLS, SYSTEM_PROMPT
+from sentinel.core.ui import UI
+from sentinel.core.schema import AgentAction
+from sentinel.tools import memory_ops
+from sentinel.paths import USER_DATA_DIR, DB_PATH, VECTOR_PATH, AUDIT_LOG_PATH as AUDIT_LOG
+
+# Absolute path to scripts folder
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+SCRIPTS_DIR = os.path.join(BASE_DIR, "scripts")
+
+FACTORY_RESET_SCRIPT = os.path.join(SCRIPTS_DIR, "factory_reset.bat")
+WIPE_VECTOR_SCRIPT = os.path.join(SCRIPTS_DIR, "wipe_vector.bat")
+
+class SentinelAgent:
+    def __init__(self, config_manager):
+        self.config_manager = config_manager
+        self.brain = LLMEngine(self.config_manager)
+        self.history = []
+        self.window_size = self.config_manager.get("memory.window_size", 15)
+
+    def _parse_action(self, text) -> AgentAction | None:
+        json_data = None
+
+        try:
+            json_data = json.loads(text)
+        except:
+            # Extract first valid JSON object using a stack
+            start = text.find("{")
+            if start == -1:
+                return None
+
+            stack = 0
+            for i in range(start, len(text)):
+                if text[i] == "{":
+                    stack += 1
+                elif text[i] == "}":
+                    stack -= 1
+                    if stack == 0:
+                        try:
+                            json_data = json.loads(text[start:i + 1])
+                            break
+                        except:
+                            return None
+
+        if not json_data:
+            return None
+
+        try:
+            return AgentAction(**json_data)
+        except:
+            return None
+
+    def _enforce_memory_limit(self):
+        max_msgs = self.window_size * 2
+        while len(self.history) > max_msgs:
+            if len(self.history) < 2: break
+            old_user = self.history.pop(0)
+            old_ai = self.history.pop(0)
+            try:
+                memory_ops.archive_interaction(old_user.get('content', ''), old_ai.get('content', ''))
+            except:
+                pass
+
+    def process_slash_command(self, user_input):
+        if not user_input.startswith("/"): return False
+        parts = user_input[1:].split()
+        cmd = parts[0].lower()
+        args = parts[1:]
+
+        if cmd == "memory":
+            if not args:
+                UI.print_system(f"Current Context Window: {self.window_size} turns.")
+            else:
+                try:
+                    self.window_size = int(args[0])
+                    self.config_manager.set("memory.window_size", self.window_size)
+                    self._enforce_memory_limit()
+                    UI.print_success(f"Context Window updated to {self.window_size} turns.")
+                except:
+                    UI.print_error("Invalid number.")
+            return True
+
+        if cmd == "wipe":
+            if input("⚠️  ARE YOU SURE? This will delete ALL long-term memories. (y/n): ").lower() == 'y':
+                UI.print_system("Initiating Wipe...")
+
+                # 1. Stop background processes
+                try:
+                    from sentinel.core import scheduler
+                    scheduler.stop_all_jobs()
+                except:
+                    pass
+
+                # 2. Release Database Locks
+                try:
+                    memory_ops.teardown()
+                except:
+                    pass
+
+                # 3. Delete the specific files (Cross-Platform)
+                UI.print_system(f"Wiping data from {USER_DATA_DIR}...")
+
+                # Delete Vector DB Folder
+                if os.path.exists(VECTOR_PATH):
+                    try:
+                        shutil.rmtree(VECTOR_PATH)
+                        UI.print_success("Deleted Vector Memory.")
+                    except Exception as e:
+                        UI.print_error(f"Failed to delete vectors: {e}")
+
+                # Delete SQLite DB
+                if os.path.exists(DB_PATH):
+                    try:
+                        os.remove(DB_PATH)
+                        UI.print_success("Deleted Brain Database.")
+                    except Exception as e:
+                        UI.print_error(f"Failed to delete DB: {e}")
+
+                UI.print_system("Wipe Complete. Restarting Sentinel is recommended.")
+                sys.exit(0)
+
+            return True
+
+        if cmd == "factory_reset":
+            confirm = input("⚠️ This will DELETE EVERYTHING (Config, Keys, Memories). Type YES to confirm: ")
+            if confirm == "YES":
+                try:
+                    # Teardown everything
+                    from sentinel.core import scheduler
+                    scheduler.stop_all_jobs()
+                    memory_ops.teardown()
+
+                    # Nuke the entire .sentinel folder
+                    if os.path.exists(USER_DATA_DIR):
+                        shutil.rmtree(USER_DATA_DIR)
+                        print(f"✔ Deleted {USER_DATA_DIR}")
+
+                    print("Factory Reset Complete. Sentinel is now fresh.")
+                    sys.exit(0)
+                except Exception as e:
+                    print(f"Reset failed: {e}")
+                    # Fallback: If locked, tell user to delete manually
+                    print(f"Please manually delete this folder: {USER_DATA_DIR}")
+            return True
+
+        if cmd == "status":
+            UI.print_agent(
+                f"**Provider:** {self.brain.provider.upper()}\n**Model:** {self.brain.model}\n**Window:** {self.window_size} turns\n**Active Memory:** {len(self.history)} messages",
+                model=self.brain.model
+            )
+            return True
+
+        if cmd == "clear":
+            self.history = []
+            UI.print_success("Short-term memory cleared.")
+            return True
+
+        if cmd == "help":
+            UI.print_help()
+            return True
+
+        if cmd in ["switch", "model"]:
+            # (Keeping it brief for copy-paste)
+            provider = args[0] if args else "openai"
+            model = args[1] if len(args) > 1 else None
+            from sentinel.tools import system_ops
+            res = system_ops.switch_model(provider, model)
+            self.brain.reload_config(verbose=True)
+            UI.console.print(res)
+            return True
+
+        if cmd == "log":
+            if not args:
+                state = ConfigManager().get("system.audit_logging", True)
+                UI.print_system(f"Logging is currently: {'ON' if state else 'OFF'}")
+                return True
+
+            mode = args[0].lower()
+            if mode in ["on", "true", "enable"]:
+                from sentinel.core.audit import audit
+                UI.print_success(audit.toggle(True))
+            elif mode in ["off", "false", "disable"]:
+                from sentinel.core.audit import audit
+                UI.print_success(audit.toggle(False))
+            return True
+
+        if cmd == "setkey":
+            if len(args) < 2: return False
+            self.config_manager.set_key(args[0], args[1])
+            self.brain.reload_config()
+            UI.print_success("Key updated.")
+            return True
+
+        if cmd == "auth":
+            from sentinel.auth import fix_authentication
+            fix_authentication()
+            return True
+
+        if cmd == "config":
+            from sentinel.core.setup import setup_wizard
+            setup_wizard()
+            return True
+
+        return False
+
+    def run_loop(self):
+        if self.config_manager.get_key(self.brain.provider):
+            UI.print_system("Systems Online. Waiting for input...")
+
+        while True:
+            try:
+                user_input = UI.get_input()
+                if not user_input:
+                    continue
+
+                if user_input.lower().strip() in ["exit", "quit"]:
+                    sys.exit(0)
+
+                if self.process_slash_command(user_input):
+                    continue
+
+                # ---- Recall Memory ----
+                relevant_context = memory_ops.retrieve_relevant_context(user_input)
+                current_sys = SYSTEM_PROMPT
+                if relevant_context:
+                    current_sys += f"\n\n[RECALLED MEMORIES]\n{relevant_context}\n"
+
+                self.history.append({"role": "user", "content": user_input})
+                memory_ops.log_activity("chat", user_input)
+
+                for _ in range(5):
+                    messages = self.history[-self.window_size * 2:]
+                    full_resp = self.brain.query(current_sys, messages)
+                    action = self._parse_action(full_resp)
+
+                    # ---- Normal LLM response ----
+                    if not action:
+                        clean = full_resp.replace("```json", "").replace("```", "").strip()
+
+                        if not clean:
+                            clean = "I don't have any stored long-term information about you yet."
+
+                        UI.print_agent(clean, model=self.brain.model)
+
+                        if full_resp and full_resp.strip():
+                            self.history.append({"role": "assistant", "content": full_resp})
+                        break
+
+                    tool, args = action.tool, action.args
+
+                    # ---- Explicit response tool ----
+                    if tool == "response":
+                        text = args.get("text", "").strip()
+                        if not text:
+                            text = "I don't have any stored long-term information about you yet."
+
+                        UI.print_agent(text, model=self.brain.model)
+                        self.history.append({"role": "assistant", "content": action.model_dump_json()})
+                        break
+
+                    # ---- Tool execution ----
+                    if tool in TOOLS:
+                        UI.print_tool(tool)
+                        try:
+                            res = TOOLS[tool](**args)
+
+                            # UX fallback
+                            if not res or not str(res).strip():
+                                res = "No long-term memories stored about you yet."
+
+                            UI.print_result(res)
+
+                            self.history.append({"role": "assistant", "content": action.model_dump_json()})
+
+                            if res and str(res).strip():
+                                self.history.append({"role": "user", "content": str(res)})
+
+                        except Exception as e:
+                            UI.print_error(f"Tool Error: {e}")
+                            self.history.append({"role": "system", "content": f"Error: {e}"})
+                    else:
+                        break
+
+                self._enforce_memory_limit()
+
+            except KeyboardInterrupt:
+                sys.exit(0)
+            except Exception as e:
+                UI.print_error(f"System Error: {e}")

sentinel/core/audit.py

@@ -0,0 +1,48 @@
+import time
+import json
+import os
+from datetime import datetime
+from sentinel.core.config import ConfigManager
+from pathlib import Path
+
+BASE_DIR = Path.home() / ".sentinel-1"
+BASE_DIR.mkdir(exist_ok=True)
+LOG_FILE = BASE_DIR / "audit_log.jsonl"  # JSON Lines for easy parsing
+
+
+class AuditLogger:
+    def __init__(self):
+        self.cfg = ConfigManager()
+
+    def is_enabled(self):
+        # Check config (default to False if not set)
+        return self.cfg.get("system.audit_logging", False)
+
+    def toggle(self, state: bool):
+        self.cfg.set("system.audit_logging", state)
+        status = "ENABLED" if state else "DISABLED"
+        return f"Audit Logging is now {status}."
+
+    def log_event(self, event_type, provider, model, input_data, output_data, duration_ms):
+        if not self.is_enabled():
+            return
+
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "event": event_type,
+            "provider": provider,
+            "model": model,
+            "duration_ms": round(duration_ms, 2),
+            "input": str(input_data)[:2000],  # Truncate massive inputs
+            "output": str(output_data)
+        }
+
+        try:
+            with open(LOG_FILE, "a", encoding="utf-8") as f:
+                f.write(json.dumps(entry) + "\n")
+        except Exception as e:
+            print(f"Logger Error: {e}")
+
+
+# Global Instance
+audit = AuditLogger()

sentinel/core/cognitive.py

@@ -0,0 +1,94 @@
+import datetime
+from sentinel.core.llm import LLMEngine
+from sentinel.tools import calendar_ops, weather_ops, memory_ops, notes, email_ops
+
+
+def get_daily_briefing(config_manager):
+    """
+    The 'Brain Boot' sequence.
+    Gathers context -> Sends to LLM -> Returns Morning Briefing.
+    """
+    print("🧠 Gathering Daily Context...")
+
+    # 1. Get Date/Time
+    now = datetime.datetime.now()
+    date_str = now.strftime("%A, %B %d")
+
+    # 2. Get Weather
+    settings = config_manager.load()
+    location = "New York"
+
+    if "weather" in settings and "location" in settings["weather"]:
+        location = settings["weather"]["location"]
+    elif "location" in settings:
+        location = settings["location"]
+
+    try:
+        weather = weather_ops.get_current_weather(location)
+    except Exception as e:
+        weather = f"Weather unavailable ({e})."
+
+    # 3. Get Calendar (Next 24h)
+    try:
+        cal_events = calendar_ops.list_upcoming_events(limit=5)
+    except Exception:
+        cal_events = "Calendar access unavailable."
+
+    # 4. Get Recent Emails
+    try:
+        emails = email_ops.read_emails(limit=5)
+    except Exception:
+        emails = "Email access unavailable."
+
+    # 5. Get Todo List
+    try:
+        todos = notes.list_notes("todo")
+    except Exception:
+        todos = "No notes found."
+
+    # 6. Get Yesterday's Reflection
+    try:
+        yesterday = (now - datetime.timedelta(days=1)).strftime("%Y-%m-%d")
+        history = memory_ops.reflect_on_day(yesterday)
+    except Exception:
+        history = "Memory unavailable."
+
+    # 7. Synthesis Prompt
+    context = f"""
+        DATE: {date_str}
+        LOCATION: {location}
+        
+        WEATHER:
+        {weather}
+        
+        CALENDAR:
+        {cal_events}
+        
+        RECENT EMAILS:
+        {emails}
+        
+        PENDING TASKS:
+        {todos}
+        
+        YESTERDAY'S HISTORY:
+        {history}
+    """
+
+    sys_prompt = (
+        "You are Sentinel, a proactive Chief of Staff. "
+        "Summarize this context into a high-level Morning Briefing. "
+        "1. Highlight immediate calendar priorities. "
+        "2. Mention important or urgent emails. "
+        "3. Note the weather if it impacts travel. "
+        "4. Remind me of unfinished tasks. "
+        "5. Briefly recall where we left off yesterday. "
+        "Be concise, strategic, and motivating."
+    )
+
+    brain = LLMEngine(config_manager)
+
+    if not brain.api_key and brain.provider != "ollama":
+        return f"⚠️ Briefing skipped: No API key for {brain.provider.upper()}."
+
+    report = brain.query(sys_prompt, [{"role": "user", "content": context}])
+    return report

sentinel/core/config.py

@@ -0,0 +1,99 @@
+# FILE: sentinel/core/config.py
+import json
+import os
+import keyring
+from typing import Any, Optional
+from sentinel.paths import CONFIG_PATH  # <-- IMPORTED FROM CENTRAL PATHS
+
+APP_NAME = "sentinel-1"
+
+
+class ConfigManager:
+    def __init__(self):
+        self._ensure_config_exists()
+
+    def _ensure_config_exists(self):
+        # Check if the file exists at ~/.sentinel/config.json
+        if not CONFIG_PATH.exists():
+            default_config = {
+                "user": {"name": "User", "location": "New York"},
+                "system": {"setup_completed": False, "audit_logging": False},
+                "llm": {"provider": "openai", "model": "gpt-4o"}
+            }
+            self.save(default_config)
+
+    def exists(self) -> bool:
+        """Checks if setup has been completed."""
+        return self.get("system.setup_completed", False)
+
+    def load(self) -> dict:
+        try:
+            # CONFIG_PATH is a Path object, open() handles it natively
+            with open(CONFIG_PATH, "r") as f:
+                return json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            return {}
+
+    def save(self, data: dict):
+        # Ensure the directory exists (just in case the folder was deleted manually)
+        CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(CONFIG_PATH, "w") as f:
+            json.dump(data, f, indent=2)
+
+    def get(self, dot_path: str, default: Any = None) -> Any:
+        """
+        Retrieves a value using dot notation (e.g., "user.name").
+        """
+        data = self.load()
+        keys = dot_path.split(".")
+        for key in keys:
+            if isinstance(data, dict):
+                data = data.get(key)
+            else:
+                return default
+        return data if data is not None else default
+
+    def set(self, dot_path: str, value: Any):
+        """
+        Sets a value using dot notation and saves immediately.
+        """
+        data = self.load()
+        keys = dot_path.split(".")
+
+        # Traverse to the last key
+        current = data
+        for key in keys[:-1]:
+            if key not in current:
+                current[key] = {}
+            current = current[key]
+
+        # Set value
+        current[keys[-1]] = value
+        self.save(data)
+
+    # --- KEYRING INTEGRATION (Secrets) ---
+
+    def set_key(self, service: str, api_key: str):
+        """Stores a secret in the OS Keychain."""
+        if not api_key: return
+        try:
+            # Service = "openai", "anthropic", etc.
+            keyring.set_password(APP_NAME, service, api_key)
+        except Exception as e:
+            print(f"[Config] Error saving to Keychain: {e}")
+
+    def get_key(self, service: str) -> Optional[str]:
+        """Retrieves a secret from the OS Keychain."""
+        try:
+            return keyring.get_password(APP_NAME, service)
+        except Exception:
+            return None
+
+    def update_llm(self, provider, model):
+        """
+        Helper used by system_ops.py to switch brains and save to disk.
+        """
+        self.set("llm.provider", provider)
+        self.set("llm.model", model)
+        print(f"[Config] Saved new brain settings: {provider} / {model}")