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

sentinel/core/llm.py

@@ -0,0 +1,143 @@
+# FILE: core/llm.py
+
+import os
+from openai import OpenAI
+import anthropic
+from sentinel.core.ui import UI
+from sentinel.core.audit import audit
+import time
+
+try:
+    from groq import Groq
+except ImportError:
+    Groq = None
+
+
+class LLMEngine:
+    def __init__(self, config_manager, verbose=True):
+        """
+        Args:
+            verbose (bool): If True, prints "Brain Loaded" on init.
+                            Set False for background tasks.
+        """
+        self.cfg_manager = config_manager
+        self.provider = None
+        self.model = None
+        self.api_key = None
+        self.reload_config(verbose=verbose)
+
+    def reload_config(self, verbose=False):
+        """Reloads settings and credentials from the config manager."""
+        settings = self.cfg_manager.load()
+        llm_settings = settings.get("llm", {})
+
+        self.provider = llm_settings.get("provider", "openai").lower()
+        self.model = llm_settings.get("model", "gpt-4o")
+        self.api_key = self.cfg_manager.get_key(self.provider)
+
+        if verbose:
+            is_ready = self.api_key is not None or self.provider == "ollama"
+            if is_ready:
+                # We can comment this out if we want it strictly in the UI panel now
+                # UI.print_system(f"Brain Loaded: [bold cyan]{self.provider.upper()}[/bold cyan] | Model: [bold white]{self.model}[/bold white]")
+                pass
+
+    def stream_query(self, system_prompt, history):
+        # Hot-reload config (Silent)
+        self.reload_config(verbose=False)
+
+        if not self.api_key and self.provider != "ollama":
+            yield f"\n[bold red]Error:[/bold red] No API key found for '{self.provider}'.\n"
+            yield f"Please run: [cyan]/setkey {self.provider} YOUR_KEY_HERE[/cyan]"
+            return
+
+        # --- PREPARE MESSAGES ---
+        # 1. System Prompt is separate
+        messages = []
+        for msg in history:
+            # Anthropic hates "system" role in messages list
+            if msg["role"] != "system":
+                messages.append(msg)
+
+        try:
+            if self.provider == "groq":
+                if not Groq:
+                    yield "Error: 'groq' library not installed. Run 'pip install groq'."
+                    return
+                # Groq (via OpenAI client) EXPECTS system message in list
+                groq_msgs = [{"role": "system", "content": system_prompt}] + history
+
+                client = Groq(api_key=self.api_key)
+                stream = client.chat.completions.create(
+                    messages=groq_msgs, model=self.model, temperature=0.1, stream=True
+                )
+                for chunk in stream:
+                    if chunk.choices[0].delta.content:
+                        yield chunk.choices[0].delta.content
+
+            elif self.provider == "openai":
+                # OpenAI EXPECTS system message in list
+                openai_msgs = [{"role": "system", "content": system_prompt}] + history
+
+                client = OpenAI(api_key=self.api_key)
+                stream = client.chat.completions.create(
+                    model=self.model, messages=openai_msgs, temperature=0.1, stream=True
+                )
+                for chunk in stream:
+                    if chunk.choices[0].delta.content:
+                        yield chunk.choices[0].delta.content
+
+            elif self.provider == "anthropic":
+                # --- ANTHROPIC SPECIFIC FIX ---
+                # Pass 'system' as a top-level parameter
+                client = anthropic.Anthropic(api_key=self.api_key)
+
+                with client.messages.stream(
+                        max_tokens=4096,
+                        system=system_prompt,
+                        messages=messages,
+                        model=self.model
+                ) as stream:
+                    for text in stream.text_stream:
+                        yield text
+
+            elif self.provider == "ollama":
+                # Ollama likes system message in list
+                ollama_msgs = [{"role": "system", "content": system_prompt}] + history
+                import requests
+                import json
+                payload = {"model": self.model, "messages": ollama_msgs, "stream": True}
+                with requests.post("http://localhost:11434/api/chat", json=payload, stream=True) as r:
+                    for line in r.iter_lines():
+                        if line:
+                            body = json.loads(line)
+                            if "message" in body and "content" in body["message"]:
+                                yield body["message"]["content"]
+
+        except Exception as e:
+            error_str = str(e)
+            if "401" in error_str or "invalid_api_key" in error_str:
+                yield f"\n[bold red]🔑 Authentication Failed:[/bold red] The API key for [cyan]{self.provider.upper()}[/cyan] is invalid or expired."
+            elif "429" in error_str or "rate_limit_exceeded" in error_str:
+                yield f"\n[bold yellow]⏳ Rate Limit Reached:[/bold yellow] {self.provider.upper()} is busy."
+            else:
+                yield f"\n[bold red]System Error ({self.provider}):[/bold red] {error_str}"
+
+    def query(self, system_prompt, history):
+        start_time = time.time()
+        full_response = ""
+        for token in self.stream_query(system_prompt, history):
+            full_response += token
+
+        duration = (time.time() - start_time) * 1000
+
+        audit.log_event(
+            event_type="LLM_QUERY",
+            provider=self.provider,
+            model=self.model,
+            input_data=[{"role": "system", "content": system_prompt}] + history,
+            output_data=full_response,
+            duration_ms=duration
+        )
+
+        return full_response

