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

sentinel/tools/navigation.py

@@ -0,0 +1,109 @@
+import googlemaps
+import re
+from sentinel.core.config import ConfigManager
+
+
+def get_gmaps():
+    cfg = ConfigManager()
+    key = cfg.get_key("google_maps")
+    if not key:
+        return None
+    return googlemaps.Client(key=key)
+
+
+def geocode(address):
+    gmaps = get_gmaps()
+    if not gmaps:
+        return "Error: Google Maps API key missing in config"
+
+    try:
+        result = gmaps.geocode(address)
+        if not result:
+            return "No results."
+
+        loc = result[0]["geometry"]["location"]
+        formatted = result[0]["formatted_address"]
+        return f"Address: {formatted}\nCoordinates: {loc['lat']}, {loc['lng']}"
+    except Exception as e:
+        return f"Geocode error: {e}"
+
+
+def reverse_geocode(lat, lon):
+    gmaps = get_gmaps()
+    if not gmaps:
+        return "Error: Google Maps API key missing in config"
+
+    try:
+        lat = float(lat)
+        lon = float(lon)
+        result = gmaps.reverse_geocode((lat, lon))
+        return f"Address: {result[0]['formatted_address']}" if result else "No address."
+    except Exception as e:
+        return f"Reverse Geocode error: {e}"
+
+
+def calc_distance(origin, destination, mode="driving"):
+    gmaps = get_gmaps()
+    if not gmaps:
+        return "Error: Google Maps API key missing in config"
+
+    try:
+        matrix = gmaps.distance_matrix(origin, destination, mode=mode)
+        row = matrix["rows"][0]["elements"][0]
+        if row["status"] != "OK":
+            return f"Error: {row['status']}"
+
+        return (
+            f"Trip: {origin} -> {destination} ({mode})\n"
+            f"Distance: {row['distance']['text']}\n"
+            f"Duration: {row['duration']['text']}"
+        )
+    except Exception as e:
+        return f"Distance error: {e}"
+
+
+def get_directions(origin, destination, mode="driving"):
+    gmaps = get_gmaps()
+    if not gmaps:
+        return "Error: Google Maps API key missing in config"
+
+    try:
+        directions = gmaps.directions(origin, destination, mode=mode)
+        if not directions:
+            return "No directions."
+
+        steps = directions[0]["legs"][0]["steps"]
+        summary = [f"Directions ({mode}):"]
+
+        for i, step in enumerate(steps, 1):
+            instr = re.sub("<[^<]+?>", "", step["html_instructions"])
+            summary.append(f"{i}. {instr} ({step['distance']['text']})")
+
+        return "\n".join(summary)
+    except Exception as e:
+        return f"Directions error: {e}"
+
+
+def find_nearby(lat, lon, type="restaurant", radius=1000):
+    gmaps = get_gmaps()
+    if not gmaps:
+        return "Error: Google Maps API key missing in config"
+
+    try:
+        location = (float(lat), float(lon))
+        places = gmaps.places_nearby(
+            location=location,
+            radius=radius,
+            type=type
+        )
+
+        results = []
+        for p in places.get("results", [])[:10]:
+            name = p.get("name")
+            addr = p.get("vicinity", "No address")
+            rating = p.get("rating", "N/A")
+            results.append(f"- {name} ({rating}*) - {addr}")
+
+        return "\n".join(results) if results else "No places found."
+    except Exception as e:
+        return f"Places error: {e}"

sentinel/tools/notes.py

@@ -0,0 +1,78 @@
+import json
+import os
+import datetime
+from pathlib import Path
+
+BASE_DIR = Path.home() / ".sentinel-1"
+BASE_DIR.mkdir(exist_ok=True)
+NOTES_FILE = BASE_DIR / "memory.json"
+
+
+def _load_notes():
+    """Helper to load notes from JSON file"""
+    if not os.path.exists(NOTES_FILE):
+        return []
+    try:
+        with open(NOTES_FILE, 'r') as f:
+            return json.load(f)
+    except:
+        return []
+
+
+def _save_notes(notes):
+    """Helper to save notes to JSON file"""
+    with open(NOTES_FILE, 'w') as f:
+        json.dump(notes, f, indent=2)
+
+
+def add_note(category, content):
+    """
+    Saves a persistent memory.
+    Args:
+        category: (str) "user_pref", "project_status", "todo", "concept"
+        content: (str) The actual information to remember.
+    """
+    notes = _load_notes()
+    note = {
+        "id": len(notes) + 1,
+        "timestamp": str(datetime.datetime.now()),
+        "category": category,
+        "content": content
+    }
+    notes.append(note)
+    _save_notes(notes)
+    return f"Note added to {category}: {content}"
+
+
+def list_notes(category=None):
+    """
+    Retrieves memories.
+    Args:
+        category: (Optional) Filter by "user_pref", "todo", etc.
+    """
+    notes = _load_notes()
+    if category:
+        filtered = [n for n in notes if n["category"].lower() == category.lower()]
+        if not filtered:
+            return f"No notes found in category '{category}'."
+        return json.dumps(filtered, indent=2)
+
+    # If no category, return all (summarized)
+    return json.dumps(notes, indent=2)
+
+
+def delete_note(note_id):
+    """Removes a note by ID."""
+    notes = _load_notes()
+    # Handle string vs int ID mismatch
+    try:
+        note_id = int(note_id)
+    except:
+        pass
+
+    new_notes = [n for n in notes if n["id"] != note_id]
+    if len(notes) == len(new_notes):
+        return "Error: Note ID not found."
+
+    _save_notes(new_notes)
+    return f"Note {note_id} deleted."

sentinel/tools/office.py

@@ -0,0 +1,67 @@
+import os
+import pandas as pd
+from docx import Document
+from openpyxl import load_workbook
+
+
+def create_word(filename, content):
+    """Creates a new Word document with the given content."""
+    if not filename.endswith(".docx"):
+        filename += ".docx"
+
+    try:
+        doc = Document()
+        doc.add_paragraph(content)
+        doc.save(filename)
+        return f"Success: Created Word doc at {os.path.abspath(filename)}"
+    except Exception as e:
+        return f"Error creating Word doc: {e}"
+
+
+def create_excel(filename, data_list):
+    """
+    Creates a new Excel file from a list of dictionaries.
+    Example data_list: [{"Name": "Alice", "Age": 30}, {"Name": "Bob", "Age": 25}]
+    """
+    if not filename.endswith(".xlsx"):
+        filename += ".xlsx"
+
+    try:
+        df = pd.DataFrame(data_list)
+        df.to_excel(filename, index=False)
+        return f"Success: Created Excel sheet at {os.path.abspath(filename)}"
+    except Exception as e:
+        return f"Error creating Excel: {e}"
+
+
+def append_excel(filename, data_list):
+    """Appends data to an existing Excel file."""
+    if not os.path.exists(filename):
+        return create_excel(filename, data_list)
+
+    try:
+        # Load existing data
+        df_existing = pd.read_excel(filename)
+        df_new = pd.DataFrame(data_list)
+
+        # Combine and save
+        df_final = pd.concat([df_existing, df_new], ignore_index=True)
+        df_final.to_excel(filename, index=False)
+        return f"Success: Appended {len(data_list)} rows to {filename}."
+    except Exception as e:
+        return f"Error appending to Excel: {e}"
+
+
+def read_excel(filename):
+    """Reads an Excel file and returns a summary."""
+    if not os.path.exists(filename):
+        return "Error: File not found."
+
+    try:
+        df = pd.read_excel(filename)
+        # Return markdown string, limit to 50 rows to save tokens
+        if len(df) > 50:
+            return f"File found. Showing first 50 rows:\n{df.head(50).to_markdown(index=False)}"
+        return df.to_markdown(index=False)
+    except Exception as e:
+        return f"Error reading Excel: {e}"

sentinel/tools/organizer.py