sentinel/core/registry.py

@@ -0,0 +1,351 @@
+# FILE: core/registry.py
+
+import platform
+import datetime
+import threading
+import os
+from sentinel.core.config import ConfigManager
+import schedule
+from sentinel.tools.smart_index import smart_find
+
+# Import all tools
+from sentinel.tools import (
+    apps, browser, clock, email_ops, file_ops, indexer, notes, office,
+    system_ops, navigation, flights, sql_index, desktop, vision, audio,
+    context, calendar_ops, memory_ops, weather_ops, organizer, macros,
+    factory, installer
+)
+from sentinel.core import scheduler, cognitive
+
+# --- DETECT OS ---
+CURRENT_OS = platform.system()
+OS_VERSION = platform.release()
+NOW = datetime.datetime.now()
+
+# --- LOAD CONFIG ---
+cfg = ConfigManager()
+settings = cfg.load() if cfg.exists() else {}
+
+
+def initialize_tools():
+    print("\n[System] 🔄 Initializing File Systems...")
+
+    # 1. Fast Filename Indexer (Metadata Only)
+    t1 = threading.Thread(target=sql_index.build_index, args=(True,))
+    t1.daemon = True
+    t1.start()
+
+    # REMOVE: The content indexer thread (t2)
+
+    # 3. Schedule recurring updates (Metadata only)
+    schedule.every(60).minutes.do(sql_index.build_index, silent=True)
+
+    scheduler.start_scheduler_service()
+
+
+# --- SAFETY WRAPPERS ---
+
+def ask_permission(tool_name, func, **kwargs):
+    """
+    Intervention Layer: Pauses execution to ask the user for confirmation.
+    """
+    print(f"\n[🛑 SECURITY ALERT] Agent wants to run: {tool_name}")
+    # Hide agent_config from display
+    display_args = {k: v for k, v in kwargs.items() if k != 'agent_config'}
+    print(f"   Arguments: {display_args}")
+
+    choice = input(f"   >>> Allow this? (y/N): ").lower()
+
+    if choice == 'y':
+        try:
+            # Log successful dangerous actions to memory
+            log_args = {k: v for k, v in kwargs.items() if k != 'agent_config'}
+            memory_ops.log_activity(tool_name, str(log_args))
+        except:
+            pass
+        return func(**kwargs)
+    else:
+        return f"Action '{tool_name}' denied by user."
+
+
+def safe_run_cmd(cmd):
+    """Extra guardrails for terminal commands."""
+    dangerous_keywords = ["del", "rm", "format", "shutdown", "reboot", ">"]
+    if any(k in cmd.lower() for k in dangerous_keywords):
+        print(f"\n[⚠️ HIGH RISK] Command contains dangerous keywords: '{cmd}'")
+        confirm = input("   >>> TYPE 'CONFIRM' TO EXECUTE: ")
+        if confirm != "CONFIRM":
+            return "Safety block: Command denied."
+
+    return ask_permission("run_cmd", system_ops.run_cmd, cmd=cmd)
+
+
+def draft_code(filename, content):
+    """Safe Coding: Writes to 'drafts/' instead of executing."""
+    safe_path = os.path.join("drafts", os.path.basename(filename))
+    try:
+        with open(safe_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        return f"Code saved to '{safe_path}'. Review it manually before running."
+    except Exception as e:
+        return f"Error drafting code: {e}"
+
+
+# --- TOOL MAPPING ---
+TOOLS = {
+    # System & Apps
+    "open_app": apps.open_app,
+    "close_app": lambda **k: ask_permission("close_app", apps.close_app, **k),
+    "run_cmd": safe_run_cmd,
+    "get_clipboard": system_ops.get_clipboard,
+    "kill_process": lambda **k: ask_permission("kill_process", system_ops.kill_process, **k),
+    "get_system_stats": system_ops.get_system_stats,
+    "play_music": apps.play_music,
+
+    # Browser
+    "search_web": browser.search_web,
+    "open_url": browser.open_url,
+    "read_webpage": browser.read_webpage,
+
+    # Files & Index
+    "read_file": file_ops.read_file,
+    "write_file": file_ops.write_file,
+    "draft_code": draft_code,
+    "build_index": indexer.build_index,
+    "search_index": indexer.search_index,
+    "find_file": sql_index.search_db,
+    "rebuild_memory": sql_index.build_index,
+    "organize_files": lambda **k: ask_permission("organize_files", organizer.organize_files, **k),
+    "bulk_rename": lambda **k: ask_permission("bulk_rename", organizer.bulk_rename, **k),
+
+    # Office & Documents
+    "create_word": office.create_word,
+    "create_excel": office.create_excel,
+    "append_excel": office.append_excel,
+    "read_excel": office.read_excel,
+    "create_document": factory.create_document,
+
+    # Time & Email
+    "get_time": clock.get_time,
+    "set_timer": clock.set_timer,
+    "set_alarm": clock.set_alarm,
+    "send_email": lambda **k: ask_permission("send_email", email_ops.send_email, **k),
+    "read_emails": email_ops.read_emails,
+
+    # Memory & Cognitive
+    "add_note": notes.add_note,
+    "list_notes": notes.list_notes,
+    "store_fact": memory_ops.store_fact,
+    "delete_fact": memory_ops.delete_fact,
+    "retrieve_knowledge": lambda **kwargs: memory_ops.retrieve_relevant_context(
+        query=" ".join([str(v) for v in kwargs.values() if v])
+    ),
+
+    "reflect_on_day": memory_ops.reflect_on_day,
+    "daily_briefing": lambda: cognitive.get_daily_briefing(cfg),
+
+    # Navigation & Flights
+    "geocode": navigation.geocode,
+    "reverse_geocode": navigation.reverse_geocode,
+    "calc_distance": navigation.calc_distance,
+    "get_directions": navigation.get_directions,
+    "find_nearby": navigation.find_nearby,
+    "search_flights": flights.search_flights,
+
+    # Desktop Control
+    "set_volume": desktop.set_volume,
+    "set_brightness": desktop.set_brightness,
+    "minimize_window": desktop.minimize_window,
+    "maximize_window": desktop.maximize_window,
+    "type_text": desktop.type_text,
+    "speak": desktop.speak,
+
+    # Perception
+    "listen": audio.listen,
+    "analyze_screen": vision.analyze_screen,
+    "capture_webcam": vision.capture_webcam,
+    "get_active_app": context.get_active_app,
+    "get_weather": weather_ops.get_current_weather,
+
+    # Autonomy (Scheduler)
+    "schedule_task": lambda interval, task: ask_permission(
+        "schedule_task",
+        scheduler.schedule_task,
+        interval_minutes=interval,
+        task_description=task,
+        agent_config=settings
+    ),
+    "stop_tasks": scheduler.stop_all_jobs,
+
+    # Calendar
+    "list_calendar_events": calendar_ops.list_upcoming_events,
+    "get_calendar_range": calendar_ops.get_events_in_frame,
+    "create_calendar_event": lambda **k: ask_permission("create_event", calendar_ops.create_event, **k),
+    "calendar_quick_add": lambda **k: ask_permission("quick_add", calendar_ops.quick_add, **k),
+
+    # Macros & Installers
+    "run_macro": macros.run_macro,
+    "install_software": installer.install_software,
+    "list_installed_apps": installer.list_installed,
+
+    "find_my_file": lambda query: "\n".join(smart_find(query)),
+
+}
+
+# --- PROMPT ---
+# Note: JSON examples use DOUBLE BRACES {{ }} to escape f-string formatting
+SYSTEM_PROMPT = f"""
+You are **Sentinel**, an autonomous AI Operating System layer.
+Your role is to translate user intent into safe, deterministic system actions.
+
+System Context:
+- OS: {CURRENT_OS} {OS_VERSION}
+- Current Time: {NOW}
+
+USER PROFILE:
+Name: {cfg.get("user.name")}
+Location: {cfg.get("user.location")}
+
+CORE BEHAVIOR:
+1. You operate in **command mode**, not conversation mode.
+2. Your output must be valid JSON for tool execution.
+3. Never explain tools unless explicitly asked.
+4. Prefer direct action over discussion.
+
+DECISION POLICY:
+- If the user intent is ambiguous → ask a minimal clarifying question.
+- If the intent maps to a tool → call it immediately.
+- If no tool fits → respond with {{"tool": "response", "args": {{"text": "..."}}}}
+
+CRITICAL SAFETY PROTOCOLS:
+1. **NO CHITCHAT**: Output JSON only.
+2. **HUMAN-IN-THE-LOOP**:
+   - Killing processes
+   - Running shell commands
+   - Sending emails
+   - Scheduling tasks
+   Must go through `ask_permission`.
+3. **CODE SAFETY**:
+   - NEVER execute generated code.
+   - ALWAYS use `draft_code`.
+
+MEMORY PROTOCOLS:
+1. **Active Listening**:
+   If the user reveals a stable preference, habit, goal, or identity:
+   → Immediately call `store_fact`.
+
+2. **Context Recall**:
+   Before solving complex tasks:
+   → Check `retrieve_knowledge` or `list_notes`.
+
+3. **Persistence Triggers**:
+   Phrases like:
+   - "remember this"
+   - "from now on"
+   - "in the future"
+   Must result in memory storage.
+
+AUTONOMY RULES:
+- Background agents must be:
+  - Explicitly approved
+  - Clearly scoped
+  - Easy to stop
+
+AVAILABLE TOOLS:
+(only use tools listed below, no hallucinations)
+
+SYSTEM & APPS:
+- open_app(name): launch an application
+- close_app(name): close a running application [REQUIRES APPROVAL]
+- run_cmd(cmd): run shell command [REQUIRES APPROVAL]
+- get_clipboard(): get clipboard text
+- kill_process(name): kill a running process [REQUIRES APPROVAL]
+- get_system_stats(): CPU, RAM, battery status
+- play_music(song_name): play music
+
+BROWSER:
+- search_web(query): search internet
+- open_url(url): open website
+- read_webpage(url): extract webpage text
+
+FILES & INDEX:
+- read_file(path): read file
+- write_file(path, content): write file
+- draft_code(filename, content): save code safely
+- build_index(verbose): scan filesystem
+- search_index(query): semantic file search
+- find_file(query): exact filename search (SQL, literal)
+- find_my_file(query): semantic + recency search (vague queries like "that pdf I edited last week")
+- rebuild_memory(verbose): rebuild index
+- organize_files(directory, strategy): organize files [REQUIRES APPROVAL]
+- bulk_rename(directory, pattern, replace_with): rename files [REQUIRES APPROVAL]
+
+OFFICE & DOCUMENTS:
+- create_word(filename, content)
+- create_excel(filename, data_list)
+- append_excel(filename, data_list)
+- read_excel(filename)
+- create_document(filename, blocks)
+
+TIME & EMAIL:
+- get_time()
+- set_timer(seconds)
+- set_alarm(time_str)
+- send_email(to, subject, body) [REQUIRES APPROVAL]
+- read_emails(limit)
+
+MEMORY & COGNITIVE:
+- add_note(category, content)
+- list_notes(category)
+- store_fact(subject, predicate, obj)
+- delete_fact(subject, predicate, obj): remove stored memory facts
+- retrieve_knowledge(subject, predicate, obj)
+- reflect_on_day(date_str)
+- daily_briefing()
+
+NAVIGATION & FLIGHTS:
+- geocode(address)
+- reverse_geocode(lat, lon)
+- calc_distance(origin, destination, mode)
+- get_directions(origin, destination)
+- find_nearby(lat, lon, type)
+- search_flights(departure_id, arrival_id, date)
+
+DESKTOP CONTROL:
+- set_volume(level)
+- set_brightness(level)
+- minimize_window(app_name)
+- maximize_window(app_name)
+- type_text(text)
+- speak(text)
+
+PERCEPTION:
+- listen(timeout)
+- analyze_screen(prompt)
+- capture_webcam(prompt)
+- get_active_app()
+- get_weather(location): retrieve the current location first/else ask user if cannot find
+
+AUTONOMY:
+- schedule_task(interval, task) [REQUIRES APPROVAL]
+- stop_tasks()
+
+CALENDAR:
+- list_calendar_events(max_results)
+- get_calendar_range(start_iso, end_iso)
+- create_calendar_event(summary, start_time, duration_mins, description) [REQUIRES APPROVAL]
+- calendar_quick_add(text) [REQUIRES APPROVAL]
+
+MACROS & INSTALLERS:
+- run_macro(name)
+- install_software(package_list): install Windows apps via winget
+- list_installed_apps(): list installed applications
+
+
+FINAL RULE:
+Your response MUST ALWAYS be one of:
+1. Tool call JSON
+2. {{"tool": "response", "args": {{"text": "..."}}}}
+
+NO prose. NO markdown. NO explanations.
+"""

sentinel/core/scheduler.py

@@ -0,0 +1,61 @@
+import schedule
+import time
+import threading
+from sentinel.core.llm import LLMEngine
+
+# Global registry
+ACTIVE_JOBS = {}
+
+
+def _job_runner(task_description, agent_config):
+    """Runs the background task."""
+    print(f"\n[Scheduler] ⏰ Executing background task: {task_description}")
+
+    # Create a transient brain for this task
+    brain = LLMEngine(agent_config)
+
+    # Security: Background agents get a strictly limited prompt
+    sys_prompt = f"You are a background monitoring agent. Current Task: {task_description}. Output JSON only."
+
+    try:
+        # We pass an empty history because background tasks should be stateless
+        response = brain.query(sys_prompt, [])
+        print(f"[Scheduler Result]: {response}")
+    except Exception as e:
+        print(f"[Scheduler Error]: {e}")
+
+
+def schedule_task(interval_minutes, task_description, agent_config):
+    """Schedules a new task."""
+    job_id = f"job_{len(ACTIVE_JOBS) + 1}"
+
+    # Schedule the job
+    job = schedule.every(int(interval_minutes)).minutes.do(
+        _job_runner, task_description, agent_config
+    )
+
+    ACTIVE_JOBS[job_id] = job
+    return f"✅ Scheduled: '{task_description}' every {interval_minutes}m. (ID: {job_id})"
+
+
+def stop_all_jobs():
+    """
+    EMERGENCY STOP: Clears all background schedules.
+    """
+    count = len(ACTIVE_JOBS)
+    schedule.clear()
+    ACTIVE_JOBS.clear()
+    return f"🛑 STOPPED {count} background jobs. Scheduler is now empty."
+
+
+def start_scheduler_service():
+    """Starts the loop in a background thread."""
+
+    def loop():
+        while True:
+            schedule.run_pending()
+            time.sleep(1)
+
+    t = threading.Thread(target=loop, daemon=True)
+    t.start()
+    print(">> System: Scheduler Service Online.")

sentinel/core/schema.py

@@ -0,0 +1,11 @@
+# FILE: core/schema.py
+from pydantic import BaseModel, Field, ValidationError
+from typing import Dict, Any, Optional
+
+class AgentAction(BaseModel):
+    tool: str
+    args: Dict[str, Any] = Field(default_factory=dict)
+
+    class Config:
+        # Allows the model to ignore extra fields if the LLM hallucinates them
+        extra = "ignore"

sentinel/core/setup.py

@@ -0,0 +1,101 @@
+# sentinel/core/setup.py
+
+import time
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from sentinel.core.config import ConfigManager
+from sentinel.paths import CREDENTIALS_PATH as CREDS_FILE
+
+console = Console()
+cfg = ConfigManager()
+
+
+def print_step(title):
+    console.print(f"\n[bold cyan]🔹 {title}[/bold cyan]")
+
+
+def setup_wizard():
+    console.clear()
+    console.print(Panel.fit(
+        "[bold white]Welcome to Sentinel OS[/bold white]\n[dim]Autonomous AI Agent System[/dim]",
+        border_style="cyan",
+        padding=(1, 4)
+    ))
+
+    console.print("\n[italic]Let's get your system configured. Press Enter to skip optional fields.[/italic]\n")
+
+    # 1. User Profile
+    print_step("User Profile")
+    name = Prompt.ask("What should I call you?", default="User")
+    location = Prompt.ask("What is your city? (for weather/time)", default="New York")
+
+    cfg.set("user.name", name)
+    cfg.set("user.location", location)
+
+    # 2. Intelligence Engine
+    print_step("Intelligence Engine")
+    provider = Prompt.ask(
+        "Select Primary Brain",
+        choices=["openai", "anthropic", "groq", "ollama"],
+        default="openai"
+    )
+
+    api_key = ""
+    if provider != "ollama":
+        api_key = Prompt.ask(f"Enter API Key for [cyan]{provider}[/cyan]", password=True)
+
+    cfg.set("llm.provider", provider)
+
+    if api_key:
+        cfg.set_key(provider, api_key)
+
+    # 3. Search
+    print_step("Search Capabilities")
+    console.print("Sentinel uses [bold green]Tavily[/bold green] for advanced research, falling back to DuckDuckGo.")
+
+    tavily_key = Prompt.ask("Enter Tavily API Key (Optional)", password=True)
+    if tavily_key:
+        cfg.set_key("tavily", tavily_key)
+
+    serp_key = Prompt.ask("Enter SerpAPI Key (Optional - for Flights)", password=True)
+    if serp_key:
+        cfg.set_key("serp_api", serp_key)
+
+    gmaps_key = Prompt.ask("Enter Google Maps API Key (Optional - for Navigation)", password=True)
+    if gmaps_key:
+        cfg.set_key("google_maps", gmaps_key)
+
+    # 4. Google Workspace
+    print_step("Google Workspace")
+    if Confirm.ask("Do you want to link Gmail/Calendar now?"):
+        if CREDS_FILE.exists():
+            console.print("[green]✔ credentials.json found.[/green]")
+            console.print("Authentication will trigger automatically on first use.")
+        else:
+            console.print("[red]❌ credentials.json not found.[/red]\n")
+            console.print("1. Go to Google Cloud Console")
+            console.print("2. Enable Gmail + Calendar APIs")
+            console.print("3. Create OAuth Desktop App")
+            console.print("4. Download credentials.json")
+            console.print("\nPlace it here:\n")
+            console.print(f"[bold cyan]{CREDS_FILE}[/bold cyan]")
+            console.print("\nThen run: sentinel auth")
+
+    # 5. Finalize
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+    ) as progress:
+        task = progress.add_task("Initializing Neural Interfaces...", total=100)
+        time.sleep(0.5)
+        progress.update(task, advance=50)
+        cfg.set("system.setup_completed", True)
+        time.sleep(0.5)
+        progress.update(task, advance=50)
+
+    console.print("\n[bold green]✔ Setup Complete.[/bold green] Launching Sentinel...")
+    time.sleep(1)