@@ -0,0 +1,150 @@
+import os
+import shutil
+import datetime
+from pathlib import Path
+from typing import List, Dict
+
+
+def get_downloads_folder() -> str:
+    """
+    Returns the path to the user's Downloads folder.
+    Cross-platform implementation using pathlib.
+    """
+    # This works on Windows, macOS, and Linux
+    return str(Path.home() / "Downloads")
+
+
+def _get_unique_name(destination_folder: Path, filename: str) -> Path:
+    """
+    If file exists, appends (1), (2), etc. to prevent overwrite.
+    """
+    file_path = destination_folder / filename
+    if not file_path.exists():
+        return file_path
+
+    stem = file_path.stem
+    suffix = file_path.suffix
+    counter = 1
+
+    while file_path.exists():
+        file_path = destination_folder / f"{stem} ({counter}){suffix}"
+        counter += 1
+
+    return file_path
+
+
+def organize_files(directory: str, strategy: str = "extension") -> str:
+    """
+    Organizes files in a directory into subfolders.
+    Strategies:
+      - 'extension' (Groups by type: Images, Videos, Docs)
+      - 'date' (Groups by YYYY-MM-DD)
+    """
+    if directory.lower() == "downloads":
+        directory = get_downloads_folder()
+
+    target_dir = Path(directory)
+
+    if not target_dir.exists():
+        return f"Error: Directory '{directory}' not found."
+
+    actions_taken = []
+
+    # Smart grouping for cleaner organization
+    TYPE_MAP = {
+        # Images
+        "jpg": "Images", "jpeg": "Images", "png": "Images", "gif": "Images",
+        "svg": "Images", "webp": "Images", "tiff": "Images", "bmp": "Images",
+        # Video
+        "mp4": "Videos", "mov": "Videos", "avi": "Videos", "mkv": "Videos",
+        "wmv": "Videos", "flv": "Videos", "webm": "Videos",
+        # Audio
+        "mp3": "Audio", "wav": "Audio", "aac": "Audio", "flac": "Audio", "m4a": "Audio",
+        # Documents
+        "pdf": "Documents", "doc": "Documents", "docx": "Documents",
+        "txt": "Documents", "rtf": "Documents", "odt": "Documents",
+        "xls": "Spreadsheets", "xlsx": "Spreadsheets", "csv": "Spreadsheets",
+        "ppt": "Presentations", "pptx": "Presentations",
+        # Archives
+        "zip": "Archives", "rar": "Archives", "7z": "Archives",
+        "tar": "Archives", "gz": "Archives",
+        # Installers
+        "exe": "Installers", "msi": "Installers", "dmg": "Installers",
+        "deb": "Installers", "pkg": "Installers", "iso": "Installers",
+        # Code
+        "py": "Code", "js": "Code", "html": "Code", "css": "Code",
+        "json": "Code", "java": "Code", "cpp": "Code", "ts": "Code"
+    }
+
+    try:
+        # List all files (skip directories and hidden files)
+        files = [f for f in target_dir.iterdir() if f.is_file() and not f.name.startswith('.')]
+
+        for file_path in files:
+            folder_name = "Misc"
+
+            if strategy == "extension":
+                ext = file_path.suffix.lstrip('.').lower()
+                # Use mapped name if available, else generic folder
+                folder_name = TYPE_MAP.get(ext, f"{ext.upper()}_Files")
+
+            elif strategy == "date":
+                timestamp = file_path.stat().st_mtime
+                date = datetime.datetime.fromtimestamp(timestamp)
+                folder_name = date.strftime("%Y-%m-%d")
+
+            else:
+                return f"Unknown strategy: {strategy}"
+
+            # Create destination folder
+            dest_folder = target_dir / folder_name
+            dest_folder.mkdir(exist_ok=True)
+
+            # Move file safely (rename if collision)
+            final_path = _get_unique_name(dest_folder, file_path.name)
+            shutil.move(str(file_path), str(final_path))
+
+            actions_taken.append(f"Moved {file_path.name} -> {folder_name}/")
+
+        if not actions_taken:
+            return "No files needed organizing."
+
+        return f"Organized {len(actions_taken)} files:\n" + "\n".join(actions_taken[:10]) + (
+            "\n...and more." if len(actions_taken) > 10 else "")
+
+    except Exception as e:
+        return f"Organization failed: {e}"
+
+
+def bulk_rename(directory: str, pattern: str, replace_with: str) -> str:
+    """
+    Renames files matching a pattern.
+    Example: bulk_rename(".", "Screen Shot", "Capture")
+    """
+    if directory.lower() == "downloads":
+        directory = get_downloads_folder()
+
+    target_dir = Path(directory)
+    if not target_dir.exists():
+        return f"Error: Directory '{directory}' not found."
+
+    count = 0
+    try:
+        for file_path in target_dir.iterdir():
+            if not file_path.is_file():
+                continue
+
+            if pattern in file_path.name:
+                new_name = file_path.name.replace(pattern, replace_with)
+                new_path = target_dir / new_name
+
+                # Prevent overwrite if destination exists
+                if new_path.exists():
+                    new_path = _get_unique_name(target_dir, new_name)
+
+                file_path.rename(new_path)
+                count += 1
+
+        return f"Renamed {count} files."
+    except Exception as e:
+        return f"Rename Error: {e}"

sentinel/tools/smart_index.py

@@ -0,0 +1,76 @@
+import sqlite3, os, time
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from pathlib import Path
+
+BASE_DIR = Path.home() / ".sentinel-1"
+BASE_DIR.mkdir(exist_ok=True)
+
+DB = BASE_DIR / "smart_files.db"
+MODEL = SentenceTransformer("all-MiniLM-L6-v2")
+
+def init():
+    conn = sqlite3.connect(DB)
+    conn.execute("""
+    CREATE TABLE IF NOT EXISTS files(
+        path TEXT PRIMARY KEY,
+        name TEXT,
+        ext TEXT,
+        embedding BLOB,
+        last_opened REAL,
+        last_modified REAL
+    )
+    """)
+    conn.commit()
+    conn.close()
+
+init()
+
+def embed(text):
+    return MODEL.encode(text).astype("float32").tobytes()
+
+def index_file(path):
+    if not os.path.exists(path):
+        return
+
+    name = os.path.basename(path)
+    ext = os.path.splitext(path)[1]
+    text = name  # IMPORTANT: only embed filename (fast)
+
+    emb = embed(text)
+
+    conn = sqlite3.connect(DB)
+    conn.execute("""
+    INSERT OR REPLACE INTO files
+    VALUES (?, ?, ?, ?, ?, ?)
+    """, (
+        path,
+        name,
+        ext,
+        emb,
+        time.time(),
+        os.path.getmtime(path)
+    ))
+    conn.commit()
+    conn.close()
+
+def smart_find(query, limit=5):
+    q_emb = MODEL.encode(query)
+    conn = sqlite3.connect(DB)
+    rows = conn.execute(
+        "SELECT path, embedding, last_opened FROM files"
+    ).fetchall()
+    conn.close()
+
+    scored = []
+    for path, emb, last in rows:
+        vec = np.frombuffer(emb, dtype="float32")
+        sim = np.dot(q_emb, vec) / (
+            np.linalg.norm(q_emb)*np.linalg.norm(vec)
+        )
+        recency = 1 / (1 + (time.time() - last))
+        score = sim*0.7 + recency*0.3
+        scored.append((score, path))
+
+    scored.sort(reverse=True)
+    return [p for _, p in scored[:limit]]

sentinel/tools/sql_index.py

@@ -0,0 +1,186 @@
+# FILE: tools/sql_index.py
+import sqlite3
+import os
+import datetime
+import platform
+from pathlib import Path
+
+BASE_DIR = Path.home() / ".sentinel-1"
+BASE_DIR.mkdir(exist_ok=True)
+
+DB_FILE = BASE_DIR / "sentinel-1.db"
+
+# --- CONFIGURATION: WHAT TO IGNORE ---
+# These are the "System Ones" we skip. Everything else is fair game.
+SKIP_DIRS = {
+    # System Folders
+    "Windows", "Program Files", "Program Files (x86)",
+    "AppData", "Application Data",
+    "$RECYCLE.BIN", "System Volume Information", "Recovery",
+    "boot", "efi",
+
+    # Dev Junk (Optional - keep these to avoid noise, or remove to index code)
+    "node_modules", "venv", ".venv", ".git", "__pycache__", ".idea", ".vscode"
+}
+
+
+def _get_conn():
+    conn = sqlite3.connect(DB_FILE)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def get_all_drives():
+    """
+    Returns a list of all logical drives on the system.
+    On Windows: ['C:\\', 'D:\\', 'E:\\']
+    """
+    drives = []
+    if platform.system() == "Windows":
+        import string
+        from ctypes import windll
+        drives = [f"{d}:\\" for d in string.ascii_uppercase if os.path.exists(f"{d}:\\")]
+    else:
+        # Unix-based systems
+        drives = ["/"]
+        if os.path.exists("/Volumes"):  # macOS external drives
+            drives.extend([os.path.join("/Volumes", d) for d in os.listdir("/Volumes")])
+        if os.path.exists("/media"):  # Linux external drives
+            drives.extend([os.path.join("/media", d) for d in os.listdir("/media")])
+    return drives
+
+
+def build_index(silent=True):
+    conn = _get_conn()
+    cursor = conn.cursor()
+
+    # 1. Setup Database
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS files (
+            path TEXT PRIMARY KEY,
+            name TEXT,
+            extension TEXT,
+            size_mb REAL,
+            modified_date TEXT,
+            mtime_raw REAL
+        )
+    ''')
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_name ON files(name)")
+
+    # 2. Identify Scan Targets
+    # Strategy: Scan the User Profile on C:, plus the ROOT of every other drive.
+    targets = []
+
+    # A. Always get standard user folders (Safest way to scan C:)
+    home = os.path.expanduser("~")
+    targets.extend([
+        os.path.join(home, "Desktop"),
+        os.path.join(home, "Documents"),
+        os.path.join(home, "Downloads"),
+        os.path.join(home, "Pictures"),
+        os.path.join(home, "Music"),
+        os.path.join(home, "Videos"),
+        # Add your code folder explicitly if it's not in the above
+        r"D:\Python Projects"
+    ])
+
+    # B. Add ALL other drives (D:, E:, etc)
+    all_drives = get_all_drives()
+    for drive in all_drives:
+        # We generally avoid scanning C:\ root because it's 90% OS junk.
+        # But D:\, E:\, etc. are usually pure data, so we scan their ROOT.
+        if "C:" in drive.upper():
+            continue
+        targets.append(drive)
+
+    # Remove duplicates
+    targets = list(set(targets))
+
+    # 3. Load Cache (for speed)
+    if not silent: print("[System] Loading existing file index...")
+    cursor.execute("SELECT path, mtime_raw FROM files")
+    existing_files = {row['path']: row['mtime_raw'] for row in cursor.fetchall()}
+
+    updates = []
+    seen_paths = set()
+
+    if not silent:
+        print(f"[System] Scanning {len(targets)} locations:\n" + "\n".join([f"   - {t}" for t in targets]))
+
+    # 4. The Scan Loop
+    for folder in targets:
+        if not os.path.exists(folder): continue
+
+        for root, dirs, filenames in os.walk(folder):
+            # --- FILTERING: This is where we skip "System Ones" ---
+            # We modify 'dirs' in-place so os.walk doesn't even enter them.
+            dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith(".")]
+
+            for f in filenames:
+                # Ignore temp/hidden files
+                if f.startswith("~$") or f.startswith("."): continue
+
+                fullpath = os.path.join(root, f)
+                seen_paths.add(fullpath)
+
+                try:
+                    # Check Modification Time
+                    stats = os.stat(fullpath)
+                    current_mtime = stats.st_mtime
+
+                    # Optimization: Skip if file hasn't changed since last scan
+                    if fullpath in existing_files and abs(existing_files[fullpath] - current_mtime) < 1.0:
+                        continue
+
+                    size_mb = round(stats.st_size / (1024 * 1024), 2)
+                    mtime_str = datetime.datetime.fromtimestamp(current_mtime).strftime('%Y-%m-%d %H:%M:%S')
+                    ext = os.path.splitext(f)[1].lower()
+
+                    updates.append((fullpath, f, ext, size_mb, mtime_str, current_mtime))
+
+                except (OSError, PermissionError):
+                    continue
+
+    # 5. Commit Changes
+    if updates:
+        if not silent: print(f"[System] Indexing {len(updates)} new/changed files...")
+        cursor.executemany('''
+            INSERT OR REPLACE INTO files (path, name, extension, size_mb, modified_date, mtime_raw)
+            VALUES (?, ?, ?, ?, ?, ?)
+        ''', updates)
+
+    # 6. Cleanup (Remove files that were deleted from disk)
+    deleted_paths = set(existing_files.keys()) - seen_paths
+    if deleted_paths:
+        deleted_list = list(deleted_paths)
+        chunk_size = 900
+        for i in range(0, len(deleted_list), chunk_size):
+            chunk = deleted_list[i:i + chunk_size]
+            cursor.executemany("DELETE FROM files WHERE path = ?", [(p,) for p in chunk])
+
+    conn.commit()
+    conn.close()
+    return f"Index Updated: {len(updates)} new, {len(deleted_paths)} removed."
+
+
+def search_db(query):
+    conn = _get_conn()
+    cursor = conn.cursor()
+
+    sql_query = f"%{query}%"
+
+    # Prioritize exact matches in name, then partial matches
+    cursor.execute('''
+        SELECT name, path, modified_date 
+        FROM files 
+        WHERE name LIKE ? 
+        ORDER BY mtime_raw DESC
+        LIMIT 10
+    ''', (sql_query,))
+
+    results = cursor.fetchall()
+    conn.close()
+
+    if not results: return "No files found matching that name."
+
+    return "\n".join([f"- {r['name']} ({r['modified_date']})\n  Path: {r['path']}" for r in results])